mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/providers/model-proxy-provider.mjs

@@ -90,9 +90,19 @@ export function inlineModelProxyAttachments(messages, { maxBytes = MODEL_PROXY_I
   return out ?? messages;
 }
 
+/** A first-response budget the PC reported, or null for anything malformed. */
+function reportedBudget(value) {
+  const transportMs = Number(value?.transportMs);
+  const semanticMs = Number(value?.semanticMs);
+  return transportMs > 0 && semanticMs > 0 && Number.isFinite(transportMs) && Number.isFinite(semanticMs)
+    ? { transportMs, semanticMs }
+    : null;
+}
+
 export class ModelProxyProvider {
   #channel;
   #modelInfo = new Map();
+  #noWireRoute = new Set();
 
   constructor(name, config = {}, channel = getModelProxyChannel()) {
     this.name = name;
@@ -100,6 +110,7 @@ export class ModelProxyProvider {
     this.#channel = channel;
     // Adapter traits are reported by the PC's real instance.
     if (typeof this.config.modelProxy?.nativePdf === 'boolean') this.nativePdf = this.config.modelProxy.nativePdf;
+    if (this.config.modelProxy?.consumesReadWindows === true) this.consumesReadWindows = true;
   }
 
   #call(method, fields = {}, options = {}) {
@@ -109,18 +120,32 @@ export class ModelProxyProvider {
   async send(messages, model, tools, sendOpts) {
     const { options, callbacks } = splitModelProxySendOptions(sendOpts);
     const finalized = isFinalizedProviderRequestTools(tools);
-    return this.#call(
-      'send',
-      {
-        model: model ?? null,
-        messages: inlineModelProxyAttachments(messages),
-        tools: Array.isArray(tools) ? tools : null,
-        toolsFinalized: finalized,
-        nativePrefixCount: finalized ? providerNativeToolPrefixCount(tools) : 0,
-        options,
-      },
-      { signal: sendOpts?.signal || null, callbacks }
-    );
+    const fields = {
+      model: model ?? null,
+      messages: inlineModelProxyAttachments(messages),
+      tools: Array.isArray(tools) ? tools : null,
+      toolsFinalized: finalized,
+      nativePrefixCount: finalized ? providerNativeToolPrefixCount(tools) : 0,
+      options,
+    };
+    const signal = sendOpts?.signal || null;
+    const result = await this.#call('send', fields, { signal, callbacks });
+    // The PC rerouted the wire (a clear "unsupported" refusal) and reports the
+    // route it used: the daemon's own session adopts it, so the next proxied
+    // turn starts on the new wire instead of repeating the refusal.
+    const rerouted = result?.wireReroute;
+    const session = sendOpts?.session;
+    if (
+      rerouted?.source === 'reroute' &&
+      session?.wireRoute &&
+      session.wireRoute.provider === this.name &&
+      session.wireRoute.model === (model ?? null) &&
+      rerouted.provider === this.name &&
+      rerouted.model === session.wireRoute.model
+    ) {
+      session.wireRoute = rerouted;
+    }
+    return result;
   }
 
   #adoptCatalog(catalog) {
@@ -145,6 +170,31 @@ export class ModelProxyProvider {
   getCachedModelInfo(model) {
     return this.#modelInfo.get(String(model ?? '')) ?? null;
   }
+
+  /** The PC adapter's first-response budget for `model`: the catalog's
+   *  model-specific figure, else the adapter's own from its provider config;
+   *  null keeps the agent watchdog default. */
+  firstResponseBudget(model) {
+    return (
+      reportedBudget(this.getCachedModelInfo(model)?.firstResponseBudget) ??
+      reportedBudget(this.config.modelProxy?.firstResponseBudget)
+    );
+  }
+
+  /** The PC adapter's wire route for `model` (its config and roster decide);
+   *  null for a single-wire adapter, which is remembered so every later turn
+   *  skips the round trip. */
+  async resolveWireRoute(model, ctx = {}) {
+    const key = String(model ?? '');
+    if (this.#noWireRoute.has(key)) return null;
+    const route = await this.#call('resolveWireRoute', {
+      model: model ?? null,
+      context: { agent: ctx.agent === true, legacy: ctx.legacy === true },
+    });
+    if (route && typeof route === 'object') return route;
+    this.#noWireRoute.add(key);
+    return null;
+  }
 }
 
 /** A proxy instance whose class carries the PC adapter's usage convention. */
@@ -190,10 +240,12 @@ export function loadModelProxyProviderConfig({
   channel = getModelProxyChannel(),
   now = Date.now,
   waitMs = MODEL_PROXY_CONFIG_WAIT_MS,
+  force = false,
 } = {}) {
   const generation = channel.generation;
   const cached = _providerConfigCache;
   if (
+    !force &&
     cached &&
     cached.channel === channel &&
     cached.generation === generation &&
@@ -202,7 +254,16 @@ export function loadModelProxyProviderConfig({
     return Promise.resolve(cached.value);
   }
   const inFlight = _providerConfigInFlight;
-  if (inFlight && inFlight.channel === channel && inFlight.generation === generation) return inFlight.promise;
+  // A forced read starts after the caller's change, never reuses an older
+  // snapshot. Short setup reads also cannot inherit a registry init's budget.
+  if (
+    !force &&
+    inFlight &&
+    inFlight.channel === channel &&
+    inFlight.generation === generation &&
+    inFlight.waitMs === waitMs
+  )
+    return inFlight.promise;
   const promise = (async () => {
     const deadline = Date.now() + waitMs;
     let delay = CONFIG_RETRY_FIRST_MS;
@@ -215,12 +276,27 @@ export function loadModelProxyProviderConfig({
         }
       }
       try {
-        const reply = await channel.request({ provider: '', method: 'providerConfig' });
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) throw new ModelProxyUnavailableError('the desktop provider request timed out');
+        const controller = new AbortController();
+        const timer = setTimeout(
+          () => controller.abort(new ModelProxyUnavailableError('the desktop provider request timed out')),
+          remaining
+        );
+        timer.unref?.();
+        let reply;
+        try {
+          reply = await channel.request({ provider: '', method: 'providerConfig' }, { signal: controller.signal });
+        } finally {
+          clearTimeout(timer);
+        }
         const raw = reply?.providers && typeof reply.providers === 'object' ? reply.providers : {};
         // Defense in depth: the PC already strips secrets before sending.
         const value = stripModelProxySecrets(raw);
         if (providerConfigReady(reply, value)) {
-          if (channel.generation === generation) {
+          // An older read may finish after a forced refresh; only the newest
+          // request may publish to the shared cache.
+          if (channel.generation === generation && _providerConfigInFlight === entry) {
             _providerConfigCache = { at: now(), value, channel, generation };
           }
           return value;
@@ -236,7 +312,7 @@ export function loadModelProxyProviderConfig({
       delay = Math.min(delay * 2, CONFIG_RETRY_MAX_MS);
     }
   })();
-  const entry = { channel, generation, promise };
+  const entry = { channel, generation, waitMs, promise };
   _providerConfigInFlight = entry;
   const clear = () => {
     if (_providerConfigInFlight === entry) _providerConfigInFlight = null;

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -56,11 +56,6 @@ function resolveProbeState(paths, evaluate) {
   return sawUnreadable ? 'unreadable' : 'absent';
 }
 
-function pushUnique(list, value) {
-  if (!value || typeof value !== 'string') return;
-  if (!list.includes(value)) list.push(value);
-}
-
 // Short-TTL memo. Under simultaneous multi-agent launch, buildDefaultConfig
 // and registry lazy-init call these probes in bursts; each probe does
 // synchronous existsSync + readFileSync disk work. Cache the STATE per key
@@ -113,9 +108,11 @@ function memoProbe(key, paths, compute, extraSignature = '') {
 }
 
 function anthropicOAuthState() {
-  const paths = [];
-  pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
-  pushUnique(paths, ANTHROPIC_DEFAULT_CREDENTIALS_PATH);
+  const paths = [
+    boundProviderAuthPath('anthropic-oauth') ||
+      process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH ||
+      ANTHROPIC_DEFAULT_CREDENTIALS_PATH,
+  ];
   return memoProbe('anthropic-oauth', paths, () => {
     return resolveProbeState(paths, (docs) => {
       const candidates = [];
@@ -176,9 +173,7 @@ function mimoOAuthState() {
       process.env.MIMO_OAUTH_CREDENTIALS_PATH ||
       join(resolvePluginData(), 'mimo-oauth.json'),
   ];
-  return memoProbe('mimo-oauth', paths, () =>
-    resolveProbeState(paths, (docs) => docs.some((own) => !!own?.apiKey))
-  );
+  return memoProbe('mimo-oauth', paths, () => resolveProbeState(paths, (docs) => docs.some((own) => !!own?.apiKey)));
 }
 
 function commandCodeOAuthState() {
@@ -230,7 +225,10 @@ function cursorEnvTokenFingerprint() {
 }
 
 function cursorOAuthState() {
-  const paths = [process.env.CURSOR_OAUTH_CREDENTIALS_PATH, join(resolvePluginData(), 'cursor-oauth.json')];
+  // Match the adapter: selected account, then explicit path, then legacy file.
+  // An environment token must not authenticate a different selected account.
+  const bound = boundProviderAuthPath('cursor-oauth');
+  const paths = [bound || process.env.CURSOR_OAUTH_CREDENTIALS_PATH || join(resolvePluginData(), 'cursor-oauth.json')];
   // The env token is the whole answer on this branch and has no file metadata
   // behind it, so its VALUE is what the memo signature has to track: a length
   // (or a bare present/absent flag) let a swap to an equal-length expired token
@@ -245,13 +243,15 @@ function cursorOAuthState() {
       // Expiry is read by the one shared JWT reader (cursor-auth.cursorTokenExpiry),
       // which answers 0 for a non-JWT or unparseable token — exactly the "assume
       // usable" outcome this branch already took for those shapes.
-      if (process.env.CURSOR_ACCESS_TOKEN) {
+      if (process.env.CURSOR_ACCESS_TOKEN && !bound) {
         const expiresAt = cursorTokenExpiry(process.env.CURSOR_ACCESS_TOKEN);
         return expiresAt === 0 || expiresAt > Date.now() ? 'present' : 'absent';
       }
       return resolveProbeState(paths, (docs) =>
         docs.some((own) => {
           if (!own?.access_token) return false;
+          // Cursor permanently rejected the refresh token: signed out until a new login.
+          if (own.reauth_required === true) return false;
           const expiresAt = Number(own.expires_at) || 0;
           return expiresAt === 0 || expiresAt > Date.now() || Boolean(own.refresh_token);
         })

package/src/runtime/agent/orchestrator/providers/openai-codex-metadata.mjs

@@ -101,6 +101,8 @@ function _codexMetadataBase({ poolKey, cacheKey, sendOpts, handshake = false } =
       sendOpts?.codexSessionId ||
         sendOpts?.session?.codexWireSessionId ||
         sendOpts?.session?.codexSessionId ||
+        // A forked transport scope keeps its session's wire identity.
+        (sendOpts?.transportScope ? sendOpts?.sessionId : '') ||
         poolKey ||
         cacheKey
     ) || 'mixdog-session';

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-send.mjs

@@ -14,16 +14,37 @@ import {
   toOpenAITools,
   parseToolCalls,
   knownToolNamesFromOpenAITools,
-  deepseekReplaysReasoningContent,
 } from './openai-compat-wire.mjs';
-import { applyCompatProviderChatOptions } from './openai-compat-options.mjs';
+import { applyCompatProviderChatOptions, deepseekThinkingMode } from './openai-compat-options.mjs';
 import { normalizeCompatChatResponse } from './openai-compat-response-normalization.mjs';
 import { applyCompatToolChoice, compatStreamRetryReporter } from './compat-request-policy.mjs';
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
 import { xaiCacheRouting } from './openai-compat-xai.mjs';
-import { compatRetryOptions, withCompatRetryProfile } from './openai-compat-retry-profile.mjs';
+import { compatFirstByteWindowMs, compatRetryOptions, withCompatRetryProfile } from './openai-compat-retry-profile.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
-import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
+import { customWireFormat, isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
+import { geminiAcceptedTools } from './gemini-schema.mjs';
+import { acceptedWireTools } from './lib/claude-bridge-schema.mjs';
+import { isGeminiFamilyModel } from './gemini-family.mjs';
+import { compatReasoningShape, isTogetherBaseURL, readChatMessage } from './openai-compat-reasoning-field.mjs';
+
+// Endpoint families with their own reasoning field (Together, vLLM, Groq,
+// Mistral, OpenRouter); a custom provider's row may declare the vLLM format.
+function reasoningShapeFor(provider, modelInfo) {
+  return compatReasoningShape({
+    providerName: provider.name,
+    baseURL: provider.baseURL,
+    wireFormat: isCustomProviderName(provider.name) ? customWireFormat(modelInfo, provider.baseURL) : undefined,
+  });
+}
+
+// The `developer` role is documented by MiMo and by Together's gpt-oss models;
+// every other chat endpoint only knows `system`.
+function keepsDeveloperRole(provider, profile, useModel) {
+  if (profile?.developerRole === true) return true;
+  return isTogetherBaseURL(provider.baseURL) && /gpt-oss/i.test(String(useModel || ''));
+}
 
 export async function sendCompatChat(provider, messages, useModel, tools, opts) {
   const signal = opts.signal || null;
@@ -49,13 +70,17 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
         protocol: 'openai-chat',
         model: modelInfo,
         effort: opts.effort ?? provider.config?.reasoningEffort,
+        baseURL: provider.baseURL,
       })
     : null;
+  // DeepSeek thinking models need the prior reasoning_content back once tools
+  // are in play and ignore it otherwise, so it always goes back.
   const replaysReasoningContent = isCustom
     ? customReasoning.replay
     : modelInfo?.reasoningContentField === 'reasoning_content' ||
       profile?.replaysReasoningContent === true ||
-      (provider.name === 'deepseek' && deepseekReplaysReasoningContent(useModel));
+      provider.name === 'deepseek';
+  const reasoningShape = reasoningShapeFor(provider, modelInfo);
   messages = await preparePdfTextForProvider(messages, provider);
   const params = {
     model: useModel,
@@ -65,82 +90,123 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
     messages: ensureChatToolPairs(
       toOpenAIMessages(messages, provider.name, {
         replaysReasoningContent,
+        ...(reasoningShape ? { reasoningShape } : {}),
         ...(isCustom ? { customReplay: customReasoning.replay } : {}),
+        ...(keepsDeveloperRole(provider, profile, useModel) ? { developerRole: true } : {}),
         nativePdf: provider.nativePdf,
+        cacheControl: provider.chatCacheControl === true,
       })
     ),
   };
   const maxOutputTokens = resolveCompatMaxOutputTokens(opts);
   if (maxOutputTokens) params.max_tokens = maxOutputTokens;
-  if (tools?.length) params.tools = toOpenAITools(tools);
-  applyCompatToolChoice(params, opts);
+  // A Gemini-family model behind this route (google/gemini-* on OpenRouter)
+  // fails the whole request on one schema Google rejects; such a tool is left
+  // out and reported like on the native Gemini routes.
+  // Every other model's `parameters` must be a valid 2020-12 object schema;
+  // a draft-07 one is lowered and a broken one left out and reported.
+  let sendTools = tools;
+  if (tools?.length) {
+    sendTools = isGeminiFamilyModel(useModel)
+      ? geminiAcceptedTools(tools, opts.onToolExcluded)
+      : acceptedWireTools(tools, 'openai', opts.onToolExcluded, `[${provider.name}] tool`);
+  }
+  if (sendTools?.length) params.tools = toOpenAITools(sendTools);
+  // A forced tool_choice goes out only on the documented providers; DeepSeek
+  // gets it only with thinking explicitly disabled (never silently in thinking
+  // mode, and never as an error for a turn whose thinking is enabled).
+  applyCompatToolChoice(params, opts, {
+    provider: provider.name,
+    baseURL: provider.baseURL,
+    wire: 'chat',
+    thinking:
+      provider.name === 'deepseek' && deepseekThinkingMode(opts, provider.config) === 'disabled' ? 'disabled' : null,
+  });
   applyCompatProviderChatOptions(params, provider.name, opts, provider.config, modelInfo);
   profile?.applyParams?.(params, { opts, config: provider.config, modelInfo });
   const firstByteTimeoutMs = profile?.firstByteTimeoutMs || PROVIDER_FIRST_BYTE_TIMEOUT_MS;
   const totalSignal = createPassthroughSignal(signal);
   const cacheRouting = provider.name === 'xai' ? xaiCacheRouting(opts, params, tools || [], useModel) : null;
   const cacheRoutingKey = cacheRouting?.key || null;
+  // xAI Chat pins a conversation to the server holding its cached prefix with
+  // the x-grok-conv-id header (the Responses equivalent is prompt_cache_key).
+  const requestHeaders = cacheRoutingKey
+    ? { 'x-grok-conv-id': cacheRoutingKey, ...(opts.requestHeaders || {}) }
+    : opts.requestHeaders;
   params.stream = true;
   params.stream_options = { include_usage: true };
   let assembled;
   try {
     try {
       assembled = await withRetry(
-        withCompatRetryProfile(provider.name, refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
-          try {
-            opts.onStageChange?.('requesting');
-          } catch {
-            /* heartbeat best-effort */
-          }
-          const stream = await withRetry(
-            ({ signal: openSignal }) =>
-              provider.client.chat.completions.create(params, {
-                signal: openSignal,
-                ...(opts.requestHeaders ? { headers: opts.requestHeaders } : {}),
-              }),
-            {
-              signal: attemptSignal,
-              // Single attempt: this inner wrapper exists only to
-              // apply the first-byte per-attempt timeout. Retry is
-              // owned by the outer withRetry — nesting retry loops
-              // here multiplied tail latency (5x5).
-              maxAttempts: 1,
-              perAttemptTimeoutMs: firstByteTimeoutMs,
-              perAttemptLabel: `${provider.name} first byte`,
+        withCompatRetryProfile(
+          provider.name,
+          refineAttemptErrors(profile, async ({ signal: attemptSignal, firstByteTimeouts = 0 }) => {
+            try {
+              opts.onStageChange?.('requesting');
+            } catch {
+              /* heartbeat best-effort */
+            }
+            const windowMs = compatFirstByteWindowMs(provider.name, firstByteTimeoutMs, firstByteTimeouts);
+            let stream;
+            try {
+              stream = await withRetry(
+                ({ signal: openSignal }) =>
+                  provider.client.chat.completions.create(params, {
+                    signal: openSignal,
+                    ...(requestHeaders ? { headers: requestHeaders } : {}),
+                  }),
+                {
+                  signal: attemptSignal,
+                  // Single attempt: this inner wrapper exists only to
+                  // apply the first-byte per-attempt timeout. Retry is
+                  // owned by the outer withRetry — nesting retry loops
+                  // here multiplied tail latency (5x5).
+                  maxAttempts: 1,
+                  perAttemptTimeoutMs: windowMs,
+                  perAttemptLabel: `${provider.name} first byte`,
+                }
+              );
+            } catch (error) {
+              // The per-attempt window (the only timer here) expired before headers.
+              if (error?.code === 'EPROVIDERTIMEOUT' && !attemptSignal?.aborted) {
+                error.timeoutPhase = TIMEOUT_PHASE.HEADERS;
+              }
+              throw error;
             }
-          );
-          try {
-            opts.onStageChange?.('streaming');
-          } catch {
-            /* heartbeat best-effort */
-          }
-          try {
-            return await consumeCompatChatCompletionStream(stream, {
-              signal: attemptSignal,
-              label: provider.name,
-              providerName: provider.name,
-              onStreamDelta: opts.onStreamDelta,
-              onToolCall: opts.onToolCall,
-              onTextDelta: opts.onTextDelta,
-              parseToolCalls,
-              // Known tool names for the leaked-tool-call guard:
-              // recovered leaked calls only synthesize when they name
-              // a tool actually offered to this request.
-              knownToolNames: knownToolNamesFromOpenAITools(params.tools),
-              ...(profile?.firstByteTimeoutMs ? { firstByteTimeoutMs: profile.firstByteTimeoutMs } : {}),
-              ...(profile?.semanticIdleTimeoutMs ? { semanticIdleTimeoutMs: profile.semanticIdleTimeoutMs } : {}),
-            });
-          } catch (error) {
-            // Grok's reference sampler treats content-idle as a
-            // terminal sampling decision, not a resample signal.
-            if (provider.name === 'xai' && error?.streamStalled === true) {
-              throw markProviderRecoveryExhausted(error, {
-                owner: 'xai-content-idle-policy',
+            try {
+              opts.onStageChange?.('streaming');
+            } catch {
+              /* heartbeat best-effort */
+            }
+            try {
+              return await consumeCompatChatCompletionStream(stream, {
+                signal: attemptSignal,
+                label: provider.name,
+                providerName: provider.name,
+                onStreamDelta: opts.onStreamDelta,
+                onToolCall: opts.onToolCall,
+                onTextDelta: opts.onTextDelta,
+                parseToolCalls,
+                // Known tool names for the leaked-tool-call guard:
+                // recovered leaked calls only synthesize when they name
+                // a tool actually offered to this request.
+                knownToolNames: knownToolNamesFromOpenAITools(params.tools),
+                ...(profile?.firstByteTimeoutMs ? { firstByteTimeoutMs: windowMs } : {}),
+                ...(profile?.semanticIdleTimeoutMs ? { semanticIdleTimeoutMs: profile.semanticIdleTimeoutMs } : {}),
               });
+            } catch (error) {
+              // Grok's reference sampler treats content-idle as a
+              // terminal sampling decision, not a resample signal.
+              if (provider.name === 'xai' && error?.streamStalled === true) {
+                throw markProviderRecoveryExhausted(error, {
+                  owner: 'xai-content-idle-policy',
+                });
+              }
+              throw error;
             }
-            throw error;
-          }
-        })),
+          })
+        ),
         {
           signal: totalSignal.signal,
           onRetry: compatStreamRetryReporter(provider.name, opts),
@@ -152,7 +218,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
       const recovered = await provider._recoverCompatNonStreaming({
         streamErr,
         params,
-        opts,
+        opts: requestHeaders === opts.requestHeaders ? opts : { ...opts, requestHeaders },
         signal: totalSignal.signal,
         useModel,
       });
@@ -172,6 +238,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
     cacheRoutingKey,
     cacheRouting,
     replaysReasoningContent,
+    reasoningShape,
   });
 }
 
@@ -236,13 +303,17 @@ export async function recoverCompatNonStreaming(provider, { streamErr, params, o
     /* best-effort */
   }
   traceNonStreamingFallback({ provider: provider.name, model: useModel, opts, streamErr });
+  const { content, reasoningContent, reasoningSource } = readChatMessage(message, {
+    shape: reasoningShapeFor(provider, provider.getCachedModelInfo?.(useModel) || null),
+  });
   return {
     response,
     model: response.model || useModel,
-    content: typeof message.content === 'string' ? message.content : '',
+    content,
     toolCalls,
     stopReason: choice.finish_reason || null,
-    reasoningContent: typeof message.reasoning_content === 'string' ? message.reasoning_content : null,
+    reasoningContent,
+    reasoningSource,
     rawUsage: response.usage || null,
   };
 }

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/chunk-events.mjs

@@ -4,7 +4,18 @@
  * reasoning aliases, tool_calls deltas, finish reason and usage.
  */
 import { mergeToolCallDelta } from './tool-call-acc.mjs';
-import { appendText, relayText, reportProgress, reportTransport } from './stream-state.mjs';
+import { appendText, drainLeakedCalls, relayText, reportProgress, reportTransport } from './stream-state.mjs';
+import { chatContentParts } from '../openai-compat-reasoning-field.mjs';
+
+function appendReasoning(state, text, source) {
+  state.sawReasoningContent = true;
+  state.reasoningSource = source;
+  state.reasoningContent += text;
+  if (text) {
+    state.emittedReasoning = true;
+    reportProgress(state, 'reasoning');
+  }
+}
 
 function applyReasoning(state, delta) {
   if (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length) {
@@ -12,14 +23,22 @@ function applyReasoning(state, delta) {
     reportProgress(state, 'reasoning');
   }
   // These provider fields are aliases, never independent text segments.
-  const reasoningDelta =
-    [delta?.reasoning_content, delta?.reasoning, delta?.thinking].find((value) => typeof value === 'string') ?? null;
-  if (reasoningDelta === null) return;
-  state.sawReasoningContent = true;
-  state.reasoningContent += reasoningDelta;
-  if (reasoningDelta) {
-    state.emittedReasoning = true;
-    reportProgress(state, 'reasoning');
+  const source = ['reasoning_content', 'reasoning', 'thinking'].find((key) => typeof delta?.[key] === 'string');
+  if (source === undefined) return;
+  appendReasoning(state, delta[source], source);
+}
+
+function applyContent(state, content) {
+  if (state.leakGuard.enabled) relayText(state, content);
+  else appendText(state, content);
+}
+
+// Mistral-style typed chunk lists: thinking → reasoning, text → assistant
+// text, applied in arrival order.
+function applyContentParts(state, parts) {
+  for (const part of parts) {
+    if (part.kind === 'reasoning') appendReasoning(state, part.text, 'content_chunks');
+    else if (part.text) applyContent(state, part.text);
   }
 }
 
@@ -32,15 +51,17 @@ export function applyCompatChunk(state, chunk) {
   if (typeof delta?.role === 'string' && delta.role) {
     reportProgress(state, 'semantic');
   }
-  if (delta?.content) {
-    if (state.leakGuard.enabled) relayText(state, delta.content);
-    else appendText(state, delta.content);
-  }
+  const contentParts = chatContentParts(delta?.content);
+  if (contentParts) applyContentParts(state, contentParts);
+  else if (delta?.content) applyContent(state, delta.content);
   applyReasoning(state, delta);
   if (Array.isArray(delta?.tool_calls) && delta.tool_calls.length) {
     reportProgress(state, 'tool');
   }
   mergeToolCallDelta(state.toolAcc, delta?.tool_calls);
-  if (choice?.finish_reason) state.stopReason = choice.finish_reason;
+  if (choice?.finish_reason) {
+    state.stopReason = choice.finish_reason;
+    drainLeakedCalls(state);
+  }
   if (chunk?.usage) state.rawUsage = chunk.usage;
 }

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/stream-result.mjs

@@ -13,7 +13,7 @@ import {
   markUnsafeRetryIfToolEmitted,
 } from '../openai-compat-stream-common.mjs';
 import { orderedToolCalls, toolCallsFromStreamAcc } from './tool-call-acc.mjs';
-import { attachPartial, attachReportedUsage, stampCompatOutcome } from './stream-state.mjs';
+import { attachPartial, attachReportedUsage, isIncompleteFinishReason, stampCompatOutcome } from './stream-state.mjs';
 
 /** Rejection for a stream that ended without a terminal event. */
 export function incompleteStreamError(state, label) {
@@ -86,7 +86,9 @@ export function settleCompatStream(state, { label, parseToolCalls }) {
   if (failing) throw finishReasonInterruption(state, failing);
   const response = buildResponse(state);
   let toolCalls = parseAccumulatedToolCalls(state, { label, parseToolCalls });
-  if (Array.isArray(toolCalls) && toolCalls.length) {
+  // A length-truncated or content-filtered call is a partial result that
+  // normalizeCompatChatResponse rejects: it must never reach the executor.
+  if (!isIncompleteFinishReason(state.stopReason) && Array.isArray(toolCalls) && toolCalls.length) {
     for (const call of toolCalls) emitCompatToolCallOnce(state.streamEmitState, call, state.onToolCall);
   }
   if (state.leakedCalls.length) {
@@ -99,6 +101,7 @@ export function settleCompatStream(state, { label, parseToolCalls }) {
     toolCalls,
     stopReason: state.stopReason,
     reasoningContent: state.sawReasoningContent ? state.reasoningContent : null,
+    reasoningSource: state.sawReasoningContent ? state.reasoningSource : null,
     reasoningDetails: state.reasoningDetails.length ? state.reasoningDetails : null,
     rawUsage: state.rawUsage,
   };