codex-overleaf-link 2.5.0 → 2.6.0

package/native-host/src/bootstrapUpdate.js

@@ -0,0 +1,269 @@
+'use strict';
+
+// Coordination for the one compatible 2.5.0 -> 2.5.1 Bootstrap revision.
+// All mutations run under updateManager's existing cross-process lock.
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const vm = require('node:vm');
+const { spawn } = require('node:child_process');
+const Files = require('./bootstrapMigration');
+const Contract = require('./bootstrapMigrationContract');
+const { updateError } = require('./updateTrust');
+
+const BOOTSTRAP_DEADLINE_MS = 120000;
+const MAX_AUTOMATIC_ROLLBACK_ATTEMPTS = 3;
+const BOOTSTRAP_STATES = new Set(['bootstrap_pending', 'bootstrap_rolling_back']);
+const backupRoot = context => path.join(context.updatesRoot, 'bootstrap-migrations');
+const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+
+function migrationHint(context, journal) {
+  if (!journal || !['awaiting_health', ...BOOTSTRAP_STATES].includes(journal.state)) return null;
+  if (journal.bootstrapMigration) return journal.bootstrapMigration;
+  if (journal.sourceVersion !== '2.5.0' || journal.targetVersion !== '2.5.1') return null;
+  // This exact release pair requires migration even when discovery data was
+  // lost. Missing evidence must not downgrade an update into a false success.
+  return { phase: 'pending', targetRevision: '3.1' };
+}
+
+function bindBootstrapMigration(context, journal, deps) {
+  if (journal?.state !== 'awaiting_health' || journal.bootstrapMigration || !migrationHint(context, journal)) return journal;
+  const candidate = readJson(path.join(context.updatesRoot, 'candidate.json'));
+  let verificationError = '';
+  try { deps.assertAuthorization(journal); verifiedDescriptor(journal, candidate, deps); }
+  catch (error) { verificationError = error.code || 'update_bootstrap_manifest_mismatch'; }
+  const next = { ...journal, state: 'bootstrap_pending', bootstrapMigration: {
+    phase: 'pending', targetRevision: '3.1', reloadCount: 0, verificationError,
+    manifestBase64: candidate?.manifestBase64 || '', signatureBase64: candidate?.signatureBase64 || ''
+  }, updatedAt: new Date().toISOString() };
+  deps.writeJournal(next);
+  return next;
+}
+
+function verifiedDescriptor(journal, evidence, deps) {
+  const bytes = Buffer.from(evidence?.manifestBase64 || '', 'base64');
+  if (!journal.manifestSha256 || hash(bytes) !== journal.manifestSha256) {
+    throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap migration does not match the applied release.');
+  }
+  const manifest = deps.verifyManifest(bytes, Buffer.from(evidence?.signatureBase64 || '', 'base64'));
+  if (manifest.version !== journal.targetVersion || manifest.updateBundle?.sha256 !== journal.bundleSha256
+    || manifest.updateBundle?.size !== journal.bundleSize) {
+    throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap migration does not match the update archive.');
+  }
+  const descriptor = Contract.validateBootstrapMigrationDescriptor(manifest.bootstrapMigration, { targetVersion: journal.targetVersion });
+  if (!descriptor.sourceVersions.includes(journal.sourceVersion)) {
+    throw updateError('update_bootstrap_source_version_mismatch', 'This installation has no compatible Bootstrap migration.');
+  }
+  return descriptor;
+}
+
+function payloadRootFor(context, journal) {
+  return path.join(context.nativeRoot, 'versions', journal.targetVersion, 'native-host', 'bootstrap-payload');
+}
+
+function loadPlan(context, journal) {
+  const root = backupRoot(context);
+  if (!fs.existsSync(path.join(root, journal.id, 'state.json'))) return null;
+  const plan = Files.loadBootstrapMigration({ backupRoot: root, transactionId: journal.id });
+  if (plan.extensionRoot !== context.extensionRoot || plan.payloadRoot !== payloadRootFor(context, journal)
+    || plan.sourceVersion !== journal.sourceVersion || plan.targetVersion !== journal.targetVersion) {
+    throw updateError('update_bootstrap_transaction_mismatch', 'Bootstrap recovery belongs to a different installation.');
+  }
+  return plan;
+}
+
+async function advanceBootstrapMigration(context, journal, params, deps, options = {}) {
+  if (!journal || !migrationHint(context, journal)) return { state: 'not_required' };
+  if (params.transactionId !== journal.id) throw updateError('update_transaction_mismatch', 'Bootstrap update transaction changed.');
+  journal = bindBootstrapMigration(context, journal, deps);
+  if (journal.state !== 'bootstrap_pending') {
+    throw updateError('update_transaction_state_changed', 'Bootstrap migration is no longer waiting to continue.');
+  }
+  if (deps.runningVersion !== journal.targetVersion) {
+    throw updateError('update_bootstrap_native_restart_required', 'The target Native Host must start before updating Bootstrap.');
+  }
+  deps.assertAuthorization(journal);
+  const descriptor = verifiedDescriptor(journal, journal.bootstrapMigration, deps);
+  const payloadRoot = payloadRootFor(context, journal);
+  Contract.assertBootstrapManifestShape(JSON.parse(fs.readFileSync(path.join(context.extensionRoot, 'manifest.json'), 'utf8')),
+    { version: journal.targetVersion });
+  Contract.assertBootstrapManifestShape(JSON.parse(fs.readFileSync(path.join(payloadRoot, 'manifest.template.json'), 'utf8')),
+    { version: journal.targetVersion });
+  // A syntax failure must be found before changing the only background entry.
+  for (const file of descriptor.files) {
+    const bytes = fs.readFileSync(path.join(payloadRoot, file.path));
+    if (hash(bytes) !== file.targetSha256) throw updateError('update_bootstrap_payload_mismatch', 'Bootstrap payload changed after verification.');
+    if (file.path.endsWith('.js')) new vm.Script(bytes.toString('utf8'), { filename: file.path });
+  }
+  deps.verifyArchive(journal);
+  let plan = loadPlan(context, journal);
+  if (!plan) plan = Files.prepareBootstrapMigration({
+    descriptor, payloadRoot, extensionRoot: context.extensionRoot, backupRoot: backupRoot(context),
+    transactionId: journal.id, sourceVersion: journal.sourceVersion, targetVersion: journal.targetVersion
+  });
+  if (plan.descriptorSha256 !== hash(JSON.stringify(descriptor))) {
+    throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap recovery material does not match the signed release.');
+  }
+  let migration = { ...journal.bootstrapMigration, phase: plan.state === 'applied' ? 'applied' : 'prepared',
+    targetDigest: plan.targetDigest, sourceDigest: plan.sourceDigest,
+    deadline: journal.bootstrapMigration.deadline || Date.now() + BOOTSTRAP_DEADLINE_MS };
+  if (Date.now() >= migration.deadline) throw updateError('update_bootstrap_health_timeout', 'Bootstrap update did not finish within its health window.');
+  journal = { ...journal, bootstrapMigration: migration };
+  deps.writeJournal(journal);
+  // A new connection always establishes a new monitor handshake. PID reuse
+  // alone can never authorize writing the only browser background entry.
+  {
+    const token = crypto.randomUUID();
+    migration = { ...migration, watchdogToken: token, watchdogPid: null };
+    journal = { ...journal, bootstrapMigration: migration };
+    deps.writeJournal(journal);
+    const pid = await (options.startWatchdog || startWatchdog)(context, journal, token);
+    migration = { ...migration, watchdogPid: pid };
+    journal = { ...journal, bootstrapMigration: migration };
+    deps.writeJournal(journal);
+  }
+  Files.applyBootstrapMigration(plan, options.fileHooks);
+  const observed = Files.verifyBootstrapMigration(plan);
+  migration = { ...migration, phase: 'applied', targetDigest: observed.digest };
+  if (params.bootstrapRevision === descriptor.targetRevision) {
+    migration = { ...migration, phase: 'loaded', loadedAt: new Date().toISOString() };
+    deps.writeJournal({ ...journal, state: 'awaiting_health', bootstrapMigration: migration });
+    return { state: 'awaiting_health', transactionId: journal.id, targetVersion: journal.targetVersion,
+      bootstrapRevision: descriptor.targetRevision };
+  }
+  if (migration.reloadCount >= 2) throw updateError('update_bootstrap_reload_failed', 'The new Bootstrap did not load after extension restart.');
+  migration.reloadCount += 1;
+  deps.writeJournal({ ...journal, bootstrapMigration: migration });
+  return { state: 'reload_required', transactionId: journal.id, targetVersion: journal.targetVersion,
+    bootstrapRevision: descriptor.targetRevision };
+}
+
+function assertBootstrapConfirmation(context, journal, params) {
+  if (!journal.bootstrapMigration) {
+    if (migrationHint(context, journal)) throw updateError('update_bootstrap_confirmation_pending', 'Bootstrap migration is still pending.');
+    return;
+  }
+  if (journal.bootstrapMigration.phase !== 'loaded' || params.bootstrapRevision !== journal.bootstrapMigration.targetRevision) {
+    throw updateError('update_bootstrap_confirmation_pending', 'The loaded Bootstrap did not confirm the target revision.');
+  }
+  const plan = loadPlan(context, journal);
+  if (!plan || Files.verifyBootstrapMigration(plan).digest !== journal.bootstrapMigration.targetDigest) {
+    throw updateError('update_bootstrap_target_mismatch', 'The confirmed Bootstrap bytes no longer match the target.');
+  }
+}
+
+function restoreBootstrap(context, journal) {
+  const plan = loadPlan(context, journal);
+  if (!plan) {
+    if (journal.bootstrapMigration && journal.bootstrapMigration.phase !== 'pending') {
+      throw updateError('update_bootstrap_record_missing', 'Bootstrap recovery material is missing.');
+    }
+    if (journal.bootstrapMigration) return untouchedBootstrap(context, journal);
+  }
+  return plan ? Files.restoreBootstrapMigration(plan) : null;
+}
+
+function bootstrapEvidence(context, journal, expected) {
+  const plan = loadPlan(context, journal);
+  if (!plan && journal.bootstrapMigration) {
+    if (expected !== 'source' || !(journal.bootstrapMigration.phase === 'pending'
+      || journal.bootstrapMigration.phase === 'restored' && journal.bootstrapMigration.sourceUnchanged === true)) {
+      throw updateError('update_bootstrap_record_missing', 'Bootstrap recovery material is missing.');
+    }
+    return untouchedBootstrap(context, journal);
+  }
+  return plan ? Files.verifyBootstrapMigration(plan, { expected }) : null;
+}
+
+// Without a file plan this transaction never wrote Bootstrap, so recovery only
+// leaves it in place. Published source bytes keep the baseline digest; any other
+// installed bytes (an earlier release candidate or local build) are recorded as
+// observed. Later reads compare the same digest, so changes still block.
+function untouchedBootstrap(context, journal) {
+  let knownSource = true;
+  const entries = Object.entries(Contract.BOOTSTRAP_MIGRATION_BASELINE).sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([relative, expected]) => {
+      const actual = readBootstrapFileHash(context, relative);
+      if (actual !== expected) knownSource = false;
+      return [relative, actual];
+    });
+  return { transactionId: journal.id, migrationId: 'bootstrap-v3.1-from-2.5.0',
+    state: 'restored', expected: 'source', digest: hash(JSON.stringify(entries)), unmodified: true, knownSource };
+}
+
+function readBootstrapFileHash(context, relative) {
+  const filename = path.join(context.extensionRoot, relative);
+  if (!fs.existsSync(filename)) return null;
+  if (!fs.lstatSync(filename).isFile()) {
+    throw updateError('update_bootstrap_source_mismatch', 'Bootstrap source bytes cannot be confirmed.');
+  }
+  return hash(fs.readFileSync(filename));
+}
+
+// Runs before staging and in the update check. A signed migration starts only
+// from the exact source bytes it names; other installations need a full
+// reinstall instead of a transaction that cannot finish. This reads only the
+// descriptor's file list, so later migration contracts use the same check.
+function assertMigrationSource(context, manifest, sourceVersion) {
+  const descriptor = manifest?.bootstrapMigration;
+  if (!descriptor || !Array.isArray(descriptor.sourceVersions) || !descriptor.sourceVersions.includes(sourceVersion)
+    || !Array.isArray(descriptor.files)) return;
+  for (const file of descriptor.files) {
+    const relative = String(file?.path || '');
+    if (!/^bootstrap\/[A-Za-z0-9._-]+$/.test(relative)) {
+      throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap migration file identity is invalid.');
+    }
+    if (readBootstrapFileHash(context, relative) !== (file.sourceSha256 ?? null)) {
+      throw updateError('update_bootstrap_source_mismatch',
+        'The installed startup files do not match the published source of this update.');
+    }
+  }
+}
+
+function bootstrapExpired(journal, { recoveryRequested = false, context } = {}) {
+  const migration = journal?.bootstrapMigration;
+  if (!migration || !['bootstrap_pending', 'bootstrap_rolling_back', 'awaiting_health'].includes(journal.state)) return false;
+  // Automatic retries are bounded; an explicit update.rollback still runs.
+  if (journal.state === 'bootstrap_rolling_back') {
+    return Number(journal.rollbackFailure?.attempts || 0) < MAX_AUTOMATIC_ROLLBACK_ATTEMPTS;
+  }
+  return (migration.deadline && Date.now() >= migration.deadline)
+    || (recoveryRequested && migration.phase !== 'pending' && !watchdogAlive(migration, context, journal));
+}
+
+function watchdogAlive(migration, context, journal) {
+  if (!Number.isInteger(migration?.watchdogPid) || migration.watchdogPid < 1) return false;
+  const heartbeat = context && journal && readJson(path.join(backupRoot(context), journal.id, 'watchdog.json'));
+  if (!heartbeat || heartbeat.token !== migration.watchdogToken || heartbeat.pid !== migration.watchdogPid
+    || heartbeat.transactionId !== journal.id || Date.now() - heartbeat.at > 2500 || heartbeat.at > Date.now() + 1000) return false;
+  try { process.kill(migration.watchdogPid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
+}
+
+function startWatchdog(context, journal, token) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, 'bootstrapUpdateWatchdog.js'),
+      context.nativeRoot, context.extensionRoot, journal.id, token], {
+      env: { ...context.env }, detached: true, windowsHide: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc']
+    });
+    const timer = setTimeout(() => fail(new Error('Bootstrap recovery monitor did not become ready.')), 5000);
+    let settled = false;
+    function fail(error) {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      try { child.kill(); } catch (_) { /* A failed child may already be gone. */ }
+      reject(Object.assign(error, { code: 'update_bootstrap_monitor_unavailable' }));
+    }
+    child.on('error', fail);
+    child.on('exit', () => { if (!settled) fail(new Error('Bootstrap recovery monitor exited before readiness.')); });
+    child.on('message', message => {
+      if (settled || message?.type !== 'ready' || message.token !== token || message.pid !== child.pid) return;
+      settled = true; clearTimeout(timer); child.disconnect(); child.unref(); resolve(child.pid);
+    });
+  });
+}
+
+function readJson(filename) { try { return JSON.parse(fs.readFileSync(filename, 'utf8')); } catch (_) { return null; } }
+
+module.exports = { BOOTSTRAP_DEADLINE_MS, BOOTSTRAP_STATES, MAX_AUTOMATIC_ROLLBACK_ATTEMPTS, migrationHint,
+  bindBootstrapMigration, advanceBootstrapMigration, assertBootstrapConfirmation, assertMigrationSource,
+  restoreBootstrap, bootstrapEvidence, bootstrapExpired, watchdogAlive };

