mixdog 1.2.2 → 1.2.4

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

@@ -6,7 +6,11 @@
  */
 import { stampStreamOutcome, STREAM_TRANSPORTS } from '../lib/stream-outcome.mjs';
 import { createLeakGuard, createToolCallDedupe } from '../lib/leaked-toolcall.mjs';
-import { emitCompatToolCallOnce, synthLeakedOpenAICall } from '../openai-compat-stream-common.mjs';
+import {
+  emitCompatToolCallOnce,
+  failingFinishReasonError,
+  synthLeakedOpenAICall,
+} from '../openai-compat-stream-common.mjs';
 import { chatCompletionUsage } from '../openai-compat-response-normalization.mjs';
 import { noteAbandonedUsage } from '../../../../shared/llm/usage-context.mjs';
 import { createToolCallAccumulator } from './tool-call-acc.mjs';
@@ -31,6 +35,8 @@ export function createCompatStreamState({
     content: '',
     reasoningContent: '',
     sawReasoningContent: false,
+    // Where the last reasoning text came from: a delta field name or 'content_chunks'.
+    reasoningSource: null,
     reasoningDetails: [],
     // Both text and reasoning exposure prohibit resampling the request.
     emittedText: false,
@@ -43,6 +49,7 @@ export function createCompatStreamState({
     streamEmitState: { emittedToolCallKeys: new Set(), emittedToolCall: false, _toolDedupe: toolDedupe },
     leakGuard: createLeakGuard({ knownToolNames, harmony: true }),
     leakedCalls: [],
+    pendingLeakedCalls: [],
   };
 }
 
@@ -71,16 +78,41 @@ export function appendText(state, text) {
   }
 }
 
-function dispatchLeakedCall(state, recovered) {
+/** A length-truncated or content-filtered turn is a partial result:
+ *  normalizeCompatChatResponse rejects it, so no tool call of it may execute. */
+export function isIncompleteFinishReason(finishReason) {
+  return finishReason === 'length' || finishReason === 'content_filter';
+}
+
+/** Whether `finish_reason` confirms a normal end of the turn: present, not an
+ *  incomplete outcome and not a gateway-reported failure (network_error/error). */
+export function isNormalFinishReason(finishReason) {
+  return (
+    Boolean(finishReason) && !isIncompleteFinishReason(finishReason) && !failingFinishReasonError(finishReason, '')
+  );
+}
+
+/** Dispatch held leaked calls once a normal finish_reason confirms the turn
+ *  ended. Otherwise they stay on `leakedCalls` (partial tool calls) and never
+ *  reach the executor. */
+export function drainLeakedCalls(state) {
+  if (!isNormalFinishReason(state.stopReason)) return;
+  for (const call of state.pendingLeakedCalls.splice(0)) {
+    emitCompatToolCallOnce(state.streamEmitState, call, state.onToolCall);
+  }
+}
+
+function recordLeakedCall(state, recovered) {
   const call = synthLeakedOpenAICall(recovered);
-  emitCompatToolCallOnce(state.streamEmitState, call, state.onToolCall);
+  state.pendingLeakedCalls.push(call);
   reportProgress(state, 'tool');
   return call;
 }
 
 function relayGuarded(state, { text, calls }) {
   if (text) appendText(state, text);
-  for (const c of calls) state.leakedCalls.push(dispatchLeakedCall(state, c));
+  for (const c of calls) state.leakedCalls.push(recordLeakedCall(state, c));
+  drainLeakedCalls(state);
 }
 
 /** Route a text delta through the leak guard, dispatching rescued calls. */
@@ -113,9 +145,9 @@ export function noteReportedUsage(state) {
 }
 
 /** Keep the partial output on the error for upstream salvage: the text, the
- *  recovered leaked calls already dispatched (native calls only dispatch once
- *  the stream finishes) and whether a native call's arguments were still
- *  streaming. */
+ *  recovered leaked calls (none dispatched unless a normal finish_reason
+ *  arrived; native calls only dispatch once the stream finishes) and whether a
+ *  native call's arguments were still streaming. */
 export function attachPartial(state, err) {
   try {
     err.partialContent = state.content;

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/tool-call-acc.mjs

@@ -35,15 +35,8 @@ export function mergeToolCallDelta(acc, deltaCalls) {
     if (tc.id) prev.id = tc.id;
     if (tc.type) prev.type = tc.type;
     if (tc.function?.name && !prev.function.name) prev.function.name = tc.function.name;
-    if (tc.function?.arguments) {
-      const delta = tc.function.arguments;
-      // Preserve support for providers that repeat cumulative arguments.
-      if (prev.function.arguments && delta.startsWith(prev.function.arguments)) {
-        prev.function.arguments = delta;
-      } else {
-        prev.function.arguments += delta;
-      }
-    }
+    // Argument fragments are deltas: always append, never infer snapshots.
+    if (tc.function?.arguments) prev.function.arguments += tc.function.arguments;
   }
 }
 

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

@@ -11,6 +11,7 @@ import {
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   createTimeoutSignal,
 } from '../stall-policy.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import {
   closeCompatStream,
   markErrorLiveTextEmitted,
@@ -86,6 +87,10 @@ export async function consumeCompatChatCompletionStream(
     }
     if (state.leakGuard.enabled) flushLeak(state);
   } catch (err) {
+    // The first-byte window (not a caller cancellation) ended the wait for the first chunk.
+    if (!signal?.aborted && err && typeof err === 'object' && err === firstByteTimeout.signal.reason) {
+      err.timeoutPhase = TIMEOUT_PHASE.FIRST_CHUNK;
+    }
     // Keep exposed partial text without permitting the request to replay;
     // every mid-flight failure carries what the stream completed (a
     // cancellation keeps the caller's own reason untouched).

package/src/runtime/agent/orchestrator/providers/openai-compat-error-contract.mjs

@@ -14,7 +14,7 @@ function resetAtFrom(wire, now) {
   if (wire?.resets_in_seconds != null && Number.isFinite(inSeconds) && inSeconds >= 0) {
     return now + Math.ceil(inSeconds * 1000);
   }
-  const raw = wire?.resets_at ?? wire?.reset_at;
+  const raw = wire?.resets_at ?? wire?.reset_at ?? wire?.metadata?.resets_at;
   if (raw == null || raw === '') return null;
   const numeric = Number(raw);
   if (Number.isFinite(numeric) && numeric > 0) return numeric < 1e12 ? Math.round(numeric * 1000) : Math.round(numeric);

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

@@ -2,12 +2,51 @@ import { resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, createTimeoutSignal, resolveTimeoutMs } from '../stall-policy.mjs';
+import { CUSTOM_EFFORT_LEVELS, normalizeCustomEffort } from './custom-reasoning.mjs';
 
 const MODEL_LIST_TIMEOUT_MS = resolveTimeoutMs('MIXDOG_COMPAT_MODEL_LIST_TIMEOUT_MS', 10_000, {
   minMs: 1_000,
   maxMs: PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
 });
 
+/** Preserve endpoint-declared effort levels without inventing a default ladder. */
+export function extractCompatReasoningEffort(model) {
+  if (!model || typeof model !== 'object') return null;
+  const rawLevels = [
+    model.reasoning_efforts,
+    model.reasoning_levels,
+    model.reasoningLevels,
+    model.capabilities?.reasoning_efforts,
+    model.capabilities?.reasoning_effort,
+  ].find(Array.isArray);
+  if (rawLevels) {
+    const declared = new Set(
+      rawLevels
+        .map((level) => (typeof level === 'string' ? level : level?.value))
+        .filter((level) => typeof level === 'string')
+        .map(normalizeCustomEffort)
+        .filter(Boolean)
+    );
+    const levels = CUSTOM_EFFORT_LEVELS.filter((level) => declared.has(level));
+    if (levels.length > 0) {
+      return {
+        supportsReasoning: levels.some((level) => level !== 'none'),
+        reasoningLevels: levels,
+        reasoningOptions: [{ type: 'effort', values: [...levels] }],
+      };
+    }
+    return null;
+  }
+  if (
+    model.supports_reasoning_effort === true ||
+    model.capabilities?.reasoning_effort === true ||
+    model.capabilities?.reasoning_efforts === true
+  ) {
+    return { supportsReasoning: true };
+  }
+  return null;
+}
+
 // `keyless` omits the Authorization header entirely (keyless endpoints);
 // `signal` aborts the request together with the list timeout.
 export async function fetchCompatModelItems(provider, { signal = null, keyless = false } = {}) {
@@ -34,6 +73,25 @@ export async function fetchCompatModelItems(provider, { signal = null, keyless =
   }
 }
 
+// Provider-native chat-ness: Together `type`, Mistral `capabilities`. Returns a
+// sanitize-compatible mode, or null when the listing says nothing.
+function nativeMode(m) {
+  const type = typeof m?.type === 'string' ? m.type.trim().toLowerCase() : '';
+  if (type === 'chat') return 'chat';
+  if (type === 'language' || type === 'code') return 'completion';
+  if (['embedding', 'embeddings', 'image', 'audio', 'rerank', 'moderation', 'video', 'transcribe'].includes(type)) {
+    return type;
+  }
+  // OpenRouter: a model that cannot emit text (image/audio generation) is no chat model.
+  const outputs = m?.architecture?.output_modalities;
+  if (Array.isArray(outputs) && outputs.length && !outputs.includes('text')) return 'non_chat';
+  const caps = m?.capabilities;
+  if (caps && typeof caps === 'object' && typeof caps.completion_chat === 'boolean') {
+    return caps.completion_chat ? 'chat' : 'non_chat';
+  }
+  return null;
+}
+
 export async function listCompatModels(provider, { throwOnError = false, signal = null } = {}) {
   try {
     const list = await provider._fetchModelItems({ signal });
@@ -45,10 +103,20 @@ export async function listCompatModels(provider, { throwOnError = false, signal
           m?.max_input_tokens ??
           m?.max_model_len ??
           m?.context_length ??
+          m?.max_context_length ??
+          m?.top_provider?.context_length ??
           m?.contextWindow ??
           0
       );
-      const outputTokens = Number(m?.max_output_tokens ?? m?.output_tokens ?? m?.maxOutputTokens ?? 0);
+      const outputTokens = Number(
+        m?.max_output_tokens ?? m?.output_tokens ?? m?.maxOutputTokens ?? m?.top_provider?.max_completion_tokens ?? 0
+      );
+      const mode = nativeMode(m);
+      // A catalog alias (OpenRouter `~anthropic/claude-opus-latest`) keeps its
+      // own slug for routing; the slug it currently points at is retained for
+      // capability lookup only.
+      const aliasTarget = typeof m?.alias_target === 'string' ? m.alias_target : m?.alias_target?.slug;
+      const effortInfo = extractCompatReasoningEffort(m);
       models.push({
         id: m?.id,
         name: m?.id,
@@ -56,10 +124,24 @@ export async function listCompatModels(provider, { throwOnError = false, signal
         contextWindow: Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : 0,
         outputTokens: Number.isFinite(outputTokens) && outputTokens > 0 ? outputTokens : null,
         created: typeof m?.created === 'number' ? m.created : null,
+        ...(mode ? { mode } : {}),
+        ...(typeof aliasTarget === 'string' && aliasTarget ? { aliasTarget } : {}),
+        ...(effortInfo || {}),
       });
     }
     const filtered = models.filter((m) => m.id);
-    const enriched = sanitizeModelList(await enrichModels(filtered), { provider: provider.name });
+    // The catalog fills gaps only: native limits and chat-ness are restored
+    // over whatever enrichment derived.
+    const enrichedRows = (await enrichModels(filtered)).map((row, i) => {
+      const native = filtered[i];
+      return {
+        ...row,
+        ...(native.contextWindow ? { contextWindow: native.contextWindow } : {}),
+        ...(native.outputTokens ? { outputTokens: native.outputTokens } : {}),
+        ...(native.mode ? { mode: native.mode } : {}),
+      };
+    });
+    const enriched = sanitizeModelList(enrichedRows, { provider: provider.name });
     provider._enrichedModels = enriched;
     return enriched;
   } catch (error) {

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

@@ -12,6 +12,41 @@ function normalizeReasoningEffort(value, allowed) {
   return allowed.includes(effort) ? effort : null;
 }
 
+/**
+ * OpenRouter's unified `reasoning` field, shared by its Chat and Responses
+ * wires: `openRouterReasoningEffort`, else the turn effort, else the configured
+ * effort; `none` disables reasoning. Null when no effort applies.
+ */
+export function openRouterReasoning(opts = {}, config = {}) {
+  const effort = normalizeReasoningEffort(opts.openRouterReasoningEffort ?? opts.effort ?? config?.reasoningEffort, [
+    'none',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+  ]);
+  if (effort === 'none') return { enabled: false };
+  return effort ? { enabled: true, effort } : null;
+}
+
+function deepseekRawEffort(opts, config) {
+  return opts.deepseekReasoningEffort ?? opts.effort ?? config?.reasoningEffort;
+}
+
+/** 'enabled' | 'disabled' as the DeepSeek request will carry it, or null when nothing sets it. */
+export function deepseekThinkingMode(opts = {}, config = {}) {
+  const rawThinking = opts.deepseekThinking ?? opts.thinking ?? config?.thinking;
+  const rawEffort = deepseekRawEffort(opts, config);
+  if (rawThinking === undefined && rawEffort === undefined) return null;
+  const thinkingMode = String(rawThinking?.type ?? rawThinking ?? rawEffort)
+    .trim()
+    .toLowerCase();
+  const disabled = rawThinking === false || thinkingMode === 'disabled' || thinkingMode === 'none';
+  return disabled ? 'disabled' : 'enabled';
+}
+
 // Keep provider extensions isolated: fields accepted by one OpenAI-compatible
 // backend are frequently rejected by another even when the core Chat schema
 // is shared.
@@ -23,22 +58,14 @@ export function applyCompatProviderChatOptions(params, providerName, opts = {},
       protocol: 'openai-chat',
       model: modelInfo,
       effort: opts.effort ?? config?.reasoningEffort,
+      baseURL: config?.baseURL,
     });
     Object.assign(params, fields);
     return params;
   }
   if (providerName === 'openrouter') {
-    const effort = normalizeReasoningEffort(opts.openRouterReasoningEffort ?? opts.effort ?? config?.reasoningEffort, [
-      'none',
-      'minimal',
-      'low',
-      'medium',
-      'high',
-      'xhigh',
-      'max',
-    ]);
-    if (effort === 'none') params.reasoning = { enabled: false };
-    else if (effort) params.reasoning = { enabled: true, effort };
+    const reasoning = openRouterReasoning(opts, config);
+    if (reasoning) params.reasoning = reasoning;
     return params;
   }
   if (providerName === 'xai') {
@@ -53,22 +80,17 @@ export function applyCompatProviderChatOptions(params, providerName, opts = {},
     return params;
   }
   if (providerName === 'deepseek') {
-    const rawThinking = opts.deepseekThinking ?? opts.thinking ?? config?.thinking;
-    const rawEffort = opts.deepseekReasoningEffort ?? opts.effort ?? config?.reasoningEffort;
-    if (rawThinking !== undefined || rawEffort !== undefined) {
-      const thinkingMode = String(rawThinking?.type ?? rawThinking ?? rawEffort)
-        .trim()
-        .toLowerCase();
-      const disabled = rawThinking === false || thinkingMode === 'disabled' || thinkingMode === 'none';
-      params.thinking = { type: disabled ? 'disabled' : 'enabled' };
-      if (!disabled) {
-        const effort = String(rawEffort ?? '')
+    const mode = deepseekThinkingMode(opts, config);
+    if (mode) {
+      params.thinking = { type: mode };
+      if (mode === 'enabled') {
+        const effort = String(deepseekRawEffort(opts, config) ?? '')
           .trim()
           .toLowerCase();
-        if (effort === 'max') params.reasoning_effort = 'max';
-        // DeepSeek documents low/high/max; `medium` is its own alias for
-        // high, and `low` is a real level that must not be promoted.
-        else if (effort === 'low') params.reasoning_effort = 'low';
+        // DeepSeek documents low/high/max; `ultra` is its alias for max,
+        // `minimal` for low, `medium`/`xhigh` for high; `low` must not be promoted.
+        if (effort === 'max' || effort === 'ultra') params.reasoning_effort = 'max';
+        else if (effort === 'low' || effort === 'minimal') params.reasoning_effort = 'low';
         else if (['medium', 'high', 'xhigh'].includes(effort)) params.reasoning_effort = 'high';
       }
     }

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

@@ -11,12 +11,16 @@ export const OPENAI_COMPAT_PRESETS = {
   },
   // OpenCode Go - low-cost coding-model subscription gateway.
   'opencode-go': {
-    baseURL: 'https://opencode.ai/zen/go/v1',
+    baseURL: 'https://opencode.ai/inference/go/v1',
     defaultModel: 'glm-5.2',
+    // The gateway expects an application User-Agent (not the SDK default).
+    extraHeaders: { 'User-Agent': 'mixdog' },
   },
   openrouter: {
     baseURL: 'https://openrouter.ai/api/v1',
     defaultModel: 'openrouter/auto',
+    // OpenRouter documents cache_control on Chat content blocks.
+    chatCacheControl: true,
     extraHeaders: {
       'HTTP-Referer': 'https://github.com/tribgames/mixdog',
       'X-OpenRouter-Title': 'mixdog',

package/src/runtime/agent/orchestrator/providers/openai-compat-reasoning-field.mjs

@@ -0,0 +1,155 @@
+/**
+ * openai-compat-reasoning-field.mjs — provider-specific reasoning shapes on the
+ * Chat Completions wire that the plain `reasoning_content` string path misses.
+ *
+ * Together AI (docs.together.ai/docs/inference/chat/reasoning): the chain of
+ * thought arrives on `reasoning` OR `reasoning_content` (model dependent), on
+ * the message and on each streaming delta, and must be passed back "under the
+ * same key" on prior assistant turns. vLLM reports it on `reasoning` (formerly
+ * `reasoning_content`), Groq on `message.reasoning` (reasoning_format parsed).
+ * OpenRouter reports plain text on `reasoning` next to `reasoning_details`.
+ *
+ * Mistral (docs.mistral.ai/studio/conversations/reasoning): with reasoning on,
+ * `message.content` / `delta.content` is a list of typed chunks —
+ * `{type:'thinking', thinking:[{type:'text', text}]}` and `{type:'text', text}`
+ * — and the full assistant message, thinking chunk included, goes back in the
+ * history. Receiving is by the response shape (an array), never by model name.
+ */
+
+/** `message.providerMetadata[key].reasoningField`: the key a reply's reasoning arrived on. */
+export const COMPAT_REASONING_METADATA_KEY = 'openaiCompat';
+
+const TOGETHER_HOSTS = ['together.xyz', 'together.ai'];
+const GROQ_HOSTS = ['groq.com'];
+const MISTRAL_HOSTS = ['mistral.ai'];
+
+function hostMatches(baseURL, domains) {
+  let host;
+  try {
+    host = new URL(String(baseURL || '')).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return domains.some((domain) => host === domain || host.endsWith(`.${domain}`));
+}
+
+export function isTogetherBaseURL(baseURL) {
+  return hostMatches(baseURL, TOGETHER_HOSTS);
+}
+
+/**
+ * Where an endpoint family reports reasoning and how a prior turn's reasoning
+ * goes back. `readsReasoningAlias`: the `reasoning` key is a reasoning field
+ * (otherwise only `reasoning_content` is). `resend`:
+ *   same_key        — back under the key it arrived on (Together, vLLM)
+ *   reasoning       — plain text as `reasoning`; reasoning_details win (OpenRouter)
+ *   content_chunks  — as a `thinking` chunk in the assistant content (Mistral)
+ *   none            — never echoed; the docs do not ask for it (Groq)
+ */
+const SHAPES = Object.freeze({
+  together: Object.freeze({ id: 'together', readsReasoningAlias: true, resend: 'same_key' }),
+  vllm: Object.freeze({ id: 'vllm', readsReasoningAlias: true, resend: 'same_key' }),
+  groq: Object.freeze({ id: 'groq', readsReasoningAlias: true, resend: 'none' }),
+  mistral: Object.freeze({ id: 'mistral', readsReasoningAlias: false, resend: 'content_chunks' }),
+  openrouter: Object.freeze({ id: 'openrouter', readsReasoningAlias: true, resend: 'reasoning' }),
+});
+
+/**
+ * The reasoning shape of a provider, or null for the plain `reasoning_content`
+ * path. OpenRouter is by provider name, Together/Groq/Mistral by the provider's
+ * own base URL, vLLM (no fixed host) by the model row's `vllm` wire format.
+ */
+export function compatReasoningShape({ providerName, baseURL, wireFormat } = {}) {
+  if (providerName === 'openrouter') return SHAPES.openrouter;
+  if (wireFormat === 'together' || isTogetherBaseURL(baseURL)) return SHAPES.together;
+  if (wireFormat === 'vllm') return SHAPES.vllm;
+  if (hostMatches(baseURL, GROQ_HOSTS)) return SHAPES.groq;
+  if (hostMatches(baseURL, MISTRAL_HOSTS)) return SHAPES.mistral;
+  return null;
+}
+
+/**
+ * The receive field worth recording for replay: `reasoning` (non-default key)
+ * or `content_chunks` (Mistral), per shape; `reasoning_content` is the default
+ * and needs no record. Null when nothing needs remembering.
+ */
+export function replayReasoningField(shape, source) {
+  if (!shape) return null;
+  if (shape.resend === 'same_key' && source === 'reasoning') return 'reasoning';
+  if (shape.resend === 'content_chunks' && source === 'content_chunks') return 'content_chunks';
+  return null;
+}
+
+/** Whether a reply's reasoning source is captured under this shape. */
+export function capturesShapeReasoning(shape, source) {
+  if (!shape) return source === 'content_chunks';
+  if (source === 'content_chunks') return true;
+  return source === 'reasoning_content' || (shape.readsReasoningAlias && source === 'reasoning');
+}
+
+/** Assistant content with the prior reasoning replayed as a leading `thinking` chunk. */
+export function contentWithThinkingChunk(content, reasoning) {
+  const thinking = { type: 'thinking', thinking: [{ type: 'text', text: reasoning }] };
+  if (Array.isArray(content)) return [thinking, ...content];
+  return typeof content === 'string' && content ? [thinking, { type: 'text', text: content }] : [thinking];
+}
+
+function thinkingText(thinking) {
+  if (typeof thinking === 'string') return thinking;
+  if (!Array.isArray(thinking)) return '';
+  return thinking
+    .map((inner) => {
+      if (typeof inner === 'string') return inner;
+      return typeof inner?.text === 'string' ? inner.text : '';
+    })
+    .join('');
+}
+
+/**
+ * Ordered `{kind:'reasoning'|'text', text}` parts of an array-shaped `content`,
+ * or null when `content` is not an array (the plain string/absent shape).
+ */
+export function chatContentParts(content) {
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const chunk of content) {
+    if (typeof chunk === 'string') {
+      parts.push({ kind: 'text', text: chunk });
+    } else if (chunk?.type === 'thinking') {
+      parts.push({ kind: 'reasoning', text: thinkingText(chunk.thinking) });
+    } else if (chunk?.type === 'text' && typeof chunk.text === 'string') {
+      parts.push({ kind: 'text', text: chunk.text });
+    }
+  }
+  return parts;
+}
+
+/**
+ * Content text, reasoning and reasoning source of one non-streaming message.
+ * `reasoning_content` keeps priority; the `reasoning` alias is read only under
+ * a shape that reports reasoning there; thinking chunks fill in when no field
+ * carried reasoning.
+ */
+export function readChatMessage(message, { shape = null } = {}) {
+  const parts = chatContentParts(message?.content);
+  let content;
+  if (parts) {
+    content = parts
+      .filter((part) => part.kind === 'text')
+      .map((part) => part.text)
+      .join('');
+  } else {
+    content = typeof message?.content === 'string' ? message.content : '';
+  }
+  if (typeof message?.reasoning_content === 'string') {
+    return { content, reasoningContent: message.reasoning_content, reasoningSource: 'reasoning_content' };
+  }
+  if (shape?.readsReasoningAlias && typeof message?.reasoning === 'string') {
+    return { content, reasoningContent: message.reasoning, reasoningSource: 'reasoning' };
+  }
+  const thinking = parts?.filter((part) => part.kind === 'reasoning');
+  if (thinking?.length) {
+    return { content, reasoningContent: thinking.map((part) => part.text).join(''), reasoningSource: 'content_chunks' };
+  }
+  return { content, reasoningContent: null, reasoningSource: null };
+}

package/src/runtime/agent/orchestrator/providers/openai-compat-response-normalization.mjs

@@ -7,20 +7,20 @@ import {
   writeXaiResponsesCacheTrace,
 } from './openai-compat-xai.mjs';
 import { createProviderReplay } from './lib/provider-replay.mjs';
+import { reportedCostUsd } from './lib/usage-primitives.mjs';
 import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
 import { failingFinishReasonError } from './openai-compat-stream-common.mjs';
-
-const reportedNumber = (value) =>
-  value == null || (typeof value === 'string' && value.trim() === '') ? Number.NaN : Number(value);
+import {
+  COMPAT_REASONING_METADATA_KEY,
+  capturesShapeReasoning,
+  replayReasoningField,
+} from './openai-compat-reasoning-field.mjs';
 
 export function compatReportedCostUsd(providerName, usage) {
-  if (providerName === 'openrouter') {
-    const cost = reportedNumber(usage?.cost);
-    return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
-  }
+  if (providerName === 'openrouter') return reportedCostUsd(usage?.cost);
   if (providerName === 'xai') {
-    const ticks = reportedNumber(usage?.cost_in_usd_ticks);
-    return Number.isFinite(ticks) && ticks >= 0 ? Number((ticks * 1e-10).toFixed(8)) : undefined;
+    const ticks = reportedCostUsd(usage?.cost_in_usd_ticks);
+    return ticks === undefined ? undefined : Number((ticks * 1e-10).toFixed(8));
   }
   return undefined;
 }
@@ -79,12 +79,11 @@ export function traceCompatResponseUsage({
   });
 }
 
-// Responses-wire reported cost: a gateway `cost` (decimal USD) when present,
-// else xAI ticks. null/empty/negative is "not reported", never a reported $0.
+// Responses-wire reported cost: xAI `cost_in_usd_ticks` when present, else a
+// gateway `cost` (decimal USD). null/empty/negative is "not reported", never a
+// reported $0.
 export function responsesReportedCostUsd(usage) {
-  const cost = reportedNumber(usage?.cost);
-  if (Number.isFinite(cost) && cost >= 0) return cost;
-  return costUsdFromTicks(usage?.cost_in_usd_ticks);
+  return costUsdFromTicks(usage?.cost_in_usd_ticks) ?? reportedCostUsd(usage?.cost);
 }
 
 export function chatCompletionUsage(providerName, usage) {
@@ -138,6 +137,7 @@ export function normalizeCompatChatResponse({
   cacheRoutingKey,
   cacheRouting,
   replaysReasoningContent,
+  reasoningShape = null,
 }) {
   const response = assembled.response;
   const choice = response.choices[0];
@@ -146,7 +146,7 @@ export function normalizeCompatChatResponse({
   const failingFinish = failingFinishReasonError(stopReason, providerName);
   if (failingFinish) {
     const err = failingFinish;
-    const partialContent = choice?.message?.content || '';
+    const partialContent = assembled.content || '';
     Object.assign(err, {
       partialContent,
       partialToolCalls: Array.isArray(toolCalls) && toolCalls.length ? toolCalls : undefined,
@@ -173,7 +173,7 @@ export function normalizeCompatChatResponse({
       code: 'PROVIDER_INCOMPLETE',
       providerIncomplete: true,
       finishReason: stopReason,
-      partialContent: choice?.message?.content || '',
+      partialContent: assembled.content || '',
       partialToolCalls: toolCalls,
       model: response.model || useModel,
       responseId: response.id || null,
@@ -205,14 +205,28 @@ export function normalizeCompatChatResponse({
       cachedTokens: extractCompatCachedTokens(response.usage),
     });
   }
+  // Together/vLLM/Groq/OpenRouter report reasoning on `reasoning` or
+  // `reasoning_content`; Mistral reports it as thinking chunks inside
+  // `content`. Both are captured by the provider's own shape / the response
+  // shape, whatever the replay flag says.
+  const reasoningField = replayReasoningField(reasoningShape, assembled.reasoningSource);
   const capturesReasoningContent =
-    providerName === 'deepseek' || providerName === 'xai' || providerName === 'mixdog-local' || replaysReasoningContent;
+    providerName === 'deepseek' ||
+    providerName === 'xai' ||
+    providerName === 'mixdog-local' ||
+    replaysReasoningContent ||
+    capturesShapeReasoning(reasoningShape, assembled.reasoningSource);
   const reasoningContent =
     capturesReasoningContent && typeof assembled.reasoningContent === 'string' ? assembled.reasoningContent : null;
   const reasoningDetails =
     providerName === 'openrouter' && Array.isArray(choice?.message?.reasoning_details)
       ? choice.message.reasoning_details
       : null;
+  // Replay sends reasoning back under the field it arrived on.
+  const providerMetadata = {
+    ...(reasoningDetails?.length ? { openrouter: { reasoning_details: reasoningDetails } } : {}),
+    ...(reasoningContent !== null && reasoningField ? { [COMPAT_REASONING_METADATA_KEY]: { reasoningField } } : {}),
+  };
   return {
     content: assembled.content || '',
     // Streamed chunks can omit `model`; fall back to the requested
@@ -228,11 +242,7 @@ export function normalizeCompatChatResponse({
     // instead of silently treating a truncated answer as complete.
     ...(stopReason === 'length' && (assembled.content || '').length > 0 ? { truncated: true } : {}),
     ...(reasoningContent !== null ? { reasoningContent } : {}),
-    ...(reasoningDetails?.length
-      ? {
-          providerMetadata: { openrouter: { reasoning_details: reasoningDetails } },
-        }
-      : {}),
+    ...(Object.keys(providerMetadata).length ? { providerMetadata } : {}),
     usage: response.usage ? chatCompletionUsage(providerName, response.usage) : undefined,
   };
 }
@@ -332,8 +342,14 @@ export function normalizeXaiResponsesWebSocket({
   cacheLane,
 }) {
   const responseId = result.responseId || previousResponseId || null;
-  const encryptedReasoningItems = encryptedXaiReasoningItems(result.responseItems);
-  const providerReplay = createProviderReplay('xai-responses', result.responseItems);
+  // The WS send result drops the collector's `responseItems`; its own
+  // owner-tagged `providerReplay` (traceProvider 'xai') still carries every
+  // output item in order: encrypted reasoning and server-executed tool_search
+  // call/output pairs. Always taken, so they survive to the next turn as xAI
+  // requires.
+  const responseItems = result.responseItems ?? result.providerReplay?.items;
+  const encryptedReasoningItems = encryptedXaiReasoningItems(responseItems);
+  const providerReplay = createProviderReplay('xai-responses', responseItems);
   const encryptedReasoningHistory = xaiEncryptedReasoningHistory(opts, messages, encryptedReasoningItems);
   const rawUsage = result.usage?.raw || result.usage || null;
   const response = {