mixdog 1.2.0 → 1.2.2

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.d.mts

@@ -50,6 +50,7 @@ export class ModelProxyChannel {
   attachPublisher(publish: (snapshot: ModelProxySnapshot) => void): () => void;
   disconnect(reason?: string): void;
   setClientPresent(present: boolean): void;
+  onStateChange(listener: () => void): () => void;
   request(
     call: Record<string, unknown>,
     options?: { signal?: AbortSignal | null; callbacks?: Record<string, (...args: unknown[]) => unknown> }
@@ -65,3 +66,17 @@ export class ModelProxyChannel {
 }
 
 export function getModelProxyChannel(): ModelProxyChannel;
+
+/** The channel surface model-proxy providers use; the bridge child implements only this. */
+export interface ModelProxyChannelLike {
+  readonly connected: boolean;
+  readonly generation: number;
+  whenConnected(timeoutMs: number): Promise<boolean>;
+  request(
+    call: Record<string, unknown>,
+    options?: { signal?: AbortSignal | null; callbacks?: Record<string, (...args: unknown[]) => unknown> }
+  ): Promise<unknown>;
+}
+
+/** Swap the process-wide channel; the returned function restores the previous one. */
+export function installModelProxyChannel(channel: ModelProxyChannel | ModelProxyChannelLike): () => void;

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

@@ -243,8 +243,24 @@ export class ModelProxyChannel {
     });
   }
 
+  #stateListeners = new Set();
+
+  /** `listener()` runs after every presence/generation change (the model
+   *  proxy bridge pushes it to its clients). Returns the unsubscribe. */
+  onStateChange(listener) {
+    this.#stateListeners.add(listener);
+    return () => this.#stateListeners.delete(listener);
+  }
+
   #connectionChanged() {
     this.#generation += 1;
