Support automatic Qwen tool calls for coding workflows

[Baiju Meswani (baijumeswani)]

What this changes

This PR makes Foundry Local work better with coding-style tool use on qualified Qwen chat models.

Before this change, Qwen could emit native XML tool calls, but Foundry Local treated that output as plain assistant text. That meant clients like GitHub Copilot CLI and Toolkit could see text that looked like a tool call, but they could not actually execute the tool through the normal tool-calling path.

This PR teaches Foundry Local to recognize the exact Qwen XML tool-call format we qualified, convert it into normal structured tool calls, and keep tool results associated with the correct call when the model emits multiple calls in one turn.

Why this is needed

The coding scenario depends on reliable tool use.

Simple examples:

• The model should be able to ask to view a file and get the file content back.
• The model should be able to ask to run bash for a focused test and get the test output back.
• The model should be able to emit two tool calls in one turn and still receive the right result for each call.
• The model should be able to use raw apply_patch when that path is explicitly supported, without breaking ordinary structured tool calls.

Without this change, Qwen-native tool output leaks back to the client as visible XML, or parallel tool results can be rendered back to the model in the wrong order for the qualified Qwen template.

Examples

Before

The model emits text like:

<tool_call>
<function=view>
<parameter=path>
src/main.cc
</parameter>
</function>
</tool_call>

Foundry Local returns that as assistant text instead of a structured tool call, so the client cannot run the tool through the normal tool-calling loop.

After

The same output is decoded as a normal tool call:

{
  "name": "view",
  "arguments": {
    "path": "src/main.cc"
  }
}

The client receives an actual tool-call item, executes it, and sends back the tool result through the existing tool-result path.

Multiple calls in one turn

If the model emits:

<tool_call>
<function=view>
<parameter=path>
src/a.cc
</parameter>
</function>
</tool_call>
<tool_call>
<function=view>
<parameter=path>
src/b.cc
</parameter>
</function>
</tool_call>

Foundry Local preserves that as two adjacent structured calls in source order.

If the tool results come back in a different completion order, Foundry Local still renders the results back to the qualified Qwen template in the assistant-call order the model expects.

Raw apply_patch still works

If output is already claimed by the raw-envelope path for apply_patch, that path keeps ownership of the bytes.

This PR does not replace or weaken the raw-tool behavior added for the coding harness. It composes with it.

Scope

Included:

• internal detection of the qualified Qwen model type;
• production-template probing so the behavior only enables for the exact qualified dialect;
• narrow decoding of the qualified Qwen XML tool-call format;
• schema-aware argument conversion into Foundry Local's existing structured tool-call representation;
• support for one contiguous batch of adjacent tool calls in a single assistant turn;
• positional tool-result projection for the qualified Qwen template when multiple adjacent calls are followed by their results;
• graceful fallback to visible text for malformed, incomplete, fenced, oversized, unsupported, or undeclared XML tool-call candidates.

Not included:

• arbitrary XML frameworks;
• new public API for model dialects;
• patch execution itself;
• cancellation/resource-safety work;
• prefix caching;
• model packaging or dependency pinning.

Design intent

Keep the change narrow and fail closed.

This PR only turns the behavior on for the exact qualified Qwen shape:

• exact model type: qwen3_5_text;
• matching production template behavior for tool-call rendering;
• matching production template behavior for positional tool-result consumption.

If those checks do not match, Foundry Local keeps the existing behavior.

This avoids introducing a broad XML parser, a generic dialect system, or behavior changes for unrelated models.

Behavior details

Tool-call decoding

The decoder accepts only the exact qualified form:

<tool_call>
<function=tool_name>
<parameter=parameter_name>
value
</parameter>
</function>
</tool_call>

It converts the decoded payload into the existing provider-neutral parsed tool-call shape.

Argument conversion follows the declared tool schema:

• declared string parameters stay strings;
• declared numeric, boolean, null, array, and object parameters must parse as compatible JSON;
• unsupported or ambiguous schema shapes fall back to visible text.

Fallback behavior

These cases remain visible text and are not turned into tool calls:

• malformed XML;
• incomplete XML;
• fenced examples;
• undeclared tool names;
• duplicate parameters;
• unknown parameters;
• missing required parameters;
• unsupported schema shapes;
• oversized candidates;
• alternate tags or unsupported XML constructs.