package/native-host/src/bootstrapUpdateWatchdog.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Independent of the browser worker being replaced. The Native update lock
+// serializes timeout recovery with normal health confirmation.
+const fs = require('node:fs');
+const path = require('node:path');
+const [nativeRoot, extensionRoot, transactionId, token] = process.argv.slice(2);
+const { recoverBootstrapTransaction } = require('./updateManager');
+if (typeof recoverBootstrapTransaction !== 'function') throw new Error('Bootstrap recovery entry is unavailable.');
+const env = { ...process.env, CODEX_OVERLEAF_MANAGED: '1',
+  CODEX_OVERLEAF_MANAGED_NATIVE_ROOT: nativeRoot, CODEX_OVERLEAF_MANAGED_EXTENSION_ROOT: extensionRoot };
+let busy = false;
+let failures = 0;
+function heartbeat() {
+  const directory = path.join(nativeRoot, 'updates', 'bootstrap-migrations', transactionId);
+  const temporary = path.join(directory, 'watchdog-' + process.pid + '.tmp');
+  fs.writeFileSync(temporary, JSON.stringify({ transactionId, token, pid: process.pid, at: Date.now() }), { mode: 0o600 });
+  fs.renameSync(temporary, path.join(directory, 'watchdog.json'));
+}
+const timer = setInterval(async () => {
+  if (busy) return;
+  busy = true;
+  try {
+    const journal = JSON.parse(fs.readFileSync(path.join(nativeRoot, 'updates', 'transaction.json'), 'utf8'));
+    if (journal.id !== transactionId || journal.bootstrapMigration?.watchdogToken !== token
+      || ['committed', 'superseded'].includes(journal.state)
+      || journal.state === 'rolled_back' && !journal.sourceActivationPending) {
+      clearInterval(timer); return;
+    }
+    heartbeat();
+    if (journal.sourceActivationPending || journal.bootstrapMigration?.deadline && Date.now() >= journal.bootstrapMigration.deadline) {
+      await recoverBootstrapTransaction({ env }, transactionId, token);
+      clearInterval(timer);
+    }
+  } catch (_) {
+    // Retry boundedly if a filesystem/lock is temporarily unavailable. Recovery
+    // material remains durable for the next Native start or popup recovery probe.
+    if (++failures >= 20) clearInterval(timer);
+  } finally { busy = false; }
+}, 500);
+const initial = JSON.parse(fs.readFileSync(path.join(nativeRoot, 'updates', 'transaction.json'), 'utf8'));
+if (initial.id !== transactionId || initial.bootstrapMigration?.watchdogToken !== token) throw new Error('Bootstrap recovery identity changed.');
+heartbeat();
+process.send?.({ type: 'ready', token, pid: process.pid });

