mixdog 1.2.2 → 1.2.4

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

@@ -3,11 +3,72 @@
  * to the shared stream state and relayed to the SSE sink. Returns the
  * message's forward-progress kind for the watchdog.
  */
+import { randomUUID } from 'node:crypto';
+import { registerCursorNativeCall } from './cursor-native-context.mjs';
+import { appendAgentTrace } from '../agent-trace.mjs';
 import { decodeMessage } from './cursor-wire-protobuf.mjs';
 import { MAX_CHECKPOINT_BYTES, cursorInteractionProgress } from './cursor-wire-guards.mjs';
 import { buildCursorInteractionResponse } from './cursor-wire-interactions.mjs';
 import { cursorError } from './cursor-wire-transport.mjs';
-import { handleExecMessage, handleKvMessage, sendClientMessage } from './cursor-wire-exec.mjs';
+import { handleExecMessage, handleKvMessage, sendClientMessage, sendToolResult } from './cursor-wire-exec.mjs';
+
+// Unknown fields seen on every live frame: AgentServerMessage field 8 (timing
+// doubles) and InteractionUpdate field 25 (epoch-ms timestamp). Never traced.
+const NOISE_SERVER_FIELDS = new Set([8]);
+const NOISE_UPDATE_FIELDS = new Set([25]);
+const TRACE_MAX_FIELDS = 8;
+const TRACE_PREVIEW_BYTES = 48;
+
+// Records undecoded fields (number, wire type, bounded hex of the raw field)
+// so a new server event such as a mid-turn model fallback can be inspected.
+function traceUnknownFields(trace, sessionId, scope, unknown, noise) {
+  const fields = unknown?.filter((field) => !noise.has(field.no));
+  if (!fields?.length) return;
+  try {
+    trace({
+      sessionId,
+      kind: 'cursor_unknown_field',
+      provider: 'cursor',
+      payload: {
+        scope,
+        count: fields.length,
+        fields: fields.slice(0, TRACE_MAX_FIELDS).map((field) => ({
+          no: field.no,
+          wire_type: field.wireType,
+          bytes: field.data.byteLength,
+          preview_hex: Buffer.from(field.data.subarray(0, TRACE_PREVIEW_BYTES)).toString('hex'),
+        })),
+      },
+    });
+  } catch {
+    /* best-effort */
+  }
+}
+
+// Parent edit outcomes are diagnostics, not executable calls or read results.
+function traceNativeEditFailure(trace, sessionId, update) {
+  const completed = update.toolCallCompleted;
+  const result = completed?.toolCall?.editToolCall?.result;
+  if (!result) return;
+  const outcome = ['fileNotFound', 'readPermissionDenied', 'writePermissionDenied', 'rejected', 'error'].find(
+    (key) => result[key] !== undefined
+  );
+  if (!outcome) return;
+  try {
+    trace({
+      sessionId,
+      kind: 'cursor_native_edit_failure',
+      provider: 'cursor',
+      payload: {
+        callId: (completed.callId || '').slice(0, 256),
+        modelCallId: (completed.modelCallId || '').slice(0, 256),
+        outcome,
+      },
+    });
+  } catch {
+    /* best-effort */
+  }
+}
 
 // Relays one interaction update to the SSE stream and returns its progress.
 function applyInteractionUpdate(update, state, filter, emit) {
@@ -45,9 +106,32 @@ function applyCheckpointUpdate(update, conversation, state) {
 }
 
 // Announces a newly pending native/MCP tool call as a completion chunk once.
-function announcePendingToolCall(state, pending, emit) {
-  if (state.pending.some((entry) => entry.toolCallId === pending.toolCallId)) return;
+function announcePendingToolCall(state, pending, emit, bridge, ownerSessionId) {
+  state.executions ??= new Map();
+  const executions = state.executions;
+  const execId = pending.exec.execId ?? pending.exec.id;
+  const previous = execId !== undefined ? executions.get(execId) : undefined;
+  if (previous) {
+    if (previous.completedResult) {
+      sendToolResult(
+        bridge,
+        { ...previous, exec: pending.exec },
+        previous.completedResult.result,
+        previous.completedResult.ok
+      );
+    }
+    return;
+  }
+  // A parent call can issue distinct executions; each needs its own local result.
+  if ([...executions.values(), ...state.pending].some((entry) => entry.toolCallId === pending.toolCallId)) {
+    pending.toolCallId = randomUUID();
+  }
+  if (execId !== undefined) executions.set(execId, pending);
+  registerCursorNativeCall(ownerSessionId, pending, executions);
   state.pending.push(pending);
+  // Native execs may await their result before the server completes a step.
+  // The bridge hands off only after all currently received frames are whole.
+  if (pending.native) state.batchBoundaryReady = true;
   emit({
     tool_calls: [
       {
@@ -62,11 +146,30 @@ function announcePendingToolCall(state, pending, emit) {
 
 /**
  * @param {Uint8Array} bytes one Connect frame payload
- * @param {object} ctx { state, filter, emit, conversation, tools, cloudRule, bridge }
+ * @param {object} ctx { state, filter, emit, conversation, tools, cloudRule, bridge, sessionId?, trace? }
  * @returns {'work'|'park'|'none'|string} progress kind for the watchdog
  */
-export function processServerMessage(bytes, { state, filter, emit, conversation, tools, cloudRule, bridge }) {
+export function processServerMessage(
+  bytes,
+  {
+    state,
+    filter,
+    emit,
+    conversation,
+    tools,
+    cloudRule,
+    bridge,
+    sessionId = '',
+    ownerSessionId = '',
+    trace = appendAgentTrace,
+  }
+) {
   const message = decodeMessage('AgentServerMessage', bytes);
+  traceUnknownFields(trace, sessionId, 'agent_server_message', message.$unknown, NOISE_SERVER_FIELDS);
+  if (message.interactionUpdate) {
+    traceUnknownFields(trace, sessionId, 'interaction_update', message.interactionUpdate.$unknown, NOISE_UPDATE_FIELDS);
+    traceNativeEditFailure(trace, sessionId, message.interactionUpdate);
+  }
   if (message.interactionUpdate) return applyInteractionUpdate(message.interactionUpdate, state, filter, emit);
   if (message.kvServerMessage) {
     handleKvMessage(bridge, message.kvServerMessage, conversation);
@@ -78,7 +181,7 @@ export function processServerMessage(bytes, { state, filter, emit, conversation,
   }
   if (message.execServerMessage) {
     const handled = handleExecMessage(bridge, message.execServerMessage, tools, cloudRule, (pending) =>
-      announcePendingToolCall(state, pending, emit)
+      announcePendingToolCall(state, pending, emit, bridge, ownerSessionId)
     );
     return handled === false ? 'park' : 'work';
   }

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

@@ -42,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';
 
@@ -117,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;
@@ -325,11 +328,12 @@ function createPendingToolBatchResponse(active, model, key) {
 }
 
 // Stream state shared by the sink, the message router and the bridge controller.
-function freshStreamState(sawTurnEnded) {
+function freshStreamState(sawTurnEnded, executions) {
   return {
     outputTokens: 0,
     contextTokens: null,
     pending: [],
+    executions,
     closed: false,
     sawEnd: false,
     sawTurnEnded: sawTurnEnded === true,
@@ -357,7 +361,9 @@ function createStreamResponse({
   // Owning session, carried into the stored run so a session close can find
   // and tear down the pending batch's bridge/heartbeat.
   sessionId = '',
+  ownerSessionId = sessionId,
   sawTurnEnded = false,
+  executions = new Map(),
   restart = null,
   sleep = undefined,
   onStageChange = null,
@@ -373,7 +379,7 @@ function createStreamResponse({
   const stream = new ReadableStream({
     start(controller) {
       const filter = thinkingFilter();
-      const state = freshStreamState(sawTurnEnded);
+      const state = freshStreamState(sawTurnEnded, executions);
       const tuning = resolveCursorStreamTuning();
       watchdog = createCursorStreamWatchdog({
         idleTimeoutMs: tuning.idleTimeoutMs,
@@ -397,7 +403,7 @@ function createStreamResponse({
         watchdog,
         sink,
         tuning,
-        run: { key, conversation, tools, cloudRule, modelParameters, maxMode, sessionId },
+        run: { key, conversation, tools, cloudRule, modelParameters, maxMode, sessionId, ownerSessionId },
         runs,
         restart,
         sleep,
@@ -446,6 +452,7 @@ function resumeRun(active, toolResults, userText, model, key) {
     }
     const payload = { ...result, content: String(result.content ?? '') };
     if (pendingUserText && pending.exec.execId === lastExecId) {
+      if (pending.native?.resultType === 'readResult') pending.nativeUserMessage = pendingUserText;
       payload.content += `\n\n<user_message>\n${pendingUserText}\n</user_message>`;
       userTextDelivered = true;
     }
@@ -468,7 +475,11 @@ function noUserMessageResponse() {
   });
 }
 
-export async function handleChatCompletion(body, accessToken, { onStageChange = null, getAccessToken = null } = {}) {
+export async function handleChatCompletion(
+  body,
+  accessToken,
+  { onStageChange = null, getAccessToken = null, resetActiveRun = false, ownerSessionId = '' } = {}
+) {
   await warmCursorClientVersion();
   const parsed = parseMessages(body.messages);
   if (
@@ -489,6 +500,7 @@ export async function handleChatCompletion(body, accessToken, { onStageChange =
   const cloudRule = parsed.systems.join('\n\n') || undefined;
   const active = activeRuns.get(key);
   if (
+    !resetActiveRun &&
     active &&
     parsed.toolResults.length &&
     active.bridge.alive &&
@@ -528,6 +540,7 @@ export async function handleChatCompletion(body, accessToken, { onStageChange =
     maxMode,
     key,
     sessionId,
+    ownerSessionId,
     onStageChange,
     restart: async ({ fromCheckpoint, reason, error }) => {
       if (reason === 'throttle') {

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

@@ -12,6 +12,7 @@ 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,
@@ -48,6 +49,7 @@ function toCursorMessages(messages, providerName, { nativePdf } = {}) {
       ...toolMessage,
       mixdog_tool_error: message.toolKind === 'error' || message.isError === true,
       ...(media.length ? { mixdog_tool_media: media } : {}),
+      ...(message.readWindow?.lineClipped === true ? { mixdog_read_window: { lineClipped: true } } : {}),
     });
   }
   return output;
@@ -544,6 +546,9 @@ function selectCursorVariant(group, { effort = null, fast = false } = {}) {
 class CursorProviderBase {
   // Cursor's chat wire has no document block: PDFs lower to text.
   nativePdf = false;
+  // Native read results are judged as exact source windows, so the tool
+  // finalizer reports their clipped lines next to the text.
+  consumesReadWindows = true;
 
   static inputExcludesCache = false;
   // The in-place stream retry budget is the whole recovery: a spent budget
@@ -639,6 +644,13 @@ class CursorProviderBase {
       const response = await runtime.handleChatCompletion(body, accessToken, {
         onStageChange: sendOpts.onStageChange,
         getAccessToken: (options) => this._accessToken({ signal, ...options }),
+        // A deliberate history reset must reach Cursor's private parked run,
+        // not just the orchestrator's providerState.
+        resetActiveRun: Boolean(sendOpts.cacheBreakIntent),
+        // Native read/edit capabilities are process-local. An explicit empty
+        // executor (the model-proxy host: tools run in the server daemon)
+        // keeps every call an ordinary Mixdog tool call.
+        ownerSessionId: String(sendOpts.toolExecutionSessionId ?? (sendOpts.sessionId || '')),
       });
       try {
         sendOpts.onStageChange?.('streaming');
@@ -693,10 +705,18 @@ 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 } : {}),
   };
 }
 
@@ -323,6 +386,14 @@ function catalogLevels(row) {
   return levels.size ? [...levels].sort(byRank) : null;
 }
 
+function reasoningLevelFields(levels) {
+  if (!levels) return {};
+  return {
+    reasoningOptions: levels.length ? [{ type: 'effort', values: [...levels] }] : [],
+    reasoningLevels: [...levels],
+  };
+}
+
 function effectiveRow(base, override, { providerId, discovered, newModelsHidden }) {
   const ov = override || {};
   const reasoning = ov.reasoning || {};
@@ -350,12 +421,7 @@ function effectiveRow(base, override, { providerId, discovered, newModelsHidden
     hidden,
     manual: ov.manual === true,
     supportsReasoning: levels ? levels.some((level) => level !== 'none') : base.supportsReasoning === true,
-    ...(levels
-      ? {
-          reasoningOptions: levels.length ? [{ type: 'effort', values: [...levels] }] : [],
-          reasoningLevels: [...levels],
-        }
-      : {}),
+    ...reasoningLevelFields(levels),
     customReasoning: { wireFormat: reasoning.wireFormat ?? 'standard', wireValues, replay },
     ...(replay ? { reasoningContentField: 'reasoning_content' } : {}),
   };

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,45 @@ 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 +208,11 @@ 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());

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

@@ -4,6 +4,8 @@
 // effort to a supported level and serializes it for the provider protocol.
 // First-party providers never route through here.
 
+import { isTogetherBaseURL } from './openai-compat-reasoning-field.mjs';
+
 export const CUSTOM_EFFORT_LEVELS = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
 const RANK = new Map(CUSTOM_EFFORT_LEVELS.map((level, index) => [level, index]));
 
@@ -63,16 +65,30 @@ export function snapCustomEffort(levels, effort) {
 }
 
 const EMPTY = Object.freeze({ level: null, fields: {}, thinking: null, replay: false });
+// Chat-only extensions on top of the standard `reasoning_effort`.
+const CHAT_ONLY_WIRE_FORMATS = new Set(['deepseek', 'together', 'vllm']);
+
+/**
+ * The effective wire format of a row: its declared format, else `together`
+ * when the provider's own base URL is Together AI (whose hybrid models toggle
+ * reasoning with a `reasoning.enabled` flag), else `standard`.
+ */
+export function customWireFormat(model, baseURL) {
+  const declared = model?.customReasoning?.wireFormat;
+  if (CHAT_ONLY_WIRE_FORMATS.has(declared)) return declared;
+  return isTogetherBaseURL(baseURL) ? 'together' : 'standard';
+}
 
 /**
- * @param {{ protocol: 'openai-chat'|'openai-responses'|'anthropic', model: object|null, effort: string|null|undefined }} input
+ * @param {{ protocol: 'openai-chat'|'openai-responses'|'anthropic', model: object|null, effort: string|null|undefined, baseURL?: string }} input
  * @returns {{ level: string|null, fields: object, thinking: 'on'|'off'|null, replay: boolean }}
  */
-export function resolveCustomReasoning({ protocol, model, effort } = {}) {
+export function resolveCustomReasoning({ protocol, model, effort, baseURL } = {}) {
   const custom = model?.customReasoning || {};
-  const wireFormat = custom.wireFormat === 'deepseek' ? 'deepseek' : 'standard';
-  // DeepSeek's `thinking` extension exists only on the Chat wire.
-  if (wireFormat === 'deepseek' && protocol !== 'openai-chat') return { ...EMPTY, fields: {} };
+  const wireFormat = protocol === 'openai-chat' ? customWireFormat(model, baseURL) : 'standard';
+  // The `thinking` / `reasoning.enabled` / chat_template_kwargs extensions
+  // exist only on the Chat wire.
+  if (CHAT_ONLY_WIRE_FORMATS.has(custom.wireFormat) && protocol !== 'openai-chat') return { ...EMPTY, fields: {} };
   const level = snapCustomEffort(customEffortLevels(model), effort);
   let thinking = null;
   if (level !== null) thinking = level === 'none' ? 'off' : 'on';
@@ -86,6 +102,18 @@ export function resolveCustomReasoning({ protocol, model, effort } = {}) {
           level === 'none'
             ? { thinking: { type: 'disabled' } }
             : { thinking: { type: 'enabled' }, reasoning_effort: value };
+      } else if (wireFormat === 'together') {
+        // Together: `reasoning.enabled` toggles hybrid models (those that can
+        // be turned off); `reasoning_effort` sets the depth of the others.
+        if (level === 'none') fields = { reasoning: { enabled: false } };
+        else {
+          fields = { reasoning_effort: value };
+          if (customEffortLevels(model)?.includes('none')) fields.reasoning = { enabled: true };
+        }
+      } else if (wireFormat === 'vllm') {
+        // vLLM switches thinking through the chat template.
+        fields = { chat_template_kwargs: { enable_thinking: level !== 'none' } };
+        if (level !== 'none') fields.reasoning_effort = value;
       } else {
         fields = { reasoning_effort: value };
       }
@@ -101,7 +129,6 @@ export function resolveCustomReasoning({ protocol, model, effort } = {}) {
   // An explicit replay flag wins over the catalog's reasoning_content field.
   const replayFlag =
     typeof custom.replay === 'boolean' ? custom.replay : model?.reasoningContentField === 'reasoning_content';
-  const replay =
-    protocol === 'openai-chat' && replayFlag && thinking !== 'off' && !/reasoner/i.test(String(model?.id || ''));
+  const replay = protocol === 'openai-chat' && replayFlag && thinking !== 'off';
   return { level, fields, thinking, replay };
 }