mixdog 1.2.3 → 1.2.4

package/src/runtime/agent/orchestrator/providers/gemini-thinking.mjs

@@ -19,21 +19,43 @@ function catalogThinkingLevels(model, provider) {
 // Documented ranges: 2.5 Pro 128–32768 (cannot disable), 2.5 Flash 0–24576,
 // 2.5 Flash-Lite 0 or 512–24576; -1 is dynamic thinking for all of them.
 function budgetSpec(model) {
-  const bare = String(model || '').replace(/^models\//i, '').toLowerCase();
+  const bare = String(model || '')
+    .replace(/^models\//i, '')
+    .toLowerCase();
   if (!/^gemini-2\.5(?:-|$)/.test(bare)) return null;
   if (/^gemini-2\.5-pro/.test(bare)) {
-    return { name: 'Gemini 2.5 Pro', min: 128, max: 32768, canDisable: false, efforts: { minimal: 128, low: 1024, medium: 8192, high: 32768 } };
+    return {
+      name: 'Gemini 2.5 Pro',
+      min: 128,
+      max: 32768,
+      canDisable: false,
+      efforts: { minimal: 128, low: 1024, medium: 8192, high: 32768 },
+    };
   }
   if (/^gemini-2\.5-flash-lite/.test(bare)) {
-    return { name: 'Gemini 2.5 Flash-Lite', min: 512, max: 24576, canDisable: true, efforts: { minimal: 512, low: 1024, medium: 8192, high: 24576 } };
+    return {
+      name: 'Gemini 2.5 Flash-Lite',
+      min: 512,
+      max: 24576,
+      canDisable: true,
+      efforts: { minimal: 512, low: 1024, medium: 8192, high: 24576 },
+    };
   }
-  return { name: 'Gemini 2.5 Flash', min: 0, max: 24576, canDisable: true, efforts: { minimal: 0, low: 1024, medium: 8192, high: 24576 } };
+  return {
+    name: 'Gemini 2.5 Flash',
+    min: 0,
+    max: 24576,
+    canDisable: true,
+    efforts: { minimal: 0, low: 1024, medium: 8192, high: 24576 },
+  };
 }
 
 // Levels documented for models whose ladder differs from the generic wire
 // vocabulary (a catalog ladder, when declared, still takes precedence).
 function documentedThinkingLevels(model) {
-  const bare = String(model || '').replace(/^models\//i, '').toLowerCase();
+  const bare = String(model || '')
+    .replace(/^models\//i, '')
+    .toLowerCase();
   if (bare === 'gemini-4-argon' || bare === 'gemini-3.8-flash') return ['low', 'medium', 'high'];
   return null;
 }
@@ -47,7 +69,9 @@ function checkBudget(model, spec, budget) {
     throw new TypeError(`${model} (${spec.name}) cannot disable thinking; thinkingBudget 0 is not allowed.`);
   }
   if (budget !== 0 && (budget < spec.min || budget > spec.max)) {
-    throw new TypeError(`${model} (${spec.name}) thinkingBudget must be -1, ${spec.canDisable ? '0, or ' : ''}${spec.min}–${spec.max}; received ${budget}.`);
+    throw new TypeError(
+      `${model} (${spec.name}) thinkingBudget must be -1, ${spec.canDisable ? '0, or ' : ''}${spec.min}–${spec.max}; received ${budget}.`
+    );
   }
 }
 
@@ -75,7 +99,9 @@ export function geminiThinkingConfig(model, opts = {}, { includeThoughts, provid
   }
   if (spec && level) {
     if (!Object.hasOwn(spec.efforts, level)) {
-      throw new TypeError(`${model} supports thinking levels ${Object.keys(spec.efforts).join(', ')}; received ${level}.`);
+      throw new TypeError(
+        `${model} supports thinking levels ${Object.keys(spec.efforts).join(', ')}; received ${level}.`
+      );
     }
     config.thinkingBudget = spec.efforts[level];
   } else if (level) {

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

@@ -731,8 +731,17 @@ export class GeminiProvider {
   }
 
   async _streamViaSdk(stream) {
-    const { opts, signal, useModel, systemInstruction, geminiTools, toolConfig, generationConfig, safetySettings, contents } =
-      stream;
+    const {
+      opts,
+      signal,
+      useModel,
+      systemInstruction,
+      geminiTools,
+      toolConfig,
+      generationConfig,
+      safetySettings,
+      contents,
+    } = stream;
     const genModel = this._currentGenAI().getGenerativeModel({
       model: useModel,
       systemInstruction,

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

@@ -3,7 +3,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // Grok CLI client version for the cli-chat-proxy version gate (HTTP 426).
 // Effective = env override, else max(floor, learned-from-426, live npm latest
 // of the official @xai-official/grok CLI).
-export const GROK_CLI_VERSION_FLOOR = '1.0.60';
+export const GROK_CLI_VERSION_FLOOR = '1.0.62';
 export const GROK_CLI_NPM_PACKAGE = '@xai-official/grok';
 
 const live = createNpmVersionSource(GROK_CLI_NPM_PACKAGE, { persistKey: 'grok-cli' });

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -37,7 +37,9 @@ function lastEligibleBlockIndex(content) {
 export function countAnthropicCacheControls(value) {
   if (Array.isArray(value)) return value.reduce((sum, item) => sum + countAnthropicCacheControls(item), 0);
   if (!value || typeof value !== 'object') return 0;
-  return (value.cache_control ? 1 : 0) + (Array.isArray(value.content) ? countAnthropicCacheControls(value.content) : 0);
+  return (
+    (value.cache_control ? 1 : 0) + (Array.isArray(value.content) ? countAnthropicCacheControls(value.content) : 0)
+  );
 }
 
 function stripCacheControl(block, budget) {
@@ -546,7 +548,12 @@ function toAnthropicTools(tools, logTag, onToolExcluded) {
 // `supportsDisableParallelToolUse: false` (gateway capability).
 export function toAnthropicToolChoice(
   toolChoice,
-  { thinking = false, disableParallelToolUse = false, supportsDisableParallelToolUse = true, onThinkingConflict = 'fallback' } = {}
+  {
+    thinking = false,
+    disableParallelToolUse = false,
+    supportsDisableParallelToolUse = true,
+    onThinkingConflict = 'fallback',
+  } = {}
 ) {
   let choice;
   if (toolChoice === 'none') choice = { type: 'none' };

package/src/runtime/agent/orchestrator/providers/lib/claude-bridge-schema.mjs

@@ -203,7 +203,8 @@ function assertObjectRoot(schema, rule) {
 function buildSchema(inputSchema) {
   if (!isPlainObject(inputSchema)) throw new SchemaProblem('', 'the input schema must be a JSON object schema');
   const { $schema, ...rest } = inputSchema;
-  const schema = dialectOf(inputSchema) === 'draft-07' ? translateDraft07(rest, '', true, DRAFT07) : structuredClone(rest);
+  const schema =
+    dialectOf(inputSchema) === 'draft-07' ? translateDraft07(rest, '', true, DRAFT07) : structuredClone(rest);
   assertValidDraft202012(schema);
   assertObjectRoot(schema, 'anthropic');
   return schema;
@@ -222,8 +223,7 @@ function repairRoot(schema) {
   if (Array.isArray(type) && type.includes('object')) return { ...schema, type: 'object' };
   if (type !== undefined || Object.hasOwn(schema, '$ref')) return schema;
   const out = { type: 'object', ...schema };
-  if (!Object.hasOwn(out, 'properties') && !ROOT_FORBIDDEN_KEYS.some((k) => Object.hasOwn(out, k)))
-    out.properties = {};
+  if (!Object.hasOwn(out, 'properties') && !ROOT_FORBIDDEN_KEYS.some((k) => Object.hasOwn(out, k))) out.properties = {};
   return out;
 }
 
@@ -232,7 +232,8 @@ function refsIntoDefinitions(node) {
   if (Array.isArray(node)) return node.some(refsIntoDefinitions);
   if (!isPlainObject(node)) return false;
   return Object.entries(node).some(
-    ([key, value]) => (key === '$ref' && typeof value === 'string' && /^#\/definitions(\/|$)/.test(value)) || refsIntoDefinitions(value)
+    ([key, value]) =>
+      (key === '$ref' && typeof value === 'string' && /^#\/definitions(\/|$)/.test(value)) || refsIntoDefinitions(value)
   );
 }
 
@@ -348,7 +349,10 @@ export function claudeBridgeInputSchema(inputSchema) {
       // Not valid as written: lower undeclared draft-07/04 constructs and
       // fill the root type; only a schema still broken is excluded.
       const repaired = repairedToolInputSchema(inputSchema, 'anthropic');
-      result = repaired && !wireProblem(repaired, 'anthropic') ? { schema: repaired } : { pointer: error.pointer, reason: error.message };
+      result =
+        repaired && !wireProblem(repaired, 'anthropic')
+          ? { schema: repaired }
+          : { pointer: error.pointer, reason: error.message };
     }
     if (key !== null) {
       if (cache.size >= CACHE_LIMIT) cache.clear();

package/src/runtime/agent/orchestrator/providers/lib/request-compression.mjs

@@ -0,0 +1,86 @@
+// Shared request-body compression for provider POSTs (Anthropic gzip, Codex
+// zstd). Policy in one place:
+//  - bodies below REQ_COMPRESSION_MIN_BYTES are never compressed (CPU + header
+//    cost outweighs the upload saving);
+//  - a request that already carries Content-Encoding is never double-encoded;
+//  - a compression failure fails open to the plain body;
+//  - a 400/415 on a compressed request is drained and the SAME request is
+//    resent once uncompressed; compression latches off process-wide only when
+//    that plain resend succeeds (the encoding was the cause). If the resend
+//    fails too, nothing latches and the resend's response is returned.
+import { promisify } from 'node:util';
+import { gzip } from 'node:zlib';
+
+export const REQ_COMPRESSION_MIN_BYTES = 8 * 1024;
+
+export function createCompressionLatch(envVar) {
+  let latched = false;
+  return {
+    disabled: () => latched || process.env[envVar] === '0',
+    latchOff: () => {
+      latched = true;
+    },
+    reset: () => {
+      latched = false;
+    },
+  };
+}
+
+// One latch for every api.anthropic.com /v1/messages path (OAuth + API key).
+export const anthropicGzipLatch = createCompressionLatch('MIXDOG_ANTHROPIC_REQ_GZIP');
+// Compress on the libuv threadpool so large turn bodies never block the main thread.
+export const gzipAsync = promisify(gzip);
+
+export const hasContentEncoding = (headers) => new Headers(headers || {}).has('content-encoding');
+
+export function withContentEncoding(headers, encoding) {
+  if (headers instanceof Headers || Array.isArray(headers)) {
+    const next = new Headers(headers);
+    next.delete('content-length');
+    next.set('Content-Encoding', encoding);
+    return next;
+  }
+  const rest = Object.fromEntries(
+    Object.entries(headers || {}).filter(([name]) => name.toLowerCase() !== 'content-length')
+  );
+  return { ...rest, 'Content-Encoding': encoding };
+}
+
+// Fail open: any compression error yields the plain body.
+export async function compressBody(raw, compress, encoding) {
+  try {
+    return { bytes: await compress(raw), encoding };
+  } catch {
+    return { bytes: raw, encoding: null };
+  }
+}
+
+export const isEncodingRejection = (response) => response.status === 400 || response.status === 415;
+
+export async function resendIfEncodingRejected({ response, encoded, resend, latch }) {
+  if (!encoded || !isEncodingRejection(response)) return response;
+  try {
+    await response.arrayBuffer();
+  } catch {
+    /* drain best-effort */
+  }
+  const retry = await resend();
+  if (retry.ok) latch.latchOff();
+  return retry;
+}
+
+/**
+ * Send `raw` compressed when eligible, with the rejection resend above.
+ * `send(bytes, headers)` performs one HTTP request.
+ */
+export async function sendWithCompression({ raw, headers, encoding, compress, latch, send }) {
+  const plain = () => send(raw, headers);
+  if (latch.disabled() || raw.length < REQ_COMPRESSION_MIN_BYTES || hasContentEncoding(headers)) return plain();
+  const packed = await compressBody(raw, compress, encoding);
+  if (!packed.encoding) return plain();
+  const response = await send(packed.bytes, withContentEncoding(headers, encoding));
+  return resendIfEncodingRejected({ response, encoded: true, resend: plain, latch });
+}
+
+export const sendGzipCompressed = ({ compress = gzipAsync, ...rest }) =>
+  sendWithCompression({ ...rest, encoding: 'gzip', compress, latch: anthropicGzipLatch });

package/src/runtime/agent/orchestrator/providers/lib/wire-pairing.mjs

@@ -29,8 +29,10 @@ function isObject(value) {
 // answered by the server inside the same response. It is never a client call
 // awaiting a client output, so the guard neither pairs nor synthesizes it.
 function isServerToolSearch(item) {
-  return (item.type === 'tool_search_call' || item.type === 'tool_search_output') &&
-    (item.execution === 'server' || item.call_id === null);
+  return (
+    (item.type === 'tool_search_call' || item.type === 'tool_search_output') &&
+    (item.execution === 'server' || item.call_id === null)
+  );
 }
 
 function responsesCallId(item) {

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -167,7 +167,11 @@ function officeTextForFile(file) {
     });
   if (file.ref) return memoized(officeTextMemo, `ref:${file.ref}\0${file.filename || ''}`, compute);
   if (file.part && inlineOfficeText.has(file.part)) return inlineOfficeText.get(file.part);
-  const key = createHash('sha256').update(file.filename || '').update('\0').update(file.data).digest('hex');
+  const key = createHash('sha256')
+    .update(file.filename || '')
+    .update('\0')
+    .update(file.data)
+    .digest('hex');
   const text = memoized(officeTextMemo, key, compute);
   if (file.part) inlineOfficeText.set(file.part, text);
   return text;
@@ -403,15 +407,19 @@ export async function preparePdfTextForProvider(messages, provider) {
         continue;
       }
       if (file && fileKind(file) === 'pdf') found.push({ part, file });
-      else if (noDocuments && (file || part.type === 'document')) texts.set(part, file ? textFormOfFilePart(part) : documentSourceText(part));
+      else if (noDocuments && (file || part.type === 'document'))
+        texts.set(part, file ? textFormOfFilePart(part) : documentSourceText(part));
     }
   }
   if (!found.length && !texts.size) return messages;
   const extracted = await Promise.all(found.map(({ file }) => pdfTextFor(file)));
-  found.forEach(({ part, file }, i) => texts.set(part, `--- ${fileLabel(file)} ---\n${extracted[i]}`));
+  found.forEach(({ part, file }, i) => {
+    texts.set(part, `--- ${fileLabel(file)} ---\n${extracted[i]}`);
+  });
   return messages.map((message) => {
     // A message whose content is one bare part becomes a one-part array.
-    if (texts.has(message?.content)) return { ...message, content: [{ type: 'text', text: texts.get(message.content) }] };
+    if (texts.has(message?.content))
+      return { ...message, content: [{ type: 'text', text: texts.get(message.content) }] };
     const content = replacePdfParts(message?.content, texts);
     return content === message?.content ? message : { ...message, content };
   });
@@ -681,7 +689,10 @@ export function contentMediaBytes(content, { nativePdf = true } = {}) {
     if (!part || typeof part !== 'object') continue;
     if (isAttachmentReference(part)) {
       if (part.type === 'image') bytes += Math.ceil((Number(part.sizeBytes) || 0) / 3) * 4;
-      else if (part.type === 'file' && countsAsMedia(String(part.mimeType || part.mediaType || 'application/pdf'), '')) {
+      else if (
+        part.type === 'file' &&
+        countsAsMedia(String(part.mimeType || part.mediaType || 'application/pdf'), '')
+      ) {
         bytes += Math.ceil((Number(part.sizeBytes) || 0) / 3) * 4;
       }
       continue;

package/src/runtime/agent/orchestrator/providers/mimo-oauth.mjs

@@ -9,7 +9,7 @@
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { fileMtimeMs, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
-import { COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
+import { COMPAT_RETRY_POLICY, compatFirstResponseBudget } from './openai-compat-retry-profile.mjs';
 import { fetchCompatModelItems, listCompatModels } from './openai-compat-models.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import {
@@ -152,6 +152,12 @@ export class MimoOAuthProvider {
     return this.tokens;
   }
 
+  // The inner client's chat profile sets a longer first-byte window; the
+  // budget needs no credentials, so it is read from the profile directly.
+  firstResponseBudget() {
+    return compatFirstResponseBudget(this.name, MIMO_CHAT_PROFILE);
+  }
+
   _ensureInner() {
     const { apiKey, baseUrl } = this.ensureAuth();
     const key = `${baseUrl}:${apiKey}`;

package/src/runtime/agent/orchestrator/providers/model-proxy-provider.mjs

@@ -90,6 +90,15 @@ export function inlineModelProxyAttachments(messages, { maxBytes = MODEL_PROXY_I
   return out ?? messages;
 }
 
+/** A first-response budget the PC reported, or null for anything malformed. */
+function reportedBudget(value) {
+  const transportMs = Number(value?.transportMs);
+  const semanticMs = Number(value?.semanticMs);
+  return transportMs > 0 && semanticMs > 0 && Number.isFinite(transportMs) && Number.isFinite(semanticMs)
+    ? { transportMs, semanticMs }
+    : null;
+}
+
 export class ModelProxyProvider {
   #channel;
   #modelInfo = new Map();
@@ -101,6 +110,7 @@ export class ModelProxyProvider {
     this.#channel = channel;
     // Adapter traits are reported by the PC's real instance.
     if (typeof this.config.modelProxy?.nativePdf === 'boolean') this.nativePdf = this.config.modelProxy.nativePdf;
+    if (this.config.modelProxy?.consumesReadWindows === true) this.consumesReadWindows = true;
   }
 
   #call(method, fields = {}, options = {}) {
@@ -110,18 +120,16 @@ export class ModelProxyProvider {
   async send(messages, model, tools, sendOpts) {
     const { options, callbacks } = splitModelProxySendOptions(sendOpts);
     const finalized = isFinalizedProviderRequestTools(tools);
-    const result = await this.#call(
-      'send',
-      {
-        model: model ?? null,
-        messages: inlineModelProxyAttachments(messages),
-        tools: Array.isArray(tools) ? tools : null,
-        toolsFinalized: finalized,
-        nativePrefixCount: finalized ? providerNativeToolPrefixCount(tools) : 0,
-        options,
-      },
-      { signal: sendOpts?.signal || null, callbacks }
-    );
+    const fields = {
+      model: model ?? null,
+      messages: inlineModelProxyAttachments(messages),
+      tools: Array.isArray(tools) ? tools : null,
+      toolsFinalized: finalized,
+      nativePrefixCount: finalized ? providerNativeToolPrefixCount(tools) : 0,
+      options,
+    };
+    const signal = sendOpts?.signal || null;
+    const result = await this.#call('send', fields, { signal, callbacks });
     // The PC rerouted the wire (a clear "unsupported" refusal) and reports the
     // route it used: the daemon's own session adopts it, so the next proxied
     // turn starts on the new wire instead of repeating the refusal.
@@ -163,6 +171,16 @@ export class ModelProxyProvider {
     return this.#modelInfo.get(String(model ?? '')) ?? null;
   }
 
+  /** The PC adapter's first-response budget for `model`: the catalog's
+   *  model-specific figure, else the adapter's own from its provider config;
+   *  null keeps the agent watchdog default. */
+  firstResponseBudget(model) {
+    return (
+      reportedBudget(this.getCachedModelInfo(model)?.firstResponseBudget) ??
+      reportedBudget(this.config.modelProxy?.firstResponseBudget)
+    );
+  }
+
   /** The PC adapter's wire route for `model` (its config and roster decide);
    *  null for a single-wire adapter, which is remembered so every later turn
    *  skips the round trip. */
@@ -222,10 +240,12 @@ export function loadModelProxyProviderConfig({
   channel = getModelProxyChannel(),
   now = Date.now,
   waitMs = MODEL_PROXY_CONFIG_WAIT_MS,
+  force = false,
 } = {}) {
   const generation = channel.generation;
   const cached = _providerConfigCache;
   if (
+    !force &&
     cached &&
     cached.channel === channel &&
     cached.generation === generation &&
@@ -234,7 +254,16 @@ export function loadModelProxyProviderConfig({
     return Promise.resolve(cached.value);
   }
   const inFlight = _providerConfigInFlight;
-  if (inFlight && inFlight.channel === channel && inFlight.generation === generation) return inFlight.promise;
+  // A forced read starts after the caller's change, never reuses an older
+  // snapshot. Short setup reads also cannot inherit a registry init's budget.
+  if (
+    !force &&
+    inFlight &&
+    inFlight.channel === channel &&
+    inFlight.generation === generation &&
+    inFlight.waitMs === waitMs
+  )
+    return inFlight.promise;
   const promise = (async () => {
     const deadline = Date.now() + waitMs;
     let delay = CONFIG_RETRY_FIRST_MS;
@@ -247,12 +276,27 @@ export function loadModelProxyProviderConfig({
         }
       }
       try {
-        const reply = await channel.request({ provider: '', method: 'providerConfig' });
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) throw new ModelProxyUnavailableError('the desktop provider request timed out');
+        const controller = new AbortController();
+        const timer = setTimeout(
+          () => controller.abort(new ModelProxyUnavailableError('the desktop provider request timed out')),
+          remaining
+        );
+        timer.unref?.();
+        let reply;
+        try {
+          reply = await channel.request({ provider: '', method: 'providerConfig' }, { signal: controller.signal });
+        } finally {
+          clearTimeout(timer);
+        }
         const raw = reply?.providers && typeof reply.providers === 'object' ? reply.providers : {};
         // Defense in depth: the PC already strips secrets before sending.
         const value = stripModelProxySecrets(raw);
         if (providerConfigReady(reply, value)) {
-          if (channel.generation === generation) {
+          // An older read may finish after a forced refresh; only the newest
+          // request may publish to the shared cache.
+          if (channel.generation === generation && _providerConfigInFlight === entry) {
             _providerConfigCache = { at: now(), value, channel, generation };
           }
           return value;
@@ -268,7 +312,7 @@ export function loadModelProxyProviderConfig({
       delay = Math.min(delay * 2, CONFIG_RETRY_MAX_MS);
     }
   })();
-  const entry = { channel, generation, promise };
+  const entry = { channel, generation, waitMs, promise };
   _providerConfigInFlight = entry;
   const clear = () => {
     if (_providerConfigInFlight === entry) _providerConfigInFlight = null;

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -56,11 +56,6 @@ function resolveProbeState(paths, evaluate) {
   return sawUnreadable ? 'unreadable' : 'absent';
 }
 
-function pushUnique(list, value) {
-  if (!value || typeof value !== 'string') return;
-  if (!list.includes(value)) list.push(value);
-}
-
 // Short-TTL memo. Under simultaneous multi-agent launch, buildDefaultConfig
 // and registry lazy-init call these probes in bursts; each probe does
 // synchronous existsSync + readFileSync disk work. Cache the STATE per key
@@ -113,9 +108,11 @@ function memoProbe(key, paths, compute, extraSignature = '') {
 }
 
 function anthropicOAuthState() {
-  const paths = [];
-  pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
-  pushUnique(paths, ANTHROPIC_DEFAULT_CREDENTIALS_PATH);
+  const paths = [
+    boundProviderAuthPath('anthropic-oauth') ||
+      process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH ||
+      ANTHROPIC_DEFAULT_CREDENTIALS_PATH,
+  ];
   return memoProbe('anthropic-oauth', paths, () => {
     return resolveProbeState(paths, (docs) => {
       const candidates = [];
@@ -176,9 +173,7 @@ function mimoOAuthState() {
       process.env.MIMO_OAUTH_CREDENTIALS_PATH ||
       join(resolvePluginData(), 'mimo-oauth.json'),
   ];
-  return memoProbe('mimo-oauth', paths, () =>
-    resolveProbeState(paths, (docs) => docs.some((own) => !!own?.apiKey))
-  );
+  return memoProbe('mimo-oauth', paths, () => resolveProbeState(paths, (docs) => docs.some((own) => !!own?.apiKey)));
 }
 
 function commandCodeOAuthState() {
@@ -230,7 +225,10 @@ function cursorEnvTokenFingerprint() {
 }
 
 function cursorOAuthState() {
-  const paths = [process.env.CURSOR_OAUTH_CREDENTIALS_PATH, join(resolvePluginData(), 'cursor-oauth.json')];
+  // Match the adapter: selected account, then explicit path, then legacy file.
+  // An environment token must not authenticate a different selected account.
+  const bound = boundProviderAuthPath('cursor-oauth');
+  const paths = [bound || process.env.CURSOR_OAUTH_CREDENTIALS_PATH || join(resolvePluginData(), 'cursor-oauth.json')];
   // The env token is the whole answer on this branch and has no file metadata
   // behind it, so its VALUE is what the memo signature has to track: a length
   // (or a bare present/absent flag) let a swap to an equal-length expired token
@@ -245,7 +243,7 @@ function cursorOAuthState() {
       // Expiry is read by the one shared JWT reader (cursor-auth.cursorTokenExpiry),
       // which answers 0 for a non-JWT or unparseable token — exactly the "assume
       // usable" outcome this branch already took for those shapes.
-      if (process.env.CURSOR_ACCESS_TOKEN) {
+      if (process.env.CURSOR_ACCESS_TOKEN && !bound) {
         const expiresAt = cursorTokenExpiry(process.env.CURSOR_ACCESS_TOKEN);
         return expiresAt === 0 || expiresAt > Date.now() ? 'present' : 'absent';
       }

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-send.mjs

@@ -20,7 +20,8 @@ import { normalizeCompatChatResponse } from './openai-compat-response-normalizat
 import { applyCompatToolChoice, compatStreamRetryReporter } from './compat-request-policy.mjs';
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
 import { xaiCacheRouting } from './openai-compat-xai.mjs';
-import { compatRetryOptions, withCompatRetryProfile } from './openai-compat-retry-profile.mjs';
+import { compatFirstByteWindowMs, compatRetryOptions, withCompatRetryProfile } from './openai-compat-retry-profile.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
 import { customWireFormat, isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 import { geminiAcceptedTools } from './gemini-schema.mjs';
@@ -140,29 +141,39 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
       assembled = await withRetry(
         withCompatRetryProfile(
           provider.name,
-          refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
+          refineAttemptErrors(profile, async ({ signal: attemptSignal, firstByteTimeouts = 0 }) => {
             try {
               opts.onStageChange?.('requesting');
             } catch {
               /* heartbeat best-effort */
             }
-            const stream = await withRetry(
-              ({ signal: openSignal }) =>
-                provider.client.chat.completions.create(params, {
-                  signal: openSignal,
-                  ...(requestHeaders ? { headers: requestHeaders } : {}),
-                }),
-              {
-                signal: attemptSignal,
-                // Single attempt: this inner wrapper exists only to
-                // apply the first-byte per-attempt timeout. Retry is
-                // owned by the outer withRetry — nesting retry loops
-                // here multiplied tail latency (5x5).
-                maxAttempts: 1,
-                perAttemptTimeoutMs: firstByteTimeoutMs,
-                perAttemptLabel: `${provider.name} first byte`,
+            const windowMs = compatFirstByteWindowMs(provider.name, firstByteTimeoutMs, firstByteTimeouts);
+            let stream;
+            try {
+              stream = await withRetry(
+                ({ signal: openSignal }) =>
+                  provider.client.chat.completions.create(params, {
+                    signal: openSignal,
+                    ...(requestHeaders ? { headers: requestHeaders } : {}),
+                  }),
+                {
+                  signal: attemptSignal,
+                  // Single attempt: this inner wrapper exists only to
+                  // apply the first-byte per-attempt timeout. Retry is
+                  // owned by the outer withRetry — nesting retry loops
+                  // here multiplied tail latency (5x5).
+                  maxAttempts: 1,
+                  perAttemptTimeoutMs: windowMs,
+                  perAttemptLabel: `${provider.name} first byte`,
+                }
+              );
+            } catch (error) {
+              // The per-attempt window (the only timer here) expired before headers.
+              if (error?.code === 'EPROVIDERTIMEOUT' && !attemptSignal?.aborted) {
+                error.timeoutPhase = TIMEOUT_PHASE.HEADERS;
               }
-            );
+              throw error;
+            }
             try {
               opts.onStageChange?.('streaming');
             } catch {
@@ -181,7 +192,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
                 // recovered leaked calls only synthesize when they name
                 // a tool actually offered to this request.
                 knownToolNames: knownToolNamesFromOpenAITools(params.tools),
-                ...(profile?.firstByteTimeoutMs ? { firstByteTimeoutMs: profile.firstByteTimeoutMs } : {}),
+                ...(profile?.firstByteTimeoutMs ? { firstByteTimeoutMs: windowMs } : {}),
                 ...(profile?.semanticIdleTimeoutMs ? { semanticIdleTimeoutMs: profile.semanticIdleTimeoutMs } : {}),
               });
             } catch (error) {

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/stream-state.mjs

@@ -87,7 +87,9 @@ export function isIncompleteFinishReason(finishReason) {
 /** Whether `finish_reason` confirms a normal end of the turn: present, not an
  *  incomplete outcome and not a gateway-reported failure (network_error/error). */
 export function isNormalFinishReason(finishReason) {
-  return Boolean(finishReason) && !isIncompleteFinishReason(finishReason) && !failingFinishReasonError(finishReason, '');
+  return (
+    Boolean(finishReason) && !isIncompleteFinishReason(finishReason) && !failingFinishReasonError(finishReason, '')
+  );
 }
 
 /** Dispatch held leaked calls once a normal finish_reason confirms the turn

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream.mjs

@@ -11,6 +11,7 @@ import {
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   createTimeoutSignal,
 } from '../stall-policy.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import {
   closeCompatStream,
   markErrorLiveTextEmitted,
@@ -86,6 +87,10 @@ export async function consumeCompatChatCompletionStream(
     }
     if (state.leakGuard.enabled) flushLeak(state);
   } catch (err) {
+    // The first-byte window (not a caller cancellation) ended the wait for the first chunk.
+    if (!signal?.aborted && err && typeof err === 'object' && err === firstByteTimeout.signal.reason) {
+      err.timeoutPhase = TIMEOUT_PHASE.FIRST_CHUNK;
+    }
     // Keep exposed partial text without permitting the request to replay;
     // every mid-flight failure carries what the stream completed (a
     // cancellation keeps the caller's own reason untouched).