mixdog 1.2.1 → 1.2.3

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

@@ -8,6 +8,7 @@ import { modelProxyClientMode } from '../../../shared/model-proxy-mode.mjs';
 import { openInBrowser } from '../../../shared/open-url.mjs';
 import { createOAuthPkce } from './lib/oauth-pkce.mjs';
 import { accountIdentityFields, normalizeAccountIdentity } from './lib/oauth-token-utils.mjs';
+import { retryAfterMsFromError } from './retry-classifier.mjs';
 
 const LOGIN_URL = 'https://cursor.com/loginDeepControl';
 const POLL_URL = 'https://api2.cursor.sh/auth/poll';
@@ -17,6 +18,23 @@ const REFRESH_SKEW_MS = 5 * 60_000;
 // abort signal, which must never govern work every other waiter depends on.
 const REFRESH_TIMEOUT_MS = 30_000;
 const refreshesInFlight = new Map();
+export const REAUTH_GUIDANCE = 'Open /providers in Mixdog to sign in again.';
+// The refresh credential itself was rejected.
+const PERMANENT_REFRESH_STATUS = new Set([400, 401, 403]);
+const EXCHANGE_STATUS_CODE = Object.freeze({
+  400: 'invalid_argument',
+  401: 'unauthenticated',
+  403: 'permission_denied',
+  429: 'resource_exhausted',
+  500: 'internal',
+  502: 'unavailable',
+  503: 'unavailable',
+  504: 'deadline_exceeded',
+});
+
+function reauthError(message) {
+  return Object.assign(new Error(message), { reauthRequired: true });
+}
 
 // Wait on the shared refresh while still honouring THIS caller's abort signal.
 // Aborting only ends this caller's wait; the exchange keeps running for the
@@ -112,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);
 }
@@ -129,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;
@@ -197,8 +227,25 @@ export async function exchangeCursorToken(token, { fetchFn = fetch, signal } = {
   });
   if (!response.ok) {
     const detail = await response.text().catch(() => '');
-    const error = new Error(`Cursor token exchange failed (${response.status})${detail ? `: ${detail}` : ''}`);
+    // Only a credential verdict is permanent; throttles, 5xx and network
+    // failures leave the refresh token valid and stay retryable upstream.
+    const reauthRequired = PERMANENT_REFRESH_STATUS.has(response.status);
+    const error = new Error(
+      `Cursor token exchange failed (${response.status})${detail ? `: ${detail}` : ''}${
+        reauthRequired ? `. ${REAUTH_GUIDANCE}` : ''
+      }`
+    );
     error.status = response.status;
+    error.httpStatus = response.status;
+    const code = EXCHANGE_STATUS_CODE[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;
+    }
+    if (reauthRequired) error.reauthRequired = true;
     throw error;
   }
   const data = await response.json();