Multi-call result ordering

For the qualified Qwen template, consecutive tool results are interpreted positionally.

This PR reorders only the copied render group that is sent back through the prompt-building path. It does not mutate the canonical transcript or public tool-call IDs.

If the result history is ambiguous, Foundry Local rejects the request before generation instead of guessing.

User-visible effect

For qualified Qwen coding models, automatic tool use becomes much more reliable.

Examples of workflows this enables:

1. Read a file with view.
2. Search code with rg.
3. Run a focused test with bash.
4. Continue after tool results without leaking XML back to the user.

That is the core behavior needed for coding harnesses that rely on automatic tool calling.

Validation summary

The change was qualified against targeted unit and integration coverage, including:

• ordinary text responses;
• one-call and two-call automatic tool use;
• mixed string and structured arguments;
• streaming and non-streaming behavior;
• raw apply_patch coexistence;
• malformed/incomplete/fenced fallback;
• ambiguous result-history rejection;
• long-context continuation scenarios.

Real Qwen qualification showed the expected improvement for coding-style tool loops such as reading files, running shell commands, and continuing after tool results.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated
foundry-local	Ready	Preview	Sep 16, 2026 12:34am UTC

[Copilot]

🟡 Changes recommended

Boundary handling, duplicate-schema ambiguity, required-tool enforcement, and streaming performance issues remain unresolved.

Get a fresh assessment by requesting another Copilot review.

Pull request overview

Adds qualified Qwen XML tool-call decoding and positional result ordering across chat backends.

Changes:

• Detects compatible Qwen model templates and enables native XML decoding.
• Adds schema-aware, streaming-safe tool-call parsing and result projection.
• Expands ABI, fallback, streaming, and integration coverage.

File summaries

File	Description
sdk_v2/cpp/CMakeLists.txt	Builds the Qwen decoder.
sdk_v2/cpp/test/CMakeLists.txt	Registers capability tests.
tool_definition_abi_test.cc	Covers legacy serialized tools.
tool_call_utils_test.cc	Tests malformed metadata handling.
tool_call_stream_accumulator_test.cc	Covers Qwen streaming and fallbacks.
grammar_test.cc	Tests malformed schemas.
genai_model_instance_test.cc	Tests capability probing.
chat_transcript_test.cc	Tests positional result projection.
chat_session_test.cc	Adds end-to-end Qwen coverage.
tool_call_utils.cc	Safely reads advertised names.
tool_call_stream_accumulator.h	Adds payload-parser streaming mode.
tool_call_payload_parser.h	Defines the parser contract.
qwen_xml_tool_call_decoder.h	Declares Qwen decoder creation.
qwen_xml_tool_call_decoder.cc	Implements schema-aware XML decoding.
markdown_fence_tracker.h	Prevents fenced examples becoming calls.
grammar.cc	Hardens schema generation.
genai_model_instance.h	Exposes detected capabilities.
genai_model_instance.cc	Probes model type and templates.
onnx_engine_chat_stream.h	Accepts prepared messages.
onnx_engine_chat_stream.cc	Renders projected Engine prompts.
onnx_chat_generator.h	Accepts prepared messages.
onnx_chat_generator.cc	Renders projected Generator prompts.
chat_template.h	Defines positional projection APIs.
chat_template.cc	Implements result reordering.
chat_session.h	Adds parser and preparer integration.
chat_session.cc	Routes Qwen calls through production paths.
chat_generator.h	Updates the backend interface.

Review details

Suppressed comments (1)

sdk_v2/cpp/src/inferencing/generative/toolcalling/qwen_xml_tool_call_decoder.cc:173

• This parameterless-schema branch also ignores duplicate insertion failure. Two declarations with the same name and empty/object-with-no-properties schemas therefore leave one declaration valid, even though the selected schema is ambiguous. Use the same duplicate-invalidating insertion path for this branch.

    if (parameters.empty() ||
        (parameter_type.has_value() && *parameter_type == "object" && has_no_properties &&
         has_no_required_parameters)) {
      schema.valid =
          !parameters.contains("properties") || parameters["properties"].is_object();
      schemas.emplace(name, std::move(schema));
      continue;

• Files reviewed: 27/27 changed files
• Comments generated: 6
• Review effort level: Balanced

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.