mixdog 1.2.1 → 1.2.3

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

@@ -4,6 +4,7 @@ import crypto from 'node:crypto';
 import http2 from 'node:http2';
 import { MAX_CONNECT_FRAME_BYTES, createCursorByteQueue } from './cursor-wire-guards.mjs';
 import { cursorClientVersion, warmCursorClientVersion } from './cursor-client-version.mjs';
+import { retryAfterMsFromError } from './retry-classifier.mjs';
 
 export { warmCursorClientVersion };
 
@@ -40,7 +41,66 @@ function rpcHeaders(accessToken, path, unary) {
   };
 }
 
-export function cursorError(message, { status = 0, code = '', retryAfter = null } = {}) {
+// HTTP-equivalent status for every Connect error code.
+const CONNECT_CODE_STATUS = Object.freeze({
+  canceled: 499,
+  unknown: 500,
+  invalid_argument: 400,
+  deadline_exceeded: 504,
+  not_found: 404,
+  already_exists: 409,
+  permission_denied: 403,
+  resource_exhausted: 429,
+  failed_precondition: 400,
+  aborted: 409,
+  out_of_range: 400,
+  unimplemented: 501,
+  internal: 500,
+  unavailable: 503,
+  data_loss: 500,
+  unauthenticated: 401,
+});
+
+// Connect code for a plain HTTP failure that carried no Connect error body.
+const HTTP_STATUS_CODE = Object.freeze({
+  401: 'unauthenticated',
+  403: 'permission_denied',
+  404: 'not_found',
+  429: 'resource_exhausted',
+  500: 'internal',
+  502: 'unavailable',
+  503: 'unavailable',
+  504: 'deadline_exceeded',
+});
+
+// Only explicit wording about the tool catalog or request payload being too
+// large counts; resource_exhausted otherwise stays a throttle.
+const REQUEST_TOO_LARGE_RE =
+  /\b(?:tool\s+(?:catalog|definitions?|schemas?)|tools|payload|request(?:\s+body)?)\b[^.\n]{0,80}?\b(?:too\s+(?:large|big)|exceed(?:s|ed)?\b[^.\n]{0,30}?\b(?:size|limit|maximum))/i;
+
+// Rate/quota wording wins over the size match: "request exceeded the rate
+// limit" is a throttle, not an oversized request.
+const THROTTLE_CUE_RE = /too\s+many\s+requests|quota|rate[\s_-]*limit|throttl/i;
+
+function firstValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+
+// Lowercased string-valued header map without HTTP/2 pseudo-headers.
+function plainHeaders(source) {
+  const headers = {};
+  for (const [key, value] of Object.entries(source || {})) {
+    const first = firstValue(value);
+    if (key.startsWith(':') || first == null || typeof first === 'object') continue;
+    headers[key.toLowerCase()] = String(first);
+  }
+  return headers;
+}
+
+export function cursorError(
+  message,
+  { status = 0, code = '', cursorCode = code, headers = null, retryAfter = null, reauthRequired = false, detail } = {}
+) {
   const error = new Error(message);
   if (status) {
     error.status = status;
@@ -48,17 +108,32 @@ export function cursorError(message, { status = 0, code = '', retryAfter = null
   }
   if (code) {
     error.code = code;
-    error.cursorCode = code;
+    error.cursorCode = cursorCode;
   }
+  if (detail != null) error.cursorDetail = detail;
+  if (reauthRequired) error.reauthRequired = true;
+  const errorHeaders = plainHeaders(headers);
   if (retryAfter != null && retryAfter !== '') {
-    const headers = { 'retry-after': String(retryAfter) };
     error.retryAfter = retryAfter;
-    error.headers = headers;
-    error.response = { status, headers };
+    errorHeaders['retry-after'] = String(retryAfter);
+  }
+  if (Object.keys(errorHeaders).length) {
+    error.headers = errorHeaders;
+    error.response = { status, headers: errorHeaders };
+    const retryAfterMs = retryAfterMsFromError(error);
+    if (Number.isFinite(retryAfterMs)) error.retryAfterMs = retryAfterMs;
   }
   return error;
 }
 
+function httpStatusError(status, headers) {
+  return cursorError(`Cursor request failed (${status})`, {
+    status,
+    code: HTTP_STATUS_CODE[status] || '',
+    headers,
+  });
+}
+
 export function openCursorStream({ accessToken, path = RUN_PATH, url = API_URL }) {
   const session = http2.connect(url);
   const request = session.request(rpcHeaders(accessToken, path, false));
@@ -66,7 +141,7 @@ export function openCursorStream({ accessToken, path = RUN_PATH, url = API_URL }
   let closeHandler = null;
   let closed = false;
   let status = 0;
-  let retryAfter = null;
+  let responseHeaders = null;
   let closeError = null;
   let timeout = setTimeout(
     () => close(cursorError('Cursor connection timed out', { code: 'connection_timeout' })),
@@ -97,8 +172,7 @@ export function openCursorStream({ accessToken, path = RUN_PATH, url = API_URL }
     closed = true;
     clearTimeout(timeout);
     clearInterval(ping);
-    closeError =
-      error || (status >= 400 ? cursorError(`Cursor request failed (${status})`, { status, retryAfter }) : null);
+    closeError = error || (status >= 400 ? httpStatusError(status, responseHeaders) : null);
     try {
       request.close();
     } catch {}
@@ -120,7 +194,7 @@ export function openCursorStream({ accessToken, path = RUN_PATH, url = API_URL }
 
   request.on('response', (headers) => {
     status = Number(headers[':status'] || 0);
-    retryAfter = headers['retry-after'] ?? null;
+    responseHeaders = headers;
     resetTimeout();
   });
   request.on('data', (chunk) => {
@@ -167,7 +241,7 @@ export async function callCursorUnary({ accessToken, path, body, url = API_URL,
     const request = session.request(rpcHeaders(accessToken, path, true));
     const chunks = [];
     let status = 0;
-    let retryAfter = null;
+    let responseHeaders = null;
     let settled = false;
     const timeout = setTimeout(() => finish(new Error('Cursor request timed out')), timeoutMs);
     const finish = (error = null) => {
@@ -181,12 +255,12 @@ export async function callCursorUnary({ accessToken, path, body, url = API_URL,
         session.close();
       } catch {}
       if (error) reject(error);
-      else if (status >= 400) reject(cursorError(`Cursor request failed (${status})`, { status, retryAfter }));
+      else if (status >= 400) reject(httpStatusError(status, responseHeaders));
       else resolve(Buffer.concat(chunks));
     };
     request.on('response', (headers) => {
       status = Number(headers[':status'] || 0);
-      retryAfter = headers['retry-after'] ?? null;
+      responseHeaders = headers;
     });
     request.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
     request.on('end', () => finish());
@@ -235,7 +309,7 @@ export function createFrameParser(onMessage, onEnd) {
   };
   parse.finish = () => {
     if (pending.byteLength) {
-      throw cursorError('Cursor stream ended with a truncated frame', { code: 'protocol_error' });
+      throw cursorError('Cursor stream ended with a truncated frame', { code: 'incomplete_stream' });
     }
   };
   parse.bufferedBytes = () => pending.byteLength;
@@ -246,26 +320,22 @@ export function parseEndStream(bytes) {
   try {
     const payload = JSON.parse(textDecoder.decode(bytes));
     if (!payload?.error) return null;
-    const code = String(payload.error.code || 'error');
-    const status =
-      {
-        unauthenticated: 401,
-        permission_denied: 403,
-        not_found: 404,
-        resource_exhausted: 429,
-        invalid_argument: 400,
-        internal: 500,
-        unavailable: 503,
-      }[code] || 0;
-    return cursorError(`Cursor ${code}: ${payload.error.message || 'request failed'}`, {
-      status,
-      code,
-      retryAfter:
-        payload.error.retryAfter ??
-        payload.error.retry_after ??
-        payload.metadata?.['retry-after'] ??
-        payload.metadata?.retryAfter ??
-        null,
+    const connectCode = String(payload.error.code || 'error').toLowerCase();
+    const detail = String(payload.error.message || 'request failed');
+    const tooLarge = connectCode === 'resource_exhausted' && !THROTTLE_CUE_RE.test(detail) && REQUEST_TOO_LARGE_RE.test(detail);
+    const retryAfter =
+      payload.error.retryAfter ??
+      payload.error.retry_after ??
+      payload.metadata?.['retry-after'] ??
+      payload.metadata?.retryAfter ??
+      null;
+    return cursorError(`Cursor ${connectCode}: ${detail}`, {
+      status: tooLarge ? 413 : CONNECT_CODE_STATUS[connectCode] || 0,
+      code: tooLarge ? 'request_too_large' : connectCode,
+      cursorCode: connectCode,
+      headers: payload.metadata,
+      retryAfter: firstValue(retryAfter),
+      detail,
     });
   } catch {
     return cursorError('Cursor returned an invalid end-stream frame', { code: 'protocol_error' });

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

@@ -14,6 +14,7 @@ import {
 } from './cursor-wire-protobuf.mjs';
 import {
   assertCursorUserImages,
+  createCursorCredentialRefresher,
   createCursorStreamWatchdog,
   resolveCursorStreamTuning,
   storeCursorBlob,
@@ -41,6 +42,7 @@ import {
 import { handleExecMessage, heartbeatFrame, sendToolResult } from './cursor-wire-exec.mjs';
 import { completionChunk, createStreamSink } from './cursor-wire-stream-sink.mjs';
 import { createBridgeController } from './cursor-wire-stream-bridge.mjs';
+import { TRANSPORT_SCOPE_DISPOSED } from './transport-scope.mjs';
 
 export { clearModelCache, getCursorModels, getCursorUsage } from './cursor-wire-models.mjs';
 
@@ -116,6 +118,8 @@ globalThis.__mixdogCloseProviderConnectionsForSession = (sessionId, reason) => {
     _priorCursorSessionCloseHook?.(sessionId, reason);
   } finally {
     closeCursorRunsForSession(sessionId, reason);
+    // A disposed transport scope never sends again: drop its conversation.
+    if (reason === TRANSPORT_SCOPE_DISPOSED && sessionId) conversations.delete(conversationKey([], sessionId));
   }
 };
 const _priorCursorDrainHook = globalThis.__mixdogDrainProviderConnections;
@@ -358,12 +362,16 @@ function createStreamResponse({
   sessionId = '',
   sawTurnEnded = false,
   restart = null,
+  sleep = undefined,
+  onStageChange = null,
 }) {
   const id = newCompletionId();
   // The bridge currently feeding the stream; a restart swaps it in place.
   const live = { bridge, heartbeat };
   let watchdog = null;
   let cancelled = false;
+  // Cuts a pending retry backoff short when the caller cancels.
+  const cancelController = new AbortController();
   const runs = { get: (runKey) => activeRuns.get(runKey), store: storeActiveRun, forget: forgetActiveRun };
   const stream = new ReadableStream({
     start(controller) {
@@ -395,12 +403,16 @@ function createStreamResponse({
         run: { key, conversation, tools, cloudRule, modelParameters, maxMode, sessionId },
         runs,
         restart,
+        sleep,
+        onStageChange,
+        cancelSignal: cancelController.signal,
         isCancelled: () => cancelled,
       });
       bridges.attach(bridge, heartbeat);
     },
     cancel(reason) {
       cancelled = true;
+      cancelController.abort();
       watchdog?.stop();
       clearInterval(live.heartbeat);
       const active = activeRuns.get(key);
@@ -459,7 +471,7 @@ function noUserMessageResponse() {
   });
 }
 
-export async function handleChatCompletion(body, accessToken) {
+export async function handleChatCompletion(body, accessToken, { onStageChange = null, getAccessToken = null } = {}) {
   await warmCursorClientVersion();
   const parsed = parseMessages(body.messages);
   if (
@@ -504,6 +516,10 @@ export async function handleChatCompletion(body, accessToken) {
   };
   const requestBytes = buildRunRequest(runInput);
   const { bridge, heartbeat } = startRun(accessToken, requestBytes);
+  // Every retry force-refreshes credentials and falls back to the previous
+  // token if the refresh fails. A rejected credential is only
+  // retried when the refresh produced a different token.
+  const credentials = createCursorCredentialRefresher(accessToken, getAccessToken);
   return createStreamResponse({
     bridge,
     heartbeat,
@@ -515,11 +531,21 @@ export async function handleChatCompletion(body, accessToken) {
     maxMode,
     key,
     sessionId,
-    restart: ({ fromCheckpoint }) =>
-      startRun(
-        accessToken,
-        fromCheckpoint ? buildRunRequest({ ...runInput, userText: '', userImages: [] }) : requestBytes
-      ),
+    onStageChange,
+    restart: async ({ fromCheckpoint, reason, error }) => {
+      if (reason === 'throttle') {
+        // Cursor can pin resource_exhausted to one conversation id (conversation
+        // rotation after a rate limit): start a fresh one from the full
+        // history instead of the checkpoint it refused.
+        conversation.id = crypto.randomUUID();
+        conversation.checkpoint = null;
+      }
+      const token = await credentials.refresh(reason, error);
+      let bytes = requestBytes;
+      if (fromCheckpoint) bytes = buildRunRequest({ ...runInput, userText: '', userImages: [] });
+      else if (reason === 'throttle') bytes = buildRunRequest(runInput);
+      return startRun(token, bytes);
+    },
   });
 }
 

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

@@ -10,7 +10,9 @@ import {
 } from './openai-compat-wire.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
 import { consumeCompatChatCompletionStream } from './openai-compat-stream.mjs';
+import { retryAfterMsFromError } from './retry-classifier.mjs';
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
+import { acceptedWireTools } from './lib/claude-bridge-schema.mjs';
 import { cursorTokenExpiry, exchangeCursorToken, resolveCursorOAuthAccessToken } from './cursor-auth.mjs';
 import {
   canonicalCursorModelId,
@@ -62,14 +64,24 @@ function toCursorToolChoice(toolChoice) {
 async function responseError(response, label) {
   const text = await response.text().catch(() => '');
   let message = text;
+  let code = '';
   try {
     const parsed = JSON.parse(text);
     message = parsed?.error?.message || parsed?.message || text;
+    code = String(parsed?.error?.code || parsed?.code || '').toLowerCase();
   } catch {
     /* plain text */
   }
   const error = new Error(`${label} request failed (${response.status})${message ? `: ${message}` : ''}`);
   error.status = response.status;
+  error.httpStatus = response.status;
+  if (code) error.code = code;
+  const headers = Object.fromEntries(response.headers?.entries?.() ?? []);
+  if (Object.keys(headers).length) {
+    error.headers = headers;
+    const retryAfterMs = retryAfterMsFromError(error);
+    if (Number.isFinite(retryAfterMs)) error.retryAfterMs = retryAfterMs;
+  }
   throw error;
 }
 
@@ -535,6 +547,9 @@ class CursorProviderBase {
   nativePdf = false;
 
   static inputExcludesCache = false;
+  // The in-place stream retry budget is the whole recovery: a spent budget
+  // surfaces instead of being re-run by the outer recovery cycles.
+  retryPolicy = Object.freeze({ recoveryCycles: false });
   name;
   config;
   _runtimeOverride;
@@ -622,7 +637,10 @@ class CursorProviderBase {
       sendOpts.onStageChange?.('requesting');
     } catch {}
     try {
-      const response = await runtime.handleChatCompletion(body, accessToken);
+      const response = await runtime.handleChatCompletion(body, accessToken, {
+        onStageChange: sendOpts.onStageChange,
+        getAccessToken: (options) => this._accessToken({ signal, ...options }),
+      });
       try {
         sendOpts.onStageChange?.('streaming');
       } catch {}
@@ -676,10 +694,16 @@ class CursorProviderBase {
     const runtime = await this._runtime();
     let accessToken = await this._accessToken({ signal });
     let cursorSelection = await this._resolveCursorModel(model, sendOpts, runtime, accessToken);
+    // The Cursor run and conversation (checkpoint, pending tool batch) live
+    // under this scope; a forked request keeps its own (transport-scope.mjs).
     const sessionScope = String(
-      sendOpts.sessionId || sendOpts.providerCacheKey || sendOpts.promptCacheKey || `cursor-call:${randomUUID()}`
+      sendOpts.transportScope ||
+        sendOpts.sessionId ||
+        sendOpts.providerCacheKey || sendOpts.promptCacheKey || `cursor-call:${randomUUID()}`
     );
-    const openAiTools = tools?.length ? toOpenAITools(tools) : undefined;
+    const openAiTools = tools?.length
+      ? toOpenAITools(acceptedWireTools(tools, 'openai', sendOpts.onToolExcluded, '[cursor] tool'))
+      : undefined;
     const dispatch = async () => {
       noteRequestServiceTier(cursorSelectionIsFast(cursorSelection) ? 'fast' : '');
       // Every attempt (retries included) prepares right before it lowers.

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

@@ -9,7 +9,7 @@ export const CUSTOM_PROVIDER_PROTOCOLS = Object.freeze(['openai-chat', 'openai-r
 export const CUSTOM_PROVIDER_SCHEMA_VERSION = 2;
 // Ranked weakest → strongest.
 export const CUSTOM_REASONING_LEVELS = CUSTOM_EFFORT_LEVELS;
-export const CUSTOM_REASONING_WIRE_FORMATS = Object.freeze(['standard', 'deepseek']);
+export const CUSTOM_REASONING_WIRE_FORMATS = Object.freeze(['standard', 'deepseek', 'together', 'vllm']);
 export const CUSTOM_PROVIDER_AUTH_MODES = Object.freeze(['key', 'none']);
 export const CUSTOM_MODEL_OVERRIDE_LIMIT = 500;
 
@@ -74,10 +74,22 @@ const V2_TOP_LEVEL_KEYS = new Set([
   'auth',
   'discovery',
   'modelOverrides',
+  'wires',
+  'modelWires',
   'id',
   'apiKey',
+  'apiKeyEnv',
   'preconnect',
 ]);
+export const CUSTOM_API_KEY_ENV_RE = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/;
+
+// Env var name that supplies the key, or '' when unset (undefined / null).
+function normalizeApiKeyEnv(raw) {
+  if (raw === undefined || raw === null) return '';
+  if (typeof raw !== 'string' || !CUSTOM_API_KEY_ENV_RE.test(raw))
+    fail('apiKeyEnv must be a valid environment variable name');
+  return raw;
+}
 const MAX_BASE_URL = 2048;
 
 function onlyKnownKeys(value, allowed, label) {
@@ -229,6 +241,49 @@ function normalizeOverrides(raw, protocol, legacy) {
   return out;
 }
 
+// The wire each OpenAI-compatible protocol speaks (wire-route.mjs WIRES).
+export const CUSTOM_PROTOCOL_WIRES = Object.freeze({
+  'openai-chat': 'chat',
+  'openai-responses': 'responses',
+  anthropic: 'messages',
+});
+// Wires a user-defined OpenAI-compatible endpoint can be declared to serve.
+export const CUSTOM_PROVIDER_WIRES = Object.freeze(['chat', 'responses', 'messages']);
+
+// `wires`: the wires the endpoint serves (the protocol's own wire included);
+// absent = the protocol's wire only. Anthropic-protocol providers speak one wire.
+function normalizeWires(raw, protocol) {
+  if (raw === undefined) return null;
+  if (protocol === 'anthropic') fail("wires requires an 'openai-chat' or 'openai-responses' protocol");
+  if (!Array.isArray(raw) || raw.length === 0) fail('wires must be a non-empty array');
+  const seen = new Set();
+  for (const wire of raw) {
+    if (!CUSTOM_PROVIDER_WIRES.includes(wire)) fail(`wires has unsupported wire: ${String(wire)}`);
+    if (seen.has(wire)) fail(`wires has duplicate wire: ${wire}`);
+    seen.add(wire);
+  }
+  if (!seen.has(CUSTOM_PROTOCOL_WIRES[protocol]))
+    fail(`wires must include the protocol wire: ${CUSTOM_PROTOCOL_WIRES[protocol]}`);
+  return CUSTOM_PROVIDER_WIRES.filter((wire) => seen.has(wire));
+}
+
+// `modelWires`: per-model wire override, each one of the served wires.
+function normalizeModelWires(raw, protocol, wires) {
+  if (raw === undefined) return {};
+  if (protocol === 'anthropic') fail("modelWires requires an 'openai-chat' or 'openai-responses' protocol");
+  if (!isPlainObject(raw)) fail('modelWires must be an object');
+  const keys = Object.keys(raw);
+  if (keys.length > CUSTOM_MODEL_OVERRIDE_LIMIT) fail(`at most ${CUSTOM_MODEL_OVERRIDE_LIMIT} model wires are allowed`);
+  const served = wires || [CUSTOM_PROTOCOL_WIRES[protocol]];
+  const out = {};
+  for (const key of keys) {
+    const id = modelIdKey(key, 'modelWires key');
+    if (!served.includes(raw[key])) fail(`modelWires[${id}] must be one of the served wires: ${served.join(', ')}`);
+    out[id] = raw[key];
+  }
+  return out;
+}
+
 // Legacy (pre-v2) `models: [{ id, name?, contextWindow?, maxOutputTokens? }]`
 // become manual, visible overrides; their presence hides newly discovered ids.
 function migrateLegacy(input) {
@@ -268,6 +323,8 @@ export function normalizeCustomProviderConfig(input) {
     // v2 fields without the version would be silently dropped by migration.
     if (input.modelOverrides !== undefined || input.discovery !== undefined)
       fail('modelOverrides and discovery require schemaVersion 2');
+    if (input.wires !== undefined || input.modelWires !== undefined)
+      fail('wires and modelWires require schemaVersion 2');
     source = migrateLegacy(input);
   } else if (Number.isInteger(version) && version > CUSTOM_PROVIDER_SCHEMA_VERSION)
     fail(`unsupported schemaVersion ${version}; update mixdog to use this provider`);
@@ -293,10 +350,13 @@ export function normalizeCustomProviderConfig(input) {
   if (!CUSTOM_PROVIDER_PROTOCOLS.includes(protocol)) fail(`unsupported protocol: ${protocol}`);
   const auth = source.auth === undefined || source.auth === null ? 'key' : text(source.auth);
   if (!CUSTOM_PROVIDER_AUTH_MODES.includes(auth)) fail(`invalid auth: ${String(source.auth)}`);
+  const apiKeyEnv = normalizeApiKeyEnv(source.apiKeyEnv);
   const discovery = source.discovery === undefined ? {} : source.discovery;
   if (!isPlainObject(discovery)) fail('discovery must be an object');
   onlyKnownKeys(discovery, DISCOVERY_KEYS, 'discovery');
   const newModelsHidden = optionalBoolean(discovery.newModelsHidden, 'discovery.newModelsHidden') ?? false;
+  const wires = normalizeWires(source.wires, protocol);
+  const modelWires = normalizeModelWires(source.modelWires, protocol, wires);
   return {
     type: 'custom',
     schemaVersion: CUSTOM_PROVIDER_SCHEMA_VERSION,
@@ -305,8 +365,11 @@ export function normalizeCustomProviderConfig(input) {
     baseURL: normalizeBaseURL(source.baseURL),
     enabled: source.enabled !== false,
     auth,
+    ...(apiKeyEnv && auth === 'key' ? { apiKeyEnv } : {}),
     discovery: { newModelsHidden },
     modelOverrides: normalizeOverrides(source.modelOverrides, protocol, legacy),
+    ...(wires ? { wires } : {}),
+    ...(Object.keys(modelWires).length ? { modelWires } : {}),
   };
 }
 

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

@@ -5,7 +5,19 @@
 // under the custom id so model routes and provider identity stay `custom-…`.
 
 import { resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
-import { effectiveCustomModelRows, normalizeCustomProviderConfig } from './custom-provider-config.mjs';
+import {
+  CUSTOM_PROTOCOL_WIRES,
+  effectiveCustomModelRows,
+  normalizeCustomProviderConfig,
+} from './custom-provider-config.mjs';
+import {
+  customWireProfile,
+  providerOffersWire,
+  registerWireProfile,
+  resolveWireRoute,
+  sendOnRoute,
+} from './wire-route.mjs';
+import { withInclusiveUsage } from './lib/inclusive-usage.mjs';
 import { ANTHROPIC_VERSION } from './lib/anthropic-models.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { fetchCompatModelItems, listCompatModels } from './openai-compat-models.mjs';
@@ -45,6 +57,22 @@ function withCustomModels(Base, discover) {
     _customKey() {
       return this._customKeyless ? '' : resolveProviderApiKey(this.name, this.config);
     }
+    // Env mode with the variable unset: fail before any request is sent.
+    _assertCustomKey() {
+      const name = this.customConfig?.apiKeyEnv;
+      if (name && !this._customKeyless && !resolveProviderApiKey(this.name, this.config))
+        throw new Error(`API key environment variable ${name} is not set`);
+    }
+    // A 401 reload must not fall back to the stale key once the variable is
+    // gone; with a new value the base reload picks it up for the retry.
+    reloadApiKey() {
+      this._assertCustomKey();
+      return super.reloadApiKey();
+    }
+    async send(...args) {
+      this._assertCustomKey();
+      return super.send(...args);
+    }
     _customRows() {
       return effectiveCustomModelRows(this.customConfig, this._customDiscovered || [], { providerId: this.name });
     }
@@ -57,6 +85,7 @@ function withCustomModels(Base, discover) {
     async listModels({ signal = null, throwOnError = false } = {}) {
       let failure = null;
       try {
+        this._assertCustomKey();
         this._customDiscovered = await discover(this, signal);
         this.customDiscoveryError = null;
       } catch (error) {
@@ -112,10 +141,14 @@ export async function createCustomProvider(id, config) {
   // `auth: 'none'` is authoritative: a supplied/injected key is ignored and
   // `keyless` makes the engine omit every credential header.
   const keyless = cfg.auth === 'none';
-  const apiKey = keyless ? '' : config.apiKey || '';
+  // Env mode: the named variable is the only key source.
+  let apiKey = '';
+  if (cfg.apiKeyEnv) apiKey = process.env[cfg.apiKeyEnv] || '';
+  else if (!keyless) apiKey = config.apiKey || '';
   const engine = {
     baseURL: cfg.baseURL,
     apiKey: apiKey || undefined,
+    ...(cfg.apiKeyEnv ? { apiKeyEnv: cfg.apiKeyEnv } : {}),
     ...(keyless ? { keyless: true } : {}),
     ...(config.preconnect === false ? { preconnect: false } : {}),
   };
@@ -129,14 +162,41 @@ export async function createCustomProvider(id, config) {
     provider.nativePdf = false;
   } else {
     const { OpenAICompatProvider } = await import('./openai-compat.mjs');
-    const responses = cfg.protocol === 'openai-responses';
+    // The wires the endpoint is declared to serve (default: the protocol's
+    // own) and the per-model `modelWires` override pick each model's wire
+    // through the shared wire-route table, pinned per session like a gateway.
+    registerWireProfile(
+      providerId,
+      customWireProfile({ protocolWire: CUSTOM_PROTOCOL_WIRES[cfg.protocol], wires: cfg.wires })
+    );
+    let messagesEngine = null;
+    if (providerOffersWire(providerId, 'messages')) {
+      const { AnthropicProvider } = await import('./anthropic.mjs');
+      // The Anthropic SDK appends /v1/messages itself; the endpoint's /v1 base maps to it.
+      messagesEngine = new AnthropicProvider({ ...engine, name: providerId, baseURL: cfg.baseURL.replace(/\/v1$/i, '') });
+      messagesEngine.nativePdf = false;
+    }
     class CompatBase extends OpenAICompatProvider {
+      messagesEngine = messagesEngine;
       _fetchModelItems({ signal = null } = {}) {
         return fetchCompatModelItems(this, { signal, keyless: this._customKeyless });
       }
-      _doSend(messages, model, tools, sendOpts) {
-        if (!responses) return super._doSend(messages, model, tools, sendOpts);
-        return super._doSend(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
+      resolveWireRoute(model, ctx = {}) {
+        return resolveWireRoute(this.name, model, { ...ctx, override: cfg.modelWires?.[model] ?? null });
+      }
+      send(messages, model, tools, sendOpts) {
+        const useModel = model || this.defaultModel;
+        // The resolved route is the only wire authority: a caller's own wire
+        // switches never reach the engine. A custom provider declares the
+        // wires its endpoint serves, so a clear "unsupported" refusal moves
+        // the send to another declared wire once (sendOnRoute).
+        return sendOnRoute(this, useModel, tools, sendOpts, messages, (wire, history, opts) => {
+          if (wire === 'messages' && this.messagesEngine) {
+            return withInclusiveUsage(() => this.messagesEngine.send(history, useModel, tools, opts));
+          }
+          if (wire === 'responses') return super.send(history, model, tools, { ...opts, compatWireApi: 'responses' });
+          return super.send(history, model, tools, opts);
+        });
       }
     }
     const Custom = withCustomModels(CompatBase, (self, signal) =>
@@ -144,6 +204,10 @@ export async function createCustomProvider(id, config) {
     );
     provider = new Custom(providerId, engine);
   }
+  // The bound Messages engine reads the parent's model rows, so a routed
+  // Messages request carries the same row-driven thinking/effort as the
+  // Anthropic protocol.
+  if (provider.messagesEngine) provider.messagesEngine.getCachedModelInfo = (model) => provider.getCachedModelInfo(model);
   provider.customConfig = cfg;
   provider._customKeyless = keyless;
   provider._applyCustomRows(provider._customRows());