melchizedek-agents 0.9.2 → 0.9.4

package/dist/lib/compile.js

@@ -0,0 +1,105 @@
+/**
+ * lib/compile.ts — the one YAML → ADK agent-graph compiler.
+ *
+ * WHY this file exists:
+ *   The A2A server carried this logic as two closures inside its executor,
+ *   and the observatory (observatory/, the eval harness) needs to run the
+ *   EXACT graph production runs — same subagent wiring, same tool
+ *   resolution, same generateContentConfig merge, same nested
+ *   `yaml_reference` handling. A second copy would have been a second place
+ *   for the two to drift, which is how toolRegistry.ts came to exist.
+ *   So the compiler moved here and both callers import it.
+ *
+ * What it does NOT own: model resolution and nested-config loading. Both are
+ * injected, because the two callers differ precisely there:
+ *   - the A2A server resolves `model` to a provider INSTANCE carrying the
+ *     caller's BYOK key (lib/models/registry.ts resolveModel);
+ *   - the observatory passes the model id through as a string (the
+ *     LLMRegistry routes it) and loads nested syndicates with its
+ *     per-variant overrides already applied.
+ *
+ * ── Two orchestration methods, one compiler ───────────────────────────────
+ * DELEGATE (no `dispatch:` block): every subagent becomes an AgentTool on
+ * the orchestrator. PLAN-DISPATCH (`dispatch:` present): the orchestrator
+ * is compiled WITHOUT subagent tools — it is a pure classifier — and the
+ * caller runs `compileSubagent(route)` directly for the chosen route. Both
+ * paths build subagents through the same function, so the agent a route
+ * dispatches to is identical to the one DELEGATE would have wrapped.
+ * Contract and rationale: lib/dispatch.ts.
+ */
+import { AgentTool, LlmAgent } from '@google/adk';
+import { isDispatchSyndicate } from "./dispatch.js";
+import { loadSyndicate } from "./loadSyndicate.js";
+import { resolveTools as resolveNamedTools } from "./toolRegistry.js";
+import { createMcpTools } from "./tools/mcpToolFactory.js";
+/** generateContentConfig as every entrypoint has always sent it to ADK. */
+function withServerSideToolInvocations(generateContentConfig) {
+    const cfg = (generateContentConfig ?? {});
+    return {
+        ...cfg,
+        toolConfig: {
+            ...(cfg.toolConfig ?? {}),
+            includeServerSideToolInvocations: true,
+        },
+    };
+}
+async function resolveAgentTools(toolNames, mcpServerUrl, opts) {
+    const tools = resolveNamedTools(toolNames, opts.onUnknownTool);
+    if (mcpServerUrl) {
+        opts.log?.(`Loading MCP tools: ${mcpServerUrl}`);
+        const mcpTools = await createMcpTools(mcpServerUrl);
+        for (const mcpTool of mcpTools) {
+            if (!tools.some((t) => t.name === mcpTool.name))
+                tools.push(mcpTool);
+        }
+    }
+    return tools;
+}
+/**
+ * Builds ONE runnable agent from a subagent entry. A `yaml_reference` entry
+ * compiles the nested syndicate's whole graph under this entry's name and
+ * description, so the parent sees one tool (or one route) either way.
+ */
+export async function compileSubagent(subCfg, opts = {}) {
+    if (subCfg.yaml_reference) {
+        opts.log?.(`Loading nested syndicate: ${subCfg.yaml_reference}`);
+        const nested = (opts.loadNested ?? loadSyndicate)(subCfg.yaml_reference);
+        return compileGraph(nested, opts, subCfg.name, subCfg.description);
+    }
+    const tools = await resolveAgentTools(subCfg.tools, subCfg.mcp_server_url, opts);
+    const resolveModel = opts.resolveModel ?? ((m) => m);
+    return new LlmAgent({
+        name: subCfg.name,
+        description: subCfg.description,
+        model: resolveModel(subCfg.model),
+        instruction: subCfg.instruction,
+        tools: tools.length > 0 ? tools : undefined,
+        outputSchema: subCfg.outputSchema,
+        generateContentConfig: withServerSideToolInvocations(subCfg.generateContentConfig),
+    });
+}
+/**
+ * Compiles a syndicate's orchestrator. In DELEGATE mode its subagents are
+ * attached as AgentTools; in PLAN-DISPATCH mode it gets none (ADK refuses
+ * outputSchema + AgentTool on one agent — see config/agents/critic.yaml),
+ * and the caller dispatches to `compileSubagent(route)` itself.
+ */
+export async function compileGraph(config, opts = {}, overrideName, overrideDescription) {
+    const compiledTools = isDispatchSyndicate(config)
+        ? []
+        : await Promise.all((config.subagents ?? []).map(async (subCfg) => new AgentTool({ agent: await compileSubagent(subCfg, opts) })));
+    // Orchestrator tools are registry names only — no entrypoint has ever
+    // attached an MCP server to an orchestrator, and this compiler preserves
+    // that exactly rather than widening the contract in passing.
+    compiledTools.push(...(await resolveAgentTools(config.orchestrator.tools, undefined, opts)));
+    const resolveModel = opts.resolveModel ?? ((m) => m);
+    return new LlmAgent({
+        name: overrideName || config.orchestrator.name,
+        description: overrideDescription || config.orchestrator.description,
+        model: resolveModel(config.orchestrator.model),
+        instruction: config.orchestrator.instruction,
+        tools: compiledTools.length > 0 ? compiledTools : undefined,
+        outputSchema: config.orchestrator.outputSchema,
+        generateContentConfig: withServerSideToolInvocations(config.orchestrator.generateContentConfig),
+    });
+}

