@framers/agentos 0.10.22 → 0.10.24

package/dist/core/llm/providers/model-forced-tool-choice.js

@@ -5,9 +5,10 @@
  * Anthropic structured output and `toolChoice: 'required'` both resolve to a
  * FORCED `tool_choice` on the Messages API (`{ type: 'tool', name }` or
  * `{ type: 'any' }`). Most Claude models accept this, and it is the most
- * reliable way to constrain output. Claude Fable 5 / 5.1 and Claude Opus 5.5
- * reject a forced `tool_choice` at the API level with a 400. Those models can
- * still call tools under `{ type: 'auto' }`; they only refuse to be forced.
+ * reliable way to constrain output. Claude Fable 5 / 5.1, Claude Mythos 5.1,
+ * Claude Opus 5.5 and Claude Sonnet 5.5 reject a forced `tool_choice` at the
+ * API level with a 400. Those models can still call tools under
+ * `{ type: 'auto' }`; they only refuse to be forced.
  *
  * Two consumers read this:
  *   - {@link AnthropicProvider} clamps any resolved forced `tool_choice` to
@@ -26,22 +27,28 @@
  * Whether Anthropic will accept a forced `tool_choice` (`{ type: 'tool' }` or
  * `{ type: 'any' }`) for the given Claude model id.
  *
- * Deny-by-explicit-model. Two families reject forced tool use, and every other
- * current Claude model (Sonnet, Opus 5 and earlier, Haiku) accepts it:
+ * Deny-by-explicit-model. These models reject forced tool use, and every
+ * other current Claude model (Sonnet 5 and earlier, Opus 5 and earlier,
+ * Haiku) accepts it:
  *
  *   - Claude Fable 5 and 5.1, including dated variants such as
  *     `claude-fable-5-20260601`. The `fable-5` alternative also matches
  *     `claude-fable-5-1` because `\b` matches at the hyphen, which is intended
  *     since 5.1 is the same family under the same constraint.
+ *   - Claude Mythos 5.1 (`claude-mythos-5-1`), per Anthropic's model docs.
  *   - Claude Opus 5.5 (`claude-opus-5-5`). Claude Opus 5 accepts forced tool
  *     use, so the pattern names the full `opus-5-5` id. A bare `opus-5` prefix
  *     would deny Opus 5 as well.
+ *   - Claude Sonnet 5.5 (`claude-sonnet-5-5`). Claude Sonnet 5 accepts forced
+ *     tool use, so the pattern names the full `sonnet-5-5` id for the same
+ *     reason.
  *
  * Live-probed 2026-09-29 on the Messages API. `{type:'tool'}` and
  * `{type:'any'}` both return HTTP 400 on `claude-opus-5-5` and
  * `claude-fable-5-1`, with the message `tool_choice: type "tool" and "any" are
  * not supported for this model.` The same two requests return 200 on
- * `claude-opus-5`.
+ * `claude-opus-5`. Both return HTTP 400 on `claude-sonnet-5-5` (probed
+ * 2026-09-30).
  *
  * `AnthropicProvider` clamps an unsupported forced choice to `{ type: 'auto' }`
  * and logs a warning. An extra entry here therefore costs guaranteed tool
@@ -55,6 +62,6 @@
  *   model, `true` otherwise.
  */
 export function modelSupportsForcedToolChoice(modelId) {
-    return !/^claude-(fable-5|opus-5-5)\b/i.test(modelId);
+    return !/^claude-(fable-5|mythos-5-1|opus-5-5|sonnet-5-5)\b/i.test(modelId);
 }
 //# sourceMappingURL=model-forced-tool-choice.js.map

package/dist/core/llm/providers/model-forced-tool-choice.js.map

@@ -1 +1 @@
-{"version":3,"file":"model-forced-tool-choice.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/model-forced-tool-choice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,6BAA6B,CAAC,OAAe;IAC3D,OAAO,CAAC,+BAA+B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACxD,CAAC"}
+{"version":3,"file":"model-forced-tool-choice.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/model-forced-tool-choice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,UAAU,6BAA6B,CAAC,OAAe;IAC3D,OAAO,CAAC,qDAAqD,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC9E,CAAC"}

package/dist/core/llm/providers/model-thinking.d.ts

@@ -2,20 +2,23 @@
  * @fileoverview Extended-thinking helpers for the Anthropic
  * reasoning-default Claude models.
  *