+    for (const listener of [...this.#stateListeners]) {
+      try {
+        listener();
+      } catch {
+        /* a listener never breaks the transport that reported the change */
+      }
+    }
     if (!this.connected) return;
     for (const waiter of [...this.#connectionWaiters]) waiter(true);
   }
@@ -519,3 +535,22 @@ export function getModelProxyChannel() {
   globalThis[CHANNEL_KEY] ??= new ModelProxyChannel();
   return globalThis[CHANNEL_KEY];
 }
+
+/**
+ * Make `channel` the process-wide channel (a headless child talks through the
+ * daemon's model proxy bridge instead). The returned restore puts the previous
+ * channel back once, unless another install replaced this one since.
+ */
+export function installModelProxyChannel(channel) {
+  const hadPrevious = Object.hasOwn(globalThis, CHANNEL_KEY);
+  const previous = globalThis[CHANNEL_KEY];
+  globalThis[CHANNEL_KEY] = channel;
+  let restored = false;
+  return () => {
+    if (restored) return;
+    restored = true;
+    if (globalThis[CHANNEL_KEY] !== channel) return;
+    if (hadPrevious) globalThis[CHANNEL_KEY] = previous;
+    else delete globalThis[CHANNEL_KEY];
+  };
+}

package/src/runtime/agent/orchestrator/providers/muse-code-oauth.mjs

@@ -10,8 +10,10 @@ import { createHash } from 'node:crypto';
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { fileMtimeMs } from './lib/oauth-token-utils.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
+import { COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
 import { getModelMetadataSync } from './model-catalog.mjs';
 import { makeModelCache } from './model-cache.mjs';
+import { normalizeCacheKey } from '../agent-runtime/cache-strategy.mjs';
 import { PRICING_RATE_KEYS } from '../../../shared/llm/model-pricing-rates.mjs';
 import {
   MUSE_DEFAULT_EFFORT_LEVELS as FIVE_LEVELS,
@@ -100,15 +102,6 @@ function museRow(id, discovered = null) {
 const EFFORT_DOWNGRADE = { max: 'xhigh' };
 const SUMMARY_MODES = new Set(['auto', 'detailed', 'concise']);
 
-// Cache identities beyond the wire limit become a bounded hash identity.
-function normalizeCacheKey(value) {
-  const text = String(value ?? '').trim();
-  if (!text) return '';
-  const wellFormed = text.toWellFormed();
-  if (wellFormed.length <= 64) return wellFormed;
-  return `pc_${createHash('sha256').update(wellFormed).digest('hex').slice(0, 32)}`;
-}
-
 // Final request shaping on the Responses wire (installed through the shared
 // transport's opt-in params hook).
 function shapeResponsesParams(params, { opts, modelInfo }, config = {}) {
@@ -321,6 +314,8 @@ export class MuseCodeOAuthProvider {
   nativePdf = false;
   static inputExcludesCache = false;
   name = 'muse-code-oauth';
+  // The retry profile's limits are final: no loop-level recovery cycles on top.
+  retryPolicy = COMPAT_RETRY_POLICY;
   config;
   tokens = null;
   _inner = null;

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

@@ -181,6 +181,17 @@ function mimoOAuthState() {
   );
 }
 
+function commandCodeOAuthState() {
+  const paths = [
+    boundProviderAuthPath('command-code-oauth') ||
+      process.env.COMMAND_CODE_OAUTH_CREDENTIALS_PATH ||
+      join(resolvePluginData(), 'command-code-oauth.json'),
+  ];
+  return memoProbe('command-code-oauth', paths, () =>
+    resolveProbeState(paths, (docs) => docs.some((own) => typeof own?.apiKey === 'string' && !!own.apiKey.trim()))
+  );
+}
+
 function museCodeOAuthState() {
   const paths = [
     boundProviderAuthPath('muse-code-oauth') ||
@@ -255,6 +266,7 @@ const OAUTH_PROBE_STATES = new Map([
   ['openai-oauth', openAIOAuthState],
   ['grok-oauth', grokOAuthState],
   ['muse-code-oauth', museCodeOAuthState],
+  ['command-code-oauth', commandCodeOAuthState],
   ['mimo-oauth', mimoOAuthState],
   ['cursor-oauth', cursorOAuthState],
   ['antigravity-oauth', antigravityOAuthState],

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -868,7 +868,8 @@ async function measureUsage(provider, providerObj, routeInfo) {
     (provider === 'cursor-oauth' ||
       provider === 'cursor-api' ||
       provider === 'antigravity-oauth' ||
-      provider === 'muse-code-oauth') &&
+      provider === 'muse-code-oauth' ||
+      provider === 'command-code-oauth') &&
     typeof providerObj?.getUsageSnapshot === 'function'
   ) {
     return await providerObj.getUsageSnapshot();
@@ -893,12 +894,12 @@ async function measureUsageWithAuthRetry(provider, providerObj, routeInfo) {
 // refresh cannot vouch for the reading it last produced: keeping a 100% meter
 // earned by a dead token would hold the account out of the roster until its
 // reset time, so the recorded quota goes with the credential.
-function usageAfterFailure(err, provider, accountId, log) {
+async function usageAfterFailure(err, provider, accountId, log) {
   const snapshot = provider === 'anthropic-oauth' && accountId === 'default' ? latestClaudeStatuslineUsage() : null;
   if (snapshot) return snapshot;
   if (isUsageAuthRejection(err) && ACCOUNT_PROVIDERS.includes(provider)) {
     try {
-      clearProviderAccountQuotaState(provider, accountId);
+      await clearProviderAccountQuotaState(provider, accountId);
     } catch (error) {
       log(`Account usage could not be cleared: ${error.message}`);
     }
@@ -952,7 +953,7 @@ export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () =
     try {
       snapshot = await measureUsageWithAuthRetry(provider, providerObj, routeInfo);
     } catch (err) {
-      snapshot = usageAfterFailure(err, provider, accountId, log);
+      snapshot = await usageAfterFailure(err, provider, accountId, log);
     }
     if (!isContentfulSnapshot(snapshot)) {
       cacheNegative(key, 'empty');
@@ -961,7 +962,7 @@ export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () =
     }
     if (ACCOUNT_PROVIDERS.includes(provider)) {
       try {
-        recordProviderAccountUsage(provider, accountId, snapshot);
+        await recordProviderAccountUsage(provider, accountId, snapshot);
       } catch (error) {
         log(`Account usage could not be saved: ${error.message}`);
       }

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

@@ -21,6 +21,7 @@ import { normalizeCompatChatResponse } from './openai-compat-response-normalizat
 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 { preparePdfTextForProvider } from './media-normalization.mjs';
 import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 
@@ -38,7 +39,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   // global catalog must not shape a user-defined endpoint's request.
   let modelInfo = null;
   if (isCustom) modelInfo = provider.getCachedModelInfo(useModel) || null;
-  else if (provider.name === 'opencode-go')
+  else if (provider.name === 'opencode-go' || provider.name === 'command-code-oauth')
     modelInfo = provider.getCachedModelInfo(useModel) || getModelMetadataSync(useModel, provider.name);
   else if (profile?.resolveModelInfo) modelInfo = profile.resolveModelInfo(provider, useModel) || null;
   // Resolved before lowering: replay eligibility depends on the snapped level
@@ -85,7 +86,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   try {
     try {
       assembled = await withRetry(
-        refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
+        withCompatRetryProfile(provider.name, refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
           try {
             opts.onStageChange?.('requesting');
           } catch {
@@ -139,11 +140,12 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
             }
             throw error;
           }
-        }),
+        })),
         {
           signal: totalSignal.signal,
           onRetry: compatStreamRetryReporter(provider.name, opts),
           retry529: opts.retry529,
+          ...compatRetryOptions(provider.name),
         }
       );
     } catch (streamErr) {

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

@@ -8,6 +8,7 @@ import { truncatedCompatStreamError } from '../lib/openai-tool-args.mjs';
 import {
   emitCompatToolCallOnce,
   firstByteCompatStreamError,
+  failingFinishReasonError,
   markErrorLiveTextEmitted,
   markUnsafeRetryIfToolEmitted,
 } from '../openai-compat-stream-common.mjs';
@@ -61,7 +62,28 @@ function parseAccumulatedToolCalls(state, { label, parseToolCalls }) {
   }
 }
 
+// A gateway-reported failing finish_reason (`network_error`, `error`) is an
+// interruption: the stream carries no terminal, so exposure keeps its replay
+// gates.
+function finishReasonInterruption(state, err) {
+  attachPartial(state, err);
+  if (state.emittedText) {
+    markErrorLiveTextEmitted(err);
+    try {
+      err.streamStalled = true;
+    } catch {
+      /* best-effort */
+    }
+  }
+  return stampCompatOutcome(state, markUnsafeRetryIfToolEmitted(err, state.streamEmitState), {
+    terminalObserved: false,
+    continuation: true,
+  });
+}
+
 export function settleCompatStream(state, { label, parseToolCalls }) {
+  const failing = failingFinishReasonError(state.stopReason, label);
+  if (failing) throw finishReasonInterruption(state, failing);
   const response = buildResponse(state);
   let toolCalls = parseAccumulatedToolCalls(state, { label, parseToolCalls });
   if (Array.isArray(toolCalls) && toolCalls.length) {

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

@@ -71,6 +71,7 @@ export async function consumeCompatChatCompletionStream(
         idleDeadlineAt: state.semanticIdleDeadlineAt,
         idleEnabled: state.sawFirstEvent && idleEnabled && state.semanticIdleDeadlineAt > 0,
         idleLabel: `${label} SSE idle`,
+        streamLabel: label,
         emittedToolCall: () => toolWorkStarted(state),
       });
       if (done) {

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

@@ -0,0 +1,50 @@
+/**
+ * openai-compat-error-contract.mjs — the error contract of the OpenAI-compatible
+ * provider boundary: `status`, lowercased `code` (from the wire error's `code`
+ * or `type`), `headers`, `retryAfterMs` and `resetAt` when the provider sent
+ * them. Evidence is structural only; message text is never parsed.
+ */
+import { retryAfterMsFromError, typedStatusFrom } from './retry-classifier.mjs';
+
+const lowered = (value) => (typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : '');
+
+// Epoch seconds, epoch ms or an ISO date → epoch ms; `resets_in_seconds` is relative.
+function resetAtFrom(wire, now) {
+  const inSeconds = Number(wire?.resets_in_seconds);
+  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;
+  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);
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+/** Stamp the boundary contract onto a provider error in place and return it. */
+export function applyCompatErrorContract(err, detail = err?.error ?? err?.providerError, now = Date.now()) {
+  if (!err || typeof err !== 'object') return err;
+  try {
+    const wire = detail && typeof detail === 'object' ? detail : null;
+    const status = typedStatusFrom(err, err.response, wire);
+    if (status && !(Number(err.status) >= 100)) err.status = status;
+    const wireCode = lowered(wire?.code) || lowered(wire?.type) || lowered(err.type);
+    // Keep an errno / SDK-local code (ECONNRESET, ...) that is not the wire code.
+    if (wireCode && (typeof err.code !== 'string' || !err.code.trim() || lowered(err.code) === wireCode)) {
+      err.code = wireCode;
+    }
+    if (!err.headers && err.response?.headers) err.headers = err.response.headers;
+    if (!Number.isFinite(err.retryAfterMs)) {
+      const retryAfterMs = retryAfterMsFromError(err);
+      if (retryAfterMs != null) err.retryAfterMs = retryAfterMs;
+    }
+    if (!Number.isFinite(err.resetAt)) {
+      const resetAt = resetAtFrom(wire, now);
+      if (resetAt) err.resetAt = resetAt;
+    }
+  } catch {
+    /* the contract is best-effort; the original error stays authoritative */
+  }
+  return err;
+}

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

@@ -1,3 +1,4 @@
+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';
@@ -10,12 +11,15 @@ const MODEL_LIST_TIMEOUT_MS = resolveTimeoutMs('MIXDOG_COMPAT_MODEL_LIST_TIMEOUT
 // `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 } = {}) {
-  const timeout = createTimeoutSignal(signal, MODEL_LIST_TIMEOUT_MS, `${provider.name} model list`);
+  const name = provider.name;
+  const timeout = createTimeoutSignal(signal, MODEL_LIST_TIMEOUT_MS, `${name} model list`);
   try {
     const res = await fetch(`${String(provider.baseURL || '').replace(/\/+$/, '')}/models`, {
       method: 'GET',
       headers: {
-        ...(keyless ? {} : { Authorization: `Bearer ${provider.apiKey || 'no-key'}` }),
+        ...(keyless
+          ? {}
+          : { Authorization: `Bearer ${resolveProviderApiKey(name, provider.config || provider) || 'no-key'}` }),
         ...(provider.defaultHeaders || {}),
       },
       signal: timeout.signal,

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

@@ -74,6 +74,17 @@ export function applyCompatProviderChatOptions(params, providerName, opts = {},
     }
     return params;
   }
+  if (providerName === 'command-code-oauth') {
+    // The API's field is undocumented; mirror the common `reasoning_effort`
+    // (levels the catalog row declares, else low/medium/high).
+    const rawEffort = opts.effort ?? config?.reasoningEffort;
+    const declared = modelInfo?.reasoningOptions?.some((option) => option?.type === 'effort');
+    const effort = declared
+      ? normalizeOpencodeGoReasoningEffort(rawEffort, modelInfo)
+      : normalizeReasoningEffort(rawEffort, ['low', 'medium', 'high']);
+    if (effort) params.reasoning_effort = effort;
+    return params;
+  }
   if (providerName === 'opencode-go') {
     const reasoningEffort = normalizeOpencodeGoReasoningEffort(opts.effort ?? config?.reasoningEffort, modelInfo);
     // OpenCode Go's OpenAI-compatible contract exposes reasoning_effort,

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

@@ -7,6 +7,8 @@ import {
   writeXaiResponsesCacheTrace,
 } from './openai-compat-xai.mjs';
 import { createProviderReplay } from './lib/provider-replay.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);
@@ -141,6 +143,27 @@ export function normalizeCompatChatResponse({
   const choice = response.choices[0];
   const toolCalls = assembled.toolCalls;
   const stopReason = choice?.finish_reason || null;
+  const failingFinish = failingFinishReasonError(stopReason, providerName);
+  if (failingFinish) {
+    const err = failingFinish;
+    const partialContent = choice?.message?.content || '';
+    Object.assign(err, {
+      partialContent,
+      partialToolCalls: Array.isArray(toolCalls) && toolCalls.length ? toolCalls : undefined,
+      pendingToolUse: false,
+      partialModel: response.model || useModel,
+      ...(response.usage ? { partialUsage: chatCompletionUsage(providerName, response.usage) } : {}),
+    });
+    stampStreamOutcome(err, {
+      transport: STREAM_TRANSPORTS.NON_STREAMING,
+      provider: 'openai-compat',
+      terminalObserved: false,
+      continuation: true,
+      textObservedChars: partialContent.length,
+      toolCallsComplete: err.partialToolCalls?.length || 0,
+    });
+    throw err;
+  }
   if (
     (stopReason === 'length' && Array.isArray(toolCalls) && toolCalls.length > 0) ||
     stopReason === 'content_filter'

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

@@ -2,6 +2,7 @@
 // wire event type maps to one handler over the shared stream `state`; `ctx`
 // carries the label, the caller callbacks and the leaked-text relay.
 import { typedStatusFrom } from './retry-classifier.mjs';
+import { applyCompatErrorContract } from './openai-compat-error-contract.mjs';
 import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from './custom-tool-wire.mjs';
 import { emitCompatToolCallOnce } from './openai-compat-stream-common.mjs';
 import { truncatedCompatStreamError, parseCompletedToolCallArgumentsJson } from './lib/openai-tool-args.mjs';
@@ -41,9 +42,11 @@ function typedResponsesFailure(message, event) {
   if (code != null && code !== '') err.providerErrorCode = String(code);
   if (detail) err.providerError = detail;
   err.providerWireError = true;
-  return err;
+  return applyCompatErrorContract(err, detail || (event?.code != null ? { code: event.code } : null));
 }
 
+const streamLabel = (ctx) => ctx?.label || 'compat Responses';
+
 // Reconcile a COMPLETED function_call item into state.toolCalls: fill in the
 // id/name a streamed call may still be missing, or adopt the item as a new
 // call. `response.output_item.done` and the `response.completed` sweep see the
@@ -289,6 +292,7 @@ function onCompleted(event, state, ctx) {
 }
 
 function onDone(event, state, ctx) {
+  const label = streamLabel(ctx);
   if (!event.response || event.response.status === 'completed') {
     state.completed = true;
     // A stream that never emits response.completed: this frame carries usage.
@@ -298,7 +302,7 @@ function onDone(event, state, ctx) {
   if (event.response.status === 'failed') {
     const msg = event.response?.error?.message || 'response.done failed';
     throw withIncompleteUsage(
-      typedResponsesFailure(`xAI Responses stream response.done failed: ${msg}`, event),
+      typedResponsesFailure(`${label} stream response.done failed: ${msg}`, event),
       event,
       state
     );
@@ -306,27 +310,31 @@ function onDone(event, state, ctx) {
   if (event.response.status === 'incomplete') {
     const reason = incompleteReasonFromEvent(event);
     if (isMaxOutputIncompleteReason(reason)) return settleMaxOutputIncomplete(event, state, ctx, reason);
-    throw withIncompleteUsage(new Error(`xAI Responses stream response.done incomplete: ${reason}`), event, state);
+    throw withIncompleteUsage(new Error(`${label} stream response.done incomplete: ${reason}`), event, state);
   }
 }
 
-function onFailed(event, state) {
+function onFailed(event, state, ctx) {
   const msg = event.response?.error?.message || event.error?.message || event.message || 'response.failed';
   // The wire event's OWN typed status/code is preserved verbatim. A
   // forbidden/unknown failure is never coerced into a synthetic 500:
   // without typed evidence it stays unclassified and is surfaced.
-  throw withIncompleteUsage(typedResponsesFailure(`xAI Responses stream response.failed: ${msg}`, event), event, state);
+  throw withIncompleteUsage(
+    typedResponsesFailure(`${streamLabel(ctx)} stream response.failed: ${msg}`, event),
+    event,
+    state
+  );
 }
 
 function onIncomplete(event, state, ctx) {
   const reason = incompleteReasonFromEvent(event);
   if (isMaxOutputIncompleteReason(reason)) return settleMaxOutputIncomplete(event, state, ctx, reason);
-  throw withIncompleteUsage(new Error(`xAI Responses stream response.incomplete: ${reason}`), event, state);
+  throw withIncompleteUsage(new Error(`${streamLabel(ctx)} stream response.incomplete: ${reason}`), event, state);
 }
 
-function onError(event) {
+function onError(event, _state, ctx) {
   const msg = event.message || event.error?.message || 'unknown';
-  throw typedResponsesFailure(`xAI Responses stream error: ${msg}`, event);
+  throw typedResponsesFailure(`${streamLabel(ctx)} stream error: ${msg}`, event);
 }
 
 const RESPONSES_EVENT_HANDLERS = new Map([

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

@@ -139,11 +139,11 @@ export function createResponsesOutcomeStamper(state, leakedCalls) {
 }
 
 /** A streamed function_call whose id/name never arrived cannot be dispatched. */
-export function unresolvedSalvageError(state) {
+export function unresolvedSalvageError(state, label) {
   const unresolved = state.toolCalls.find((t) => t._pendingItemId);
   if (!unresolved) return null;
   return new Error(
-    `xAI Responses stream function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`
+    `${label || 'compat Responses'} stream function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`
   );
 }
 
@@ -169,5 +169,6 @@ export function finalizeResponsesStream(state, { leakedCalls, parseResponsesTool
     model: state.model || response.model || null,
     responseId: state.responseId || response.id || null,
     stopReason: state.stopReason || null,
+    reasoningEmitted: state.emittedReasoning === true,
   };
 }