Support automatic Qwen tool calls for coding workflows

[Baiju Meswani (baijumeswani)]

Summary

This PR enables automatic tool use for the qualified Qwen chat-template dialect used by coding harnesses.

Qwen emits native XML when tool_choice is omitted or auto. Foundry Local previously returned that XML as visible
assistant text, so clients such as GitHub Copilot CLI and Toolkit could not execute the requested tool through the
normal tool-calling path.

This change:

• recognizes the exact qualified Qwen XML tool-call form;
• converts complete valid output into Foundry Local's existing provider-neutral structured tool calls;
• supports one contiguous, atomic batch of adjacent calls;
• renders multi-call tool results back to the qualified Qwen template in original call order, even when results arrive
  in a different order;
• composes with the raw-envelope behavior from Support declared raw-envelope output for custom tools #1088 without changing its public contract.

Example

Qwen output such as:

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

is exposed to the client as the equivalent structured view call rather than visible XML.

If Qwen emits multiple adjacent calls, Foundry Local preserves their source order. Public call IDs remain unchanged,
while a copied prompt-render group reorders corresponding results into the positional order expected by the qualified
template.

Activation and compatibility

The Qwen-native decoder is internal and enables only when all of these conditions hold:

• the loaded model type is exactly qwen3_5_text;
• production-template probes confirm the exact qualified call-output and positional-result behavior;
• tools are present;
• tool choice is omitted or auto, with no forced tool;
• no explicit guidance is active;
• the effective call markers are exactly <tool_call> and </tool_call>;
• every serialized tool declaration is recognized and supported by the exact decoder.

Required/forced tool guidance and unrelated model types continue through the existing provider-neutral paths.
Broader structurally supported JSON Schema keywords remain available to shared guidance; a schema outside the Qwen decoder's supported
subset disables only native XML decoding rather than redefining global schema compatibility. Reference-bearing tool schemas
fail generated guidance closed because embedding them would change local $ref resolution; general reference rebasing remains out of scope.

guidance_type and guidance_data must be supplied together. Partial explicit guidance is rejected before generator
construction instead of producing asymmetric routing.

Decoding and fallback

The decoder accepts only the qualified LF-delimited function/parameter form. Argument conversion follows the declared
tool schema:

• declared strings remain strings and preserve internal newlines;
• declared number, integer, boolean, null, array, and object values must parse as compatible JSON;
• custom-tool declarations are accepted only in their canonical normalized shape.

The selected payload is bounded to 64 KiB. A contiguous multi-call batch is published atomically, so a malformed or
unsupported later call cannot expose an earlier partial batch.

Malformed, incomplete, fenced, oversized, unsupported, or undeclared candidates remain visible non-actionable text.
The implementation does not repair or fabricate calls.

Raw-envelope and structured candidates retain ownership of bytes once opened. A valid raw apply_patch envelope still
uses the #1088 path; a valid Qwen XML batch uses the structured path; ordinary output remains text.

Positional result projection

For the qualified template, a multi-call assistant turn followed by its contiguous tool-result group must contain an
exact call-ID bijection. Foundry Local reorders only a copied render group into assistant-call order.

The canonical transcript and public result IDs are not mutated. Duplicate, missing, unknown, intervening, or otherwise
ambiguous result groups fail before generation with an invalid-request error. Non-Qwen rendering is unchanged.

Scope

Included:

• internal model-type and production-template capability detection;
• exact Qwen automatic XML decoding;
• schema-aware conversion to existing structured calls;
• adjacent-call batch atomicity;
• positional result projection for the qualified template;
• composition with Support declared raw-envelope output for custom tools #1088 raw-envelope routing.

Not included:

• arbitrary XML or dialect registration;
• a new public model-dialect API;
• malformed-call repair or retry;
• patch execution;
• cancellation/resource-safety work;
• prefix caching;
• model packaging or dependency pinning.

Validation

Exact pushed head a4ce726609dd7c3b7e601f3f6681fd44d56cb74b:

• canonical RelWithDebInfo build passed;
• 2,004 native tests passed;
• one qualified-package capability test skipped because it runs only when FOUNDRY_QUALIFIED_QWEN_MODEL_PATH explicitly selects the qualified external package;
• five pre-existing tests remain disabled;
• independent correctness, C++ safety, architecture/compatibility, and adversarial-coverage reviews completed, with the
  identified shared-schema compatibility blocker corrected and re-reviewed.

Feature qualification during development also covered direct Chat Completions and Responses, streaming and
non-streaming calls, one-call and two-call automatic tool use, reverse-arrival result association, raw apply_patch
coexistence, malformed fallback, concurrent mixed traffic, and a 128K-token call/result continuation.

[vercel]

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

Project	Deployment	Actions	Updated
foundry-local	Ready	Preview	Sep 17, 2026 6:52am 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.

[Copilot]

🟡 Changes recommended

Valid json_object requests and supported JSON Schema constructs currently regress.

Get a fresh assessment by requesting another Copilot review.

Review details

• Files reviewed: 29/29 changed files
• Comments generated: 3
• Review effort level: Balanced