mixdog 1.3.1 → 1.3.2

package/src/runtime/agent/orchestrator/providers/cursor-wire.mjs

@@ -40,8 +40,10 @@ import {
   textContent,
 } from './cursor-wire-request.mjs';
 import { handleExecMessage, heartbeatFrame, sendToolResult } from './cursor-wire-exec.mjs';
+import { releaseCursorNativeCall } from './cursor-native-context.mjs';
 import { completionChunk, createStreamSink } from './cursor-wire-stream-sink.mjs';
 import { createBridgeController } from './cursor-wire-stream-bridge.mjs';
+import { markProviderRecoveryExhausted } from './retry-classifier.mjs';
 import { TRANSPORT_SCOPE_DISPOSED } from './transport-scope.mjs';
 
 export { clearModelCache, getCursorModels, getCursorUsage } from './cursor-wire-models.mjs';
@@ -70,16 +72,22 @@ function storeActiveRun(key, active) {
   activeRuns.set(key, active);
 }
 
-// Tear down one stored run: drop it from the registry, stop its 5s heartbeat
-// interval, and close the Cursor bridge it was holding open.
-function closeActiveRun(key, active, error) {
-  if (!forgetActiveRun(key, active)) return false;
+function disposeActiveRun(active, error) {
   clearInterval(active.heartbeat);
+  for (const pending of active.pending) releaseCursorNativeCall(pending);
+  active.pending = [];
   try {
     active.bridge.close(error);
   } catch {
     /* already closing */
   }
+}
+
+// Tear down one stored run: drop it from the registry, stop its 5s heartbeat
+// interval, and close the Cursor bridge it was holding open.
+function closeActiveRun(key, active, error) {
+  if (!forgetActiveRun(key, active)) return false;
+  disposeActiveRun(active, error);
   return true;
 }
 
@@ -458,6 +466,25 @@ function resumeRun(active, toolResults, userText, model, key) {
     }
     sendToolResult(active.bridge, pending, payload, result.isError !== true);
   }
+  // Every pending call was already handed to the executor. Re-emitting the
+  // same batch without accepting a result makes the transcript rename its
+  // ids, breaks native authorization, and can loop without another model call.
+  // Partial progress is valid; an unchanged pending batch is a terminal
+  // handoff failure, not a transport retry or an invitation to execute again.
+  if (remaining.length > 0 && remaining.length === active.pending.length) {
+    const error = markProviderRecoveryExhausted(
+      cursorError(
+        `Cursor tool-result handoff made no progress: ${remaining.length} pending call(s) received no matching result. Stopped to avoid repeating tool execution.`,
+        { status: 400, code: 'tool_result_no_progress' }
+      ),
+      { owner: 'cursor-wire', terminal: true }
+    );
+    // handleChatCompletion already detached this run; direct partial-batch
+    // resumes may still own its registry entry and expiry timer.
+    forgetActiveRun(key, active);
+    disposeActiveRun(active, error);
+    throw error;
+  }
   active.pending = remaining;
   active.pendingUserText = userTextDelivered ? '' : pendingUserText;
   if (remaining.length > 0) {

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

@@ -35,7 +35,10 @@ async function loadCursorRuntime() {
 function toCursorMessages(messages, providerName, { nativePdf } = {}) {
   const output = [];
   for (const message of messages || []) {
-    const converted = toOpenAIMessages([message], providerName, { nativePdf });
+    // This is a local envelope over Cursor's execution protocol, not an
+    // OpenAI request. Its pending executions and native capabilities require
+    // the exact original id, including ids longer than OpenAI's 40-char cap.
+    const converted = toOpenAIMessages([message], providerName, { nativePdf, preserveToolCallIds: true });
     if (message?.role !== 'tool') {
       output.push(...converted);
       continue;

package/src/runtime/agent/orchestrator/providers/custom-provider.mjs

@@ -40,6 +40,7 @@ function sanitizeDiscoveryError(error, apiKey) {
   if (apiKey) message = message.split(apiKey).join('[redacted]');
   const out = new Error(message);
   if (Number.isInteger(error?.status)) out.status = error.status;
+  if (error?.code === 'EPROVIDERTIMEOUT' || error?.name === 'TimeoutError') out.code = 'EPROVIDERTIMEOUT';
   return out;
 }
 
@@ -82,11 +83,13 @@ function withCustomModels(Base, discover) {
       const first = rows.find((row) => !row.hidden);
       if (first) this.defaultModel = first.id;
     }
-    async listModels({ signal = null, throwOnError = false } = {}) {
+    // `timeoutMs` lets an interactive caller wait longer than the default
+    // catalog timeout (slow gateways); the runtime refresh keeps the default.
+    async listModels({ signal = null, throwOnError = false, timeoutMs } = {}) {
       let failure = null;
       try {
         this._assertCustomKey();
-        this._customDiscovered = await discover(this, signal);
+        this._customDiscovered = await discover(this, signal, timeoutMs);
         this.customDiscoveryError = null;
       } catch (error) {
         if (signal?.aborted) throw error;
@@ -109,8 +112,8 @@ function withCustomModels(Base, discover) {
   };
 }
 
-async function discoverAnthropicModels(provider, signal) {
-  const timeout = AbortSignal.timeout(DISCOVERY_TIMEOUT_MS);
+async function discoverAnthropicModels(provider, signal, timeoutMs = DISCOVERY_TIMEOUT_MS) {
+  const timeout = AbortSignal.timeout(timeoutMs);
   const res = await fetch(`${provider.config.baseURL}/v1/models`, {
     method: 'GET',
     signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
@@ -182,8 +185,8 @@ export async function createCustomProvider(id, config) {
     }
     class CompatBase extends OpenAICompatProvider {
       messagesEngine = messagesEngine;
-      _fetchModelItems({ signal = null } = {}) {
-        return fetchCompatModelItems(this, { signal, keyless: this._customKeyless });
+      _fetchModelItems({ signal = null, timeoutMs } = {}) {
+        return fetchCompatModelItems(this, { signal, timeoutMs, keyless: this._customKeyless });
       }
       resolveWireRoute(model, ctx = {}) {
         return resolveWireRoute(this.name, model, { ...ctx, override: cfg.modelWires?.[model] ?? null });
@@ -203,8 +206,8 @@ export async function createCustomProvider(id, config) {
         });
       }
     }
-    const Custom = withCustomModels(CompatBase, (self, signal) =>
-      listCompatModels(self, { throwOnError: true, signal })
+    const Custom = withCustomModels(CompatBase, (self, signal, timeoutMs) =>
+      listCompatModels(self, { throwOnError: true, signal, timeoutMs })
     );
     provider = new Custom(providerId, engine);
   }

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

@@ -82,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) => {

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/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-wire.mjs

@@ -40,7 +40,8 @@ export function resolveCompatMaxOutputTokens(opts = {}) {
 }
 
 export function toOpenAIMessages(transcript, providerName, options = {}) {
-  const messages = withWireToolCallIds(transcript, OPENAI_CHAT_TOOL_CALL_IDS);
+  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

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-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/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