mixdog 1.2.3 → 1.2.5

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

@@ -876,11 +876,11 @@ const isFailedToolResult = (message) => message.toolKind === 'error' || message.
 // recorded part, and a recorded Gemini part may carry no id at all, in which
 // case the response carries none either. An unmatched result keeps its own id.
 function toGeminiToolResult(message, toolNameByCallId, nestMedia, callsByFinalId) {
-  const functionName = toolNameByCallId?.get(message.toolCallId) || message.toolCallId || '';
+  const replayedCall = callsByFinalId?.get(message.toolCallId);
+  const functionName = replayedCall?.name || toolNameByCallId?.get(message.toolCallId) || message.toolCallId || '';
   const { response: rawResponse, mediaParts } = splitGeminiToolContent(message.content);
   const response = isFailedToolResult(message) && 'result' in rawResponse ? { error: rawResponse.result } : rawResponse;
   const functionResponse = { name: functionName, response };
-  const replayedCall = callsByFinalId?.get(message.toolCallId);
   const responseId = replayedCall ? replayedCall.id : message.toolCallId;
   if (typeof responseId === 'string' && responseId) functionResponse.id = responseId;
   if (!nestMedia) return { functionResponsePart: { functionResponse }, mediaParts };
@@ -895,16 +895,20 @@ function toGeminiToolResult(message, toolNameByCallId, nestMedia, callsByFinalId
 // A replay recorded by a non-Gemini model (Claude behind Antigravity) carries
 // signatures Gemini rejects: its replay envelope and the signed metadata
 // derived from the same response must not reach a Gemini request.
-function hasForeignReplay(message) {
+function hasForeignReplay(message, model) {
   const replay = message?.providerReplay;
   if (replay?.provider !== 'gemini' && replay?.provider !== 'antigravity') return false;
   const recorded = replay.requestContext?.model;
-  return typeof recorded === 'string' && recorded !== '' && !isGeminiFamilyModel(recorded);
+  return (
+    typeof recorded === 'string' &&
+    recorded !== '' &&
+    (!isGeminiFamilyModel(recorded) || (replay.provider === 'gemini' && model && recorded !== model))
+  );
 }
 
-function toGeminiContent(message) {
+function toGeminiContent(message, model) {
   if (!message || message.role === 'system') return null;
-  const foreign = message.role === 'assistant' && hasForeignReplay(message);
+  const foreign = message.role === 'assistant' && hasForeignReplay(message, model);
   if (foreign) message = { ...message, providerMetadata: undefined };
   const orderedReplay =
     message.role === 'assistant' && !foreign ? providerReplayItems(message, ['gemini', 'antigravity']) : undefined;
@@ -1019,7 +1023,7 @@ export function toGeminiContents(messages, model = '', { repairToolSignatures =
       for (const tc of m.toolCalls) {
         if (tc?.id && tc?.name) toolNameByCallId.set(tc.id, tc.name);
       }
-      const content = toGeminiContent(m);
+      const content = toGeminiContent(m, model);
       assistantContent.set(m, content);
       const replayed = (content?.parts || []).filter((part) => part?.functionCall);
       m.toolCalls.forEach((tc, index) => {
@@ -1039,6 +1043,7 @@ export function toGeminiContents(messages, model = '', { repairToolSignatures =
   // first (one per call, in call order), then the media the results carried as
   // sibling inlineData/fileData parts.
   let toolTurn = null;
+  let toolCallOrder = new Map();
   const nestMedia = supportsFunctionResponseParts(model);
   for (const message of messages) {
     if (message?.role === 'tool') {
@@ -1049,16 +1054,23 @@ export function toGeminiContents(messages, model = '', { repairToolSignatures =
         callsByFinalId
       );
       if (!toolTurn) {
-        toolTurn = { content: { role: 'user', parts: [] }, responseCount: 0 };
+        toolTurn = { content: { role: 'user', parts: [] }, responseCount: 0, responseOrder: [] };
         contents.push(toolTurn.content);
       }
-      toolTurn.content.parts.splice(toolTurn.responseCount, 0, functionResponsePart);
+      // Completion order is not call order. Anonymous parallel calls to the
+      // same function can only be correlated by their original position.
+      const order = toolCallOrder.get(message.toolCallId) ?? Infinity;
+      const next = toolTurn.responseOrder.findIndex((value) => value > order);
+      const index = next < 0 ? toolTurn.responseCount : next;
+      toolTurn.responseOrder.splice(index, 0, order);
+      toolTurn.content.parts.splice(index, 0, functionResponsePart);
       toolTurn.responseCount += 1;
       toolTurn.content.parts.push(...mediaParts);
       continue;
     }
     toolTurn = null;
-    const content = assistantContent.has(message) ? assistantContent.get(message) : toGeminiContent(message);
+    toolCallOrder = new Map((message.toolCalls || []).map((call, index) => [call.id, index]));
+    const content = assistantContent.has(message) ? assistantContent.get(message) : toGeminiContent(message, model);
     if (content) contents.push(content);
   }
   return repairToolSignatures ? ensureGeminiToolCallSignatures(contents, model) : contents;

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

@@ -513,7 +513,8 @@ function createLeakGuardFinalizer(textLeakGuard) {
 // `unwrapChunk` adapts a transport that nests the Gemini payload one level
 // deeper. Cloud Code Assist (Antigravity) streams `{ response: { candidates … } }`
 // while the public API streams the candidates directly; everything downstream —
-// aggregation, leak guard, watchdogs — stays shared.
+// aggregation, leak guard, watchdogs — stays shared. `firstByteTimeoutMs` is
+// the wait for the first chunk once the response headers arrived.
 export async function consumeGeminiRestStreamResponse(
   response,
   {
@@ -525,6 +526,7 @@ export async function consumeGeminiRestStreamResponse(
     unwrapChunk = null,
     onChunk = null,
     failureUsage = null,
+    firstByteTimeoutMs = GEMINI_FIRST_BYTE_TIMEOUT_MS,
   }
 ) {
   const unwrap =
@@ -548,7 +550,7 @@ export async function consumeGeminiRestStreamResponse(
   const watchdogs = createRestStreamWatchdogs({
     reader,
     label,
-    firstByteTimeoutMs: GEMINI_FIRST_BYTE_TIMEOUT_MS,
+    firstByteTimeoutMs,
     timeoutError: geminiTimeoutError,
   });
   // One decoded chunk: collected for aggregation and relayed to every sink.

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';
       }