mixdog 1.2.1 → 1.2.3

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

@@ -18,6 +18,7 @@ import { withEffortConfigurationFallback } from './effort-configuration.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { sendViaHttpSse, _envFlag } from './openai-oauth-http-sse.mjs';
+import { waitForRetryDeadline } from './openai-error-contract.mjs';
 import { isWsMessageTooBigClose, shouldFallbackTransport } from './retry-classifier.mjs';
 import { resolveOpenAiTransportPolicy } from './openai-transport-policy.mjs';
 import { applyOpenAIDirectCachePolicy } from './openai-direct-request.mjs';
@@ -77,6 +78,9 @@ export class OpenAIDirectProvider {
   // input_tokens INCLUDES cached tokens (OpenAI convention). See registry.mjs.
   static inputExcludesCache = false;
   name = 'openai';
+  // Loop retry policy (send-with-recovery loopRetryPolicy): a connect failure waits for
+  // the network, and a content_filter refusal is replayed under the budget.
+  retryPolicy = Object.freeze({ unboundedConnectionRetry: true, contentFilterRetryable: true });
   config;
   // Sessions (WS pool keys) the server refused with close 1009. Every later
   // full frame of such a session would be refused again, so it stays on
@@ -107,6 +111,10 @@ export class OpenAIDirectProvider {
     }
     return null;
   }
