mixdog 1.2.1 → 1.2.3

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

@@ -14,15 +14,36 @@ 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 { 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;
@@ -48,13 +69,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,
@@ -64,93 +89,125 @@ 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(
-        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 }) => {
+            try {
+              opts.onStageChange?.('requesting');
+            } catch {
+              /* heartbeat best-effort */
+            }
+            const 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: firstByteTimeoutMs,
+                perAttemptLabel: `${provider.name} first byte`,
+              }
+            );
+            try {
+              opts.onStageChange?.('streaming');
+            } catch {
+              /* heartbeat best-effort */
             }
-          );
-          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 {
+              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',
+                });
+              }
+              throw error;
             }
-            throw error;
-          }
-        }),
+          })
+        ),
         {
           signal: totalSignal.signal,
           onRetry: compatStreamRetryReporter(provider.name, opts),
           retry529: opts.retry529,
+          ...compatRetryOptions(provider.name),
         }
       );
     } catch (streamErr) {
       const recovered = await provider._recoverCompatNonStreaming({
         streamErr,
         params,
-        opts,
+        opts: requestHeaders === opts.requestHeaders ? opts : { ...opts, requestHeaders },
         signal: totalSignal.signal,
         useModel,
       });
@@ -170,6 +227,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
     cacheRoutingKey,
     cacheRouting,
     replaysReasoningContent,
+    reasoningShape,
   });
 }
 
@@ -234,13 +292,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

@@ -8,11 +8,12 @@ import { truncatedCompatStreamError } from '../lib/openai-tool-args.mjs';
 import {
   emitCompatToolCallOnce,
   firstByteCompatStreamError,
+  failingFinishReasonError,
   markErrorLiveTextEmitted,
   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) {
@@ -61,10 +62,33 @@ 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) {
+  // 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) {
@@ -77,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,
   };

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,39 @@ 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 +143,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

@@ -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 ?? 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);
+  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

@@ -34,6 +34,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 +64,23 @@ 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;
       models.push({
         id: m?.id,
         name: m?.id,
@@ -56,10 +88,23 @@ 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 } : {}),
       });
     }
     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) {