mixdog 1.3.0 → 1.3.2

package/src/runtime/agent/orchestrator/providers/lib/anthropic-prefix-trace.mjs

@@ -0,0 +1,76 @@
+// Diagnostic per-block prefix fingerprint of an Anthropic request: the tools,
+// each system block (BP1/BP2/BP3/env, the routing prefix included) and the
+// cache_control marker positions, as short hashes only — never any text, so
+// it is safe in shipped builds. The last two requests per session are kept in
+// memory so a usage-detected cache miss (session/loop/send-phase.mjs) can say
+// which block or marker moved.
+import { createHash } from 'node:crypto';
+
+const HASH_CHARS = 12;
+const MAX_SESSIONS = 256;
+const bySession = new Map();
+
+const hash = (value) =>
+  createHash('sha256')
+    .update(JSON.stringify(value ?? null))
+    .digest('hex')
+    .slice(0, HASH_CHARS);
+
+const withoutMarker = (block) => {
+  if (!block || typeof block !== 'object') return block;
+  const { cache_control: _marker, ...rest } = block;
+  return rest;
+};
+
+const markerTtl = (marker) => (marker?.ttl ? String(marker.ttl) : '5m');
+
+/** `{ tools, system: [hash…], markers: ['s1:1h', 'm12:5m', …] }` of a request body. */
+export function anthropicPrefixFingerprint(body) {
+  const system = Array.isArray(body?.system) ? body.system : [];
+  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const markers = [];
+  system.forEach((block, index) => {
+    if (block?.cache_control) markers.push(`s${index}:${markerTtl(block.cache_control)}`);
+  });
+  messages.forEach((message, index) => {
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const marked = content.find((block) => block?.cache_control);
+    if (marked) markers.push(`m${index}:${markerTtl(marked.cache_control)}`);
+  });
+  return { tools: hash(body?.tools || []), system: system.map((block) => hash(withoutMarker(block))), markers };
+}
+
+/** Keep `fingerprint` as the session's latest request (the one before it stays as previous). */
+export function recordAnthropicPrefix(sessionId, fingerprint) {
+  if (!sessionId || !fingerprint) return;
+  const key = String(sessionId);
+  const previous = bySession.get(key)?.current || null;
+  bySession.delete(key);
+  bySession.set(key, { previous, current: fingerprint });
+  if (bySession.size > MAX_SESSIONS) bySession.delete(bySession.keys().next().value);
+}
+
+/** The session's latest fingerprint, or null. */
+export function latestAnthropicPrefix(sessionId) {
+  return bySession.get(String(sessionId || ''))?.current || null;
+}
+
+/** `{ changedBlocks: 'tools,s3' | 'none', markersChanged }` between the session's
+ *  last two requests, or null before it has two. */
+export function anthropicPrefixChanges(sessionId) {
+  const entry = bySession.get(String(sessionId || ''));
+  if (!entry?.previous) return null;
+  const { previous, current } = entry;
+  const changed = [];
+  if (previous.tools !== current.tools) changed.push('tools');
+  const blocks = Math.max(previous.system.length, current.system.length);
+  for (let index = 0; index < blocks; index += 1) {
+    if (previous.system[index] !== current.system[index]) changed.push(`s${index}`);
+  }
+  // Message markers move every turn; only the system markers are a layout change.
+  const systemMarkers = (print) => print.markers.filter((marker) => marker.startsWith('s')).join(',');
+  return {
+    changedBlocks: changed.length ? changed.join(',') : 'none',
+    markersChanged: systemMarkers(previous) !== systemMarkers(current),
+  };
+}

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -10,6 +10,7 @@ import { mergeFlatSchemaProperty } from './flat-schema-merge.mjs';
 import { reportedCostUsd } from './usage-primitives.mjs';
 import { reportInvalidTool, wireInputSchema } from './claude-bridge-schema.mjs';
 import { normalizeServerToolUse } from './anthropic-server-tool-usage.mjs';
+import { ANTHROPIC_TOOL_CALL_IDS, withWireToolCallIds } from './tool-call-wire-ids.mjs';
 export const ANTHROPIC_CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
 const ANTHROPIC_CACHE_TTL_VOLATILE = { type: 'ephemeral' };
 