- * The Opus 4.7 / 4.8 family and Fable 5 reason by default and accept ONLY
- * the adaptive thinking form on the Messages API: `thinking: { type:
- * 'adaptive' }`. The older manual form `thinking: { type: 'enabled',
- * budget_tokens }` is removed on this family and returns a 400
- * ('"thinking.type.enabled" is not supported for this model'). Fable 5 adds
- * one more constraint — an explicit `thinking: { type: 'disabled' }` also
- * 400s — but the provider only ever emits the adaptive form (or nothing),
- * never `disabled`, so that path is never hit. Depth is
+ * Turning thinking on: the Opus 4.7 / 4.8 family, Opus 5.x, Sonnet 5.x and
+ * Fable 5.x take ONLY the adaptive form as the on-switch on the Messages API:
+ * `thinking: { type: 'adaptive' }`. The older manual form `thinking: { type:
+ * 'enabled', budget_tokens }` is removed on this family and returns a 400
+ * ('"thinking.type.enabled" is not supported for this model'). Depth is
  * controlled by `output_config.effort`, not a token budget, so the
  * caller-facing `{ budgetTokens }` option acts as the on-switch and the
  * number itself is not sent. {@link AnthropicProvider} sends the block
  * through {@link resolveThinkingPayload} when a caller passes a thinking
  * budget AND the model supports it.
  *
+ * Turning thinking off (`thinking: false`): leaving the field out keeps the
+ * model's default, which is thinking ON for Opus 5, Sonnet 5 and Sonnet 5.5,
+ * and always on for Opus 5.5, Fable and Mythos. The models that can turn it
+ * off each take their own shape, and some only at a capped effort;
+ * {@link resolveThinkingOff} maps a model id to it.
+ *
  * This is the thinking-capability sibling of `modelSupportsTemperature`
  * in AnthropicProvider.ts — the same reasoning-default family that
  * REJECTS `temperature` is the family that ACCEPTS `thinking`. Kept in
@@ -27,10 +30,13 @@
  * `thinking` parameter.
  *
  * Allow-by-explicit-family: only the reasoning-default Opus 4.7 / 4.8
- * line, Sonnet 5, and Fable 5 (and their dated variants like
+ * line, Opus 5, Sonnet 5, and Fable 5 (and their dated variants like
  * `claude-opus-4-8-20260501`) accept it; every other Claude model ignores
- * or rejects it. Future reasoning-first siblings get added to the regex as
- * Anthropic releases them, in lockstep with `modelSupportsTemperature`.
+ * or rejects it. Opus 5.5, Sonnet 5.5 and Fable 5.1 match the `opus-5`,
+ * `sonnet-5` and `fable-5` alternatives on purpose, because `\b` matches at
+ * the hyphen before their trailing version digit. Future reasoning-first
+ * siblings get added to the regex as Anthropic releases them, in lockstep
+ * with `modelSupportsTemperature`.
  *
  * @param modelId Anthropic-side model id.
  * @returns `true` when Anthropic accepts a `thinking` block for this model.
@@ -58,10 +64,55 @@ export interface ResolvedThinkingPayload {
  * max_tokens change).
  *
  * @param modelId Anthropic-side model id.
- * @param thinking Caller-supplied `{ budgetTokens }`, or `undefined`.
+ * @param thinking Caller-supplied `{ budgetTokens }`; `false` (thinking
+ *   off, see {@link resolveThinkingOff}) and `undefined` return `null`.
  * @param requestedMaxTokens The max_tokens already resolved for the request.
  */
 export declare function resolveThinkingPayload(modelId: string, thinking: {
     budgetTokens: number;
-} | undefined, requestedMaxTokens: number | undefined): ResolvedThinkingPayload | null;
+} | false | undefined, requestedMaxTokens: number | undefined): ResolvedThinkingPayload | null;
+/**
+ * How one model takes a request to turn thinking off.
+ *
+ * - `omit`: the model does not think unless asked, so leaving `thinking` out
+ *   is off.
+ * - `send`: the model thinks by default and turns it off only for this
+ *   `thinking` value. `maxEffort` is the highest `output_config.effort` the
+ *   value is accepted with; absent means any effort.
+ * - `always_on`: the model always thinks and rejects every off shape.
+ */
+export type ThinkingOffShape = {
+    kind: 'omit';
+} | {
+    kind: 'send';
+    thinking: {
+        type: 'disabled';
+    } | {
+        type: 'between_tools';
+    };
+    maxEffort?: 'high';
+} | {
+    kind: 'always_on';
+};
+/**
+ * The request shape that turns thinking off on a Claude model, for a caller
+ * passing `thinking: false`.
+ *
+ * | Model | Off shape | Source |
+ * | --- | --- | --- |
+ * | Sonnet 5.5 | `{ type: 'between_tools' }` at effort high or below | probed 2026-09-30: `disabled` returns 400, `between_tools` 200 |
+ * | Opus 5 | `{ type: 'disabled' }` at effort high or below | probed 2026-09-30: `disabled` 200, `between_tools` 400 |
+ * | Sonnet 5 | `{ type: 'disabled' }` | Anthropic's model docs |
+ * | Opus 5.5, Fable 5.x, Mythos 5.x | none: always on | probed 2026-09-30 on Opus 5.5 and Fable 5.1: both shapes return 400 |
+ * | everything else | omit the field | thinks only when asked |
+ *
+ * The 5.5 checks run first because `opus-5\b` and `sonnet-5\b` also match
+ * the 5.5 ids. An unknown id gets `omit`, which never sends a shape that
+ * could return 400. Anchored like {@link modelSupportsThinking}, so the id
+ * is the bare Anthropic-side one.
+ *
+ * @param modelId Anthropic-side model id, bare or dated.
+ * @returns The off shape for the model.
+ */
+export declare function resolveThinkingOff(modelId: string): ThinkingOffShape;
 //# sourceMappingURL=model-thinking.d.ts.map