package/native-host/src/chatBridgeRequest.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const crypto = require('node:crypto');
+const { providerError } = require('./providerProfile');
 
 const {
   applyReasoningControl,
@@ -58,7 +59,15 @@ function appendResponsesInput(messages, input, { replayReasoning = false, toolKi
   }
   if (!Array.isArray(input)) return;
   let pendingToolCalls = [];
+  let pendingToolOutputContent = [];
   let pendingReasoning = '';
+  const flushToolOutputContent = () => {
+    if (!pendingToolOutputContent.length) return;
+    // Chat tool messages accept text only. Attach images after the complete
+    // tool-result group so a user message cannot split parallel tool results.
+    messages.push({ role: 'user', content: pendingToolOutputContent });
+    pendingToolOutputContent = [];
+  };
   const flushToolCalls = () => {
     if (!pendingToolCalls.length) return;
     const assistant = {
@@ -73,6 +82,9 @@ function appendResponsesInput(messages, input, { replayReasoning = false, toolKi
   };
   for (const item of input) {
     if (!item || typeof item !== 'object') continue;
+    const isToolOutput = item.type === 'function_call_output' || item.type === 'custom_tool_call_output'
+      || item.type === 'computer_call_output' || item.type === 'tool_search_output';
+    if (!isToolOutput && item.type !== 'reasoning') flushToolOutputContent();
     if (item.type === 'reasoning') {
       flushToolCalls();
       pendingReasoning = extractReasoningText(item);
@@ -83,12 +95,22 @@ function appendResponsesInput(messages, input, { replayReasoning = false, toolKi
       continue;
     }
     flushToolCalls();
-    if (item.type === 'function_call_output' || item.type === 'custom_tool_call_output' || item.type === 'computer_call_output' || item.type === 'tool_search_output') {
+    if (isToolOutput) {
+      const callId = normalizeText(item.call_id) || normalizeText(item.id);
+      const imageContent = translateImageToolOutput(item.output);
       messages.push({
         role: 'tool',
-        tool_call_id: normalizeText(item.call_id) || normalizeText(item.id),
-        content: normalizeToolOutput(item.output)
+        tool_call_id: callId,
+        content: imageContent
+          ? 'The tool output, including images, is attached after the tool results.'
+          : normalizeToolOutput(item.output)
       });
+      if (imageContent) {
+        pendingToolOutputContent.push(
+          { type: 'text', text: `Output from tool call ${callId}:` },
+          ...imageContent
+        );
+      }
       continue;
     }
     if (item.type === 'message' || item.role) {
@@ -105,6 +127,38 @@ function appendResponsesInput(messages, input, { replayReasoning = false, toolKi
     }
   }
   flushToolCalls();
+  flushToolOutputContent();
+}
+
+function translateImageToolOutput(output) {
+  const parts = Array.isArray(output) ? output : [output];
+  if (!parts.some(isImagePart)) return null;
+  return parts.map(part => {
+    if (isImagePart(part)) {
+      const image = translateImagePart(part);
+      if (!image) {
+        throw providerError('provider_request_invalid', 'A tool image requires an image URL or data URL for Chat Completions.');
+      }
+      return image;
+    }
+    const text = ['input_text', 'output_text', 'text'].includes(part?.type)
+      ? normalizeText(part.text)
+      : normalizeToolOutput(part);
+    return { type: 'text', text };
+  });
+}
+
+function isImagePart(part) {
+  return part?.type === 'input_image' || part?.type === 'image_url' || part?.type === 'computer_screenshot';
+}
+
+function translateImagePart(part) {
+  const url = normalizeText(part.image_url?.url || part.image_url || part.url);
+  if (!url) return null;
+  const detail = normalizeText(part.image_url?.detail || part.detail);
+  const image = { type: 'image_url', image_url: { url } };
+  if (['auto', 'low', 'high'].includes(detail)) image.image_url.detail = detail;
+  return image;
 }
 
 function extractReasoningText(item) {
@@ -142,10 +196,10 @@ function translateMessageContent(content) {
     if (part.type === 'input_text' || part.type === 'output_text' || part.type === 'text') {
       parts.push({ type: 'text', text: normalizeText(part.text) });
     } else if (part.type === 'input_image' || part.type === 'image_url') {
-      const url = normalizeText(part.image_url?.url || part.image_url || part.url);
-      if (url) {
+      const image = translateImagePart(part);
+      if (image) {
         hasStructuredPart = true;
-        parts.push({ type: 'image_url', image_url: { url } });
+        parts.push(image);
       }
     }
   }

package/native-host/src/chatBridgeResponse.js

@@ -2,9 +2,11 @@
 
 const crypto = require('node:crypto');
 const { requiresReasoningContentReplay } = require('./providerReasoning');
+const { isContextLimitError } = require('./providerContextError');
 const MAX_STREAM_BUFFER_BYTES = 8 * 1024 * 1024;
 
 function convertChatResponse(chat = {}, context = {}) {
+  if (chat.error) throwUpstreamError(chat.error);
   const choice = Array.isArray(chat.choices) ? chat.choices[0] || {} : {};
   const message = choice.message || {};
   assertNoLeakedToolControlTokens(message);
@@ -131,7 +133,7 @@ function writeConvertedResponseAsSse(res, converted, context = {}, onComplete =
 
 function processChatChunk(state, res, chunk) {
   if (!chunk || typeof chunk !== 'object') return;
-  if (chunk.error) throw new Error(normalizeText(chunk.error.message) || 'Upstream provider returned an error.');
+  if (chunk.error) throwUpstreamError(chunk.error);
   if (chunk.id && !state.upstreamId) {
     state.upstreamId = chunk.id;
   }
@@ -295,6 +297,7 @@ function completeMessage(state, res) {
 }
 
 function completeTool(state, res, tool) {
+  assertCompleteToolArguments(tool.arguments);
   if (!tool.opened) openTool(state, res, tool);
   tool.item.status = 'completed';
   if (tool.kind === 'custom') {
@@ -419,6 +422,7 @@ function normalizeToolCalls(values, toolKinds) {
     const name = normalizeText(value?.function?.name) || 'tool';
     const callId = normalizeText(value?.id) || randomId('call');
     const argumentsText = normalizeText(value?.function?.arguments) || '{}';
+    assertCompleteToolArguments(argumentsText);
     const spec = toolKinds?.get(name);
     const kind = (typeof spec === 'object' ? spec.kind : spec) === 'custom' ? 'custom' : 'function';
     const originalName = typeof spec === 'object' ? spec.name || name : name;
@@ -489,6 +493,13 @@ function mapChatFinishReason(value) {
   return { status: 'completed', incompleteReason: null };
 }
 
+function throwUpstreamError(detail) {
+  throw responseError(
+    normalizeText(detail?.message) || normalizeText(detail) || 'Upstream provider returned an error.',
+    isContextLimitError(detail) ? 'context_length_exceeded' : 'provider_upstream_error'
+  );
+}
+
 function responseError(message, code = 'provider_response_invalid') {
   const error = new Error(message);
   error.code = code;
@@ -533,6 +544,14 @@ function unwrapCustomArguments(value) {
   }
 }
 
+function assertCompleteToolArguments(value) {
+  try {
+    JSON.parse(value || '{}');
+  } catch (_error) {
+    throw responseError('The provider returned incomplete or invalid JSON tool arguments.');
+  }
+}
+
 function reserveItem(state, item) {
   const index = state.items.length;
   state.items.push(item);

package/native-host/src/chatCompletionsBridge.js

@@ -11,7 +11,9 @@ const {
 const { requiresReasoningContentReplay } = require('./providerReasoning');
 const { classifyResponsesRoute } = require('./providerBridgeRoutes');
 const { providerError } = require('./providerProfile');
+const { fetchProvider, readProviderText, readProviderJson } = require('./providerHttp');
 const { sanitizeProviderMessage } = require('./providerRedaction');
+const { isContextLimitError } = require('./providerContextError');
 const { logDebug } = require('./debugLog');
 const {
   createProviderStreamLifecycle,
@@ -118,15 +120,19 @@ async function handleRequest({
   const startedAt = Date.now();
   const previousResponseId = String(requestBody.previous_response_id || '');
   const previous = history.get(previousResponseId);
-  const fallbackAnchor = previous
+  const fallbackAllowed = !previousResponseId || previousResponseId === continuationState.responseId;
+  const fallbackAnchor = previous || !fallbackAllowed
     ? []
     : continuationState.anchorMessages;
+  const continuationAttempts = previous
+    ? Number(previous.continuationAttempts) || 0
+    : fallbackAllowed ? continuationState.attempts : 0;
   const translated = buildChatRequest({
     requestBody,
     launch,
     historyMessages: previous?.messages || fallbackAnchor
   });
-  assertReasoningContinuationBudget(translated.messages, continuationState.attempts);
+  assertReasoningContinuationBudget(translated.messages, continuationAttempts);
   const idleTimeoutMs = resolveProviderIdleTimeoutMs(launch);
   const totalTimeoutMs = resolveProviderTotalTimeoutMs(launch, idleTimeoutMs);
   logDebug('provider.bridge.request', {
@@ -141,7 +147,7 @@ async function handleRequest({
     usedFallbackAnchor: fallbackAnchor.length > 0,
     inputItemCount: Array.isArray(requestBody.input) ? requestBody.input.length : requestBody.input ? 1 : 0,
     messageCount: translated.messages.length,
-    continuationAttempts: continuationState.attempts,
+    continuationAttempts,
     idleTimeoutMs,
     totalTimeoutMs
   });
@@ -161,15 +167,15 @@ async function handleRequest({
   res.on('close', onClientClose);
   lifecycle.start();
   try {
-    const upstream = await fetch(buildChatCompletionsUrl(launch.baseUrl, launch), {
+    const upstream = await fetchProvider(buildChatCompletionsUrl(launch.baseUrl, launch), {
       method: 'POST',
       headers: buildUpstreamHeaders(launch),
       body: JSON.stringify(translated.body),
       signal: controller.signal
-    });
+    }, launch);
     lifecycle.touch();
     if (!upstream.ok) {
-      await forwardUpstreamError(upstream, res, launch.apiKey);
+      await forwardUpstreamError(upstream, res, launch.apiKey, lifecycle.touch, requestBody.stream !== false);
       return;
     }
     const context = {
@@ -193,7 +199,7 @@ async function handleRequest({
         : 0;
       if (anchored) {
         continuationState.anchorMessages = continuation;
-        continuationState.attempts += 1;
+        continuationState.attempts = continuationAttempts + 1;
         continuationState.responseId = converted.response.id;
       } else {
         continuationState.anchorMessages = [];
@@ -217,7 +223,7 @@ async function handleRequest({
       rememberHistory(history, converted.response.id, [
         ...translated.messages,
         ...continuation
-      ]);
+      ], { continuationAttempts: anchored ? continuationAttempts + 1 : 0 });
     };
     if (requestBody.stream !== false) {
       const contentType = String(upstream.headers.get('content-type') || '').toLowerCase();
@@ -231,11 +237,11 @@ async function handleRequest({
           recoverInterrupted: lifecycle.recoverInterrupted
         });
       } else {
-        const converted = convertChatResponse(await upstream.json(), context);
+        const converted = convertChatResponse(await readProviderJson(upstream, lifecycle.touch), context);
         writeConvertedResponseAsSse(res, converted, context, remember);
       }
     } else {
-      const converted = convertChatResponse(await upstream.json(), context);
+      const converted = convertChatResponse(await readProviderJson(upstream, lifecycle.touch), context);
       remember(converted);
       sendJson(res, 200, converted.response);
     }
@@ -250,6 +256,10 @@ async function handleRequest({
     if (controller.signal.aborted) {
       throw providerError('provider_connection_timeout', 'The provider request was cancelled or timed out.');
     }
+    if (error?.code === 'context_length_exceeded' && !res.headersSent) {
+      sendContextLimitError(res, sanitizeProviderMessage(error.message, [launch.apiKey]), requestBody.stream !== false);
+      return;
+    }
     throw error;
   } finally {
     lifecycle.dispose();
@@ -376,7 +386,9 @@ function normalizeBridgeErrorCode(value) {
     'provider_agent_tools_incompatible',
     'provider_reasoning_continuation_exhausted',
     'provider_stream_tool_parse_failed',
-    'provider_protocol_incompatible'
+    'provider_protocol_incompatible',
+    'context_length_exceeded',
+    'provider_upstream_error'
   ].includes(value) ? value : 'provider_bridge_failed';
 }
 
@@ -386,19 +398,40 @@ function bridgeErrorMessage(code) {
     : 'The local provider bridge failed.';
 }
 
-async function forwardUpstreamError(upstream, res, apiKey) {
-  const text = (await upstream.text()).slice(0, MAX_ERROR_BYTES);
+async function forwardUpstreamError(upstream, res, apiKey, onActivity, clientStream) {
+  const text = (await readProviderText(upstream, onActivity)).slice(0, MAX_ERROR_BYTES);
   let message = `Provider returned HTTP ${upstream.status}.`;
+  let error;
   try {
     const parsed = JSON.parse(text);
+    error = parsed?.error || parsed;
     message = parsed?.error?.message || parsed?.message || message;
   } catch (_error) {}
+  if ([400, 413, 422].includes(upstream.status) && isContextLimitError(error || text)) {
+    sendContextLimitError(res, sanitizeProviderMessage(error ? message : text, [apiKey]), clientStream);
+    return;
+  }
   sendJsonError(res, upstream.status, 'provider_upstream_error', sanitizeProviderMessage(message, [apiKey]));
 }
 
-function rememberHistory(history, responseId, messages) {
+function sendContextLimitError(res, message, stream) {
+  const error = { type: 'invalid_request_error', code: 'context_length_exceeded', message };
+  if (!stream) {
+    sendJson(res, 400, { error });
+    return;
+  }
+  // Non-2xx JSON is a generic HTTP failure to the installed Codex client.
+  // Its typed context recovery consumes a Responses failure event instead.
+  res.writeHead(200, { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-store' });
+  res.end(`event: response.failed\ndata: ${JSON.stringify({
+    type: 'response.failed', sequence_number: 0,
+    response: { id: `resp_${crypto.randomUUID()}`, object: 'response', status: 'failed', error }
+  })}\n\n`);
+}
+
+function rememberHistory(history, responseId, messages, metadata = {}) {
   history.delete(responseId);
-  history.set(responseId, { messages });
+  history.set(responseId, { messages, ...metadata });
   while (history.size > MAX_HISTORY_ENTRIES) {
     history.delete(history.keys().next().value);
   }