@@ -277,9 +324,7 @@ export async function resolveCursorOAuthAccessToken({ forceRefresh = false, fetc
   if (!forceRefresh && !expiring) return tokens.access_token;
   if (!tokens.refresh_token) {
     if (!tokens.expires_at || tokens.expires_at > Date.now()) return tokens.access_token;
-    throw new Error(
-      'Cursor access token expired and has no refresh token. Open /providers in Mixdog to sign in again.'
-    );
+    throw reauthError(`Cursor access token expired and has no refresh token. ${REAUTH_GUIDANCE}`);
   }
   const refreshPath = credentialsPath();
   let refreshInFlight = refreshesInFlight.get(refreshPath);
@@ -296,17 +341,37 @@ export async function resolveCursorOAuthAccessToken({ forceRefresh = false, fetc
           return latest;
         }
         if (!latest.refresh_token) {
-          throw new Error('Cursor OAuth refresh token is unavailable. Open /providers in Mixdog to sign in again.');
+          throw reauthError(`Cursor OAuth refresh token is unavailable. ${REAUTH_GUIDANCE}`);
         }
         // Deliberately NOT the caller's signal: this exchange is shared by
         // every concurrent waiter, so letting the first caller's abort
         // (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.12-d47ca18';
+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-guards.mjs

@@ -1,4 +1,6 @@
 import { mergeFlatSchemaProperty } from './lib/flat-schema-merge.mjs';
+import { REAUTH_GUIDANCE } from './cursor-auth.mjs';
+import { isTransientErrorCode } from './provider-error-kind.mjs';
 
 const SCHEMA_ANNOTATIONS = new Set([
   '$comment',
@@ -32,6 +34,15 @@ export function resolveCursorStreamTuning(env = process.env) {
     idleTimeoutMs: boundedInteger(env.MIXDOG_CURSOR_STREAM_IDLE_TIMEOUT_MS, 180_000),
     parkTimeoutMs: boundedInteger(env.MIXDOG_CURSOR_STREAM_PARK_TIMEOUT_MS, 45_000, { min: 1_000 }),
     maxRetries: boundedInteger(env.MIXDOG_CURSOR_STREAM_IDLE_MAX_RETRIES, 5, { max: 10 }),
+    // Transport retry: 250ms base, 2s ceiling.
+    retryBaseDelayMs: boundedInteger(env.MIXDOG_CURSOR_STREAM_RETRY_BASE_MS, 250, { max: 60_000 }),
+    retryMaxDelayMs: boundedInteger(env.MIXDOG_CURSOR_STREAM_RETRY_MAX_MS, 2_000, { max: 120_000 }),
+    // A rate limit gets one recovery (min(1, maxRetries)).
+    maxThrottleRetries: boundedInteger(env.MIXDOG_CURSOR_THROTTLE_MAX_RETRIES, 1, { max: 5 }),
+    // One credential-refresh retry; the outer provider layer adds none for a
+    // stream that already ran, and re-sending a rejected credential only
+    // hammers the token endpoint.
+    maxAuthRetries: boundedInteger(env.MIXDOG_CURSOR_AUTH_MAX_RETRIES, 1, { max: 5 }),
   };
 }
 
@@ -221,6 +232,13 @@ export function createCursorStreamWatchdog({ idleTimeoutMs, parkTimeoutMs, onTim
       if (kind === 'work') arm(idleTimeoutMs, 'idle');
       else if (kind === 'park') arm(parkTimeoutMs, 'park');
     },
+    // Suspend both deadlines during an intentional retry wait; the next
+    // start()/progress('work'|'park') re-arms them, so only real stream
+    // silence is ever counted.
+    pause() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+    },
     stop() {
       stopped = true;
       if (timer) clearTimeout(timer);
@@ -251,8 +269,85 @@ export function cursorInteractionProgress(update) {
   return 'none';
 }
 
+// Codes that describe a transient server verdict or a recognized transport
+// truncation. Everything else (protocol/decoding errors, 4xx verdicts,
+// unknown failures) is deterministic and is never replayed in place.
+const TRANSIENT_STREAM_CODES = new Set([
+  'unavailable',
+  'internal',
+  'deadline_exceeded',
+  'stream_aborted',
+  'goaway',
+  'connection_timeout',
+  'stream_idle_timeout',
+  'stream_park_timeout',
+  'incomplete_stream',
+  'ERR_HTTP2_STREAM_CANCEL',
+  'ERR_HTTP2_GOAWAY_SESSION',
+]);
+
+// Protocol-mismatch check: Cursor wraps a wire mismatch in `internal`, and
+// re-sending a request the schema cannot decode only burns the retry budget.
+// Tested on the server's own detail, before the transient code is trusted.
+const PROTOCOL_DRIFT_RE = /\b(protocol|protobuf|wire drift|invalid argument|failed_precondition)\b/i;
+
+export function isCursorProtocolDrift(error) {
+  if (error?.code === 'protocol_error') return true;
+  return PROTOCOL_DRIFT_RE.test(String(error?.cursorDetail ?? ''));
+}
+
 export function isRetryableCursorStreamError(error) {
-  const status = Number(error?.httpStatus || error?.status || 0);
   if (error?.name === 'AbortError') return false;
-  return status === 0 || status >= 500;
+  const code = String(error?.code || '');
+  if (!TRANSIENT_STREAM_CODES.has(code) && !isTransientErrorCode(code)) return false;
+  return !isCursorProtocolDrift(error);
+}
+
+// Rejected credentials: worth one forced token refresh before giving up.
+export function isCursorAuthError(error) {
+  if (error?.name === 'AbortError') return false;
+  return error?.code === 'unauthenticated' || error?.code === 'permission_denied';
+}
+
+// Credentials for in-place restarts. Every retry force-refreshes and keeps the
+// previous token if the refresh fails; a rejected credential is
+// only retried when the refresh produced a different token.
+export function createCursorCredentialRefresher(initialToken, getAccessToken) {
+  let current = initialToken;
+  return {
+    async refresh(reason, error) {
+      let next = current;
+      if (getAccessToken) {
+        try {
+          next = (await getAccessToken({ forceRefresh: true })) || current;
+        } catch {
+          /* keep the previous token */
+        }
+      }
+      if (reason === 'auth' && next === current) throw error;
+      current = next;
+      return current;
+    },
+  };
+}
+
+// Final-failure guidance appended once to the original Cursor detail
+// (transport-failure hint).
+export function withCursorFailureHint(error) {
+  if (!(error instanceof Error) || error.cursorHintApplied) return error;
+  const hint = isCursorAuthError(error)
+    ? REAUTH_GUIDANCE
+    : isCursorProtocolDrift(error)
+      ? 'Cursor may have changed its wire protocol; update Mixdog or set MIXDOG_CURSOR_CLIENT_VERSION if this persists.'
+      : '';
+  if (!hint) return error;
+  error.cursorHintApplied = true;
+  error.message = `${error.message} ${hint}`;
+  return error;
+}
+
+// resource_exhausted / 429 that is a throttle, not an oversized request.
+export function isCursorThrottleError(error) {
+  if (error?.name === 'AbortError' || error?.code === 'request_too_large') return false;
+  return error?.code === 'resource_exhausted' || Number(error?.httpStatus || error?.status || 0) === 429;
 }

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

@@ -3,11 +3,30 @@
  * response: frame parsing, tool-batch hand-off to the run registry, the
  * close verdict and the bounded in-place restart.
  */
-import { isRetryableCursorStreamError } from './cursor-wire-guards.mjs';
-import { markProviderRecoveryExhausted } from './retry-classifier.mjs';
+import {
+  isCursorAuthError,
+  isCursorThrottleError,
+  isRetryableCursorStreamError,
+  withCursorFailureHint,
+} from './cursor-wire-guards.mjs';
+import { emitProviderRetryStage, markProviderRecoveryExhausted, retryAfterMsFromError } from './retry-classifier.mjs';
 import { createFrameParser, cursorError, parseEndStream } from './cursor-wire-transport.mjs';
 import { processServerMessage } from './cursor-wire-stream-messages.mjs';
 
+// Resolves after `ms`, or early when the stream is cancelled.
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve();
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener('abort', done, { once: true });
+  });
+}
+
 /**
  * @param {object} ctx
  * @param {{ bridge, heartbeat }} ctx.live  the bridge currently feeding the stream (mutated on restart)
@@ -16,7 +35,10 @@ import { processServerMessage } from './cursor-wire-stream-messages.mjs';
  */
 export function createBridgeController(ctx) {
   const { live, state, filter, watchdog, sink, tuning, run, runs, restart, isCancelled } = ctx;
+  const { sleep = abortableSleep, cancelSignal = null, onStageChange = null } = ctx;
   let retryCount = 0;
+  let throttleCount = 0;
+  let authCount = 0;
 
   const finishToolBatch = () => {
     if (state.closed || state.pending.length === 0) return;
@@ -35,37 +57,91 @@ export function createBridgeController(ctx) {
     sink.finish('tool_calls');
   };
 
+  // Exponential backoff with +-20% jitter for in-place retries.
+  const backoffMs = (attempt) => {
+    const ceiling = Math.min(tuning.retryMaxDelayMs, tuning.retryBaseDelayMs * 2 ** (attempt - 1));
+    return Math.floor(ceiling * (0.8 + Math.random() * 0.4));
+  };
+
   const recoverOrFail = (error) => {
     const retryable = isRetryableCursorStreamError(error);
+    // A throttle retries within the bounded throttle retry count; otherwise
+    // the error surfaces with retryAfterMs for the outer layer.
+    const throttled = !retryable && isCursorThrottleError(error);
+    // Rejected credentials get a forced token refresh before the retry.
+    const authFailure = !retryable && !throttled && isCursorAuthError(error);
+    // A throttle retry rotates the conversation and drops the checkpoint
+    // so unlike other recoveries it can only replay a run that
+    // has shown nothing; the rest may also continue from a checkpoint.
     const recoveryEligible =
-      !isCancelled() && typeof restart === 'function' && (!state.visibleOutput || run.conversation.checkpoint);
-    const canRetry = retryCount < tuning.maxRetries && recoveryEligible && retryable;
+      !isCancelled() &&
+      typeof restart === 'function' &&
+      (!state.visibleOutput || (!throttled && Boolean(run.conversation.checkpoint)));
+    const serverDelay = retryAfterMsFromError(error);
+    // Server advice is honored in full for every retryable kind; local
+    // backoff applies only when the server gave none.
+    const delayMs = Number.isFinite(serverDelay)
+      ? serverDelay
+      : backoffMs(throttled ? throttleCount + 1 : retryCount + 1);
+    const throttleOk = throttled && throttleCount < tuning.maxThrottleRetries;
+    const authOk = authFailure && authCount < tuning.maxAuthRetries;
+    const canRetry =
+      retryCount < tuning.maxRetries && recoveryEligible && (retryable || throttleOk || authOk);
     if (!canRetry) {
       // A fresh Cursor run owns its bounded in-place retries. Mark
       // exhaustion so the outer loop does not multiply that budget.
       // Resumed tool-result streams have no restart closure; those
       // intentionally fall through unmarked so the outer loop can
       // rebuild from the committed assistant/tool-result history.
-      if (retryable && recoveryEligible && retryCount >= tuning.maxRetries) {
+      // A throttle that spent its bounded retries is final for the turn too.
+      if (
+        recoveryEligible &&
+        ((retryable && retryCount >= tuning.maxRetries) ||
+          (throttled && throttleCount >= tuning.maxThrottleRetries))
+      ) {
         markProviderRecoveryExhausted(error, { owner: 'cursor-wire', attempts: retryCount + 1 });
       }
-      sink.fail(error);
+      sink.fail(withCursorFailureHint(error));
       return;
     }
     retryCount += 1;
+    if (throttled) throttleCount += 1;
+    if (authFailure) authCount += 1;
     state.sawEnd = false;
     state.batchBoundaryReady = false;
     state.batchBoundaryChunkSeq = -1;
-    try {
-      const next = restart({
-        attempt: retryCount,
-        fromCheckpoint: Boolean(run.conversation.checkpoint),
-        visibleOutput: state.visibleOutput,
-      });
-      attach(next.bridge, next.heartbeat);
-    } catch (restartError) {
-      sink.fail(restartError);
-    }
+    // The wait is intentional, not stream silence; attach() re-arms on restart.
+    watchdog.pause();
+    emitProviderRetryStage(onStageChange, {
+      attempt: retryCount + 1,
+      maxAttempts: tuning.maxRetries + 1,
+      lastErr: error,
+      delayMs,
+    });
+    void sleep(delayMs, cancelSignal).then(async () => {
+      if (isCancelled() || state.closed) return;
+      try {
+        // restart() may refresh credentials first, so it can be async.
+        const next = await restart({
+          attempt: retryCount,
+          fromCheckpoint: !throttled && Boolean(run.conversation.checkpoint),
+          visibleOutput: state.visibleOutput,
+          reason: throttled ? 'throttle' : authFailure ? 'auth' : 'transient',
+          error,
+        });
+        if (isCancelled() || state.closed) {
+          clearInterval(next.heartbeat);
+          next.bridge.close();
+          return;
+        }
+        attach(next.bridge, next.heartbeat);
+        try {
+          onStageChange?.('streaming');
+        } catch {}
+      } catch (restartError) {
+        sink.fail(withCursorFailureHint(restartError));
+      }
+    });
   };
 
   /** The Connect end frame: an error closes, pending tools delimit, a finished turn completes. */
@@ -99,20 +175,23 @@ export function createBridgeController(ctx) {
         closeError = frameError;
       }
     }
-    // Cursor commonly closes HTTP/2 immediately after turnEnded without
-    // a separate Connect end frame. The turn is already complete.
-    if (state.sawTurnEnded) {
-      sink.finish();
-      return;
-    }
     // Tool calls already emitted to the caller remain actionable even if
     // the parked transport vanished. The next request rebuilds/resumes.
+    // Checked before turnEnded: a close that follows turnEnded only ends a
+    // completed turn when no exec is still waiting (turn ended
+    // with no MCP exec outstanding), never by dropping a tool call.
     if (state.pending.length > 0) {
       sink.finish('tool_calls');
       return;
     }
+    // Cursor commonly closes HTTP/2 immediately after turnEnded, with or
+    // without an end-stream error. The turn is already complete.
+    if (state.sawTurnEnded) {
+      sink.finish();
+      return;
+    }
     if (!closeError && !state.sawEnd) {
-      closeError = cursorError('Cursor stream closed before its end frame', { code: 'protocol_error' });
+      closeError = cursorError('Cursor stream closed before its end frame', { code: 'incomplete_stream' });
     }
     if (closeError) recoverOrFail(closeError);
     else sink.finish();
@@ -128,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);