@@ -81,6 +82,22 @@ function appendAnthropicCacheControl(content, ttl = ANTHROPIC_CACHE_TTL_VOLATILE
   return next;
 }
 
+// The builders lift the tail reminder off (splitTailReminder) before lowering and
+// cache marking, then append it here as the final text block, so the message
+// breakpoint stays on the block before it and the cached prefix is unchanged.
+export function appendAnthropicTailReminder(anthropicMessages, reminder) {
+  if (!reminder) return anthropicMessages;
+  const block = { type: 'text', text: reminder };
+  const last = anthropicMessages[anthropicMessages.length - 1];
+  if (last?.role === 'user') {
+    const content = typeof last.content === 'string' ? [{ type: 'text', text: last.content }] : last.content || [];
+    last.content = [...content, block];
+  } else {
+    anthropicMessages.push({ role: 'user', content: [block] });
+  }
+  return anthropicMessages;
+}
+
 export function resolveAnthropicCacheTtls(opts) {
   const strategy = opts?.cacheStrategy || {};
   const pick = (layer, fallback) => {
@@ -232,7 +249,8 @@ const ANTHROPIC_NATIVE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
 
 // `provider`: the engine's provider name. A gateway on a native Messages
 // route (wire-route.mjs) also replays the references it tagged itself.
-export function toAnthropicMessages(messages, availableTools, provider = '') {
+export function toAnthropicMessages(transcript, availableTools, provider = '') {
+  const messages = withWireToolCallIds(transcript, ANTHROPIC_TOOL_CALL_IDS);
   const ownProvider = String(provider || '').toLowerCase();
   const availableNames = anthropicToolNameSet(availableTools);
   const result = [];

package/src/runtime/agent/orchestrator/providers/lib/tail-reminder-split.mjs

@@ -0,0 +1,13 @@
+// The tail reminder (session/tail-reminder-rules.mjs) rides the outgoing request
+// as its last message, marked meta.source 'tail-reminder'. It is ephemeral: a
+// provider builder that keeps per-message state (cache breakpoints, message
+// counts, continuation indexes, tool-loop closure) lifts it off first with
+// splitTailReminder, builds from the real history, and appends the reminder as
+// the final wire element, so the history-derived prefix never contains it.
+export const TAIL_REMINDER_META = 'tail-reminder';
+
+export function splitTailReminder(messages) {
+  const last = Array.isArray(messages) ? messages[messages.length - 1] : null;
+  if (last?.role !== 'user' || last.meta?.source !== TAIL_REMINDER_META) return { messages, reminder: '' };
+  return { messages: messages.slice(0, -1), reminder: String(last.content || '') };
+}

package/src/runtime/agent/orchestrator/providers/lib/tool-call-wire-ids.mjs

@@ -0,0 +1,65 @@
+// Tool-call ids at the wire. A transcript keeps each tool call's id as the
+// provider that produced it minted it; after a model switch another provider
+// may refuse it (Anthropic accepts only [A-Za-z0-9_-]; OpenAI chat caps the
+// length). Each request builder projects the ids onto its own rule just
+// before lowering: a valid id passes unchanged (so native replay items and
+// the provider's own ids stay byte-exact), an invalid one becomes a
+// deterministic, collision-free stand-in, and a call and its result always
+// map to the same value. Persisted history is never rewritten.
+import { createHash } from 'node:crypto';
+
+export const ANTHROPIC_TOOL_CALL_IDS = Object.freeze({ allowed: /^[A-Za-z0-9_-]+$/, maxLength: 64 });
+export const OPENAI_RESPONSES_TOOL_CALL_IDS = Object.freeze({ allowed: /^[A-Za-z0-9_.:-]+$/, maxLength: 64 });
+export const OPENAI_CHAT_TOOL_CALL_IDS = Object.freeze({ allowed: /^[A-Za-z0-9_.:-]+$/, maxLength: 40 });
+
+const HASH_CHARS = 10;
+
+function standIn(id, rule, salt) {
+  const hash = createHash('sha256').update(`${salt}\u0000${id}`).digest('hex').slice(0, HASH_CHARS);
+  const stem = String(id)
+    .replace(/[^A-Za-z0-9_-]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, Math.max(0, rule.maxLength - HASH_CHARS - 1));
+  return stem ? `${stem}_${hash}` : `call_${hash}`.slice(0, rule.maxLength);
+}
+
+const isValid = (id, rule) => id.length > 0 && id.length <= rule.maxLength && rule.allowed.test(id);
+
+/** id → wire id for every tool call and result in `messages` under `rule`. */
+export function toolCallWireIdMap(messages, rule) {
+  const ids = new Set();
+  for (const message of Array.isArray(messages) ? messages : []) {
+    if (message?.role === 'assistant')
+      for (const call of message.toolCalls || []) if (call?.id) ids.add(String(call.id));
+    if (message?.role === 'tool' && message.toolCallId) ids.add(String(message.toolCallId));
+  }
+  const map = new Map();
+  const taken = new Set([...ids].filter((id) => isValid(id, rule)));
+  for (const id of ids) {
+    if (isValid(id, rule)) continue;
+    let salt = 0;
+    let wire = standIn(id, rule, salt);
+    while (taken.has(wire)) wire = standIn(id, rule, ++salt);
+    taken.add(wire);
+    map.set(id, wire);
+  }
+  return map;
+}
+
+/** `messages` with tool-call ids projected onto `rule`; the same array when none needs it. */
+export function withWireToolCallIds(messages, rule) {
+  const map = toolCallWireIdMap(messages, rule);
+  if (!map.size) return messages;
+  return messages.map((message) => {
+    if (message?.role === 'tool' && map.has(String(message.toolCallId))) {
+      return { ...message, toolCallId: map.get(String(message.toolCallId)) };
+    }
+    if (message?.role !== 'assistant' || !message.toolCalls?.some((call) => map.has(String(call?.id)))) return message;
+    return {
+      ...message,
+      toolCalls: message.toolCalls.map((call) =>
+        map.has(String(call?.id)) ? { ...call, id: map.get(String(call.id)) } : call
+      ),
+    };
+  });
+}

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -652,9 +652,17 @@ export function contentImageDescriptors(content) {
 // one-line description.
 // The page count (recorded by intake and by the read tool) rides on the part
 // itself, so an inline part and its stored reference carry the same one.
+// The text-layer character count (recorded with it) prices the text a native
+// reader extracts on top of each page image.
 function pdfDescriptor(sizeBytes, part) {
   const pageCount = Math.floor(Number(part?.pageCount));
-  return { mimeType: 'application/pdf', sizeBytes, ...(pageCount > 0 ? { pageCount } : {}) };
+  const textChars = Number(part?.textChars);
+  return {
+    mimeType: 'application/pdf',
+    sizeBytes,
+    ...(pageCount > 0 ? { pageCount } : {}),
+    ...(pageCount > 0 && Number.isFinite(textChars) && textChars >= 0 ? { textChars: Math.floor(textChars) } : {}),
+  };
 }
 
 export function contentFileDescriptors(content) {
@@ -974,6 +982,13 @@ function normalizeAnthropicPart(part) {
   if (part?.type === 'text' && isAttachmentReference(part)) {
     return { type: 'text', text: attachmentTextForPart(part) };
   }
+  // A media reference (attachment-reference.mjs) is a text part whose
+  // `attachmentReference` metadata stays in saved history. It is not a
+  // Messages API text-block field, and the API rejects the whole request for it.
+  if (part?.type === 'text' && part.attachmentReference !== undefined) {
+    const { attachmentReference: _internal, ...wirePart } = part;
+    return wirePart;
+  }
   return part;
 }
 

package/src/runtime/agent/orchestrator/providers/mixdog-local.mjs

@@ -13,8 +13,10 @@ import { beginLocalInference, localModelState } from '../../../local-provider/mo
 
 export class MixdogLocalProvider {
   static inputExcludesCache = false;
-  // The managed local runtime is text-only: PDFs lower to text.
+  // The managed local runtime is text-only: PDFs lower to text and images to
+  // a placeholder (input-capabilities.mjs).
   nativePdf = false;
+  takesImages = false;
 
   constructor(config = {}, { ensureServer = ensureLocalProviderServer, runRequest = runLocalProviderRequest } = {}) {
     this.name = 'mixdog-local';

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

@@ -111,6 +111,7 @@ export class ModelProxyProvider {
     // 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;
+    if (this.config.modelProxy?.takesImages === false) this.takesImages = false;
   }
 
   #call(method, fields = {}, options = {}) {

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

@@ -3,8 +3,9 @@
 // handshake-header projection, and the per-turn x-codex-turn-state guard.
 // openai-oauth-ws.mjs owns the transport flow only.
 import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { writeFileAtomicSync } from '../../../shared/atomic-file.mjs';
 import { cleanString } from '../../../shared/clean.mjs';
 import { getPluginData } from '../config.mjs';
 import { activateCodexTurnState } from './openai-turn-state.mjs';
@@ -77,15 +78,14 @@ function _codexInstallationId(sendOpts) {
   const generated = randomUUID();
   try {
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    try {
-      writeFileSync(file, generated, { encoding: 'utf8', flag: 'wx', mode: 0o644 });
-    } catch {
+    // Atomic create-if-absent; a damaged (empty/NUL) file is replaced whole.
+    if (!writeFileAtomicSync(file, generated, { createOnly: true, mode: 0o644 })) {
       const winner = readFileSync(file, 'utf8').trim().toLowerCase();
       if (UUID_RE.test(winner)) {
         _installationId = winner;
         return _installationId;
       }
-      writeFileSync(file, generated, { encoding: 'utf8', mode: 0o644 });
+      writeFileAtomicSync(file, generated, { mode: 0o644 });
     }
   } catch {}
   _installationId = generated;

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

@@ -94,10 +94,14 @@ async function compatModelsError(name, res, apiKey = '') {
 }
 
 // `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 } = {}) {
+// `signal` aborts the request together with the list timeout; `timeoutMs`
+// replaces the default list timeout for callers that wait on a slow catalog.
+export async function fetchCompatModelItems(
+  provider,
+  { signal = null, keyless = false, timeoutMs = MODEL_LIST_TIMEOUT_MS } = {}
+) {
   const name = provider.name;
-  const timeout = createTimeoutSignal(signal, MODEL_LIST_TIMEOUT_MS, `${name} model list`);
+  const timeout = createTimeoutSignal(signal, timeoutMs, `${name} model list`);
   try {
     const apiKey = keyless ? '' : resolveProviderApiKey(name, provider.config || provider);
     const res = await fetch(`${String(provider.baseURL || '').replace(/\/+$/, '')}/models`, {
@@ -137,9 +141,9 @@ function nativeMode(m) {
   return null;
 }
 
-export async function listCompatModels(provider, { throwOnError = false, signal = null } = {}) {
+export async function listCompatModels(provider, { throwOnError = false, signal = null, timeoutMs } = {}) {
   try {
-    const list = await provider._fetchModelItems({ signal });
+    const list = await provider._fetchModelItems({ signal, timeoutMs });
     const models = [];
     for (const m of list) {
       const contextWindow = Number(

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

@@ -29,6 +29,7 @@ import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning
 import { projectEffortConfiguration, withEffortConfigurationFallback } from './effort-configuration.mjs';
 import { normalizeCacheKey } from '../agent-runtime/cache-strategy.mjs';
 import { createProviderReplay } from './lib/provider-replay.mjs';
+import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 import {
   applyCompatToolChoice,
   compatResponsesReplayProvider,
@@ -296,7 +297,13 @@ export function sendCompatResponses(provider, messages, useModel, tools, opts =
   return withEffortConfigurationFallback(provider.name, useModel, opts, send);
 }
 
-async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts) {
+async function sendCompatResponsesOnce(provider, requestMessages, useModel, tools, opts) {
+  // The continuation state below is indexed by transcript position
+  // (seenMessageCount, reasoning messageIndex): the ephemeral tail reminder is
+  // not part of the transcript, so it is lifted off here and appended to the
+  // wire input last.
+  const { messages: transcript, reminder } = splitTailReminder(requestMessages);
+  let messages = transcript;
   const replayProvider = compatResponsesReplayProvider(provider.name);
   const signal = opts.signal || null;
   if (signal?.aborted) {
@@ -320,6 +327,7 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
     includeSystem: provider.config?.responsesSystemAsInstructions !== true,
   });
   const instructions = provider.config?.responsesSystemAsInstructions === true ? xaiSystemInstructions(messages) : '';
+  if (reminder) input.push({ role: 'user', content: [{ type: 'input_text', text: reminder }] });
   const params = buildCompatResponsesParams({
     provider,
     useModel,

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

@@ -104,10 +104,16 @@ export const COMPAT_RETRY_PROFILES = Object.freeze({
   }),
 });
 
-/** withRetry options (attempt budget, schedule, jitter) for a provider; {} for the shared defaults. */
+// A provider without a profile (custom endpoints, gateways, local servers)
+// keeps the shared ladder, but a Retry-After beyond a minute is not waited
+// out: it surfaces with its wait so the account pool can rotate and the
+// notice can name when to try again.
+export const COMPAT_DEFAULT_MAX_RETRY_AFTER_MS = 60_000;
+
+/** withRetry options (attempt budget, schedule, jitter) for a provider; only the advice ceiling for the shared defaults. */
 export function compatRetryOptions(providerName) {
   const profile = COMPAT_RETRY_PROFILES[providerName];
-  if (!profile) return {};
+  if (!profile) return { maxRetryAfterMs: COMPAT_DEFAULT_MAX_RETRY_AFTER_MS };
   return {
     maxAttempts: profile.maxAttempts,
     backoffMs: profile.backoffMs,

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

@@ -17,6 +17,11 @@ import {
 } from './media-normalization.mjs';
 import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from './custom-tool-wire.mjs';
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import {
+  OPENAI_CHAT_TOOL_CALL_IDS,
+  OPENAI_RESPONSES_TOOL_CALL_IDS,
+  withWireToolCallIds,
+} from './lib/tool-call-wire-ids.mjs';
 import { acceptedWireTools } from './lib/claude-bridge-schema.mjs';
 import { ensureResponsesCallOutputs } from './lib/wire-pairing.mjs';
 import { responsesEffortUpdates } from './effort-configuration.mjs';
@@ -34,7 +39,9 @@ export function resolveCompatMaxOutputTokens(opts = {}) {
   );
 }
 
-export function toOpenAIMessages(messages, providerName, options = {}) {
+export function toOpenAIMessages(transcript, providerName, options = {}) {
+  const messages =
+    options.preserveToolCallIds === true ? transcript : withWireToolCallIds(transcript, OPENAI_CHAT_TOOL_CALL_IDS);
   // NOTE: chat.completions has no equivalent slot for replaying reasoning
   // encrypted_content the way the Responses API does (no `type:'reasoning'`
   // input item). Whatever reasoningItems may be attached to assistant
@@ -421,7 +428,8 @@ export function xaiSystemInstructions(messages) {
   return instructions || undefined;
 }
 
-export function toXaiResponsesInput(messages, providerState, options = {}) {
+export function toXaiResponsesInput(transcript, providerState, options = {}) {
+  const messages = withWireToolCallIds(transcript, OPENAI_RESPONSES_TOOL_CALL_IDS);
   const includeSystem = options.includeSystem !== false;
   // Generic Responses callers (opencode-go gateway) keep their own state
   // slot and replay tag so a provider switch never replays foreign items.

package/src/runtime/agent/orchestrator/providers/openai-direct-request.mjs

@@ -41,7 +41,25 @@ function promptCacheForm(model) {
   return openAiSupportsExtendedRetention(model) ? 'retention' : null;
 }
 
-export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {
+// The environment developer item buildRequestBody places first in `input`:
+// the end of the session's stable prefix (tools + instructions + environment).
+// Top-level `instructions` cannot carry a breakpoint, so this is the earliest
+// place one fits.
+function stablePrefixBlock(body) {
+  const first = Array.isArray(body.input) ? body.input[0] : null;
+  const content = first?.type === 'message' && first.role === 'developer' ? first.content : null;
+  const block = Array.isArray(content) && content.length === 1 ? content[0] : null;
+  return block?.type === 'input_text' && String(block.text || '').startsWith('<environment_context>') ? block : null;
+}
+
+/**
+ * Public-API cache lifetime fields. GPT-5.6+: request ttl "30m" for the
+ * moving tail; `prefixTtl` '12h' (Lead class, cache-strategy.mjs
+ * resolveOpenAiPrefixCacheTtl) adds one explicit 12h breakpoint at the end of
+ * the stable prefix in the default implicit mode, so the implicit tail
+ * breakpoint stays 30m. Earlier models are unchanged.
+ */
+export function applyOpenAIDirectCachePolicy(body, model, storeResponses, { prefixTtl = null } = {}) {
   body.store = storeResponses;
   delete body.prompt_cache_retention;
   delete body.prompt_cache_options;
@@ -49,7 +67,16 @@ export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {
   // response storage is disabled. The provider's default cache still applies.
   if (!storeResponses) return body;
   const form = promptCacheForm(model);
-  if (form === 'options') body.prompt_cache_options = { ttl: '30m' };
-  else if (form === 'retention') body.prompt_cache_retention = '24h';
+  if (form === 'options') {
+    body.prompt_cache_options = { ttl: '30m' };
+    const block = prefixTtl === '12h' ? stablePrefixBlock(body) : null;
+    if (block) {
+      const [first, ...rest] = body.input;
+      body.input = [
+        { ...first, content: [{ ...block, prompt_cache_breakpoint: { mode: 'explicit', ttl: '12h' } }] },
+        ...rest,
+      ];
+    }
+  } else if (form === 'retention') body.prompt_cache_retention = '24h';
   return body;
 }

package/src/runtime/agent/orchestrator/providers/openai-model-capabilities.mjs

@@ -25,7 +25,7 @@ export function openAiCatalogMeta(model) {
 // gpt-5.4 -> [5, 4]; gpt-6-astra -> [6, 0]; non-GPT ids -> null.
 // A bare multi-digit major with no minor or family suffix (gpt-60) is not a
 // generation id.
-function gptVersion(id) {
+export function gptVersion(id) {
   const m = /^gpt-(\d+)(?:\.(\d+))?(?=-|$)/.exec(id);
   if (!m || (m[1].length > 1 && m[2] === undefined && m[0] === id)) return null;
   return [Number(m[1]), Number(m[2] || 0)];

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

@@ -1,6 +1,7 @@
 // Transcript lowering is independent of request/turn metadata. A retained
 // message must have the same wire representation in every subsequent request.
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import { OPENAI_RESPONSES_TOOL_CALL_IDS, withWireToolCallIds } from './lib/tool-call-wire-ids.mjs';
 import { responsesEffortUpdates } from './effort-configuration.mjs';
 import { ensureResponsesCallOutputs } from './lib/wire-pairing.mjs';
 import { normalizeContentForOpenAIResponses, splitToolContentForOpenAIResponses } from './media-normalization.mjs';
@@ -147,7 +148,8 @@ function pushAssistantToolCalls(toolCalls, { out, customToolCallIds, nativeSearc
  *  - `includeSystem`, `nativePdf`, `splitToolContent`, `startIndex`: the
  *    gateway's system/media/continuation handling.
  */
-export function convertMessagesToResponsesInput(messages, opts = {}) {
+export function convertMessagesToResponsesInput(transcript, opts = {}) {
+  const messages = withWireToolCallIds(transcript, OPENAI_RESPONSES_TOOL_CALL_IDS);
   const out = [];
   const pendingToolMedia = [];
   const pendingToolLoads = [];

package/src/runtime/agent/orchestrator/providers/openai-ws.mjs

@@ -142,7 +142,9 @@ export class OpenAIDirectProvider {
     // Keep public response storage and model-specific cache options out of
     // the shared OAuth payload. Storage opt-out still forces full frames in
     // _computeDelta; retained output items make those frames self-contained.
-    applyOpenAIDirectCachePolicy(body, useModel, _envFlag('MIXDOG_OAI_STORE', true));
+    applyOpenAIDirectCachePolicy(body, useModel, _envFlag('MIXDOG_OAI_STORE', true), {
+      prefixTtl: opts.promptCachePrefixTtl || null,
+    });
     // poolKey MUST be sessionId-only. Falling back to promptCacheKey would
     // let unrelated raw sessions sharing the same provider-scoped cache
     // bucket reuse each other's pooled socket and inherit lastResponseId

package/src/runtime/agent/orchestrator/providers/opencode-go-oauth.mjs

@@ -4,11 +4,14 @@
  * The organization's remote config (`/api/v2/config` → providers.opencode-go)
  * is the authority for the inference base URL, the request headers and the
  * model catalog (the gateway's own `/models` is not served on this base).
+ * When that config lists no models at all (the console serves `models: {}` for
+ * an organization without overrides, as the OpenCode CLI sees it), the catalog
+ * is the models.dev `opencode-go` provider, the list the CLI itself shows.
  * Requests run on the OpenCode Go gateway engines (opencode-go.mjs) with the
  * access token as the bearer; a 401 refreshes the token once and retries.
  */
 import { scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
-import { getModelMetadataSync } from './model-catalog.mjs';
+import { getModelMetadataSync, getModelsDevProviderModelsSync, loadModelsDevCatalog } from './model-catalog.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { OpenCodeGoProvider, WIRE_API_BY_NPM, resolveOpenCodeGoWireRoute } from './opencode-go.mjs';
 import { fetchOpenCodeGoOAuthUsageSnapshot } from './opencode-go-usage.mjs';
@@ -90,11 +93,51 @@ function catalogRow(id, model, providerPackage) {
   };
 }
 
+// A models.dev row in the remote config's model shape, for catalogRow.
+function configModelFromModelsDev(row) {
+  const cost = isPlainObject(row.cost) ? row.cost : null;
+  const effort = Array.isArray(row.reasoning_options)
+    ? row.reasoning_options.find((option) => option?.type === 'effort')?.values
+    : null;
+  return {
+    name: row.name,
+    ...(typeof row.npm === 'string' ? { package: row.npm } : {}),
+    limit: row.limit,
+    ...(cost
+      ? { cost: { input: cost.input, output: cost.output, cache: { read: cost.cache_read, write: cost.cache_write } } }
+      : {}),
+    ...(typeof row.reasoning === 'boolean'
+      ? { capabilities: { reasoning: { supported: row.reasoning, ...(effort ? { effort } : {}) } } }
+      : {}),
+  };
+}
+
+// models.dev serves the Go models over the OpenAI-compatible package unless a row names its own.
+const MODELS_DEV_PROVIDER_PACKAGE = '@ai-sdk/openai-compatible';
+
+const listsGoModels = (json) => Object.keys(json?.providers?.[CONFIG_PROVIDER_KEY]?.models || {}).length > 0;
+
+// The models.dev Go catalog, loaded first because the sync read is null on a cold cache.
+// The loader swallows its own failure, so a missing catalog is a failed discovery
+// (the last published roster stays), never an authoritative empty roster.
+async function loadModelsDevGoModels() {
+  await loadModelsDevCatalog();
+  const models = getModelsDevProviderModelsSync(CONFIG_PROVIDER_KEY);
+  if (!models || Object.keys(models).length === 0) {
+    throw openCodeGoError(
+      `[${PROVIDER_ID}] the OpenCode organization config lists no models and the models.dev OpenCode Go catalog is unavailable`,
+      { kind: 'catalog' }
+    );
+  }
+  return models;
+}
+
 /**
  * The Go provider of a remote config response: `{ baseURL, headers, models }`
- * with one catalog row per enabled model.
+ * with one catalog row per enabled model. A config that lists no models takes
+ * the models.dev Go models (`modelsDevModels`, id → row) instead.
  */
-export function goConfigFromResponse(json) {
+export function goConfigFromResponse(json, modelsDevModels = null) {
   const entry = json?.providers?.[CONFIG_PROVIDER_KEY];
   if (!isPlainObject(entry)) {
     throw openCodeGoError(`[${PROVIDER_ID}] the OpenCode organization config has no OpenCode Go provider`, {
@@ -102,9 +145,20 @@ export function goConfigFromResponse(json) {
     });
   }
   const providerPackage = typeof entry.package === 'string' ? entry.package : '';
-  const models = Object.entries(isPlainObject(entry.models) ? entry.models : {})
+  const fallback = !listsGoModels(json) && isPlainObject(modelsDevModels);
+  const source = fallback
+    ? Object.fromEntries(
+        Object.entries(modelsDevModels).map(([id, row]) => [
+          id,
+          isPlainObject(row) ? configModelFromModelsDev(row) : row,
+        ])
+      )
+    : isPlainObject(entry.models)
+      ? entry.models
+      : {};
+  const models = Object.entries(source)
     .filter(([id, model]) => id && isPlainObject(model) && model.disabled !== true)
-    .map(([id, model]) => catalogRow(id, model, providerPackage));
+    .map(([id, model]) => catalogRow(id, model, fallback ? MODELS_DEV_PROVIDER_PACKAGE : providerPackage));
   return {
     baseURL:
       typeof entry.settings?.baseURL === 'string' && entry.settings.baseURL
@@ -172,9 +226,8 @@ export class OpenCodeGoOAuthProvider {
       const current = loadTokens();
       return current?.account_id === tokens.account_id && current?.org_id === tokens.org_id;
     });
-    const remote = goConfigFromResponse(
-      await consoleGetJson(CONFIG_URL, tokens, { fetchFn: this.config.fetchImpl, refresh: true })
-    );
+    const response = await consoleGetJson(CONFIG_URL, tokens, { fetchFn: this.config.fetchImpl, refresh: true });
+    const remote = goConfigFromResponse(response, listsGoModels(response) ? null : await loadModelsDevGoModels());
     publish(remote.models, {
       baseURL: remote.baseURL,
       headers: remote.headers,

package/src/runtime/agent/orchestrator/providers/provider-error-kind.mjs

@@ -335,8 +335,19 @@ const CODE_KINDS = new Map(
     quota_exhausted: ['quota_exceeded', 'quota_exhausted', 'usage_limit_reached', 'provider_accounts_exhausted'],
     context_overflow: ['context_length_exceeded', 'context_window_exceeded', 'model_context_window_exceeded'],
     request_too_large: ['request_too_large', 'payload_too_large', 'request_entity_too_large'],
-    auth: ['invalid_api_key', 'authentication_error', 'unauthenticated', 'unauthorized', 'invalid_authentication'],
-    permission: ['permission_error', 'permission_denied', 'forbidden'],
+    // Google names a rejected or expired key with an ErrorInfo reason on an
+    // INVALID_ARGUMENT 400; the reason outranks the envelope status.
+    auth: [
+      'invalid_api_key',
+      'authentication_error',
+      'unauthenticated',
+      'unauthorized',
+      'invalid_authentication',
+      'api_key_invalid',
+      'api_key_expired',
+      'access_token_expired',
+    ],
+    permission: ['permission_error', 'permission_denied', 'forbidden', 'service_disabled', 'api_key_service_blocked'],
     overloaded: [
       'server_is_overloaded',
       'overloaded_error',
@@ -374,6 +385,7 @@ const CODE_KINDS = new Map(
       'not_found',
       'not_found_error',
       'model_not_found',
+      'model_not_supported',
       'unsupported_parameter',
     ],
   }).flatMap(([kind, codes]) => codes.map((code) => [code, kind]))

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -509,6 +509,15 @@ export function providerInputExcludesCache(name) {
 export function providerNativePdf(name) {
   return providerTakesNativePdf(providers.get(String(name || '').toLowerCase()));
 }
+/**
+ * Whether the named provider sends image input to its models: false only for
+ * an adapter that declares `takesImages = false` (the text-only local
+ * runtime, which lowers every image to a placeholder). A pure lookup; an
+ * unknown provider is treated as taking images, as attachments are.
+ */
+export function providerReadsImages(name) {
+  return providers.get(String(name || '').toLowerCase())?.takesImages !== false;
+}
 /**
  * Whether the named provider's adapter declares `consumesReadWindows`: it
  * needs the structured clip report of read results. A pure lookup; a proxy