package/dist/core/llm/providers/model-thinking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-thinking.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/providers/model-thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EAC9C,kBAAkB,EAAE,MAAM,GAAG,SAAS,GACrC,uBAAuB,GAAG,IAAI,CAGhC"}
+{"version":3,"file":"model-thinking.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/providers/model-thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,0EAA0E;AAC1E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,GAAG,SAAS,EACtD,kBAAkB,EAAE,MAAM,GAAG,SAAS,GACrC,uBAAuB,GAAG,IAAI,CAGhC;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,eAAe,CAAA;KAAE,CAAC;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACD;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAUpE"}

package/dist/core/llm/providers/model-thinking.js

@@ -2,20 +2,23 @@
  * @fileoverview Extended-thinking helpers for the Anthropic
  * reasoning-default Claude models.
  *
- * The Opus 4.7 / 4.8 family and Fable 5 reason by default and accept ONLY
- * the adaptive thinking form on the Messages API: `thinking: { type:
- * 'adaptive' }`. The older manual form `thinking: { type: 'enabled',
- * budget_tokens }` is removed on this family and returns a 400
- * ('"thinking.type.enabled" is not supported for this model'). Fable 5 adds
- * one more constraint — an explicit `thinking: { type: 'disabled' }` also
- * 400s — but the provider only ever emits the adaptive form (or nothing),
- * never `disabled`, so that path is never hit. Depth is
+ * Turning thinking on: the Opus 4.7 / 4.8 family, Opus 5.x, Sonnet 5.x and
+ * Fable 5.x take ONLY the adaptive form as the on-switch on the Messages API:
+ * `thinking: { type: 'adaptive' }`. The older manual form `thinking: { type:
+ * 'enabled', budget_tokens }` is removed on this family and returns a 400
+ * ('"thinking.type.enabled" is not supported for this model'). Depth is
  * controlled by `output_config.effort`, not a token budget, so the
  * caller-facing `{ budgetTokens }` option acts as the on-switch and the
  * number itself is not sent. {@link AnthropicProvider} sends the block
  * through {@link resolveThinkingPayload} when a caller passes a thinking
  * budget AND the model supports it.
  *
+ * Turning thinking off (`thinking: false`): leaving the field out keeps the
+ * model's default, which is thinking ON for Opus 5, Sonnet 5 and Sonnet 5.5,
+ * and always on for Opus 5.5, Fable and Mythos. The models that can turn it
+ * off each take their own shape, and some only at a capped effort;
+ * {@link resolveThinkingOff} maps a model id to it.
+ *
  * This is the thinking-capability sibling of `modelSupportsTemperature`
  * in AnthropicProvider.ts — the same reasoning-default family that
  * REJECTS `temperature` is the family that ACCEPTS `thinking`. Kept in
@@ -27,10 +30,13 @@
  * `thinking` parameter.
  *
  * Allow-by-explicit-family: only the reasoning-default Opus 4.7 / 4.8