package/dist/lib/models/claudeLlm.js

@@ -50,6 +50,8 @@ import { traceLlmGeneration, setLlmSpanAttribute, } from "../observability/trace
 import { wantsWebSearch, isWebSearchSentinel, } from "../tools/webSearchTool.js";
 import { toLowercaseJsonSchema } from "./schemaNormalize.js";
 /** Anthropic's minimum extended-thinking budget. */
+/** Name of the synthetic tool that carries an ADK outputSchema answer. */
+const STRUCTURED_OUTPUT_TOOL = 'structured_output';
 const MIN_THINKING_BUDGET = 1024;
 // ── Request building (exported for offline tests) ────────────────────────────
 /** ADK toolsDict → Anthropic tool definitions (lowercase schemas; the
@@ -100,7 +102,7 @@ export class ClaudeLlm extends BaseLlm {
      * llm.request OpenTelemetry span (provider/model/tokens/latency).
      */
     async *generateContentAsync(llmRequest, stream = false) {
-        yield* traceLlmGeneration({ provider: 'anthropic', model: this.model }, this.generateInner(llmRequest, stream));
+        yield* traceLlmGeneration({ provider: 'anthropic', model: this.model, llmRequest }, this.generateInner(llmRequest, stream));
     }
     async *generateInner(llmRequest, stream) {
         const apiKey = this.apiKey || process.env.ANTHROPIC_API_KEY;
@@ -199,12 +201,30 @@ export class ClaudeLlm extends BaseLlm {
             // Anthropic requires max_tokens to exceed the thinking budget.
             maxTokens = Math.max(maxTokens, budget + 2048);
         }
+        // ── Structured output (ADK outputSchema → forced tool use) ──────────────
+        // The Messages API has no response_format. Left to prose, Claude returns
+        // JSON whose KEYS drift from the schema ("grade" for "correctness"), which
+        // silently breaks any consumer that reads fields by name — the
+        // observatory's rubric judges first of all. A tool whose input_schema IS
+        // the output schema, with tool_choice forcing it, makes the API validate
+        // the shape; finalResponse() turns the tool_use block back into text.
+        // Forced tool_choice is incompatible with extended thinking, so with a
+        // thinking budget the tool is offered under 'auto' instead.
+        const structuredTool = cfg.responseSchema
+            ? {
+                name: STRUCTURED_OUTPUT_TOOL,
+                description: 'Return the final answer as a JSON object matching this schema. Call this exactly once.',
+                input_schema: toLowercaseJsonSchema(cfg.responseSchema),
+            }
+            : undefined;
+        const allTools = structuredTool ? [...anthropicTools, structuredTool] : anthropicTools;
         const requestBase = {
             model: this.model,
             max_tokens: maxTokens,
             system: systemParts.join('\n\n') || undefined,
             messages,
-            tools: anthropicTools.length > 0 ? anthropicTools : undefined,
+            tools: allTools.length > 0 ? allTools : undefined,
+            ...(structuredTool && !thinking ? { tool_choice: { type: 'tool', name: STRUCTURED_OUTPUT_TOOL } } : {}),
             ...(thinking ? { thinking } : {}),
         };
         // ── Call Anthropic API ────────────────────────────────────────────────────
@@ -234,9 +254,15 @@ export class ClaudeLlm extends BaseLlm {
                         }
                     }
                 }