+  /** Drop a disposed transport scope's sticky transport record. */
+  releaseTransportScope(scope) {
+    this._httpFallbackPoolKeys.delete(scope);
+  }
   send(messages, model, tools, sendOpts) {
     return withEffortConfigurationFallback('openai', model, sendOpts || {}, (opts) =>
       this._sendOnce(messages, model, tools, opts)
@@ -135,8 +143,9 @@ export class OpenAIDirectProvider {
     // 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
-    // delta state, producing cross-session prompt corruption.
-    const poolKey = opts.sessionId || null;
+    // delta state, producing cross-session prompt corruption. A forked
+    // request runs in its own transport scope (transport-scope.mjs).
+    const poolKey = opts.transportScope || opts.sessionId || null;
     // cacheKey (prompt_cache_key) only groups the server-side prefix-cache
     // shard — safe to share across sessions, unlike the sessionId poolKey
     // above. buildRequestBody derives it from the base namespace plus a
@@ -190,26 +199,14 @@ export class OpenAIDirectProvider {
     // any liveTextEmitted/emittedToolCall/unsafeToRetry outcome.
     const transportPolicy = resolveOpenAiTransportPolicy();
     const httpFallbackEnabled = transportPolicy.allowHttpFallback && _envFlag('MIXDOG_OPENAI_HTTP_FALLBACK', true);
-    const dispatchHttp = (a) => {
-      if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) {
-        process.stderr.write('[openai-ws] WebSocket unhealthy; falling back to HTTP/SSE\n');
-      }
-      return sendHttp({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
-    };
-    // Transport-policy switch (MIXDOG_OAI_TRANSPORT). 'http-sse' forces the
-    // HTTP/SSE transport directly — no WS attempt, so skip the fallback log
-    // that dispatchHttp emits (it is not a fallback here). All other modes
-    // ('auto'/'ws-full'/'ws-delta') keep the WS-first path below; ws-full vs
-    // ws-delta only affects the delta gate inside openai-ws-delta.mjs.
-    if (
-      transportPolicy.transport === 'http' ||
-      (poolKey && httpFallbackEnabled && this._httpFallbackPoolKeys.has(poolKey))
-    ) {
+    // One HTTP/SSE send with the single replay-safe 401 key reload. `reload`
+    // is false when the key was already reloaded earlier in this send.
+    const sendHttpWithKeyReload = async (a, reload = true) => {
       try {
-        return await sendHttp({ ...common, auth, opts, fetchFn: opts._fetchFn });
+        return await sendHttp({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
       } catch (err) {
         const unsafe = err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
-        if (err?.httpStatus !== 401 || unsafe) throw err;
+        if (!reload || err?.httpStatus !== 401 || unsafe) throw err;
         // The replay discards this attempt; its reported usage stays billed.
         noteErrorUsage(err);
         process.stderr.write('[openai-ws] 401 — reloading apiKey and retrying once over HTTP\n');
@@ -222,10 +219,32 @@ export class OpenAIDirectProvider {
           fetchFn: opts._fetchFn,
         });
       }
+    };
+    const dispatchHttp = (a, reload = true) => {
+      if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) {
+        process.stderr.write('[openai-ws] WebSocket unhealthy; falling back to HTTP/SSE\n');
+      }
+      return sendHttpWithKeyReload(a, reload);
+    };
+    // Transport-policy switch (MIXDOG_OAI_TRANSPORT). 'http-sse' forces the
+    // HTTP/SSE transport directly — no WS attempt, so skip the fallback log
+    // that dispatchHttp emits (it is not a fallback here). All other modes
+    // ('auto'/'ws-full'/'ws-delta') keep the WS-first path below; ws-full vs
+    // ws-delta only affects the delta gate inside openai-ws-delta.mjs.
+    if (
+      transportPolicy.transport === 'http' ||
+      (poolKey &&
+        httpFallbackEnabled &&
+        // A forked scope follows its session's refusal; it records its own.
+        (this._httpFallbackPoolKeys.has(poolKey) || this._httpFallbackPoolKeys.has(opts.sessionId)))
+    ) {
+      return await sendHttpWithKeyReload(auth);
     }
-    const fallbackHttp = (a, error) => {
+    const fallbackHttp = async (a, error, reload = true) => {
       if (poolKey && isWsMessageTooBigClose(error)) this._httpFallbackPoolKeys.add(poolKey);
-      return dispatchHttp(a);
+      // Changing transport must not bypass the server's retry deadline.
+      await waitForRetryDeadline(error, externalSignal, opts._sleepFn);
+      return dispatchHttp(a, reload);
     };
     try {
       return await dispatchWs(auth);
@@ -254,7 +273,7 @@ export class OpenAIDirectProvider {
             return await dispatchWs(retryAuth);
           } catch (retryErr) {
             if (shouldFallbackDirectTransport(retryErr, { signal: externalSignal, enabled: httpFallbackEnabled })) {
-              return await fallbackHttp(retryAuth, retryErr);
+              return await fallbackHttp(retryAuth, retryErr, false);
             }
             throw retryErr;
           }

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

@@ -0,0 +1,170 @@
+/**
+ * OpenCode Go's Gemini route: `@ai-sdk/google` models are served by the
+ * gateway's generateContent endpoint, `{base}/models/{id}:streamGenerateContent`
+ * (https://opencode.ai/docs/go/ — Endpoints table). This engine reuses the
+ * direct Gemini adapter's request builder, stream consumer, retry ladder and
+ * result shaping, and only moves the transport onto the gateway: the Go key
+ * (never GEMINI_API_KEY) goes to the Go origin only, as a bearer token and the
+ * `x-goog-api-key` header, with the session / User-Agent headers of every Go
+ * request. Gateway models have no explicit cachedContents.
+ */
+import { GeminiProvider, geminiRestError } from './gemini.mjs';
+import { GEMINI_FIRST_BYTE_TIMEOUT_MS, consumeGeminiRestStreamResponse } from './gemini-stream.mjs';
+import { geminiBareModelId } from './gemini-cache-policy.mjs';
+import { geminiFailureUsage } from './gemini-response.mjs';
+import { geminiEndsWithFunctionResponse, runGeminiStreamAttempts } from './gemini-retry-policy.mjs';
+import { geminiTextLeakGuardFor } from './gemini-sdk-request.mjs';
+import { emitProviderRetryStage } from './retry-classifier.mjs';
+import { originBoundFetch } from './lib/origin-bound-fetch.mjs';
+import { createPassthroughSignal, createTimeoutSignal } from '../stall-policy.mjs';
+import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
+
+const PROVIDER = 'opencode-go';
+
+/** The generateContent request body for a built Gemini request. */
+export function openCodeGoGeminiBody({ contents, systemInstruction, geminiTools, toolConfig, generationConfig, safetySettings }) {
+  return {
+    contents,
+    ...(systemInstruction ? { systemInstruction: { parts: [{ text: systemInstruction }] } } : {}),
+    ...(geminiTools ? { tools: geminiTools } : {}),
+    ...(toolConfig ? { toolConfig } : {}),
+    ...(generationConfig ? { generationConfig } : {}),
+    ...(safetySettings ? { safetySettings } : {}),
+  };
+}
+
+export class OpenCodeGoGeminiEngine extends GeminiProvider {
+  name = PROVIDER;
+
+  /** @param {object} config  the Go provider config; `baseURL` is the OpenAI-style `.../v1` base */
+  constructor(config) {
+    const base = String(config.baseURL || '').replace(/\/+$/, '');
+    super({
+      ...config,
+      fetchFn: originBoundFetch(new URL(base).origin, config.fetchImpl, PROVIDER),
+      // No Google host to warm and no Google SDK client: this engine never uses either.
+      preconnectFn: () => {},
+      createGenAI: () => null,
+    });
+    this.gatewayBase = base;
+  }
+
+  _getApiKey() {
+    return resolveProviderApiKey(PROVIDER, this.config);
+  }
+
+  reloadApiKey() {
+    const key = reloadProviderApiKey(PROVIDER, this.config);
+    if (key) this.config = { ...(this.config || {}), apiKey: key };
+    return key || '';
+  }
+
+  async isAvailable() {
+    return Boolean(this._getApiKey());
+  }
+
+  // The gateway has no cachedContents resource.
+  async _ensureGeminiCache() {
+    return null;
+  }
+
+  _headers(opts) {
+    const key = this._getApiKey();
+    return {
+      'Content-Type': 'application/json',
+      ...(key ? { Authorization: `Bearer ${key}`, 'x-goog-api-key': key } : {}),
+      ...(this.config?.extraHeaders || {}),
+      ...(opts?.requestHeaders || {}),
+    };
+  }
+
+  _url(model, method) {
+    return `${this.gatewayBase}/models/${encodeURIComponent(geminiBareModelId(model))}:${method}`;
+  }
+
+  async _openGatewayStream(url, body, opts, attemptSignal) {
+    const openFirstByte = createTimeoutSignal(attemptSignal, GEMINI_FIRST_BYTE_TIMEOUT_MS, 'OpenCode Go Gemini first byte');
+    let res;
+    try {
+      res = await this._fetch(url, {
+        method: 'POST',
+        headers: this._headers(opts),
+        body: JSON.stringify(body),
+        signal: openFirstByte.signal,
+        dispatcher: getLlmDispatcher(),
+      });
+    } finally {
+      openFirstByte.cleanup();
+    }
+    if (!res.ok) {
+      throw geminiRestError(res, await res.text().catch(() => ''), 'OpenCode Go Gemini streamGenerateContent');
+    }
+    return res;
+  }
+
+  async _generateContent(model, body, opts, signal) {
+    const res = await this._fetch(this._url(model, 'generateContent'), {
+      method: 'POST',
+      headers: this._headers(opts),
+      body: JSON.stringify(body),
+      signal,
+      dispatcher: getLlmDispatcher(),
+    });
+    if (!res.ok) {
+      throw geminiRestError(res, await res.text().catch(() => ''), 'OpenCode Go Gemini generateContent');
+    }
+    return await res.json();
+  }
+
+  async _streamViaSdk(stream) {
+    const { opts, signal, useModel, contents, callbacks } = stream;
+    const body = openCodeGoGeminiBody(stream);
+    const url = `${this._url(useModel, 'streamGenerateContent')}?alt=sse`;
+    const passthrough = createPassthroughSignal(signal);
+    try {
+      return await runGeminiStreamAttempts({
+        signal: passthrough.signal,
+        sleepFn: this.config?.sleepFn,
+        onRetry: ({ attempt, maxAttempts, lastErr, delayMs }) => {
+          emitProviderRetryStage(opts.onStageChange, { attempt: attempt + 1, maxAttempts, lastErr, delayMs });
+          process.stderr.write(
+            `[opencode-go:gemini] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}\n`
+          );
+        },
+        afterToolResult: geminiEndsWithFunctionResponse(contents),
+        run: async ({ signal: attemptSignal, connected }) => {
+          try {
+            opts.onStageChange?.('requesting');
+          } catch {
+            /* heartbeat best-effort */
+          }
+          const res = await this._openGatewayStream(url, body, opts, attemptSignal);
+          connected();
+          const textLeakGuard = geminiTextLeakGuardFor(stream);
+          const response = await consumeGeminiRestStreamResponse(res, {
+            signal: attemptSignal,
+            onStreamDelta: callbacks.onStreamDelta,
+            onTextDelta: callbacks.onTextDelta,
+            textLeakGuard,
+            label: 'OpenCode Go Gemini streamGenerateContent',
+            failureUsage: geminiFailureUsage(opts, null, useModel),
+          });
+          return { response, textLeakGuard };
+        },
+      });
+    } catch (err) {
+      const recovered = await this._recoverGeminiNonStreaming({
+        streamErr: err,
+        signal: passthrough.signal,
+        opts,
+        model: useModel,
+        generate: (fallbackSignal) => this._generateContent(useModel, body, opts, fallbackSignal),
+      });
+      if (!recovered) throw err;
+      return { response: recovered, textLeakGuard: null };
+    } finally {
+      passthrough.cleanup();
+    }
+  }
+}

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

@@ -1,30 +1,49 @@
 import { randomUUID } from 'node:crypto';
 import { AnthropicProvider } from './anthropic.mjs';
 import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs';
-import { currentUsageContext } from '../../../shared/llm/usage-context.mjs';
 import { getModelMetadataSync, getModelsDevRowSync } from './model-catalog.mjs';
+import { toInclusiveUsage, withInclusiveUsage } from './lib/inclusive-usage.mjs';
+import { providerOffersWire, resolveWireRoute, sendOnRoute } from './wire-route.mjs';
+import { gatewayMessagesOpts } from './wire-gateway.mjs';
+
+// The Go Anthropic route: the shared request builder gets the model's output
+// ceiling (models.dev limit) through the gateway options.
+class OpenCodeGoMessagesEngine extends AnthropicProvider {
+  _sendOnce(messages, model, tools, opts) {
+    return super._sendOnce(messages, model, tools, gatewayMessagesOpts(this.config, model, messages, opts));
+  }
+}
 
 // OpenCode Go publishes OpenAI chat/completions, OpenAI Responses, and
 // Anthropic Messages endpoints, and each upstream brand answers on only one
-// of them (muse-spark / gpt / grok 500 on chat/completions; minimax expects
-// Messages). models.dev names the SDK package per model, which is the
-// authoritative wire selector; the prefix tables are the cold-catalog fallback.
-const ANTHROPIC_MODEL_PREFIXES = ['minimax-', 'qwen'];
-const RESPONSES_MODEL_PREFIXES = ['muse-spark-', 'gpt-', 'grok-'];
+// of them (muse-spark / gpt / grok 500 on chat/completions; minimax and
+// Claude expect Messages). models.dev names the SDK package per model, which
+// is the authoritative wire selector; wire-route.mjs holds the cold-catalog
+// prefix fallback. `@ai-sdk/google` names the Gemini generateContent wire
+// (opencode-go-gemini.mjs).
 const WIRE_API_BY_NPM = Object.freeze({
   '@ai-sdk/openai': 'responses',
   '@ai-sdk/anthropic': 'messages',
   '@ai-sdk/openai-compatible': 'chat',
+  '@ai-sdk/google': 'gemini',
 });
 
+function openCodeGoCatalogWire(model) {
+  const npm = getModelsDevRowSync(String(model || ''), 'opencode-go')?.npm;
+  return typeof npm === 'string' && Object.hasOwn(WIRE_API_BY_NPM, npm) ? WIRE_API_BY_NPM[npm] : null;
+}
+
+function resolveOpenCodeGoWireRoute(model, ctx = {}) {
+  const catalogWire = openCodeGoCatalogWire(model);
+  // Each Go model answers on the one wire the catalog names: it narrows the
+  // offered endpoints, so an override cannot pick a wire the model lacks.
+  const endpoints = providerOffersWire('opencode-go', catalogWire) ? [catalogWire] : null;
+  return resolveWireRoute('opencode-go', model, { ...ctx, catalogWire, endpoints });
+}
+
 /** Wire API for a Go model: 'responses' | 'messages' | 'chat'. */
 function openCodeGoWireApi(model) {
-  const id = String(model || '').toLowerCase();
-  const npm = getModelsDevRowSync(String(model || ''), 'opencode-go')?.npm;
-  if (npm && WIRE_API_BY_NPM[npm]) return WIRE_API_BY_NPM[npm];
-  if (RESPONSES_MODEL_PREFIXES.some((prefix) => id.startsWith(prefix))) return 'responses';
-  if (ANTHROPIC_MODEL_PREFIXES.some((prefix) => id.startsWith(prefix))) return 'messages';
-  return 'chat';
+  return resolveOpenCodeGoWireRoute(model).wire;
 }
 
 export function isAnthropicGoModel(model) {
@@ -48,42 +67,8 @@ export function openCodeGoEndpointForModel(model, configuredBaseURL) {
   return `${bases.openai}/chat/completions`;
 }
 
-// Usage objects already converted to the inclusive convention; a converted
-// object passing through another normalization (nested send) stays as is,
-// and one source object always converts to the same object, so an abandoned
-// attempt and the error that later carries it stay one record.
-const inclusiveUsage = new WeakSet();
-const convertedUsage = new WeakMap();
-
-export function toInclusiveOpenCodeGoUsage(usage) {
-  if (!usage || inclusiveUsage.has(usage)) return usage;
-  if (convertedUsage.has(usage)) return convertedUsage.get(usage);
-  const input = Number(usage.inputTokens) || 0;
-  const cached = Number(usage.cachedTokens) || 0;
-  const cacheWrite = Number(usage.cacheWriteTokens) || 0;
-  const inclusiveInput = input + cached + cacheWrite;
-  const converted = {
-    ...usage,
-    inputTokens: inclusiveInput,
-    promptTokens: Math.max(Number(usage.promptTokens) || 0, inclusiveInput),
-  };
-  inclusiveUsage.add(converted);
-  convertedUsage.set(usage, converted);
-  return converted;
-}
-
-function normalizeOpenCodeGoResultUsage(result, anthropicRoute) {
-  if (!anthropicRoute || !result?.usage) return result;
-  return { ...result, usage: toInclusiveOpenCodeGoUsage(result.usage) };
-}
-
-function normalizeOpenCodeGoError(error) {
-  if (error && typeof error === 'object') {
-    if (error.usage) error.usage = toInclusiveOpenCodeGoUsage(error.usage);
-    if (error.partialUsage) error.partialUsage = toInclusiveOpenCodeGoUsage(error.partialUsage);
-  }
-  return error;
-}
+// The Messages route reports usage in the provider's inclusive convention.
+export const toInclusiveOpenCodeGoUsage = toInclusiveUsage;
 
 function opencodeGoContextWindow(modelId, current = 0) {
   const native = Number(current);
@@ -118,11 +103,15 @@ export class OpenCodeGoProvider {
     const preset = OPENAI_COMPAT_PRESETS['opencode-go'];
     const bases = resolveOpenCodeGoBaseURLs(config.baseURL || preset.baseURL);
     this.openai = new OpenAICompatProvider('opencode-go', { ...config, baseURL: bases.openai });
-    this.anthropic = new AnthropicProvider({
+    this.anthropic = new OpenCodeGoMessagesEngine({
       ...config,
       name: 'opencode-go',
       baseURL: bases.anthropic,
       disableBetaHeaders: true,
+      // The preset's identifying headers (User-Agent) ride the Messages wire
+      // too; the user's own headers win.
+      extraHeaders: { ...(preset.extraHeaders || {}), ...(config.extraHeaders || {}) },
+      modelMaxOutputTokens: (model) => this.getCachedModelInfo(model)?.outputTokens,
     });
     // The Anthropic route answers for this provider: PDFs lower to text.
     this.anthropic.nativePdf = this.nativePdf;
@@ -142,29 +131,45 @@ export class OpenCodeGoProvider {
         'x-opencode-session': sessionId,
       },
     };
-    const wire = openCodeGoWireApi(model);
-    if (wire === 'responses') {
-      // OpenAI-family brands on the gateway (Muse Spark, GPT, Grok)
-      // only answer on /responses; the compat transport switches wire
-      // shape per request via this flag.
-      return this.openai.send(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
-    }
-    if (wire === 'messages') {
-      // The Anthropic-style Go endpoint reports cached read/write usage
-      // and accepts the standard message shape. Preserve the caller's
-      // cache strategy so the shared Anthropic live-tail marker advances
-      // through tool loops instead of forcing every request fully cold.
-      // Abandoned attempts noted by the inner provider use the same conversion.
-      const identity = currentUsageContext();
-      if (identity) identity.normalizeAbandonedUsage = toInclusiveOpenCodeGoUsage;
-      try {
-        const result = await this.anthropic.send(messages, model, tools, sendOpts);
-        return normalizeOpenCodeGoResultUsage(result, true);
-      } catch (error) {
-        throw normalizeOpenCodeGoError(error);
+    // The session's pinned route, else this model's route (wire-route.mjs);
+    // the resolved route is the only wire authority (a caller's own wire
+    // switches never reach an engine), and one clear "unsupported" refusal
+    // moves the send to the next wire once.
+    return sendOnRoute(this, model, tools, sendOpts, messages, async (wire, history, opts) => {
+      if (wire === 'responses') {
+        // OpenAI-family brands on the gateway (Muse Spark, GPT, Grok)
+        // only answer on /responses; the compat transport switches wire
+        // shape per request via this flag.
+        return this.openai.send(history, model, tools, { ...opts, compatWireApi: 'responses' });
+      }
+      if (wire === 'messages') {
+        // The Anthropic-style Go endpoint reports cached read/write usage
+        // and accepts the standard message shape. Preserve the caller's
+        // cache strategy so the shared Anthropic live-tail marker advances
+        // through tool loops instead of forcing every request fully cold.
+        // Abandoned attempts noted by the inner provider use the same conversion.
+        return withInclusiveUsage(() => this.anthropic.send(history, model, tools, opts));
       }
+      if (wire === 'gemini') return (await this._geminiEngine()).send(history, model, tools, opts);
+      return this.openai.send(history, model, tools, opts);
+    });
+  }
+
+  // The Gemini generateContent route; the Google SDK loads only when a Gemini model is used.
+  async _geminiEngine() {
+    if (!this.gemini) {
+      const { OpenCodeGoGeminiEngine } = await import('./opencode-go-gemini.mjs');
+      this.gemini = new OpenCodeGoGeminiEngine({
+        ...this.config,
+        baseURL: this.openai.baseURL,
+        extraHeaders: { ...(OPENAI_COMPAT_PRESETS['opencode-go'].extraHeaders || {}), ...(this.config.extraHeaders || {}) },
+      });
     }
-    return this.openai.send(messages, model, tools, sendOpts);
+    return this.gemini;
+  }
+
+  resolveWireRoute(model, ctx = {}) {
+    return resolveOpenCodeGoWireRoute(model, { ...ctx, override: this.config?.modelWires?.[model] ?? null });
   }
 
   async listModels() {

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

@@ -0,0 +1,75 @@
+/**
+ * OpenRouter: one API key, three wires. Claude (`anthropic/*`, `~anthropic/*`)
+ * goes through the Anthropic Messages engine at https://openrouter.ai/api (the
+ * SDK appends /v1/messages); OpenAI GPT / o-series (`openai/gpt-*`,
+ * `openai/o*`, `~openai/*`) through the OpenAI-compatible engine's Responses
+ * wire; openrouter/auto and every other model through Chat Completions.
+ * Account-level provider-routing preferences stay OpenRouter's: no request
+ * names a provider order.
+ */
+import { WireGatewayProvider, messagesBaseFromOpenAIBase } from './wire-gateway.mjs';
+import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
+import { openRouterReasoning } from './openai-compat-options.mjs';
+
+/**
+ * The Claude id a routing slug stands for: an alias (`~anthropic/claude-opus-latest`)
+ * reads its catalog `alias_target`, the vendor prefix and a `:variant` suffix
+ * drop. Capability lookup only — the request still names the routing slug.
+ */
+export function openRouterCapabilityModel(model, aliasTarget = null) {
+  return String(aliasTarget || model || '')
+    .replace(/^~/, '')
+    .replace(/^anthropic\//i, '')
+    .replace(/:[^/]*$/, '');
+}
+
+// Responses requests carry the same reasoning control as Chat requests
+// (`openRouterReasoningEffort`, else the turn effort, else the configured
+// effort; `none` disables reasoning).
+function openRouterResponsesParams(config) {
+  return (params, { opts }) => {
+    const reasoning = openRouterReasoning(opts, config);
+    if (reasoning) params.reasoning = reasoning;
+    else delete params.reasoning;
+  };
+}
+
+// The Messages route takes the same control: the effort to send ('none' = no
+// thinking), or null to keep the engine's own handling.
+function openRouterMessagesEffort(config) {
+  return (opts) => {
+    const reasoning = openRouterReasoning(opts, config);
+    if (!reasoning) return null;
+    return reasoning.enabled === false ? 'none' : reasoning.effort;
+  };
+}
+
+/** A roster row carrying `top_provider.max_completion_tokens` as its output ceiling. */
+export function withTopProviderOutputCeiling(item) {
+  const ceiling = Number(item?.top_provider?.max_completion_tokens);
+  if (!(ceiling > 0) || item.max_output_tokens !== undefined) return item;
+  return { ...item, max_output_tokens: ceiling };
+}
+
+export class OpenRouterProvider extends WireGatewayProvider {
+  constructor(config = {}) {
+    const baseURL = config.baseURL || OPENAI_COMPAT_PRESETS.openrouter.baseURL;
+    super(
+      'openrouter',
+      config,
+      {
+        baseURL: messagesBaseFromOpenAIBase(baseURL),
+        authScheme: 'bearer',
+        // OpenRouter Messages takes PDFs natively as document blocks.
+        nativePdf: true,
+        messagesEffort: openRouterMessagesEffort(config),
+        capabilityModel: (model) => openRouterCapabilityModel(model, this.getCachedModelInfo(model)?.aliasTarget),
+      },
+      { responsesParamsHook: openRouterResponsesParams(config) }
+    );
+    // The roster's output ceiling is `top_provider.max_completion_tokens`.
+    const fetchItems = this.openai._fetchModelItems.bind(this.openai);
+    this.openai._fetchModelItems = async (options) =>
+      (await fetchItems(options)).map(withTopProviderOutputCeiling);
+  }
+}