- * line, Sonnet 5, and Fable 5 (and their dated variants like
+ * line, Opus 5, Sonnet 5, and Fable 5 (and their dated variants like
  * `claude-opus-4-8-20260501`) accept it; every other Claude model ignores
- * or rejects it. Future reasoning-first siblings get added to the regex as
- * Anthropic releases them, in lockstep with `modelSupportsTemperature`.
+ * or rejects it. Opus 5.5, Sonnet 5.5 and Fable 5.1 match the `opus-5`,
+ * `sonnet-5` and `fable-5` alternatives on purpose, because `\b` matches at
+ * the hyphen before their trailing version digit. Future reasoning-first
+ * siblings get added to the regex as Anthropic releases them, in lockstep
+ * with `modelSupportsTemperature`.
  *
  * @param modelId Anthropic-side model id.
  * @returns `true` when Anthropic accepts a `thinking` block for this model.
@@ -53,7 +59,8 @@ export function modelSupportsThinking(modelId) {
  * max_tokens change).
  *
  * @param modelId Anthropic-side model id.
- * @param thinking Caller-supplied `{ budgetTokens }`, or `undefined`.
+ * @param thinking Caller-supplied `{ budgetTokens }`; `false` (thinking
+ *   off, see {@link resolveThinkingOff}) and `undefined` return `null`.
  * @param requestedMaxTokens The max_tokens already resolved for the request.
  */
 export function resolveThinkingPayload(modelId, thinking, requestedMaxTokens) {
@@ -61,4 +68,37 @@ export function resolveThinkingPayload(modelId, thinking, requestedMaxTokens) {
         return null;
     return { thinking: { type: 'adaptive' }, maxTokens: requestedMaxTokens ?? 0 };
 }
+/**
+ * The request shape that turns thinking off on a Claude model, for a caller
+ * passing `thinking: false`.
+ *
+ * | Model | Off shape | Source |
+ * | --- | --- | --- |
+ * | Sonnet 5.5 | `{ type: 'between_tools' }` at effort high or below | probed 2026-09-30: `disabled` returns 400, `between_tools` 200 |
+ * | Opus 5 | `{ type: 'disabled' }` at effort high or below | probed 2026-09-30: `disabled` 200, `between_tools` 400 |
+ * | Sonnet 5 | `{ type: 'disabled' }` | Anthropic's model docs |
+ * | Opus 5.5, Fable 5.x, Mythos 5.x | none: always on | probed 2026-09-30 on Opus 5.5 and Fable 5.1: both shapes return 400 |
+ * | everything else | omit the field | thinks only when asked |
+ *
+ * The 5.5 checks run first because `opus-5\b` and `sonnet-5\b` also match
+ * the 5.5 ids. An unknown id gets `omit`, which never sends a shape that
+ * could return 400. Anchored like {@link modelSupportsThinking}, so the id
+ * is the bare Anthropic-side one.
+ *
+ * @param modelId Anthropic-side model id, bare or dated.
+ * @returns The off shape for the model.
+ */
+export function resolveThinkingOff(modelId) {
+    if (/^claude-sonnet-5-5\b/i.test(modelId)) {
+        return { kind: 'send', thinking: { type: 'between_tools' }, maxEffort: 'high' };
+    }
+    if (/^claude-(opus-5-5|fable-5|mythos-5)\b/i.test(modelId))
+        return { kind: 'always_on' };
+    if (/^claude-opus-5\b/i.test(modelId)) {
+        return { kind: 'send', thinking: { type: 'disabled' }, maxEffort: 'high' };
+    }
+    if (/^claude-sonnet-5\b/i.test(modelId))
+        return { kind: 'send', thinking: { type: 'disabled' } };
+    return { kind: 'omit' };
+}
 //# sourceMappingURL=model-thinking.js.map

package/dist/core/llm/providers/model-thinking.js.map

@@ -1 +1 @@
-{"version":3,"file":"model-thinking.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/model-thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAe;IACnD,OAAO,mDAAmD,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3E,CAAC;AAQD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,sBAAsB,CACpC,OAAe,EACf,QAA8C,EAC9C,kBAAsC;IAEtC,IAAI,CAAC,QAAQ,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9D,OAAO,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,kBAAkB,IAAI,CAAC,EAAE,CAAC;AAChF,CAAC"}
+{"version":3,"file":"model-thinking.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/model-thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAe;IACnD,OAAO,mDAAmD,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3E,CAAC;AAQD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,sBAAsB,CACpC,OAAe,EACf,QAAsD,EACtD,kBAAsC;IAEtC,IAAI,CAAC,QAAQ,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9D,OAAO,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,kBAAkB,IAAI,CAAC,EAAE,CAAC;AAChF,CAAC;AAqBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,IAAI,uBAAuB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAClF,CAAC;IACD,IAAI,wCAAwC,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IACzF,IAAI,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACtC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7E,CAAC;IACD,IAAI,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,CAAC;IACjG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAC1B,CAAC"}

package/dist/core/llm/providers/openrouter-only-params.d.ts

@@ -11,9 +11,13 @@
  * into the native Gemini body).
  *
  * Native providers strip these keys at their payload boundary; the
- * OpenRouterProvider keeps spreading everything. Vendor-specific extras a
- * caller legitimately aims at a native vendor (e.g. Anthropic `metadata`)
- * pass through untouched.
+ * OpenRouterProvider keeps them. Gemini's request fields (`thinkingConfig`,
+ * `topK`, `safetySettings`, ...) are the mirror case: GeminiProvider consumes
+ * them, and every other provider strips them, so a Gemini call that fails
+ * over does not hand them to OpenAI or Anthropic, which reject unknown
+ * top-level fields with HTTP 400. Vendor-specific extras a caller
+ * legitimately aims at a native vendor (e.g. Anthropic `metadata`) pass
+ * through untouched.
  */
 /**
  * OpenRouter request-body routing controls, per its API reference:
@@ -22,10 +26,25 @@
  */
 export declare const OPENROUTER_ONLY_PARAM_KEYS: readonly ["provider", "models", "route", "transforms"];
 /**
- * A copy of `params` without the OpenRouter-only routing controls.
- * `undefined` in, or nothing surviving the strip, yields `undefined` so
- * callers can keep their existing `if (params)` / spread guards. Never
- * mutates the input — fallback legs reuse the same object.
+ * Gemini generateContent request fields, in the camelCase names GeminiProvider
+ * accepts through `customModelParams` (it moves `thinkingConfig` and `topK`
+ * into `generationConfig`). No other vendor's API defines them.
+ */
+export declare const GEMINI_ONLY_PARAM_KEYS: readonly ["thinkingConfig", "topK", "safetySettings", "toolConfig", "cachedContent", "generationConfig", "systemInstruction", "responseMimeType", "responseSchema", "responseModalities", "speechConfig", "mediaResolution"];
+/**
+ * A copy of `params` without the OpenRouter-only routing controls, for
+ * GeminiProvider (which handles its own Gemini fields).
  */
 export declare function stripOpenRouterOnlyParams(params: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+/**
+ * A copy of `params` without Gemini's request fields, for OpenRouterProvider
+ * (which keeps its own routing controls).
+ */
+export declare function stripGeminiOnlyParams(params: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+/**
+ * A copy of `params` without OpenRouter's routing controls and Gemini's
+ * request fields, for native providers other than Gemini (OpenAI, Anthropic,
+ * Ollama).
+ */
+export declare function stripForeignVendorParams(params: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
 //# sourceMappingURL=openrouter-only-params.d.ts.map

package/dist/core/llm/providers/openrouter-only-params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openrouter-only-params.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/providers/openrouter-only-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,wDAK7B,CAAC;AAEX;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAQrC"}
+{"version":3,"file":"openrouter-only-params.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/providers/openrouter-only-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,wDAK7B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,8NAazB,CAAC;AA0BX;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAErC;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAErC;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAErC"}

package/dist/core/llm/providers/openrouter-only-params.js

@@ -11,9 +11,13 @@
  * into the native Gemini body).
  *
  * Native providers strip these keys at their payload boundary; the
- * OpenRouterProvider keeps spreading everything. Vendor-specific extras a
- * caller legitimately aims at a native vendor (e.g. Anthropic `metadata`)
- * pass through untouched.
+ * OpenRouterProvider keeps them. Gemini's request fields (`thinkingConfig`,
+ * `topK`, `safetySettings`, ...) are the mirror case: GeminiProvider consumes
+ * them, and every other provider strips them, so a Gemini call that fails
+ * over does not hand them to OpenAI or Anthropic, which reject unknown
+ * top-level fields with HTTP 400. Vendor-specific extras a caller
+ * legitimately aims at a native vendor (e.g. Anthropic `metadata`) pass
+ * through untouched.
  */
 /**
  * OpenRouter request-body routing controls, per its API reference:
@@ -27,20 +31,65 @@ export const OPENROUTER_ONLY_PARAM_KEYS = [
     'transforms',
 ];
 /**
- * A copy of `params` without the OpenRouter-only routing controls.
- * `undefined` in, or nothing surviving the strip, yields `undefined` so
- * callers can keep their existing `if (params)` / spread guards. Never
- * mutates the input — fallback legs reuse the same object.
+ * Gemini generateContent request fields, in the camelCase names GeminiProvider
+ * accepts through `customModelParams` (it moves `thinkingConfig` and `topK`
+ * into `generationConfig`). No other vendor's API defines them.
  */
-export function stripOpenRouterOnlyParams(params) {
+export const GEMINI_ONLY_PARAM_KEYS = [
+    'thinkingConfig',
+    'topK',
+    'safetySettings',
+    'toolConfig',
+    'cachedContent',
+    'generationConfig',
+    'systemInstruction',
+    'responseMimeType',
+    'responseSchema',
+    'responseModalities',
+    'speechConfig',
+    'mediaResolution',
+];
+/** Keys no native provider other than their own vendor accepts. */
+const FOREIGN_VENDOR_PARAM_KEYS = [
+    ...OPENROUTER_ONLY_PARAM_KEYS,
+    ...GEMINI_ONLY_PARAM_KEYS,
+];
+/**
+ * A copy of `params` without `keys`. `undefined` in, or nothing surviving the
+ * strip, yields `undefined` so callers can keep their existing `if (params)` /
+ * spread guards. Never mutates the input — fallback legs reuse the same object.
+ */
+function withoutKeys(params, keys) {
     if (!params)
         return undefined;
     let stripped;
     for (const key of Object.keys(params)) {
-        if (OPENROUTER_ONLY_PARAM_KEYS.includes(key))
+        if (keys.includes(key))
             continue;
         (stripped ?? (stripped = {}))[key] = params[key];
     }
     return stripped;
 }
+/**
+ * A copy of `params` without the OpenRouter-only routing controls, for
+ * GeminiProvider (which handles its own Gemini fields).
+ */
+export function stripOpenRouterOnlyParams(params) {
+    return withoutKeys(params, OPENROUTER_ONLY_PARAM_KEYS);
+}
+/**
+ * A copy of `params` without Gemini's request fields, for OpenRouterProvider
+ * (which keeps its own routing controls).
+ */
+export function stripGeminiOnlyParams(params) {
+    return withoutKeys(params, GEMINI_ONLY_PARAM_KEYS);
+}
+/**
+ * A copy of `params` without OpenRouter's routing controls and Gemini's
+ * request fields, for native providers other than Gemini (OpenAI, Anthropic,
+ * Ollama).
+ */
+export function stripForeignVendorParams(params) {
+    return withoutKeys(params, FOREIGN_VENDOR_PARAM_KEYS);
+}
 //# sourceMappingURL=openrouter-only-params.js.map

package/dist/core/llm/providers/openrouter-only-params.js.map

@@ -1 +1 @@
-{"version":3,"file":"openrouter-only-params.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/openrouter-only-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,UAAU;IACV,QAAQ;IACR,OAAO;IACP,YAAY;CACJ,CAAC;AAEX;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAA2C;IAE3C,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9B,IAAI,QAA6C,CAAC;IAClD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,IAAK,0BAAgD,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,SAAS;QAC9E,CAAC,QAAQ,KAAR,QAAQ,GAAK,EAAE,EAAC,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}
+{"version":3,"file":"openrouter-only-params.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/openrouter-only-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,UAAU;IACV,QAAQ;IACR,OAAO;IACP,YAAY;CACJ,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,gBAAgB;IAChB,MAAM;IACN,gBAAgB;IAChB,YAAY;IACZ,eAAe;IACf,kBAAkB;IAClB,mBAAmB;IACnB,kBAAkB;IAClB,gBAAgB;IAChB,oBAAoB;IACpB,cAAc;IACd,iBAAiB;CACT,CAAC;AAEX,mEAAmE;AACnE,MAAM,yBAAyB,GAAsB;IACnD,GAAG,0BAA0B;IAC7B,GAAG,sBAAsB;CAC1B,CAAC;AAEF;;;;GAIG;AACH,SAAS,WAAW,CAClB,MAA2C,EAC3C,IAAuB;IAEvB,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9B,IAAI,QAA6C,CAAC;IAClD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,SAAS;QACjC,CAAC,QAAQ,KAAR,QAAQ,GAAK,EAAE,EAAC,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAA2C;IAE3C,OAAO,WAAW,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,MAA2C;IAE3C,OAAO,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AACrD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAA2C;IAE3C,OAAO,WAAW,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;AACxD,CAAC"}

package/dist/core/llm/providers/url-secrets.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @module core/llm/providers/url-secrets
+ *
+ * Masks the secrets a provider request carries out of error text. fetch
+ * (undici) names secrets in three rejection messages:
+ *
+ * - `Failed to parse URL from <url>` for a base URL it cannot parse,
+ * - `Request cannot be constructed from a URL that includes credentials: <url>`
+ *   for a base URL with `user:password@`,
+ * - `Headers.append: "<value>" is an invalid header value.` for a header
+ *   value it rejects, which quotes an API key sent in a header.
+ *
+ * Providers and `embedText` pass every such message through
+ * {@link redactUrlSecrets} before it reaches an error, a log line or a span.
+ * This module has no imports, so any layer can use it without a cycle.
+ */
+/**
+ * The credentials part of a base URL, read from the raw string: the text
+ * between the authority start (after a leading `scheme://` or `//`, else the
+ * start of a scheme-less URL) and the last `@`. The last `@` is used because
+ * an email-style username carries its own `@`, and the raw string because a
+ * URL that fails to parse (for example with a `/` in the password) still
+ * appears verbatim in fetch's error.
+ *
+ * @param baseUrl Configured base URL.
+ * @returns The credentials substring, or undefined when there is none.
+ */
+export declare function baseUrlCredentials(baseUrl: string | undefined): string | undefined;
+/**
+ * Masks the secrets a request carries out of a message: any credentials in
+ * the base URL and each known secret (API keys, whether they travel in the
+ * URL or in a header). The known values are replaced literally, since a
+ * pattern cannot tell where arbitrary credentials end.
+ *
+ * @param message Text that may contain the request URL or a header value.
+ * @param baseUrl Configured base URL.
+ * @param knownSecrets Other secrets the request carried, such as API keys.
+ *   Empty and undefined entries are ignored.
+ * @returns The message with those secrets replaced by `[redacted]`.
+ */
+export declare function redactUrlSecrets(message: string, baseUrl: string | undefined, knownSecrets?: ReadonlyArray<string | undefined>): string;
+//# sourceMappingURL=url-secrets.d.ts.map

package/dist/core/llm/providers/url-secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-secrets.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/providers/url-secrets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAQlF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,YAAY,GAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAM,GACnD,MAAM,CAYR"}

package/dist/core/llm/providers/url-secrets.js

@@ -0,0 +1,64 @@
+/**
+ * @module core/llm/providers/url-secrets
+ *
+ * Masks the secrets a provider request carries out of error text. fetch
+ * (undici) names secrets in three rejection messages:
+ *
+ * - `Failed to parse URL from <url>` for a base URL it cannot parse,
+ * - `Request cannot be constructed from a URL that includes credentials: <url>`
+ *   for a base URL with `user:password@`,
+ * - `Headers.append: "<value>" is an invalid header value.` for a header
+ *   value it rejects, which quotes an API key sent in a header.
+ *
+ * Providers and `embedText` pass every such message through
+ * {@link redactUrlSecrets} before it reaches an error, a log line or a span.
+ * This module has no imports, so any layer can use it without a cycle.
+ */
+/**
+ * The credentials part of a base URL, read from the raw string: the text
+ * between the authority start (after a leading `scheme://` or `//`, else the
+ * start of a scheme-less URL) and the last `@`. The last `@` is used because
+ * an email-style username carries its own `@`, and the raw string because a
+ * URL that fails to parse (for example with a `/` in the password) still
+ * appears verbatim in fetch's error.
+ *
+ * @param baseUrl Configured base URL.
+ * @returns The credentials substring, or undefined when there is none.
+ */
+export function baseUrlCredentials(baseUrl) {
+    if (!baseUrl)
+        return undefined;
+    // Only a leading scheme or `//` opens the authority; a `//` later in the
+    // path must not move the start past the credentials.
+    const scheme = /^[a-z][a-z\d+.-]*:\/\//i.exec(baseUrl);
+    const start = scheme ? scheme[0].length : baseUrl.startsWith('//') ? 2 : 0;
+    const at = baseUrl.lastIndexOf('@');
+    return at > start ? baseUrl.slice(start, at) : undefined;
+}
+/**
+ * Masks the secrets a request carries out of a message: any credentials in
+ * the base URL and each known secret (API keys, whether they travel in the
+ * URL or in a header). The known values are replaced literally, since a
+ * pattern cannot tell where arbitrary credentials end.
+ *
+ * @param message Text that may contain the request URL or a header value.
+ * @param baseUrl Configured base URL.
+ * @param knownSecrets Other secrets the request carried, such as API keys.
+ *   Empty and undefined entries are ignored.
+ * @returns The message with those secrets replaced by `[redacted]`.
+ */
+export function redactUrlSecrets(message, baseUrl, knownSecrets = []) {
+    // Longest first, so a key that also appears inside the credentials cannot
+    // split them before the whole credentials string is replaced.
+    const secrets = [baseUrlCredentials(baseUrl), ...knownSecrets]
+        .filter((secret) => Boolean(secret))
+        .sort((a, b) => b.length - a.length);
+    let out = message;
+    for (const secret of secrets)
+        out = out.split(secret).join('[redacted]');
+    // Backstops for any other key= value or //user:password@ credentials.
+    return out
+        .replace(/([?&]key=)[^&\s"')]+/g, '$1[redacted]')
+        .replace(/(\/\/)[^/\s@"')]+@/g, '$1[redacted]@');
+}
+//# sourceMappingURL=url-secrets.js.map

package/dist/core/llm/providers/url-secrets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-secrets.js","sourceRoot":"","sources":["../../../../src/core/llm/providers/url-secrets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAA2B;IAC5D,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAC/B,yEAAyE;IACzE,qDAAqD;IACrD,MAAM,MAAM,GAAG,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACpC,OAAO,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAe,EACf,OAA2B,EAC3B,eAAkD,EAAE;IAEpD,0EAA0E;IAC1E,8DAA8D;IAC9D,MAAM,OAAO,GAAG,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,GAAG,YAAY,CAAC;SAC3D,MAAM,CAAC,CAAC,MAAM,EAAoB,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;SACrD,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,GAAG,GAAG,OAAO,CAAC;IAClB,KAAK,MAAM,MAAM,IAAI,OAAO;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACzE,sEAAsE;IACtE,OAAO,GAAG;SACP,OAAO,CAAC,uBAAuB,EAAE,cAAc,CAAC;SAChD,OAAO,CAAC,qBAAqB,EAAE,eAAe,CAAC,CAAC;AACrD,CAAC"}

package/dist/core/llm/streaming/StreamingBatcher.d.ts

@@ -2,14 +2,15 @@
  * @fileoverview Backpressure batching wrapper for provider streaming chunks (`ModelCompletionResponse`).
  * Combines small, high-frequency deltas into larger aggregated chunks to reduce downstream
  * dispatch overhead (websocket emissions, DOM updates, etc.) while preserving core invariants:
- *   - Text remains append-only (merged into a single `responseTextDelta` per batch).
+ *   - Text remains append-only (merged into a single `responseTextDelta` per batch), and so does
+ *     reasoning-summary text (`reasoningTextDelta`), kept apart from it.
  *   - Tool/function argument deltas merged per (choiceIndex, toolCallId) into single consolidated delta.
  *   - Exactly one terminal chunk with `isFinal: true` (forwarded from original final chunk).
  *   - Usage & error surfaced only when FINAL chunk encountered (or if intermediate provider error semantics change).
  *
  * Flush Triggers (any):
  *   1. Latency: maxLatencyMs elapsed since first unflushed chunk arrival.
- *   2. Size: accumulated text delta length >= maxTextDeltaChars.
+ *   2. Size: accumulated text and reasoning delta length >= maxTextDeltaChars.
  *   3. Chunk Count: buffer size >= maxChunksPerBatch.
  *   4. Explicit final provider chunk.
  *   5. Manual tool argument size threshold (maxToolArgumentChars) exceeded.
@@ -28,7 +29,7 @@ import { ModelCompletionResponse } from '../providers/IProvider';
 export interface StreamingBatcherOptions {
     /** Max wall-clock latency before forcing a flush (milliseconds). */
     maxLatencyMs?: number;
-    /** Max accumulated text delta characters before flush. */
+    /** Max accumulated text delta characters (answer and reasoning text together) before flush. */
     maxTextDeltaChars?: number;
     /** Max accumulated tool argument characters (combined per tool call) before flush. */
     maxToolArgumentChars?: number;

package/dist/core/llm/streaming/StreamingBatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StreamingBatcher.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/streaming/StreamingBatcher.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,kDAAkD;AAClD,MAAM,WAAW,uBAAuB;IACtC,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sFAAsF;IACtF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gEAAgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAuGD;;;;;GAKG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC,EAChE,OAAO,GAAE,uBAA4B,GACpC,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC,CA0E1D;AAED,sFAAsF;AACtF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,IAAI,CAAoC;gBACpC,OAAO,GAAE,uBAA4B;IAGjD,KAAK,CAAC,MAAM,EAAE,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC;CAGvE;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"StreamingBatcher.d.ts","sourceRoot":"","sources":["../../../../src/core/llm/streaming/StreamingBatcher.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,kDAAkD;AAClD,MAAM,WAAW,uBAAuB;IACtC,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sFAAsF;IACtF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gEAAgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AA2GD;;;;;GAKG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC,EAChE,OAAO,GAAE,uBAA4B,GACpC,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC,CA2E1D;AAED,sFAAsF;AACtF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,IAAI,CAAoC;gBACpC,OAAO,GAAE,uBAA4B;IAGjD,KAAK,CAAC,MAAM,EAAE,cAAc,CAAC,uBAAuB,EAAE,IAAI,EAAE,SAAS,CAAC;CAGvE;AAED,eAAe,gBAAgB,CAAC"}

package/dist/core/llm/streaming/StreamingBatcher.js

@@ -10,6 +10,8 @@ function accumulate(state, chunk) {
     state.chunks.push(chunk);
     if (chunk.responseTextDelta)
         state.textBuffer += chunk.responseTextDelta;
+    if (chunk.reasoningTextDelta)
+        state.reasoningBuffer += chunk.reasoningTextDelta;
     if (chunk.toolCallsDeltas) {
         for (const d of chunk.toolCallsDeltas) {
             const key = `${d.index}|${d.id || '_'}`;
@@ -53,6 +55,7 @@ function buildBatch(state, batchSequence, isFinalOverride = false) {
         modelId: first.modelId,
         choices: first.choices, // assume stable choice metadata
         responseTextDelta: state.textBuffer.length > 0 ? state.textBuffer : undefined,
+        reasoningTextDelta: state.reasoningBuffer.length > 0 ? state.reasoningBuffer : undefined,
         toolCallsDeltas: mergedToolCalls.length > 0 ? mergedToolCalls : undefined,
         // Only propagate usage/error when final provider chunk present.
         usage: finalProviderChunk?.usage,
@@ -66,6 +69,7 @@ function buildBatch(state, batchSequence, isFinalOverride = false) {
     // Reset state for next batch
     state.chunks = [];
     state.textBuffer = '';
+    state.reasoningBuffer = '';
     state.toolBuffers = {};
     state.firstChunkAt = 0;
     return batched;
@@ -77,7 +81,7 @@ function shouldFlush(state, opts) {
     const now = Date.now();
     if (state.firstChunkAt && (now - state.firstChunkAt) >= opts.maxLatencyMs)
         return true;
-    if (state.textBuffer.length >= opts.maxTextDeltaChars)
+    if (state.textBuffer.length + state.reasoningBuffer.length >= opts.maxTextDeltaChars)
         return true;
     if (state.chunks.length >= opts.maxChunksPerBatch)
         return true;
@@ -96,7 +100,7 @@ function shouldFlush(state, opts) {
 export async function* batchStream(stream, options = {}) {
     const opts = { ...DEFAULT_BATCHER_OPTIONS, ...options };
     let batchSequence = 0;
-    const state = { chunks: [], textBuffer: '', toolBuffers: {}, firstChunkAt: 0 };
+    const state = { chunks: [], textBuffer: '', reasoningBuffer: '', toolBuffers: {}, firstChunkAt: 0 };
     const flush = (isFinal = false) => {
         const chunk = buildBatch(state, batchSequence++, isFinal);
         if (chunk && !opts.annotateBatches) {
@@ -137,11 +141,12 @@ export async function* batchStream(stream, options = {}) {
             }
             // Flush buffered chunks first, then emit final chunk.
             let preFinal = flush(false);
-            if (!preFinal && state.textBuffer) {
+            if (!preFinal && (state.textBuffer || state.reasoningBuffer)) {
                 preFinal = {
                     ...state.chunks[0],
                     id: `${state.chunks[0]?.id || 'chunk'}-batch-${batchSequence++}`,
                     responseTextDelta: state.textBuffer || undefined,
+                    reasoningTextDelta: state.reasoningBuffer || undefined,
                     isFinal: false,
                 };
             }