-                // Final message: tool_use blocks, thinking stash, and token usage.
+                // Final message: full text, tool_use blocks, thinking stash, usage.
+                //
+                // WHY includeText is true even though the text was just streamed:
+                // ADK's runner persists only NON-partial events, so a final without
+                // text would render the reply on screen and lose it from session
+                // history — the next turn would have no record the model answered.
+                // Printers drop text on a turnComplete event they already streamed.
                 const final = await streamResponse.finalMessage();
-                yield this.finalResponse(final, /*includeText=*/ false);
+                yield this.finalResponse(final, /*includeText=*/ true);
             }
             else {
                 // Non-streaming path
@@ -271,6 +297,10 @@ export class ClaudeLlm extends BaseLlm {
             if (block.type === 'text' && includeText) {
                 parts.push({ text: block.text });
             }
+            else if (block.type === 'tool_use' && block.name === STRUCTURED_OUTPUT_TOOL) {
+                // The schema-validated answer, as the JSON text every consumer expects.
+                parts.push({ text: JSON.stringify(block.input ?? {}) });
+            }
             else if (block.type === 'tool_use') {
                 parts.push({
                     functionCall: { name: block.name, args: block.input, id: block.id },

package/dist/lib/models/gptLlm.js

@@ -48,7 +48,7 @@ import { wantsWebSearch, isWebSearchSentinel, xaiWebSearchParamsFromEnv, } from
 import { wantsXSearch, isXSearchSentinel, xSearchParamsFromEnv, } from "../tools/xSearchTool.js";
 import { wantsCollectionsSearch, isCollectionsSearchSentinel, collectionIdsFromEnv, collectionsMaxResultsFromEnv, } from "../tools/collectionsSearchTool.js";
 import { providerForModel } from "./providerMap.js";
-import { toLowercaseJsonSchema } from "./schemaNormalize.js";
+import { toLowercaseJsonSchema, toStrictJsonSchema } from "./schemaNormalize.js";
 /** Reasoning-capable ids: o-series and the gpt-5 family. The reasoning
  *  param is also dropped and retried once on a 400, so a miss here only
  *  costs one extra round trip. */
@@ -243,7 +243,7 @@ export class GptLlm extends BaseLlm {
     }
     // ── Generation ─────────────────────────────────────────────────────────────
     async *generateContentAsync(llmRequest, stream = false) {
-        yield* traceLlmGeneration({ provider: this.providerId(), model: this.model }, this.generateInner(llmRequest, stream));
+        yield* traceLlmGeneration({ provider: this.providerId(), model: this.model, llmRequest }, this.generateInner(llmRequest, stream));
     }
     async *generateInner(llmRequest, stream) {
         const apiKey = this.apiKey || this.apiKeyFromEnv();
@@ -303,7 +303,10 @@ export class GptLlm extends BaseLlm {
                         format: {
                             type: 'json_schema',
                             name: 'response',
-                            schema: toLowercaseJsonSchema(cfg.responseSchema),
+                            // Strict: the API enforces the exact property names, so a
+                            // judge rubric's fields arrive as declared, never renamed.
+                            strict: true,
+                            schema: toStrictJsonSchema(cfg.responseSchema),
                         },
                     },
                 }

package/dist/lib/models/ollamaLlm.d.ts

@@ -75,6 +75,8 @@
 import type { LlmRequest, LlmResponse } from '@google/adk';
 import { OpenAiCompatibleLlm } from './openAiCompatibleLlm.ts';
 export declare class OllamaLlm extends OpenAiCompatibleLlm {
+    /** Ollama's OpenAI-compatible endpoint takes json_object, not json_schema. */
+    protected supportsJsonSchemaFormat(): boolean;
     /**
      * Model ids namespaced "ollama/<model>" route here after registration,
      * e.g. model: "ollama/qwen3:8b" in a syndicate YAML.

package/dist/lib/models/ollamaLlm.js

@@ -77,6 +77,10 @@ import { OpenAiCompatibleLlm } from "./openAiCompatibleLlm.js";
 const DEFAULT_BASE_URL = 'http://localhost:11434/v1';
 // ── OllamaLlm ─────────────────────────────────────────────────────────────────
 export class OllamaLlm extends OpenAiCompatibleLlm {
+    /** Ollama's OpenAI-compatible endpoint takes json_object, not json_schema. */
+    supportsJsonSchemaFormat() {
+        return false;
+    }
     /**
      * Model ids namespaced "ollama/<model>" route here after registration,
      * e.g. model: "ollama/qwen3:8b" in a syndicate YAML.
@@ -105,7 +109,7 @@ export class OllamaLlm extends OpenAiCompatibleLlm {
     httpError(status, detail) {
         return {
             errorCode: 'OLLAMA_HTTP_ERROR',
-            errorMessage: `Ollama returned ${status}: ${detail.slice(0, 400)}. Is the model pulled? Try: ollama pull ${this.wireModelName()}`,
+            errorMessage: `Ollama returned ${status}: ${detail.slice(0, 4000)}. Is the model pulled? Try: ollama pull ${this.wireModelName()}`,
         };
     }
     unreachable(message) {

package/dist/lib/models/openAiCompatibleLlm.d.ts

@@ -66,6 +66,33 @@ export declare function splitThinkBlocks(text: string): {
     reasoning: string;
     answer: string;
 };
+/**
+ * Incremental counterpart to splitThinkBlocks, for the SSE path.
+ *
+ * WHY a state machine rather than the regex: on a stream the closing
+ * `</think>` has usually NOT arrived yet, so the regex matches nothing and
+ * the whole scratchpad would be printed as the reply. A tag can also be
+ * split mid-delta ("<thi" + "nk>"), so any tail that could still grow into
+ * a tag is held back instead of being emitted as answer text.
+ *
+ * Providers that report reasoning in a discrete field (Ollama's
+ * `delta.reasoning`, others' `reasoning_content`) never open a think block
+ * and pass straight through this untouched.
+ */
+export declare class ThinkStreamSplitter {
+    private inThink;
+    private held;
+    /** Routes one content delta into reasoning/answer text. */
+    push(chunk: string): {
+        reasoning: string;
+        answer: string;
+    };
+    /** Releases the held tail; the stream ended, so it was never a tag. */
+    flush(): {
+        reasoning: string;
+        answer: string;
+    };
+}
 export declare abstract class OpenAiCompatibleLlm extends BaseLlm {
     private webSearchWarned;
     /** Provider id for telemetry, e.g. 'ollama', 'xai'. */
@@ -77,6 +104,13 @@ export declare abstract class OpenAiCompatibleLlm extends BaseLlm {
     /** Model id as the wire expects it (e.g. strip the "ollama/" namespace). */
     protected wireModelName(): string;
     /** Provider-specific request body fields (merged last). */
+    /** Whether the endpoint accepts response_format json_schema (strict). */
+    protected supportsJsonSchemaFormat(): boolean;
+    /**
+     * Whether the endpoint honors stream_options.include_usage. Without it an
+     * SSE turn reports no token counts at all; Ollama and xAI both support it.
+     */
+    protected supportsStreamUsage(): boolean;
     protected extraBodyFields(_llmRequest: LlmRequest): Record<string, unknown>;
     /**
      * Body fields enabling the provider's NATIVE web search, or null when the
@@ -105,6 +139,21 @@ export declare abstract class OpenAiCompatibleLlm extends BaseLlm {
     protected unreachable(message: string): LlmResponse;
     generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void>;
     private generateInner;
+    /**
+     * SSE path: display-only partials as the tokens land, then ONE final
+     * non-partial response carrying the complete text, tool calls and usage.
+     *
+     * WHY the final repeats text already streamed: ADK's runner persists only
+     * non-partial events (`if (!event.partial) appendEvent(...)`), so a final
+     * without text would show the reply on screen and lose it from session
+     * history. Printers therefore skip text on a turnComplete event whose
+     * partials they already rendered — see scripts/syndicate_chat.ts.
+     *
+     * Thinking is deliberately NOT carried on the final: the scratchpad is
+     * display-only and stays out of history, which is what keeps it from
+     * being replayed to the model on the next turn.
+     */
+    private streamResponse;
     /** ADK Contents (Google GenAI format) → OpenAI-compatible chat messages. */
     protected buildMessages(llmRequest: LlmRequest): OpenAiMessage[];
     /** ADK toolsDict → OpenAI function-tool definitions (lowercase schemas). */

package/dist/lib/models/openAiCompatibleLlm.js

@@ -30,7 +30,7 @@
 import { BaseLlm } from '@google/adk';
 import { traceLlmGeneration, setLlmSpanAttribute, } from "../observability/tracer.js";
 import { wantsWebSearch, isWebSearchSentinel, } from "../tools/webSearchTool.js";
-import { toLowercaseJsonSchema } from "./schemaNormalize.js";
+import { toLowercaseJsonSchema, toStrictJsonSchema } from "./schemaNormalize.js";
 /** Splits "<think>…</think>" scratchpad from the reply. */
 export function splitThinkBlocks(text) {
     const blocks = [];
@@ -42,6 +42,101 @@ export function splitThinkBlocks(text) {
         .trimStart();
     return { reasoning: blocks.join('\n\n'), answer };
 }
+const OPEN_THINK = '<think>';
+const CLOSE_THINK = '</think>';
+/** Length of the longest suffix of `s` that is a proper prefix of `tag`. */
+function partialTagSuffix(s, tag) {
+    const max = Math.min(s.length, tag.length - 1);
+    for (let n = max; n > 0; n--) {
+        if (s.endsWith(tag.slice(0, n)))
+            return n;
+    }
+    return 0;
+}
+/**
+ * Incremental counterpart to splitThinkBlocks, for the SSE path.
+ *
+ * WHY a state machine rather than the regex: on a stream the closing
+ * `</think>` has usually NOT arrived yet, so the regex matches nothing and
+ * the whole scratchpad would be printed as the reply. A tag can also be
+ * split mid-delta ("<thi" + "nk>"), so any tail that could still grow into
+ * a tag is held back instead of being emitted as answer text.
+ *
+ * Providers that report reasoning in a discrete field (Ollama's
+ * `delta.reasoning`, others' `reasoning_content`) never open a think block
+ * and pass straight through this untouched.
+ */
+export class ThinkStreamSplitter {
+    inThink = false;
+    held = '';
+    /** Routes one content delta into reasoning/answer text. */
+    push(chunk) {
+        let buf = this.held + chunk;
+        let reasoning = '';
+        let answer = '';
+        for (;;) {
+            const tag = this.inThink ? CLOSE_THINK : OPEN_THINK;
+            const at = buf.indexOf(tag);
+            if (at === -1)
+                break;
+            if (this.inThink)
+                reasoning += buf.slice(0, at);
+            else
+                answer += buf.slice(0, at);
+            buf = buf.slice(at + tag.length);
+            this.inThink = !this.inThink;
+        }
+        // Hold back only what could still become the tag we're watching for.
+        const pending = this.inThink ? CLOSE_THINK : OPEN_THINK;
+        const keep = partialTagSuffix(buf, pending);
+        this.held = keep > 0 ? buf.slice(buf.length - keep) : '';
+        const emit = keep > 0 ? buf.slice(0, buf.length - keep) : buf;
+        if (this.inThink)
+            reasoning += emit;
+        else
+            answer += emit;
+        return { reasoning, answer };
+    }
+    /** Releases the held tail; the stream ended, so it was never a tag. */
+    flush() {
+        const rest = this.held;
+        this.held = '';
+        return this.inThink
+            ? { reasoning: rest, answer: '' }
+            : { reasoning: '', answer: rest };
+    }
+}
+/** Yields parsed `data:` payloads from an SSE response body. */
+async function* sseChunks(res) {
+    const reader = res.body?.getReader?.();
+    if (!reader)
+        return;
+    const decoder = new TextDecoder();
+    let buf = '';
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf('\n')) !== -1) {
+            const line = buf.slice(0, nl).trim();
+            buf = buf.slice(nl + 1);
+            // Blank separators and ":" keep-alive comments carry no payload.
+            if (!line.startsWith('data:'))
+                continue;
+            const payload = line.slice('data:'.length).trim();
+            if (payload === '[DONE]')
+                return;
+            try {
+                yield JSON.parse(payload);
+            }
+            catch {
+                /* a chunk that isn't valid JSON is not worth killing the turn for */
+            }
+        }
+    }
+}
 // ── OpenAiCompatibleLlm ──────────────────────────────────────────────────────
 export class OpenAiCompatibleLlm extends BaseLlm {
     webSearchWarned = false;
@@ -50,6 +145,17 @@ export class OpenAiCompatibleLlm extends BaseLlm {
         return this.model;
     }
     /** Provider-specific request body fields (merged last). */
+    /** Whether the endpoint accepts response_format json_schema (strict). */
+    supportsJsonSchemaFormat() {
+        return true;
+    }
+    /**
+     * Whether the endpoint honors stream_options.include_usage. Without it an
+     * SSE turn reports no token counts at all; Ollama and xAI both support it.
+     */
+    supportsStreamUsage() {
+        return true;
+    }
     extraBodyFields(_llmRequest) {
         return {};
     }
@@ -82,7 +188,7 @@ export class OpenAiCompatibleLlm extends BaseLlm {
     httpError(status, detail) {
         return {
             errorCode: `${this.providerId().toUpperCase()}_HTTP_ERROR`,
-            errorMessage: `${this.providerId()} returned ${status}: ${detail.slice(0, 400)}`,
+            errorMessage: `${this.providerId()} returned ${status}: ${detail.slice(0, 4000)}`,
         };
     }
     /** Error response when the endpoint can't be reached at all. */
@@ -94,9 +200,9 @@ export class OpenAiCompatibleLlm extends BaseLlm {
     }
     // ── Generation ─────────────────────────────────────────────────────────────
     async *generateContentAsync(llmRequest, stream = false) {
-        yield* traceLlmGeneration({ provider: this.providerId(), model: this.model }, this.generateInner(llmRequest, stream));
+        yield* traceLlmGeneration({ provider: this.providerId(), model: this.model, llmRequest }, this.generateInner(llmRequest, stream));
     }
-    async *generateInner(llmRequest, _stream) {
+    async *generateInner(llmRequest, stream) {
         const missing = this.missingRequirement();
         if (missing) {
             yield missing;
@@ -108,17 +214,34 @@ export class OpenAiCompatibleLlm extends BaseLlm {
         const body = {
             model: this.wireModelName(),
             messages,
-            stream: false,
+            stream,
+            // SSE reports token usage only if asked, in a final choices-less chunk.
+            ...(stream && this.supportsStreamUsage()
+                ? { stream_options: { include_usage: true } }
+                : {}),
             ...(cfg.temperature !== undefined ? { temperature: cfg.temperature } : {}),
             ...(cfg.topP !== undefined ? { top_p: cfg.topP } : {}),
             ...(cfg.maxOutputTokens !== undefined
                 ? { max_tokens: cfg.maxOutputTokens }
                 : {}),
-            ...(openAiTools.length > 0 ? { tools: openAiTools } : {}),
-            // critic-style structured output: responseMimeType JSON → json mode
-            ...(cfg.responseMimeType === 'application/json'
-                ? { response_format: { type: 'json_object' } }
+            // Reasoning budget. Qwen3-family models think before answering, and on
+            // a constraint-dense prompt they can spend the whole budget doing it
+            // and return an empty turn. Ollama's OpenAI-compatible endpoint honors
+            // `reasoning_effort` and IGNORES the native `think` field, so this is
+            // the only lever on this path. Opt-in per agent; omitted = unchanged.
+            ...(cfg.reasoningEffort !== undefined
+                ? { reasoning_effort: cfg.reasoningEffort }
                 : {}),
+            ...(openAiTools.length > 0 ? { tools: openAiTools } : {}),
+            // Structured output: an ADK outputSchema becomes a strict json_schema
+            // response_format where the endpoint supports it (xAI does; Ollama's
+            // OpenAI-compatible endpoint does not, see supportsJsonSchemaFormat),
+            // else plain JSON mode.
+            ...(cfg.responseSchema && this.supportsJsonSchemaFormat()
+                ? { response_format: { type: 'json_schema', json_schema: { name: 'response', strict: true, schema: toStrictJsonSchema(cfg.responseSchema) } } }
+                : cfg.responseMimeType === 'application/json' || cfg.responseSchema
+                    ? { response_format: { type: 'json_object' } }
+                    : {}),
             ...this.extraBodyFields(llmRequest),
         };
         // web_search: enable the provider's native search, or omit with a warning.
@@ -148,6 +271,10 @@ export class OpenAiCompatibleLlm extends BaseLlm {
                 yield this.httpError(res.status, detail);
                 return;
             }
+            if (stream) {
+                yield* this.streamResponse(res);
+                return;
+            }
             const data = await res.json();
             const message = data.choices?.[0]?.message ?? {};
             const usageMetadata = mapUsage(data.usage);
@@ -192,6 +319,103 @@ export class OpenAiCompatibleLlm extends BaseLlm {
             yield this.unreachable(msg);
         }
     }
+    /**
+     * SSE path: display-only partials as the tokens land, then ONE final
+     * non-partial response carrying the complete text, tool calls and usage.
+     *
+     * WHY the final repeats text already streamed: ADK's runner persists only
+     * non-partial events (`if (!event.partial) appendEvent(...)`), so a final
+     * without text would show the reply on screen and lose it from session
+     * history. Printers therefore skip text on a turnComplete event whose
+     * partials they already rendered — see scripts/syndicate_chat.ts.
+     *
+     * Thinking is deliberately NOT carried on the final: the scratchpad is
+     * display-only and stays out of history, which is what keeps it from
+     * being replayed to the model on the next turn.
+     */
+    async *streamResponse(res) {
+        const splitter = new ThinkStreamSplitter();
+        const toolCalls = new Map();
+        let answer = '';
+        let answerStarted = false;
+        let usage;
+        const partial = (text, thought) => ({
+            content: {
+                role: 'model',
+                parts: [thought ? { text, thought: true } : { text }],
+            },
+            partial: true,
+        });
+        // The scratchpad is usually trailed by blank lines; the reply must not
+        // open with them, but only the FIRST answer text may be trimmed.
+        const openAnswer = (text) => answerStarted ? text : text.trimStart();
+        for await (const chunk of sseChunks(res)) {
+            if (chunk.usage)
+                usage = chunk.usage;
+            const delta = chunk.choices?.[0]?.delta;
+            if (!delta)
+                continue;
+            // Reasoning as a discrete field (Ollama `reasoning`, others
+            // `reasoning_content`) — already separated, no tag parsing needed.
+            const fieldReasoning = delta.reasoning ?? delta.reasoning_content ?? '';
+            if (fieldReasoning)
+                yield partial(fieldReasoning, true);
+            if (typeof delta.content === 'string' && delta.content) {
+                const split = splitter.push(delta.content);
+                if (split.reasoning)
+                    yield partial(split.reasoning, true);
+                if (split.answer) {
+                    const text = openAnswer(split.answer);
+                    if (text) {
+                        answerStarted = true;
+                        answer += text;
+                        yield partial(text, false);
+                    }
+                }
+            }
+            // Tool arguments arrive as fragments keyed by index, not whole.
+            for (const call of delta.tool_calls ?? []) {
+                const index = call.index ?? 0;
+                const acc = toolCalls.get(index) ?? { args: '' };
+                if (call.id)
+                    acc.id = call.id;
+                if (call.function?.name)
+                    acc.name = call.function.name;
+                if (call.function?.arguments)
+                    acc.args += call.function.arguments;
+                toolCalls.set(index, acc);
+            }
+        }
+        const tail = splitter.flush();
+        if (tail.reasoning)
+            yield partial(tail.reasoning, true);
+        if (tail.answer) {
+            const text = openAnswer(tail.answer);
+            if (text) {
+                answer += text;
+                yield partial(text, false);
+            }
+        }
+        const parts = [];
+        if (answer)
+            parts.push({ text: answer });
+        for (const [, acc] of [...toolCalls.entries()].sort((a, b) => a[0] - b[0])) {
+            let args = {};
+            try {
+                args = JSON.parse(acc.args || '{}');
+            }
+            catch {
+                args = { raw: acc.args };
+            }
+            parts.push({ functionCall: { name: acc.name, args, id: acc.id } });
+        }
+        const usageMetadata = mapUsage(usage);
+        yield {
+            content: { role: 'model', parts },
+            turnComplete: true,
+            ...(usageMetadata ? { usageMetadata } : {}),
+        };
+    }
     // ── Translation helpers ────────────────────────────────────────────────────
     /** ADK Contents (Google GenAI format) → OpenAI-compatible chat messages. */
     buildMessages(llmRequest) {

package/dist/lib/models/registry.js

@@ -40,7 +40,7 @@ export class TracedGemini extends Gemini {
     // built-in Gemini entries instead of adding shadowed duplicates.
     static supportedModels = Gemini.supportedModels;
     async *generateContentAsync(llmRequest, stream) {
-        yield* traceLlmGeneration({ provider: 'gemini', model: this.model }, this.tagAndGenerate(llmRequest, stream));
+        yield* traceLlmGeneration({ provider: 'gemini', model: this.model, llmRequest }, this.tagAndGenerate(llmRequest, stream));
     }
     /** Tags the llm.request span (web_search = Gemini grounding), then
      *  delegates to ADK's Gemini. Runs inside the span context. */

package/dist/lib/models/schemaNormalize.d.ts

@@ -20,3 +20,12 @@
  * Never mutates the input — a Gemini agent may hold the same tool object.
  */
 export declare function toLowercaseJsonSchema(schema: unknown): Record<string, unknown>;
+/**
+ * The lowercase schema in the shape OpenAI-style "strict" structured output
+ * demands: every object node carries `additionalProperties: false` and lists
+ * ALL of its properties as required. Optional fields are expressed by the
+ * model emitting a null/empty value, not by omission — that is the strict
+ * contract, and it is what makes a judge's rubric fields arrive under the
+ * names the harness expects rather than improvised ones.
+ */
+export declare function toStrictJsonSchema(schema: unknown): Record<string, unknown>;