mixdog 1.2.2 → 1.2.3

package/src/runtime/agent/orchestrator/providers/command-code-oauth.mjs

@@ -2,23 +2,25 @@
  * Command Code provider (commandcode.ai Provider API).
  *
  * Credentials are a Studio-issued API key (command-code-oauth-tokens.mjs).
- * Each model is served on the endpoint its /models row declares: Chat
- * Completions through the OpenAI-compatible engine, Messages-only models
- * (Claude) through the Anthropic engine. Both clients are pinned to the
- * Command Code API host. The key never expires and has no refresh grant: a
- * 401 means the user must sign in again.
+ * Each model is served on a wire its /models row declares (wire-route.mjs
+ * picks among them): Chat Completions and Responses through the
+ * OpenAI-compatible engine, Messages through the Anthropic engine. Both
+ * clients are pinned to the Command Code API host. The key never expires and
+ * has no refresh grant: a 401 means the user must sign in again.
  */
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { fileMtimeMs, normalizeExpiresAtMs, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
+import { originBoundFetch } from './lib/origin-bound-fetch.mjs';
+import { withInclusiveUsage } from './lib/inclusive-usage.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
 import { COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
 import { listCompatModels } from './openai-compat-models.mjs';
 import { AnthropicProvider } from './anthropic.mjs';
-import { toInclusiveOpenCodeGoUsage as toInclusiveUsage } from './opencode-go.mjs';
 import { sanitizeToolPairs } from '../session/context-utils.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
-import { currentUsageContext } from '../../../shared/llm/usage-context.mjs';
 import { makeModelCache } from './model-cache.mjs';
+import { resolveWireRoute, sendOnRoute } from './wire-route.mjs';
+import { gatewayMessagesOpts } from './wire-gateway.mjs';
 import {
   API_ORIGIN,
   CREDITS_URL,
@@ -38,8 +40,11 @@ export {
 export { beginOAuthLogin, loginOAuth } from './command-code-oauth-login.mjs';
 
 export const DEFAULT_MODEL = 'deepseek/deepseek-v4-flash';
-const CHAT_ENDPOINT = '/chat/completions';
-const MESSAGES_ENDPOINT = '/messages';
+const ENDPOINT_WIRES = Object.freeze({
+  '/chat/completions': 'chat',
+  '/messages': 'messages',
+  '/responses': 'responses',
+});
 // The Anthropic SDK appends /v1/messages itself.
 const MESSAGES_BASE_URL = `${API_ORIGIN}/provider`;
 const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
@@ -56,35 +61,42 @@ const commandCodeModelCache = makeModelCache({
 });
 
 /**
- * The wire a /models row is served on: 'chat' when it declares Chat
- * Completions or declares no endpoints at all, 'messages' when it declares
- * only Messages, null when it declares neither.
+ * The wires a /models row declares (`supported_endpoints`), or null when it
+ * declares none — such a row is served on Chat Completions by convention.
+ */
+export function modelEndpoints(item) {
+  const declared = item?.supported_endpoints;
+  if (!Array.isArray(declared)) return null;
+  const wires = [];
+  for (const endpoint of declared) {
+    const path = String(endpoint).replace(/^\/?(?:provider\/)?(?:v1\/)?/, '/');
+    const wire = Object.hasOwn(ENDPOINT_WIRES, path) ? ENDPOINT_WIRES[path] : null;
+    if (wire && !wires.includes(wire)) wires.push(wire);
+  }
+  return wires;
+}
+
+// The route for a model with these declared endpoints (null: undeclared, Chat).
+// `undefined`: nothing describes the model, so no wire is ruled out.
+function commandCodeRoute(model, endpoints, ctx = {}) {
+  return resolveWireRoute(PROVIDER_ID, model, { ...ctx, endpoints: endpoints === undefined ? null : (endpoints ?? ['chat']) });
+}
+
+/**
+ * The wire a /models row is served on (wire-route.mjs over its declared
+ * endpoints): Responses for GPT / Muse / Grok when advertised, otherwise Chat
+ * when declared or undeclared, Messages when it is the only one, Responses
+ * for a Responses-only row; null when it declares none of them.
  */
 export function modelWire(item) {
   if (typeof item?.id !== 'string' || !item.id) return null;
-  const endpoints = item.supported_endpoints;
-  if (!Array.isArray(endpoints)) return 'chat';
-  const declared = endpoints.map((endpoint) => String(endpoint).replace(/^\/?(?:provider\/)?(?:v1\/)?/, '/'));
-  if (declared.includes(CHAT_ENDPOINT)) return 'chat';
-  if (declared.includes(MESSAGES_ENDPOINT)) return 'messages';
-  return null;
+  return commandCodeRoute(item.id, modelEndpoints(item))?.wire || null;
 }
 
-// Every request either engine makes goes through this fetch: anything outside
-// the Command Code API origin is refused before the key leaves the process,
-// and redirects are never followed (any 3xx is an error).
+// Every request either engine makes goes through this fetch: only the Command
+// Code API origin, never a redirect.
 function apiOnlyFetch(fetchImpl) {
-  return async (input, init) => {
-    const url = new URL(String(input?.url ?? input));
-    if (url.origin !== API_ORIGIN) {
-      throw new Error(`[command-code-oauth] refusing to send the API key to ${url.host}`);
-    }
-    const res = await (fetchImpl || globalThis.fetch)(input, { ...init, redirect: 'manual' });
-    if (res.status >= 300 && res.status < 400) {
-      throw new Error(`[command-code-oauth] refusing to follow a redirect from ${url.host}`);
-    }
-    return res;
-  };
+  return originBoundFetch(API_ORIGIN, fetchImpl, PROVIDER_ID);
 }
 
 // Anthropic engine bound to this credential: only the Command Code key is
@@ -98,15 +110,11 @@ class CommandCodeMessagesEngine extends AnthropicProvider {
     client.fetch = apiOnlyFetch(this.config.fetchImpl);
     return client;
   }
-}
-
-const normalizeUsageError = (err) => {
-  if (err && typeof err === 'object') {
-    if (err.usage) err.usage = toInclusiveUsage(err.usage);
-    if (err.partialUsage) err.partialUsage = toInclusiveUsage(err.partialUsage);
+  // The roster's output ceiling reaches the shared request builder.
+  _sendOnce(messages, model, tools, opts) {
+    return super._sendOnce(messages, model, tools, gatewayMessagesOpts(this.config, model, messages, opts));
   }
-  return err;
-};
+}
 
 function rosterRow(item) {
   const contextWindow = Number(item.context_window ?? item.max_context_window ?? item.context_length ?? 0);
@@ -118,6 +126,11 @@ function rosterRow(item) {
     ...(name ? { name: name.trim() } : {}),
     ...(contextWindow > 0 ? { contextWindow } : {}),
     ...(outputTokens > 0 ? { outputTokens } : {}),
+    // The full declared endpoint set: the cached route metadata a later
+    // send falls back on when the live roster cannot be read.
+    ...(Array.isArray(item.supported_endpoints)
+      ? { supportedEndpoints: item.supported_endpoints.map((endpoint) => String(endpoint)) }
+      : {}),
   };
 }
 
@@ -147,11 +160,16 @@ function scrubErrorSecrets(err, apiKey) {
 }
 
 // Redact where the transport first surfaces errors (request open and stream
-// iteration), so the shared retry reporter never logs the key.
+// iteration) on the Chat and Responses endpoints, so the shared retry
+// reporter never logs the key.
 function redactClientErrors(client, apiKey) {
-  const completions = client?.chat?.completions;
-  if (!completions || !apiKey || completions.create?.commandCodeRedacting === apiKey) return;
-  const create = completions.create.bind(completions);
+  redactCreateErrors(client?.chat?.completions, apiKey);
+  redactCreateErrors(client?.responses, apiKey);
+}
+
+function redactCreateErrors(endpoint, apiKey) {
+  if (!endpoint || !apiKey || endpoint.create?.commandCodeRedacting === apiKey) return;
+  const create = endpoint.create.bind(endpoint);
   const wrapped = async (...args) => {
     try {
       const stream = await create(...args);
@@ -177,7 +195,7 @@ function redactClientErrors(client, apiKey) {
     }
   };
   wrapped.commandCodeRedacting = apiKey;
-  completions.create = wrapped;
+  endpoint.create = wrapped;
 }
 
 // Same for the Anthropic client's streaming request (read through
@@ -253,8 +271,9 @@ export class CommandCodeOAuthProvider {
   _defaultModelKey = null;
   _messages = null;
   _messagesKey = null;
-  // Model id → wire ('chat' | 'messages') from the roster fetched with `_wiresKey`.
-  _wires = new Map();
+  // Model id → declared endpoint wires (null: undeclared) from the roster
+  // fetched with `_wiresKey`.
+  _endpoints = new Map();
   _wiresKey = null;
 
   constructor(config) {
@@ -315,6 +334,8 @@ export class CommandCodeOAuthProvider {
       apiKey,
       baseURL: MESSAGES_BASE_URL,
       disableBetaHeaders: true,
+      modelMaxOutputTokens: (model) =>
+        commandCodeModelCache.loadSync({ allowStale: true })?.find((row) => row?.id === model)?.outputTokens,
       // x-api-key from the SDK plus the bearer form of the same key.
       extraHeaders: { Authorization: `Bearer ${apiKey}` },
     });
@@ -324,8 +345,9 @@ export class CommandCodeOAuthProvider {
     return engine;
   }
 
-  // Servable rows from /models; only the latest fetch with the still-active
-  // key publishes the roster and the per-model wire map.
+  // Servable rows from /models (any declared Chat, Messages or Responses
+  // endpoint, or none declared); only the latest fetch with the still-active
+  // key publishes the roster and the per-model endpoint map.
   async _fetchRoster(apiKey, signal = null) {
     const publish = commandCodeModelCache.beginSave(() => loadTokens()?.apiKey === apiKey);
     const body = await requestCommandCodeJson(`${PROVIDER_BASE_URL}/models`, apiKey, {
@@ -338,16 +360,30 @@ export class CommandCodeOAuthProvider {
     const items = list.filter((item) => modelWire(item));
     publish(items.map(rosterRow));
     if (this.tokens?.apiKey === apiKey) {
-      this._wires = new Map(items.map((item) => [item.id, modelWire(item)]));
+      // Rows accumulate for one key: a later roster that misses a model
+      // leaves the endpoints it was last listed with.
+      const known = this._wiresKey === apiKey ? this._endpoints : new Map();
+      for (const item of items) known.set(item.id, modelEndpoints(item));
+      this._endpoints = known;
       this._wiresKey = apiKey;
     }
     return items;
   }
 
-  // The wire for a model, from this credential's roster (fetched once when
-  // missing). A model the roster does not know, or a roster that cannot be
-  // read right now, stays on Chat Completions; a rejected key is surfaced.
-  async _wireFor(inner, model) {
+  // A model's declared endpoints: what this credential's rosters listed,
+  // then the persisted roster (a roster miss or a roster that cannot be read
+  // right now must not move a known Messages-only model to Chat). null is a
+  // row declaring none (Chat); undefined is a model nothing describes.
+  _endpointsFor(apiKey, model) {
+    if (this._wiresKey === apiKey && this._endpoints.has(model)) return this._endpoints.get(model);
+    const cached = commandCodeModelCache.loadSync({ allowStale: true })?.find((row) => row?.id === model);
+    return cached ? modelEndpoints({ supported_endpoints: cached.supportedEndpoints }) : undefined;
+  }
+
+  // This credential's route for a model (the roster is fetched once when
+  // missing; a roster that cannot be read falls back on the persisted rows);
+  // a rejected key is surfaced.
+  async _routeFor(inner, model, ctx = {}) {
     if (this._wiresKey !== inner.apiKey) {
       try {
         await listCompatModels(inner, { throwOnError: true });
@@ -355,7 +391,16 @@ export class CommandCodeOAuthProvider {
         if (isUnauthorized(err)) throw err;
       }
     }
-    return (this._wiresKey === inner.apiKey && this._wires.get(model)) || 'chat';
+    const endpoints = this._endpointsFor(inner.apiKey, model);
+    return commandCodeRoute(model, endpoints, {
+      ...ctx,
+      override: this.config?.modelWires?.[model] ?? null,
+      known: endpoints !== undefined,
+    });
+  }
+
+  resolveWireRoute(model, ctx = {}) {
+    return this._routeFor(this._ensureInner(), model, ctx);
   }
 
   // A rejected key needs a fresh sign-in; the gateway's own detail stays attached.
@@ -382,17 +427,21 @@ export class CommandCodeOAuthProvider {
       throw this._shapeError(err, this.tokens?.apiKey);
     }
     const apiKey = this._innerKey;
-    // The model's declared endpoint picks the wire; a caller cannot move a
-    // model to Responses.
-    const { compatWireApi: _wire, responsesTransport: _transport, ...opts } = sendOpts || {};
+    // The model's route (the session's pinned one, else its declared
+    // endpoints) picks the wire; a caller's compat wire flag cannot move it.
+    const { compatWireApi: _wire, responsesTransport: _transport, ...callerOpts } = sendOpts || {};
     try {
       const useModel = model || (await this._pickDefaultModel(inner));
-      if ((await this._wireFor(inner, useModel)) === 'messages') {
-        return await this._sendMessages(apiKey, messages, useModel, tools, opts);
-      }
-      // _doSend directly: the compat wrapper's 401 handler reloads a static
-      // config key, which does not apply to this credential.
-      return await inner._doSend(messages, useModel, tools, opts);
+      // One clear "unsupported" refusal moves the send to the next wire once.
+      return await sendOnRoute(this, useModel, tools, callerOpts, messages, (wire, history, opts) => {
+        if (wire === 'messages') return this._sendMessages(apiKey, history, useModel, tools, opts);
+        // _doSend directly: the compat wrapper's 401 handler reloads a static
+        // config key, which does not apply to this credential.
+        if (wire === 'responses') {
+          return inner._doSend(history, useModel, tools, { ...opts, compatWireApi: 'responses' });
+        }
+        return inner._doSend(history, useModel, tools, opts);
+      });
     } catch (err) {
       throw this._shapeError(err, apiKey);
     }
@@ -405,14 +454,7 @@ export class CommandCodeOAuthProvider {
   async _sendMessages(apiKey, messages, model, tools, opts) {
     const engine = this._ensureMessages(apiKey);
     const prepared = await preparePdfTextForProvider(sanitizeToolPairs(messages), engine);
-    const identity = currentUsageContext();
-    if (identity) identity.normalizeAbandonedUsage = toInclusiveUsage;
-    try {
-      const result = await engine._doSend(prepared, model, tools, opts);
-      return result?.usage ? { ...result, usage: toInclusiveUsage(result.usage) } : result;
-    } catch (err) {
-      throw normalizeUsageError(err);
-    }
+    return withInclusiveUsage(() => engine._doSend(prepared, model, tools, opts));
   }
 
   async listModels() {

package/src/runtime/agent/orchestrator/providers/compat-request-policy.mjs

@@ -1,5 +1,6 @@
 // Shared request controls for Chat Completions and Responses gateways.
 import { emitProviderRetryStage, retryDelayLabel } from './retry-classifier.mjs';
+import { isTogetherBaseURL } from './openai-compat-reasoning-field.mjs';
 
 // withRetry onRetry for the compat stream sends: one stderr line plus a
 // display-only 'reconnecting' stage for the UI.
@@ -13,8 +14,83 @@ export function compatStreamRetryReporter(label, opts) {
   };
 }
 
-export function applyCompatToolChoice(body, opts = {}) {
-  if (body.tools?.length && opts.toolChoice === 'none') body.tool_choice = 'none';
+// Providers whose docs accept `required` / named tool_choice, and the subset
+// that also documents `parallel_tool_calls`. DeepSeek documents no
+// parallel_tool_calls, and rejects forced choices in thinking mode.
+const FORCED_CHOICE_PROVIDERS = new Set([
+  'xai',
+  'deepseek',
+  'openrouter',
+  'mistral',
+  'groq',
+  'fireworks',
+  'together',
+  'command-code-oauth',
+]);
+const PARALLEL_CALLS_PROVIDERS = new Set([
+  'xai',
+  'openrouter',
+  'mistral',
+  'groq',
+  'fireworks',
+  'together',
+  'command-code-oauth',
+]);
+
+function hostMatches(baseURL, domain) {
+  try {
+    const host = new URL(String(baseURL || '')).hostname.toLowerCase();
+    return host === domain || host.endsWith(`.${domain}`);
+  } catch {
+    return false;
+  }
+}
+
+function compatToolFamily(provider, baseURL) {
+  if (FORCED_CHOICE_PROVIDERS.has(provider)) return provider;
+  if (isTogetherBaseURL(baseURL)) return 'together';
+  if (hostMatches(baseURL, 'fireworks.ai')) return 'fireworks';
+  if (hostMatches(baseURL, 'mistral.ai')) return 'mistral';
+  if (hostMatches(baseURL, 'groq.com')) return 'groq';
+  return null;
+}
+
+function forcedToolChoice(choice, wire) {
+  if (choice === 'required') return 'required';
+  if (!choice || typeof choice !== 'object') return null;
+  const name = choice.function?.name || choice.name;
+  if (typeof name !== 'string' || !name) return null;
+  return wire === 'responses' ? { type: 'function', name } : { type: 'function', function: { name } };
+}
+
+/**
+ * Tool-choice controls. `none` is universal. With `ctx` ({ provider, baseURL,
+ * wire: 'chat'|'responses', thinking: 'enabled'|'disabled'|null }) the
+ * documented providers also get explicit `required` / named tool_choice and an
+ * explicit boolean `opts.parallelToolCalls`; without it only `none` applies.
+ * DeepSeek rejects forced choices while thinking is explicitly enabled and
+ * keeps omitting them when thinking is left to the server default.
+ */
+export function applyCompatToolChoice(body, opts = {}, ctx = null) {
+  if (!(body.tools?.length > 0)) return body;
+  if (opts.toolChoice === 'none') body.tool_choice = 'none';
+  const family = ctx?.provider ? compatToolFamily(ctx.provider, ctx.baseURL) : null;
+  if (!family) return body;
+  const forced = forcedToolChoice(opts.toolChoice, ctx.wire);
+  if (forced) {
+    if (family === 'deepseek' && ctx.thinking === 'enabled') {
+      throw Object.assign(
+        new Error(
+          '[deepseek] tool_choice "required" or a named tool is not supported in thinking mode; disable thinking (effort none) to force a tool call'
+        ),
+        { code: 'unsupported_tool_choice' }
+      );
+    }
+    if (family !== 'deepseek' || ctx.thinking === 'disabled') body.tool_choice = forced;
+  }
+  if (typeof opts.parallelToolCalls === 'boolean' && PARALLEL_CALLS_PROVIDERS.has(family)) {
+    body.parallel_tool_calls = opts.parallelToolCalls;
+  }
   return body;
 }
 

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

@@ -130,7 +130,7 @@ function saveCredentials(tokens) {
 
 export function hasCursorOAuthCredentials() {
   const tokens = loadStoredCredentials();
-  if (!tokens?.access_token) return false;
+  if (!tokens?.access_token || tokens.reauth_required === true) return false;
   const expiresAt = Number(tokens.expires_at) || 0;
   return expiresAt === 0 || expiresAt > Date.now() || Boolean(tokens.refresh_token);
 }
@@ -147,6 +147,18 @@ export function describeCursorOAuthCredentials() {
       detail: 'Mixdog token store or CURSOR_ACCESS_TOKEN',
     };
   }
+  if (tokens.reauth_required === true) {
+    return {
+      authenticated: false,
+      usable: false,
+      refreshable: false,
+      reauthRequired: true,
+      status: 'Reauth Required',
+      detail: tokens.source || 'Cursor OAuth',
+      expiresAt: Number(tokens.expires_at) || null,
+      ...accountIdentityFields(tokens.identity),
+    };
+  }
   const expiresAt = Number(tokens.expires_at) || 0;
   const expired = expiresAt > 0 && expiresAt <= Date.now();
   const expiring = expiresAt > 0 && expiresAt <= Date.now() + REFRESH_SKEW_MS;
@@ -336,10 +348,30 @@ export async function resolveCursorOAuthAccessToken({ forceRefresh = false, fetc
         // (turn cancel / session close) kill it would fail the refresh for
         // all of them and leave the process without a usable token. Its own
         // timeout bounds the request instead.
-        const next = await exchangeCursorToken(latest.refresh_token, {
-          fetchFn,
-          signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
-        });
+        let next;
+        try {
+          next = await exchangeCursorToken(latest.refresh_token, {
+            fetchFn,
+            signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
+          });
+        } catch (error) {
+          if (error?.reauthRequired !== true) throw error;
+          // Mark the account dead only if no other process replaced the
+          // refresh token meanwhile. Non-destructive: tokens stay intact and
+          // a new sign-in rewrites the file without this marker.
+          if (!process.env.CURSOR_ACCESS_TOKEN || boundProviderAuthPath('cursor-oauth')) {
+            const current = loadStoredCredentials();
+            if (current?.refresh_token && current.refresh_token === latest.refresh_token) {
+              const { source: _source, ...persisted } = current;
+              try {
+                saveCredentials({ ...persisted, reauth_required: true });
+              } catch (saveError) {
+                process.stderr.write(`[cursor-oauth] dead-account mark failed: ${String(saveError?.message || saveError).slice(0, 200)}\n`);
+              }
+            }
+          }
+          throw error;
+        }
         if (!process.env.CURSOR_ACCESS_TOKEN || boundProviderAuthPath('cursor-oauth')) {
           saveCredentials(next);
         }

package/src/runtime/agent/orchestrator/providers/cursor-client-version.mjs

@@ -4,7 +4,7 @@ import { createRemoteVersionSource } from './npm-cli-version.mjs';
 // documented version endpoint; the official installer script embeds the
 // current build (…/lab/<build>/…), parsed best-effort. Any format change or
 // failure falls back to the floor.
-export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.14-0f9edde';
+export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.14-941492e';
 const BUILD_PATTERN = /downloads\.cursor\.com\/lab\/(\d{4}\.\d{2}\.\d{2}-[0-9a-f]{6,40})\//;
 export const CURSOR_INSTALL_URL = 'https://cursor.com/install';
 

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

@@ -207,6 +207,7 @@ export function createBridgeController(ctx) {
       conversation: run.conversation,
       tools: run.tools,
       cloudRule: run.cloudRule,
+      sessionId: run.sessionId,
     };
     const frameParser = createFrameParser(
       // Server requests answer on whichever bridge is live when they arrive.

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

@@ -3,12 +3,46 @@
  * to the shared stream state and relayed to the SSE sink. Returns the
  * message's forward-progress kind for the watchdog.
  */
+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';
 
+// 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 */
+  }
+}
+
 // Relays one interaction update to the SSE stream and returns its progress.
 function applyInteractionUpdate(update, state, filter, emit) {
   if (update.textDelta?.text) {
@@ -62,11 +96,18 @@ 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 = '', 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);
+  }
   if (message.interactionUpdate) return applyInteractionUpdate(message.interactionUpdate, state, filter, emit);
   if (message.kvServerMessage) {
     handleKvMessage(bridge, message.kvServerMessage, conversation);

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;

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,
@@ -693,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.