@verboo/code 0.15.16 → 0.15.17

package/dist/cli.mjs

@@ -17973,7 +17973,7 @@ function getOauthConfig() {
   }
   return config;
 }
-var CLAUDE_AI_INFERENCE_SCOPE = "user:inference", CLAUDE_AI_PROFILE_SCOPE = "user:profile", CONSOLE_SCOPE = "org:create_api_key", OAUTH_BETA_HEADER = "oauth-2025-04-20", CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, VERBOO_API_BASE_URL = "https://code.verboo.ai", VERBOO_FRONT_BASE_URL = "https://code.verboo.ai", VERBOO_ROUTER_URL = "https://code.verboo.ai/router/v1", VERBOO_OAUTH_SCOPES, PROD_OAUTH_CONFIG, MCP_CLIENT_METADATA_URL = "https://claude.ai/oauth/claude-code-client-metadata", STAGING_OAUTH_CONFIG, ALLOWED_OAUTH_BASE_URLS;
+var CLAUDE_AI_INFERENCE_SCOPE = "user:inference", CLAUDE_AI_PROFILE_SCOPE = "user:profile", CONSOLE_SCOPE = "org:create_api_key", OAUTH_BETA_HEADER = "oauth-2025-04-20", CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, VERBOO_API_BASE_URL = "https://code.verboo.ai", VERBOO_FRONT_BASE_URL = "https://code.verboo.ai", VERBOO_ROUTER_URL = "https://code.verboo.ai/router/v1", VERBOO_OAUTH_SCOPES, PROD_OAUTH_CONFIG, MCP_CLIENT_METADATA_URL = "https://code.verboo.ai/.well-known/oauth-client/verboo-code", STAGING_OAUTH_CONFIG, ALLOWED_OAUTH_BASE_URLS;
 var init_oauth = __esm(() => {
   init_envUtils();
   CONSOLE_OAUTH_SCOPES = [
@@ -118686,7 +118686,7 @@ function getClaudeCodeUserAgent() {
   return `claude-code/${"99.0.0"}`;
 }
 function getVerbooCodeUserAgent() {
-  const version2 = "0.15.16";
+  const version2 = "0.15.17";
   return `verboo-code/${version2}`;
 }
 
@@ -152401,9 +152401,17 @@ function resolveToolNameByUniquePrefix(toolNames, name) {
   const uniqueToolNames = [...new Set(toolNames)];
   if (uniqueToolNames.includes(name))
     return name;
-  if (name.length < 3 || name.startsWith("mcp__"))
+  const caseInsensitiveExactMatches = uniqueToolNames.filter((toolName) => toolName.toLowerCase() === name.toLowerCase());
+  if (caseInsensitiveExactMatches.length === 1) {
+    return caseInsensitiveExactMatches[0];
+  }
+  const normalizedName = name.toLowerCase();
+  if (name.length < 3)
     return;
-  const prefixMatches = uniqueToolNames.filter((toolName) => toolName.startsWith(name));
+  const prefixMatches = uniqueToolNames.filter((toolName) => {
+    const normalizedToolName = toolName.toLowerCase();
+    return !normalizedToolName.startsWith("mcp__") && normalizedToolName.startsWith(normalizedName);
+  });
   const oneCharacterCompletions = prefixMatches.filter((toolName) => toolName.length === name.length + 1);
   if (oneCharacterCompletions.length === 1) {
     return oneCharacterCompletions[0];
@@ -191380,7 +191388,7 @@ async function fetchPortalUrl(accessToken) {
     throw apiError;
   }
 }
-var subscriptionSchema, subscriptionsSchema, portalSchema;
+var subscriptionSourceSchema, subscriptionSchema, subscriptionsSchema, portalSchema;
 var init_verbooSubscriptions = __esm(() => {
   init_axios2();
   init_zod();
@@ -191388,6 +191396,17 @@ var init_verbooSubscriptions = __esm(() => {
   init_debug();
   init_log3();
   init_verbooApiError();
+  subscriptionSourceSchema = exports_external2.union([
+    exports_external2.enum([
+      "stripe",
+      "manual",
+      "trial",
+      "stripe_trial",
+      "woovi",
+      "managed_seat"
+    ]),
+    exports_external2.string().min(1)
+  ]);
   subscriptionSchema = exports_external2.object({
     id: exports_external2.string().uuid(),
     groupId: exports_external2.string().uuid(),
@@ -191401,7 +191420,7 @@ var init_verbooSubscriptions = __esm(() => {
       status: exports_external2.string(),
       models: exports_external2.array(exports_external2.string()).optional()
     }).passthrough().optional(),
-    source: exports_external2.string().optional(),
+    source: subscriptionSourceSchema.optional(),
     status: exports_external2.string().min(1),
     wooviSubscriptionId: exports_external2.string().optional(),
     currentPeriodStart: exports_external2.string().datetime({ offset: true }).optional(),
@@ -192809,6 +192828,102 @@ var init_openaiSchemaSanitizer = __esm(() => {
 });
 
 // src/services/api/codexShim.ts
+function maxBufferedToolArgumentChars() {
+  const raw = process.env.VERBOO_MAX_BUFFERED_TOOL_ARGUMENT_CHARS;
+  const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS;
+}
+function parseCompletedCodexTool(item) {
+  if (typeof item.name !== "string" || !item.name || typeof item.arguments !== "string" || item.arguments.length > maxBufferedToolArgumentChars()) {
+    throw new Error("Codex completed response contained a malformed tool call; no tool was committed");
+  }
+  for (const key of ["id", "call_id"]) {
+    const value = item[key];
+    if (value != null && (typeof value !== "string" || !value.trim())) {
+      throw new Error("Codex completed response contained a malformed tool call ID; no tool was committed");
+    }
+  }
+  const rawToolUseId = item.call_id ?? item.id;
+  if (typeof rawToolUseId !== "string" || !rawToolUseId.trim()) {
+    throw new Error("Codex completed response omitted its tool call ID; no tool was committed");
+  }
+  let input;
+  try {
+    input = JSON.parse(item.arguments);
+  } catch {
+    throw new Error("Codex completed response contained invalid tool arguments; no tool was committed");
+  }
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("Codex completed response contained non-object tool arguments; no tool was committed");
+  }
+  return {
+    input,
+    toolUseId: rawToolUseId
+  };
+}
+function parseCodexSseEventChunk(chunk) {
+  const lines = chunk.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0)
+    return;
+  const eventLine = lines.find((line) => line.startsWith("event:"));
+  const dataLines = lines.filter((line) => line.startsWith("data:"));
+  if (dataLines.length === 0)
+    return;
+  const rawData = dataLines.map((line) => line.slice("data:".length).trimStart()).join(`
+`);
+  if (rawData === "[DONE]")
+    return;
+  let data;
+  try {
+    const parsed = JSON.parse(rawData);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Codex SSE data was not a JSON object");
+    }
+    data = parsed;
+  } catch (error41) {
+    throw new Error("Codex SSE emitted invalid JSON; the response was not committed", { cause: error41 });
+  }
+  const framedEvent = eventLine?.slice("event:".length).trim() ?? "";
+  const payloadEvent = typeof data.type === "string" ? data.type : "";
+  if (framedEvent && payloadEvent && framedEvent !== payloadEvent) {
+    throw new Error("Codex SSE event name contradicted its payload type; no tool was committed");
+  }
+  const event = framedEvent || payloadEvent;
+  if (!event) {
+    throw new Error("Codex SSE data omitted its event type; the response was not committed");
+  }
+  return { event, data };
+}
+function completedCodexVisibleText(response) {
+  const output = Array.isArray(response.output) ? response.output : [];
+  let visible = "";
+  for (const item of output) {
+    if (item?.type !== "message" || !Array.isArray(item.content))
+      continue;
+    for (const part of item.content) {
+      if (part?.type === "output_text" && typeof part.text === "string") {
+        visible += stripThinkTags(part.text);
+      }
+    }
+  }
+  return visible;
+}
+function requireCodexTerminalResponse(payload, expectedStatus) {
+  const response = payload?.response;
+  if (!response || typeof response !== "object" || Array.isArray(response)) {
+    throw new Error(`Codex response.${expectedStatus} omitted its response object; the response was not committed`);
+  }
+  if (response.status !== expectedStatus) {
+    throw new Error(`Codex response.${expectedStatus} carried a missing or contradictory status; the response was not committed`);
+  }
+  if (typeof response.id !== "string" || !response.id.trim()) {
+    throw new Error(`Codex response.${expectedStatus} omitted its response ID; the response was not committed`);
+  }
+  if (!Array.isArray(response.output)) {
+    throw new Error(`Codex response.${expectedStatus} omitted its output array; the response was not committed`);
+  }
+  return response;
+}
 function makeUsage(usage) {
   return buildAnthropicUsageFromRawUsage(usage);
 }
@@ -193171,80 +193286,110 @@ async function performCodexRequest(options2) {
   return response;
 }
 async function* readSseEvents(response, signal) {
-  const reader = response.body?.getReader();
-  if (!reader)
+  const responseBody = response.body;
+  if (!responseBody)
     return;
+  const reader = responseBody.getReader();
   const decoder = new TextDecoder;
   let buffer = "";
-  const STREAM_IDLE_TIMEOUT_MS = 120000;
+  const STREAM_IDLE_TIMEOUT_MS = (() => {
+    const raw = process.env.VERBOO_STREAM_IDLE_TIMEOUT_MS;
+    const parsed = raw ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 120000;
+  })();
   let lastDataTime = Date.now();
+  let pendingReaderCancellation;
+  let reachedEOF = false;
+  const cancelReader = (reason) => {
+    if (pendingReaderCancellation)
+      return;
+    pendingReaderCancellation = reader.cancel(reason).then(() => {
+      return;
+    }, () => {
+      return;
+    });
+  };
   async function readWithTimeout() {
     return new Promise((resolve19, reject) => {
+      let settled = false;
+      let abortCleanup;
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        if (signal && abortCleanup)
+          signal.removeEventListener("abort", abortCleanup);
+      };
+      const resolveOnce = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        if (result.value)
+          lastDataTime = Date.now();
+        resolve19(result);
+      };
+      const rejectOnce = (error41) => {
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        reject(error41);
+      };
       const timeoutId = setTimeout(() => {
         const elapsed = Math.round((Date.now() - lastDataTime) / 1000);
-        reject(new Error(`Codex SSE stream idle for ${elapsed}s (limit: ${STREAM_IDLE_TIMEOUT_MS / 1000}s). Connection likely dropped.`));
+        const timeoutError = new Error(`Codex SSE stream idle for ${elapsed}s (limit: ${STREAM_IDLE_TIMEOUT_MS / 1000}s). Connection likely dropped.`);
+        cancelReader(timeoutError);
+        rejectOnce(timeoutError);
       }, STREAM_IDLE_TIMEOUT_MS);
-      let abortCleanup;
       if (signal) {
         abortCleanup = () => {
-          clearTimeout(timeoutId);
+          const abortError = signal.reason instanceof Error ? signal.reason : Object.assign(new Error("The operation was aborted"), {
+            name: "AbortError"
+          });
+          cancelReader(abortError);
+          rejectOnce(abortError);
         };
+        if (signal.aborted) {
+          abortCleanup();
+          return;
+        }
         signal.addEventListener("abort", abortCleanup, { once: true });
       }
-      reader.read().then((result) => {
-        clearTimeout(timeoutId);
-        if (signal && abortCleanup)
-          signal.removeEventListener("abort", abortCleanup);
-        if (result.value)
-          lastDataTime = Date.now();
-        resolve19(result);
-      }, (err2) => {
-        clearTimeout(timeoutId);
-        if (signal && abortCleanup)
-          signal.removeEventListener("abort", abortCleanup);
-        reject(err2);
-      });
+      reader.read().then(resolveOnce, rejectOnce);
     });
   }
-  while (true) {
-    const { done, value } = await readWithTimeout();
-    if (done)
-      break;
-    buffer += decoder.decode(value, { stream: true });
-    const chunks = buffer.split(`
-
-`);
-    buffer = chunks.pop() ?? "";
-    for (const chunk of chunks) {
-      const lines = chunk.split(`
-`).map((line) => line.trim()).filter(Boolean);
-      if (lines.length === 0)
-        continue;
-      const eventLine = lines.find((line) => line.startsWith("event: "));
-      const dataLines = lines.filter((line) => line.startsWith("data: "));
-      if (!eventLine || dataLines.length === 0)
-        continue;
-      const event = eventLine.slice(7).trim();
-      const rawData = dataLines.map((line) => line.slice(6)).join(`
-`);
-      if (rawData === "[DONE]")
-        continue;
-      let data;
-      try {
-        const parsed = JSON.parse(rawData);
-        if (!parsed || typeof parsed !== "object")
-          continue;
-        data = parsed;
-      } catch {
-        continue;
+  try {
+    while (true) {
+      const { done, value } = await readWithTimeout();
+      if (done) {
+        reachedEOF = true;
+        buffer += decoder.decode();
+        const finalEvent = parseCodexSseEventChunk(buffer);
+        if (finalEvent)
+          yield finalEvent;
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const chunks = buffer.split(/\r?\n\r?\n/);
+      buffer = chunks.pop() ?? "";
+      for (const chunk of chunks) {
+        const event = parseCodexSseEventChunk(chunk);
+        if (event)
+          yield event;
       }
-      yield { event, data };
     }
+  } finally {
+    if (!reachedEOF) {
+      cancelReader("Codex SSE consumer completed before transport EOF");
+    }
+    await pendingReaderCancellation;
+    try {
+      reader.releaseLock();
+    } catch {}
   }
 }
 function determineStopReason(response, sawToolUse) {
   const output = Array.isArray(response?.output) ? response.output : [];
-  if (sawToolUse || output.some((item) => item?.type === "function_call")) {
+  if (response?.status !== "incomplete" && (sawToolUse || output.some((item) => item?.type === "function_call"))) {
     return "tool_use";
   }
   const incompleteReason = response?.incomplete_details?.reason;
@@ -193260,8 +193405,12 @@ async function collectCodexCompletedResponse(response, signal) {
       const msg = event.data?.response?.error?.message ?? event.data?.error?.message ?? "Codex response failed";
       throw APIError.generate(500, undefined, msg, new Headers);
     }
-    if (event.event === "response.completed" || event.event === "response.incomplete") {
-      completedResponse = event.data?.response;
+    if (event.event === "response.completed") {
+      completedResponse = requireCodexTerminalResponse(event.data, "completed");
+      break;
+    }
+    if (event.event === "response.incomplete") {
+      completedResponse = requireCodexTerminalResponse(event.data, "incomplete");
       break;
     }
   }
@@ -193274,18 +193423,26 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
   const messageId = makeMessageId();
   const toolBlocksByItemId = new Map;
   let activeTextBlockIndex = null;
+  let emittedVisibleText = "";
   const thinkFilter = createThinkTagFilter();
   let nextContentBlockIndex = 0;
   let sawToolUse = false;
   let finalResponse;
+  let terminalEvent;
+  let terminalErrorMessage;
+  let totalBufferedToolArgumentChars = 0;
+  const toolArgumentCharsLimit = maxBufferedToolArgumentChars();
   const closeActiveTextBlock = async function* () {
     if (activeTextBlockIndex === null)
       return;
+    const textBlockIndex = activeTextBlockIndex;
+    activeTextBlockIndex = null;
     const tail = thinkFilter.flush();
     if (tail) {
+      emittedVisibleText += tail;
       yield {
         type: "content_block_delta",
-        index: activeTextBlockIndex,
+        index: textBlockIndex,
         delta: {
           type: "text_delta",
           text: tail
@@ -193294,9 +193451,8 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
     }
     yield {
       type: "content_block_stop",
-      index: activeTextBlockIndex
+      index: textBlockIndex
     };
-    activeTextBlockIndex = null;
   };
   const startTextBlockIfNeeded = async function* () {
     if (activeTextBlockIndex !== null)
@@ -193308,6 +193464,21 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
       content_block: { type: "text", text: "" }
     };
   };
+  const replaceToolArguments = (toolBlock, nextArguments) => {
+    const nextTotal = totalBufferedToolArgumentChars - toolBlock.argumentsBuffer.length + nextArguments.length;
+    if (nextArguments.length > toolArgumentCharsLimit || nextTotal > toolArgumentCharsLimit) {
+      throw new Error("Codex tool arguments exceeded the configured safety limit; no tool was committed");
+    }
+    toolBlock.argumentsBuffer = nextArguments;
+    totalBufferedToolArgumentChars = nextTotal;
+  };
+  const appendToolArguments = (toolBlock, delta) => {
+    if (toolBlock.argumentsBuffer.length + delta.length > toolArgumentCharsLimit || totalBufferedToolArgumentChars + delta.length > toolArgumentCharsLimit) {
+      throw new Error("Codex tool arguments exceeded the configured safety limit; no tool was committed");
+    }
+    toolBlock.argumentsBuffer += delta;
+    totalBufferedToolArgumentChars += delta.length;
+  };
   const findToolBlockEntry = (item) => {
     for (const candidate of [item.id, item.call_id]) {
       if (candidate == null)
@@ -193316,12 +193487,18 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
       const toolBlock = toolBlocksByItemId.get(itemId);
       if (toolBlock)
         return [itemId, toolBlock];
+      for (const entry of toolBlocksByItemId) {
+        if (entry[0] === itemId || entry[1].toolUseId === itemId)
+          return entry;
+      }
     }
     return;
   };
-  const toolNameMayBeIncomplete = (name) => Boolean(name) && !advertisedToolNames.includes(name) && advertisedToolNames.some((toolName) => toolName.startsWith(name));
   const canonicalizeFinalToolName = (toolBlock) => {
     const resolvedName = resolveToolNameByUniquePrefix(advertisedToolNames, toolBlock.name);
+    if (advertisedToolNames.length > 0 && !resolvedName) {
+      throw new Error("Codex completed response selected an unadvertised tool; no tool was committed");
+    }
     if (resolvedName)
       toolBlock.name = resolvedName;
   };
@@ -193329,8 +193506,11 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
     if (typeof item.name === "string" && item.name) {
       toolBlock.name = item.name;
     }
-    if (typeof item.arguments === "string" && (!toolBlock.hasStarted || item.arguments.startsWith(toolBlock.argumentsBuffer))) {
-      toolBlock.argumentsBuffer = item.arguments;
+    if (typeof item.arguments === "string") {
+      replaceToolArguments(toolBlock, item.arguments);
+    }
+    if (item.call_id != null || item.id != null) {
+      toolBlock.toolUseId = String(item.call_id ?? item.id);
     }
     canonicalizeFinalToolName(toolBlock);
   };
@@ -193348,14 +193528,10 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
     };
     toolBlock.emittedArgumentsLength = toolBlock.argumentsBuffer.length;
   };
-  const startToolBlock = async function* (toolBlock, force = false) {
+  const startToolBlock = async function* (toolBlock) {
     if (toolBlock.hasStarted)
       return;
-    if (!force && (!toolBlock.name || toolNameMayBeIncomplete(toolBlock.name))) {
-      return;
-    }
-    if (force)
-      canonicalizeFinalToolName(toolBlock);
+    canonicalizeFinalToolName(toolBlock);
     toolBlock.hasStarted = true;
     toolBlock.startedName = toolBlock.name || "tool";
     yield {
@@ -193370,45 +193546,47 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
     };
     yield* emitPendingToolArguments(toolBlock);
   };
-  const flushToolBlocks = async function* (force = false) {
+  const flushToolBlocks = async function* () {
     const orderedBlocks = [...toolBlocksByItemId.values()].sort((a2, b) => a2.index - b.index);
     for (const toolBlock of orderedBlocks) {
       if (toolBlock.hasStopped)
         continue;
       if (!toolBlock.hasStarted) {
-        yield* startToolBlock(toolBlock, force || toolBlock.isDone);
+        if (!toolBlock.isDone)
+          break;
+        yield* startToolBlock(toolBlock);
         if (!toolBlock.hasStarted)
           break;
       }
-      if (toolBlock.isDone && toolBlock.startedName !== (toolBlock.name || "tool")) {
-        toolBlock.startedName = toolBlock.name || "tool";
-        yield {
-          type: "content_block_start",
-          index: toolBlock.index,
-          content_block: {
-            type: "tool_use",
-            id: toolBlock.toolUseId,
-            name: toolBlock.startedName,
-            input: {}
-          }
-        };
-      }
       yield* emitPendingToolArguments(toolBlock);
       if (toolBlock.isDone) {
+        toolBlock.hasStopped = true;
         yield {
           type: "content_block_stop",
           index: toolBlock.index
         };
-        toolBlock.hasStopped = true;
       }
     }
   };
   const removeStoppedToolBlocks = () => {
     for (const [itemId, toolBlock] of toolBlocksByItemId) {
-      if (toolBlock.hasStopped)
+      if (toolBlock.hasStopped) {
+        totalBufferedToolArgumentChars -= toolBlock.argumentsBuffer.length;
         toolBlocksByItemId.delete(itemId);
+      }
     }
   };
+  const closeOpenBlocksForFailure = async function* () {
+    yield* closeActiveTextBlock();
+    const orderedBlocks = [...new Set(toolBlocksByItemId.values())].sort((a2, b) => a2.index - b.index);
+    for (const toolBlock of orderedBlocks) {
+      if (!toolBlock.hasStarted || toolBlock.hasStopped)
+        continue;
+      toolBlock.hasStopped = true;
+      yield { type: "content_block_stop", index: toolBlock.index };
+    }
+    toolBlocksByItemId.clear();
+  };
   yield {
     type: "message_start",
     message: {
@@ -193422,116 +193600,244 @@ async function* codexStreamToAnthropic(response, model2, signal, advertisedToolN
       usage: makeUsage()
     }
   };
-  for await (const event of readSseEvents(response, signal)) {
-    const payload = event.data;
-    if (event.event === "response.output_item.added") {
-      const item = payload.item;
-      if (item?.type === "function_call") {
-        yield* closeActiveTextBlock();
+  try {
+    for await (const event of readSseEvents(response, signal)) {
+      const payload = event.data;
+      if (event.event === "response.output_item.added") {
+        const item = payload.item;
+        if (item?.type === "function_call") {
+          yield* closeActiveTextBlock();
+          const blockIndex = nextContentBlockIndex++;
+          const toolUseId = item.call_id ?? item.id ?? `call_${blockIndex}`;
+          const toolBlock = {
+            index: blockIndex,
+            toolUseId,
+            name: typeof item.name === "string" ? item.name : "",
+            argumentsBuffer: "",
+            emittedArgumentsLength: 0,
+            hasStarted: false,
+            isDone: false,
+            hasStopped: false
+          };
+          if (typeof item.arguments === "string") {
+            replaceToolArguments(toolBlock, item.arguments);
+          }
+          const itemKey = String(item.id ?? toolUseId);
+          if (toolBlocksByItemId.has(itemKey)) {
+            throw new Error("Codex stream repeated a tool item ID; no tool was committed");
+          }
+          toolBlocksByItemId.set(itemKey, toolBlock);
+        }
+        continue;
+      }
+      if (event.event === "response.content_part.added") {
+        if (payload.part?.type === "output_text") {
+          if (toolBlocksByItemId.size > 0) {
+            throw new Error("Codex emitted text after a reserved tool block; the out-of-order response was not committed");
+          }
+          yield* startTextBlockIfNeeded();
+        }
+        continue;
+      }
+      if (event.event === "response.output_text.delta") {
+        if (toolBlocksByItemId.size > 0) {
+          throw new Error("Codex emitted text after a reserved tool block; the out-of-order response was not committed");
+        }
+        yield* startTextBlockIfNeeded();
+        if (activeTextBlockIndex !== null) {
+          const visible = thinkFilter.feed(payload.delta ?? "");
+          if (visible) {
+            emittedVisibleText += visible;
+            yield {
+              type: "content_block_delta",
+              index: activeTextBlockIndex,
+              delta: {
+                type: "text_delta",
+                text: visible
+              }
+            };
+          }
+        }
+        continue;
+      }
+      if (event.event === "response.function_call_arguments.delta") {
+        const toolBlock = toolBlocksByItemId.get(String(payload.item_id ?? ""));
+        if (toolBlock) {
+          if (typeof payload.delta === "string") {
+            appendToolArguments(toolBlock, payload.delta);
+          }
+        }
+        continue;
+      }
+      if (event.event === "response.output_item.done") {
+        const item = payload.item;
+        if (item?.type === "function_call") {
+          const toolBlockEntry = findToolBlockEntry(item);
+          if (toolBlockEntry) {
+            const [, toolBlock] = toolBlockEntry;
+            applyFinalToolItem(toolBlock, item);
+            toolBlock.isDone = true;
+          }
+        } else if (item?.type === "message") {
+          yield* closeActiveTextBlock();
+        }
+        continue;
+      }
+      if (event.event === "response.completed") {
+        terminalEvent = "completed";
+        finalResponse = requireCodexTerminalResponse(payload, "completed");
+        break;
+      }
+      if (event.event === "response.incomplete") {
+        terminalEvent = "incomplete";
+        finalResponse = requireCodexTerminalResponse(payload, "incomplete");
+        break;
+      }
+      if (event.event === "response.failed") {
+        terminalEvent = "failed";
+        terminalErrorMessage = payload?.response?.error?.message ?? payload?.error?.message ?? "Codex response failed";
+        break;
+      }
+    }
+    yield* closeActiveTextBlock();
+    if (terminalEvent === "failed") {
+      toolBlocksByItemId.clear();
+      throw APIError.generate(500, undefined, terminalErrorMessage ?? "Codex response failed", new Headers);
+    }
+    if (!terminalEvent || !finalResponse) {
+      toolBlocksByItemId.clear();
+      throw APIError.generate(500, undefined, "Codex response ended without a terminal payload", new Headers);
+    }
+    const finalVisibleText = completedCodexVisibleText(finalResponse);
+    let missingSuffix = "";
+    if (!emittedVisibleText) {
+      missingSuffix = finalVisibleText;
+    } else if (finalVisibleText.startsWith(emittedVisibleText)) {
+      missingSuffix = finalVisibleText.slice(emittedVisibleText.length);
+    } else if (finalVisibleText !== emittedVisibleText) {
+      throw APIError.generate(500, undefined, "Codex completed text contradicted streamed text; response was not committed", new Headers);
+    }
+    if (missingSuffix && toolBlocksByItemId.size > 0) {
+      toolBlocksByItemId.clear();
+      throw APIError.generate(500, undefined, "Codex completed text arrived after a reserved tool block; the out-of-order response was not committed", new Headers);
+    }
+    if (missingSuffix) {
+      yield* startTextBlockIfNeeded();
+      if (activeTextBlockIndex !== null) {
+        emittedVisibleText += missingSuffix;
+        yield {
+          type: "content_block_delta",
+          index: activeTextBlockIndex,
+          delta: { type: "text_delta", text: missingSuffix }
+        };
+      }
+      yield* closeActiveTextBlock();
+    }
+    if (terminalEvent === "incomplete") {
+      toolBlocksByItemId.clear();
+      yield {
+        type: "message_delta",
+        delta: {
+          stop_reason: determineStopReason(finalResponse, false),
+          stop_sequence: null
+        },
+        usage: makeUsage(finalResponse.usage)
+      };
+      yield { type: "message_stop" };
+      return;
+    }
+    const finalOutput = Array.isArray(finalResponse?.output) ? finalResponse.output : [];
+    const reservedToolIndices = [...toolBlocksByItemId.values()].map((toolBlock) => toolBlock.index);
+    const firstFinalToolIndex = reservedToolIndices.length > 0 ? Math.min(...reservedToolIndices) : nextContentBlockIndex;
+    const completedToolBlocks = new Set;
+    const completedToolCallIds = new Set;
+    for (const item of finalOutput) {
+      if (item?.type !== "function_call")
+        continue;
+      try {
+        parseCompletedCodexTool(item);
+      } catch (error41) {
+        toolBlocksByItemId.clear();
+        throw APIError.generate(500, undefined, error41 instanceof Error ? error41.message : "Invalid Codex tool call", new Headers);
+      }
+      let toolBlockEntry = findToolBlockEntry(item);
+      if (!toolBlockEntry) {
         const blockIndex = nextContentBlockIndex++;
-        const toolUseId = item.call_id ?? item.id ?? `call_${blockIndex}`;
+        const { toolUseId } = parseCompletedCodexTool(item);
         const toolBlock = {
           index: blockIndex,
           toolUseId,
-          name: typeof item.name === "string" ? item.name : "",
-          argumentsBuffer: typeof item.arguments === "string" ? item.arguments : "",
+          name: "",
+          argumentsBuffer: "",
           emittedArgumentsLength: 0,
           hasStarted: false,
           isDone: false,
           hasStopped: false
         };
-        toolBlocksByItemId.set(String(item.id ?? toolUseId), toolBlock);
-        sawToolUse = true;
-        yield* flushToolBlocks();
+        const itemKey = String(item.id ?? item.call_id ?? toolUseId);
+        toolBlocksByItemId.set(itemKey, toolBlock);
+        toolBlockEntry = [itemKey, toolBlock];
       }
-      continue;
-    }
-    if (event.event === "response.content_part.added") {
-      if (payload.part?.type === "output_text") {
-        yield* startTextBlockIfNeeded();
+      if (completedToolBlocks.has(toolBlockEntry[1])) {
+        toolBlocksByItemId.clear();
+        throw APIError.generate(500, undefined, "Codex completed response repeated a tool call; no tool was committed", new Headers);
       }
-      continue;
-    }
-    if (event.event === "response.output_text.delta") {
-      yield* startTextBlockIfNeeded();
-      if (activeTextBlockIndex !== null) {
-        const visible = thinkFilter.feed(payload.delta ?? "");
-        if (visible) {
-          yield {
-            type: "content_block_delta",
-            index: activeTextBlockIndex,
-            delta: {
-              type: "text_delta",
-              text: visible
-            }
-          };
-        }
+      applyFinalToolItem(toolBlockEntry[1], item);
+      if (completedToolCallIds.has(toolBlockEntry[1].toolUseId)) {
+        toolBlocksByItemId.clear();
+        throw APIError.generate(500, undefined, "Codex completed response reused a tool call ID; no tool was committed", new Headers);
       }
-      continue;
+      completedToolCallIds.add(toolBlockEntry[1].toolUseId);
+      toolBlockEntry[1].isDone = true;
+      completedToolBlocks.add(toolBlockEntry[1]);
     }
-    if (event.event === "response.function_call_arguments.delta") {
-      const toolBlock = toolBlocksByItemId.get(String(payload.item_id ?? ""));
-      if (toolBlock) {
-        if (typeof payload.delta === "string") {
-          toolBlock.argumentsBuffer += payload.delta;
-        }
-        yield* flushToolBlocks();
-      }
-      continue;
+    let authoritativeToolOffset = 0;
+    for (const toolBlock of completedToolBlocks) {
+      toolBlock.index = firstFinalToolIndex + authoritativeToolOffset++;
     }
-    if (event.event === "response.output_item.done") {
-      const item = payload.item;
-      if (item?.type === "function_call") {
-        const toolBlockEntry = findToolBlockEntry(item);
-        if (toolBlockEntry) {
-          const [, toolBlock] = toolBlockEntry;
-          applyFinalToolItem(toolBlock, item);
-          toolBlock.isDone = true;
-          yield* flushToolBlocks();
-          removeStoppedToolBlocks();
-        }
-      } else if (item?.type === "message") {
-        yield* closeActiveTextBlock();
-      }
-      continue;
+    if (completedToolBlocks.size > 0) {
+      nextContentBlockIndex = firstFinalToolIndex + completedToolBlocks.size;
     }
-    if (event.event === "response.completed" || event.event === "response.incomplete") {
-      finalResponse = payload.response;
-      break;
-    }
-    if (event.event === "response.failed") {
-      const msg = payload?.response?.error?.message ?? payload?.error?.message ?? "Codex response failed";
-      throw APIError.generate(500, undefined, msg, new Headers);
+    for (const [itemId, toolBlock] of toolBlocksByItemId) {
+      if (!completedToolBlocks.has(toolBlock)) {
+        totalBufferedToolArgumentChars -= toolBlock.argumentsBuffer.length;
+        toolBlocksByItemId.delete(itemId);
+      }
     }
+    sawToolUse = completedToolBlocks.size > 0;
+    yield* flushToolBlocks();
+    removeStoppedToolBlocks();
+    yield {
+      type: "message_delta",
+      delta: {
+        stop_reason: determineStopReason(finalResponse, sawToolUse),
+        stop_sequence: null
+      },
+      usage: makeUsage(finalResponse?.usage)
+    };
+    yield { type: "message_stop" };
+  } catch (error41) {
+    yield* closeOpenBlocksForFailure();
+    throw error41;
   }
-  yield* closeActiveTextBlock();
-  const finalOutput = Array.isArray(finalResponse?.output) ? finalResponse.output : [];
-  for (const item of finalOutput) {
-    if (item?.type !== "function_call")
-      continue;
-    const toolBlockEntry = findToolBlockEntry(item);
-    if (!toolBlockEntry)
-      continue;
-    applyFinalToolItem(toolBlockEntry[1], item);
-  }
-  for (const toolBlock of toolBlocksByItemId.values()) {
-    toolBlock.isDone = true;
-  }
-  yield* flushToolBlocks(true);
-  removeStoppedToolBlocks();
-  yield {
-    type: "message_delta",
-    delta: {
-      stop_reason: determineStopReason(finalResponse, sawToolUse),
-      stop_sequence: null
-    },
-    usage: makeUsage(finalResponse?.usage)
-  };
-  yield { type: "message_stop" };
 }
 function convertCodexResponseToAnthropicMessage(data, model2, advertisedToolNames = []) {
   const content = [];
   const output = Array.isArray(data.output) ? data.output : [];
+  if (data.status == null) {
+    throw new Error("Codex response omitted its terminal status; the response was not committed");
+  }
+  if (data.status === "failed") {
+    const failureMessage = typeof data.error?.message === "string" ? `: ${data.error.message}` : "";
+    throw new Error(`Codex response failed${failureMessage}`);
+  }
+  if (data.status !== "completed" && data.status !== "incomplete") {
+    throw new Error(`Codex response carried non-terminal status "${String(data.status)}"; the response was not committed`);
+  }
+  const mayCommitTools = data.status === "completed";
+  const completedToolCallIds = new Set;
+  let completedToolArgumentChars = 0;
+  const toolArgumentCharsLimit = maxBufferedToolArgumentChars();
   for (const item of output) {
     if (item?.type === "message" && Array.isArray(item.content)) {
       for (const part of item.content) {
@@ -193544,17 +193850,23 @@ function convertCodexResponseToAnthropicMessage(data, model2, advertisedToolName
       }
       continue;
     }
-    if (item?.type === "function_call") {
+    if (item?.type === "function_call" && mayCommitTools) {
+      const { input, toolUseId } = parseCompletedCodexTool(item);
+      completedToolArgumentChars += item.arguments.length;
+      if (completedToolArgumentChars > toolArgumentCharsLimit) {
+        throw new Error("Codex tool arguments exceeded the configured safety limit; no tool was committed");
+      }
+      if (completedToolCallIds.has(toolUseId)) {
+        throw new Error("Codex completed response reused a tool call ID; no tool was committed");
+      }
+      completedToolCallIds.add(toolUseId);
       const toolName = resolveToolNameByUniquePrefix(advertisedToolNames, item.name ?? "") ?? item.name ?? "tool";
-      let input;
-      try {
-        input = JSON.parse(item.arguments ?? "{}");
-      } catch {
-        input = { raw: item.arguments ?? "" };
+      if (advertisedToolNames.length > 0 && !resolveToolNameByUniquePrefix(advertisedToolNames, item.name ?? "")) {
+        throw new Error("Codex completed response selected an unadvertised tool; no tool was committed");
       }
       content.push({
         type: "tool_use",
-        id: item.call_id ?? item.id ?? makeMessageId(),
+        id: toolUseId,
         name: toolName,
         input
       });
@@ -193571,6 +193883,7 @@ function convertCodexResponseToAnthropicMessage(data, model2, advertisedToolName
     usage: makeUsage(data.usage)
   };
 }
+var DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS;
 var init_codexShim = __esm(() => {
   init_sdk();
   init_Tool();
@@ -193579,6 +193892,7 @@ var init_codexShim = __esm(() => {
   init_fetchWithProxyRetry();
   init_openaiSchemaSanitizer();
   init_thinkTagSanitizer();
+  DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS = 64 * 1024 * 1024;
 });
 
 // src/services/api/visionDelegate.ts
@@ -194820,29 +195134,84 @@ function convertChunkUsage(usage) {
     return;
   return buildAnthropicUsageFromRawUsage(usage);
 }
-function repairPossiblyTruncatedObjectJson(raw) {
+function hasInvalidToolArguments(raw, toolName) {
+  const trimmed2 = raw.trim();
+  if (!hasToolFieldMapping(toolName)) {
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed === null || typeof parsed !== "object" || Array.isArray(parsed);
+    } catch {
+      return true;
+    }
+  }
+  if (!trimmed2.startsWith("{"))
+    return false;
   try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? raw : null;
+    JSON.parse(raw);
+    return false;
   } catch {
-    for (const combo of JSON_REPAIR_SUFFIXES) {
-      try {
-        const repaired = raw + combo;
-        const parsed = JSON.parse(repaired);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          return repaired;
-        }
-      } catch {}
+    return !(toolName.toLowerCase() === "bash" && /^\{\s*[^{}]*;\s*\}$/.test(trimmed2));
+  }
+}
+function maxBufferedToolArgumentChars2() {
+  const raw = process.env.VERBOO_MAX_BUFFERED_TOOL_ARGUMENT_CHARS;
+  const parsed = raw ? Number.parseInt(raw, 10) : NaN;
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS2;
+}
+function mergeOpaqueMetadata(current, next) {
+  const merged = Object.fromEntries(Object.entries(current ?? {}));
+  for (const [key, nextValue] of Object.entries(next)) {
+    const currentValue = merged[key];
+    if (currentValue !== null && nextValue !== null && typeof currentValue === "object" && typeof nextValue === "object" && !Array.isArray(currentValue) && !Array.isArray(nextValue)) {
+      Object.defineProperty(merged, key, {
+        value: mergeOpaqueMetadata(currentValue, nextValue),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      Object.defineProperty(merged, key, {
+        value: nextValue,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
     }
-    return null;
   }
+  return merged;
 }
-function mergeStreamedToolName(current, fragment) {
-  if (!fragment)
-    return current;
-  if (!current || fragment.startsWith(current))
-    return fragment;
-  return current + fragment;
+function resolveStreamedToolName(advertisedToolNames, fragments) {
+  const nonEmpty = fragments.filter(Boolean);
+  const concatenated = nonEmpty.join("");
+  if (advertisedToolNames.length === 0) {
+    return { name: concatenated, ambiguous: false };
+  }
+  const candidates = new Set([concatenated]);
+  let cumulative = "";
+  for (const fragment of nonEmpty) {
+    if (!cumulative) {
+      cumulative = fragment;
+      continue;
+    }
+    const currentFolded = cumulative.toLowerCase();
+    const fragmentFolded = fragment.toLowerCase();
+    if (fragmentFolded.startsWith(currentFolded)) {
+      cumulative = fragment;
+    } else if (!currentFolded.startsWith(fragmentFolded)) {
+      cumulative += fragment;
+    }
+  }
+  candidates.add(cumulative);
+  const resolved = new Set;
+  for (const candidate of candidates) {
+    const toolName = resolveToolNameByUniquePrefix(advertisedToolNames, candidate);
+    if (toolName)
+      resolved.add(toolName);
+  }
+  if (resolved.size === 1) {
+    return { name: [...resolved][0], ambiguous: false };
+  }
+  return { name: concatenated, ambiguous: true };
 }
 function getAdvertisedToolNames(params) {
   return (params.tools ?? []).flatMap((tool) => typeof tool.name === "string" && tool.name && tool.name !== "ToolSearchTool" ? [tool.name] : []);
@@ -194923,7 +195292,11 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
   let lastStopReason = null;
   let hasEmittedFinalUsage = false;
   let hasProcessedFinishReason = false;
+  let sawDoneMarker = false;
   const streamState = createStreamState();
+  let nextSyntheticProtocolIndex = -2;
+  let totalBufferedToolArgumentChars = 0;
+  const toolArgumentCharsLimit = maxBufferedToolArgumentChars2();
   yield {
     type: "message_start",
     message: {
@@ -194942,9 +195315,11 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
       }
     }
   };
-  const reader = response.body?.getReader();
-  if (!reader)
-    return;
+  const responseBody = response.body;
+  if (!responseBody) {
+    throw new Error("Upstream SSE response had no readable body");
+  }
+  const reader = responseBody.getReader();
   const decoder = new TextDecoder;
   let buffer = "";
   const STREAM_IDLE_TIMEOUT_MS = (() => {
@@ -194954,32 +195329,61 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
   })();
   let lastDataTime = Date.now();
   const streamStartedAt = Date.now();
+  let pendingReaderCancellation;
+  const cancelReader = (reason) => {
+    pendingReaderCancellation = reader.cancel(reason).then(() => {
+      return;
+    }, () => {
+      return;
+    });
+  };
   async function readWithTimeout() {
     return new Promise((resolve19, reject) => {
+      let settled = false;
+      let abortCleanup;
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        if (signal && abortCleanup) {
+          signal.removeEventListener("abort", abortCleanup);
+        }
+      };
+      const resolveOnce = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        if (result.value)
+          lastDataTime = Date.now();
+        resolve19(result);
+      };
+      const rejectOnce = (error41) => {
+        if (settled)
+          return;
+        settled = true;
+        cleanup();
+        reject(error41);
+      };
       const timeoutId = setTimeout(() => {
         const elapsed = Math.round((Date.now() - lastDataTime) / 1000);
-        reject(new Error(`OpenAI/Gemini SSE stream idle for ${elapsed}s (limit: ${STREAM_IDLE_TIMEOUT_MS / 1000}s). Connection likely dropped.`));
+        const timeoutError = new Error(`OpenAI/Gemini SSE stream idle for ${elapsed}s (limit: ${STREAM_IDLE_TIMEOUT_MS / 1000}s). Connection likely dropped.`);
+        cancelReader(timeoutError);
+        rejectOnce(timeoutError);
       }, STREAM_IDLE_TIMEOUT_MS);
-      let abortCleanup;
       if (signal) {
         abortCleanup = () => {
-          clearTimeout(timeoutId);
+          const abortError = signal.reason instanceof Error ? signal.reason : Object.assign(new Error("The operation was aborted"), {
+            name: "AbortError"
+          });
+          cancelReader(abortError);
+          rejectOnce(abortError);
         };
+        if (signal.aborted) {
+          abortCleanup();
+          return;
+        }
         signal.addEventListener("abort", abortCleanup, { once: true });
       }
-      reader.read().then((result) => {
-        clearTimeout(timeoutId);
-        if (signal && abortCleanup)
-          signal.removeEventListener("abort", abortCleanup);
-        if (result.value)
-          lastDataTime = Date.now();
-        resolve19(result);
-      }, (err2) => {
-        clearTimeout(timeoutId);
-        if (signal && abortCleanup)
-          signal.removeEventListener("abort", abortCleanup);
-        reject(err2);
-      });
+      reader.read().then(resolveOnce, rejectOnce);
     });
   }
   const closeActiveContentBlock = async function* () {
@@ -195000,25 +195404,38 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
     contentBlockIndex++;
     hasEmittedContentStart = false;
   };
-  const toolNameMayBeIncomplete = (name) => Boolean(name) && !advertisedToolNames.includes(name) && advertisedToolNames.some((toolName) => toolName.startsWith(name));
-  const canonicalizeFinalToolName = (toolCall) => {
-    const resolvedName = resolveToolNameByUniquePrefix(advertisedToolNames, toolCall.name);
-    if (resolvedName)
-      toolCall.name = resolvedName;
+  const finalizeToolCall = (toolCall) => {
+    const distinctIds = [...new Set(toolCall.idFragments.filter(Boolean))];
+    if (distinctIds.length > 1) {
+      return "conflicting_tool_call_ids";
+    }
+    if (distinctIds.length === 1)
+      toolCall.id = distinctIds[0];
+    const resolvedName = resolveStreamedToolName(advertisedToolNames, toolCall.nameFragments);
+    toolCall.name = resolvedName.name;
+    if (resolvedName.ambiguous)
+      return "ambiguous_tool_name_fragments";
+    if (!toolCall.id.trim())
+      return "missing_tool_call_id";
+    if (!toolCall.name.trim())
+      return "missing_tool_name";
+    if (toolCall.ambiguousArgumentFraming) {
+      return "ambiguous_tool_argument_fragments";
+    }
+    if (hasInvalidToolArguments(toolCall.jsonBuffer, toolCall.name)) {
+      return "malformed_structured_tool_arguments";
+    }
+    return null;
   };
-  const startToolCall = async function* (toolCall, force = false) {
-    if (toolCall.hasStarted || !toolCall.id || !toolCall.name)
+  const startToolCall = async function* (toolCall) {
+    if (toolCall.hasStarted || toolCall.index === null || !toolCall.id || !toolCall.name)
       return;
-    if (!force && toolNameMayBeIncomplete(toolCall.name))
-      return;
-    if (force)
-      canonicalizeFinalToolName(toolCall);
+    const blockIndex = toolCall.index;
     toolCall.normalizeAtStop = hasToolFieldMapping(toolCall.name);
     toolCall.hasStarted = true;
-    toolCall.startedName = toolCall.name;
     yield {
       type: "content_block_start",
-      index: toolCall.index,
+      index: blockIndex,
       content_block: {
         type: "tool_use",
         id: toolCall.id,
@@ -195033,7 +195450,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
     if (!toolCall.normalizeAtStop && toolCall.jsonBuffer) {
       yield {
         type: "content_block_delta",
-        index: toolCall.index,
+        index: blockIndex,
         delta: {
           type: "input_json_delta",
           partial_json: toolCall.jsonBuffer
@@ -195042,20 +195459,28 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
       toolCall.emittedJsonLength = toolCall.jsonBuffer.length;
     }
   };
-  const flushReadyToolCalls = async function* (force = false) {
-    const orderedCalls = [...activeToolCalls.values()].sort((a2, b) => a2.index - b.index);
-    for (const toolCall of orderedCalls) {
+  const orderedActiveToolCalls = () => [...activeToolCalls.entries()].sort(([leftProtocolIndex], [rightProtocolIndex]) => leftProtocolIndex - rightProtocolIndex).map(([, toolCall]) => toolCall);
+  const flushReadyToolCalls = async function* () {
+    for (const toolCall of orderedActiveToolCalls()) {
+      if (toolCall.index === null) {
+        toolCall.index = contentBlockIndex++;
+      }
       if (!toolCall.hasStarted) {
-        if (!force && !toolCall.readyToStart)
-          break;
-        yield* startToolCall(toolCall, force);
+        yield* startToolCall(toolCall);
         if (!toolCall.hasStarted) {
-          if (!force)
-            break;
           continue;
         }
       }
-      if (!toolCall.normalizeAtStop && toolCall.emittedJsonLength < toolCall.jsonBuffer.length) {
+      if (toolCall.normalizeAtStop) {
+        yield {
+          type: "content_block_delta",
+          index: toolCall.index,
+          delta: {
+            type: "input_json_delta",
+            partial_json: JSON.stringify(normalizeToolArguments(toolCall.name, toolCall.jsonBuffer))
+          }
+        };
+      } else if (toolCall.emittedJsonLength < toolCall.jsonBuffer.length) {
         yield {
           type: "content_block_delta",
           index: toolCall.index,
@@ -195066,7 +195491,61 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
         };
         toolCall.emittedJsonLength = toolCall.jsonBuffer.length;
       }
+      toolCall.hasStopped = true;
+      yield { type: "content_block_stop", index: toolCall.index };
+    }
+  };
+  const discardActiveToolCalls = (reason) => {
+    if (activeToolCalls.size > 0) {
+      logForDebugging(JSON.stringify({
+        type: "discarded_uncommitted_tool_calls",
+        model: model2,
+        reason,
+        count: activeToolCalls.size
+      }), { level: "warn" });
+    }
+    activeToolCalls.clear();
+  };
+  const closeOpenBlocksForFailure = async function* () {
+    if (hasEmittedContentStart) {
+      yield* closeActiveContentBlock();
+    }
+    if (hasEmittedThinkingStart && !hasClosedThinking) {
+      const thinkingBlockIndex = contentBlockIndex;
+      hasClosedThinking = true;
+      contentBlockIndex++;
+      yield { type: "content_block_stop", index: thinkingBlockIndex };
+    }
+    for (const toolCall of orderedActiveToolCalls()) {
+      if (!toolCall.hasStarted || toolCall.hasStopped || toolCall.index === null)
+        continue;
+      toolCall.hasStopped = true;
+      yield { type: "content_block_stop", index: toolCall.index };
+    }
+    discardActiveToolCalls("stream_exception");
+  };
+  const resolveProtocolIndex = (toolCall, batchSize) => {
+    if (Number.isInteger(toolCall.index))
+      return toolCall.index;
+    if (typeof toolCall.id === "string" && toolCall.id) {
+      const matches = [...activeToolCalls.entries()].filter(([, active]) => active.idFragments.includes(toolCall.id));
+      if (matches.length === 1)
+        return matches[0][0];
+      if (matches.length > 1) {
+        throw new Error("Upstream omitted tool index and reused an ambiguous tool call ID; no tool was committed.");
+      }
+      if (activeToolCalls.size === 1 && batchSize === 1) {
+        return activeToolCalls.keys().next().value;
+      }
+      return nextSyntheticProtocolIndex--;
+    }
+    if (batchSize === 1 && activeToolCalls.size === 1) {
+      return activeToolCalls.keys().next().value;
     }
+    if (batchSize === 1 && activeToolCalls.size === 0) {
+      return nextSyntheticProtocolIndex--;
+    }
+    throw new Error("Upstream omitted tool indices for parallel calls; no tool was committed.");
   };
   try {
     while (true) {
@@ -195081,18 +195560,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
             duration_ms: Date.now() - streamStartedAt,
             had_content: hasEmittedContentStart || hasEmittedThinkingStart
           }), { level: "error" });
-          if (hasEmittedContentStart) {
-            yield* closeActiveContentBlock();
-          }
-          if (hasEmittedThinkingStart && !hasClosedThinking) {
-            yield { type: "content_block_stop", index: contentBlockIndex };
-          }
-          for (const [, toolCall] of activeToolCalls) {
-            if (toolCall.hasStarted) {
-              yield { type: "content_block_stop", index: toolCall.index };
-            }
-          }
-          activeToolCalls.clear();
+          discardActiveToolCalls("premature_eof");
           throw new Error(`Upstream stream closed without finish_reason after ${elapsedSec}s — likely a guard_proxy/vLLM disconnect. The session was interrupted, not completed.`);
         }
         break;
@@ -195103,15 +195571,23 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
       buffer = lines.pop() ?? "";
       for (const line of lines) {
         const trimmed2 = line.trim();
-        if (!trimmed2 || trimmed2 === "data: [DONE]")
+        if (!trimmed2)
           continue;
+        if (trimmed2 === "data: [DONE]") {
+          if (!hasProcessedFinishReason) {
+            throw new Error("Upstream SSE emitted [DONE] without finish_reason; the response was not committed.");
+          }
+          sawDoneMarker = true;
+          cancelReader("OpenAI SSE completed");
+          break;
+        }
         if (!trimmed2.startsWith("data: "))
           continue;
         let chunk;
         try {
           chunk = JSON.parse(trimmed2.slice(6));
         } catch {
-          continue;
+          throw new Error("Upstream emitted invalid SSE JSON; the response was not committed.");
         }
         const routerStatus = chunk.router_status;
         if (typeof routerStatus === "string") {
@@ -195123,18 +195599,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
         const inStreamError = chunk.error;
         if (inStreamError && typeof inStreamError === "object") {
           const message = typeof inStreamError.message === "string" ? inStreamError.message : "Provider returned an in-stream error";
-          if (hasEmittedContentStart) {
-            yield* closeActiveContentBlock();
-          }
-          if (hasEmittedThinkingStart && !hasClosedThinking) {
-            yield { type: "content_block_stop", index: contentBlockIndex };
-          }
-          for (const [, toolCall] of activeToolCalls) {
-            if (toolCall.hasStarted) {
-              yield { type: "content_block_stop", index: toolCall.index };
-            }
-          }
-          activeToolCalls.clear();
+          discardActiveToolCalls("in_stream_error");
           const errorPayload = {
             error: {
               message,
@@ -195146,8 +195611,33 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
         }
         const chunkUsage = convertChunkUsage(chunk.usage);
         for (const choice of chunk.choices ?? []) {
-          const delta = choice.delta;
+          const delta = choice.delta ?? {};
+          if (choice.finish_reason != null && (typeof choice.finish_reason !== "string" || !choice.finish_reason.trim())) {
+            throw new Error("Upstream emitted a malformed finish_reason; the response was not committed.");
+          }
+          if (hasProcessedFinishReason) {
+            const hasLateOutput = Object.entries(delta).some(([key, value2]) => {
+              if (key === "role" || value2 == null || value2 === "")
+                return false;
+              if (Array.isArray(value2))
+                return value2.length > 0;
+              if (typeof value2 === "object") {
+                return Object.keys(value2).length > 0;
+              }
+              return true;
+            });
+            if (hasLateOutput) {
+              throw new Error("Upstream emitted assistant output after finish_reason; the late output was not committed.");
+            }
+            continue;
+          }
+          if (activeToolCalls.size > 0 && (delta.reasoning_content != null && delta.reasoning_content !== "" || delta.content != null && delta.content !== "")) {
+            throw new Error("Upstream emitted text after a reserved tool block; the out-of-order response was not committed.");
+          }
           if (delta.reasoning_content != null && delta.reasoning_content !== "") {
+            if (hasClosedThinking || hasEmittedContentStart) {
+              throw new Error("Upstream emitted reasoning after visible text; the out-of-order delta was not committed.");
+            }
             if (!hasEmittedThinkingStart) {
               yield {
                 type: "content_block_start",
@@ -195158,7 +195648,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
             }
             yield {
               type: "content_block_delta",
-              index: hasClosedThinking ? contentBlockIndex - 1 : contentBlockIndex,
+              index: contentBlockIndex,
               delta: {
                 type: "thinking_delta",
                 thinking: delta.reasoning_content
@@ -195189,9 +195679,31 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
             }
             processStreamChunk(streamState, delta.content);
           }
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              let active = activeToolCalls.get(tc.index);
+          const streamedToolCalls = [
+            ...delta.tool_calls ?? []
+          ];
+          if (delta.function_call) {
+            streamedToolCalls.push({
+              index: -1,
+              id: `${messageId}_function_call`,
+              type: "function",
+              function: delta.function_call
+            });
+          }
+          if (streamedToolCalls.length > 0) {
+            for (const tc of streamedToolCalls) {
+              if (tc.id != null && typeof tc.id !== "string" || tc.function?.name != null && typeof tc.function.name !== "string" || tc.function?.arguments != null && typeof tc.function.arguments !== "string") {
+                discardActiveToolCalls("malformed_tool_call_delta");
+                throw new Error("Upstream returned malformed tool call fields; no tool was committed.");
+              }
+              let protocolIndex;
+              try {
+                protocolIndex = resolveProtocolIndex(tc, streamedToolCalls.length);
+              } catch (error41) {
+                discardActiveToolCalls("ambiguous_missing_tool_index");
+                throw error41;
+              }
+              let active = activeToolCalls.get(protocolIndex);
               if (!active) {
                 if (hasEmittedThinkingStart && !hasClosedThinking) {
                   yield {
@@ -195207,40 +195719,52 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
                 active = {
                   id: "",
                   name: "",
-                  index: contentBlockIndex++,
+                  idFragments: [],
+                  nameFragments: [],
+                  index: null,
                   jsonBuffer: "",
+                  ambiguousArgumentFraming: false,
                   emittedJsonLength: 0,
                   normalizeAtStop: false,
                   hasStarted: false,
-                  readyToStart: false
+                  hasStopped: false
                 };
-                activeToolCalls.set(tc.index, active);
+                activeToolCalls.set(protocolIndex, active);
               }
-              if (tc.id && !active.id) {
-                active.id = tc.id;
+              if (tc.id) {
+                active.idFragments.push(tc.id);
               }
               const nameFragment = tc.function?.name;
               if (nameFragment) {
-                active.name = mergeStreamedToolName(active.name, nameFragment);
+                active.nameFragments.push(nameFragment);
               }
               const argumentFragment = tc.function?.arguments;
               if (typeof argumentFragment === "string") {
+                if (argumentFragment.length > 0 && active.jsonBuffer.length > 0 && argumentFragment.startsWith(active.jsonBuffer)) {
+                  active.ambiguousArgumentFraming = true;
+                }
+                if (active.jsonBuffer.length + argumentFragment.length > toolArgumentCharsLimit || totalBufferedToolArgumentChars + argumentFragment.length > toolArgumentCharsLimit) {
+                  discardActiveToolCalls("tool_arguments_limit_exceeded");
+                  throw new Error("Upstream tool arguments exceeded the configured safety limit; no tool was committed.");
+                }
                 active.jsonBuffer += argumentFragment;
+                totalBufferedToolArgumentChars += argumentFragment.length;
                 processStreamChunk(streamState, argumentFragment);
               }
               const thoughtSignature = tc.thought_signature;
-              const extraContent = tc.extra_content ? { ...tc.extra_content } : thoughtSignature ? { google: { thought_signature: thoughtSignature } } : undefined;
-              if (extraContent) {
-                active.extra_content = {
-                  ...active.extra_content ?? {},
-                  ...extraContent
+              let extraContent;
+              if (typeof thoughtSignature === "string" && thoughtSignature) {
+                extraContent = {
+                  google: { thought_signature: thoughtSignature }
                 };
               }
-              if (argumentFragment?.trim()) {
-                active.readyToStart = true;
+              if (tc.extra_content) {
+                extraContent = mergeOpaqueMetadata(extraContent, tc.extra_content);
+              }
+              if (extraContent) {
+                active.extra_content = mergeOpaqueMetadata(active.extra_content, extraContent);
               }
             }
-            yield* flushReadyToolCalls();
           }
           if (choice.finish_reason && !hasProcessedFinishReason) {
             hasProcessedFinishReason = true;
@@ -195252,97 +195776,32 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
             if (hasEmittedContentStart) {
               yield* closeActiveContentBlock();
             }
-            for (const toolCall of activeToolCalls.values()) {
-              canonicalizeFinalToolName(toolCall);
-              if (toolCall.emittedJsonLength === 0) {
-                toolCall.normalizeAtStop = hasToolFieldMapping(toolCall.name);
-              }
-            }
-            const startedBeforeFinish = new Set([...activeToolCalls.values()].filter((toolCall) => toolCall.hasStarted).map((toolCall) => toolCall.index));
-            yield* flushReadyToolCalls(true);
-            for (const [, tc] of activeToolCalls) {
-              const wasStarted = startedBeforeFinish.has(tc.index);
-              if (!tc.hasStarted) {
-                continue;
-              }
-              if (wasStarted && (tc.extra_content || tc.startedName !== tc.name)) {
-                yield {
-                  type: "content_block_start",
-                  index: tc.index,
-                  content_block: {
-                    type: "tool_use",
-                    id: tc.id,
-                    name: tc.name,
-                    input: {},
-                    ...tc.extra_content ? { extra_content: tc.extra_content } : {},
-                    ...tc.extra_content?.google?.thought_signature ? {
-                      signature: (tc.extra_content?.google).thought_signature
-                    } : {}
-                  }
-                };
-              }
-              if (tc.normalizeAtStop) {
-                let partialJson;
-                if (choice.finish_reason === "length") {
-                  partialJson = tc.jsonBuffer;
-                } else {
-                  const repairedStructuredJson = repairPossiblyTruncatedObjectJson(tc.jsonBuffer);
-                  if (repairedStructuredJson) {
-                    partialJson = repairedStructuredJson;
-                  } else {
-                    partialJson = JSON.stringify(normalizeToolArguments(tc.name, tc.jsonBuffer));
-                  }
-                }
-                yield {
-                  type: "content_block_delta",
-                  index: tc.index,
-                  delta: {
-                    type: "input_json_delta",
-                    partial_json: partialJson
-                  }
-                };
-                yield { type: "content_block_stop", index: tc.index };
-                continue;
-              }
-              if (tc.emittedJsonLength < tc.jsonBuffer.length) {
-                yield {
-                  type: "content_block_delta",
-                  index: tc.index,
-                  delta: {
-                    type: "input_json_delta",
-                    partial_json: tc.jsonBuffer.slice(tc.emittedJsonLength)
-                  }
-                };
-                tc.emittedJsonLength = tc.jsonBuffer.length;
-              }
-              let suffixToAdd = "";
-              if (tc.jsonBuffer) {
-                try {
-                  JSON.parse(tc.jsonBuffer);
-                } catch {
-                  const str = tc.jsonBuffer.trimEnd();
-                  for (const combo of JSON_REPAIR_SUFFIXES) {
-                    try {
-                      JSON.parse(str + combo);
-                      suffixToAdd = combo;
-                      break;
-                    } catch {}
+            const isToolFinish = choice.finish_reason === "tool_calls" || choice.finish_reason === "function_call";
+            if (!isToolFinish) {
+              discardActiveToolCalls(`finish_reason:${choice.finish_reason}`);
+            } else {
+              const invalidReasons = [];
+              const finalizedToolCallIds = new Set;
+              for (const toolCall of activeToolCalls.values()) {
+                const invalidReason = finalizeToolCall(toolCall);
+                if (invalidReason)
+                  invalidReasons.push(invalidReason);
+                if (toolCall.id) {
+                  if (finalizedToolCallIds.has(toolCall.id)) {
+                    invalidReasons.push("duplicate_tool_call_id_across_indices");
                   }
+                  finalizedToolCallIds.add(toolCall.id);
                 }
+                toolCall.normalizeAtStop = hasToolFieldMapping(toolCall.name);
               }
-              if (suffixToAdd) {
-                yield {
-                  type: "content_block_delta",
-                  index: tc.index,
-                  delta: {
-                    type: "input_json_delta",
-                    partial_json: suffixToAdd
-                  }
-                };
+              if (activeToolCalls.size === 0 || invalidReasons.length > 0) {
+                discardActiveToolCalls(invalidReasons.length > 0 ? invalidReasons.join(",") : "tool_finish_without_tool_call");
+                throw new Error(`Upstream returned ${choice.finish_reason} with an incomplete or ambiguous tool call; no tool was committed.`);
               }
-              yield { type: "content_block_stop", index: tc.index };
+              yield* flushReadyToolCalls();
+              activeToolCalls.clear();
             }
-            const stopReason = choice.finish_reason === "tool_calls" ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end_turn";
+            const stopReason = choice.finish_reason === "tool_calls" || choice.finish_reason === "function_call" ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end_turn";
             if (choice.finish_reason === "content_filter" || choice.finish_reason === "safety") {
               if (!hasEmittedContentStart) {
                 yield {
@@ -195382,6 +195841,9 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
                 }
               };
             }
+            if (hasEmittedContentStart) {
+              yield* closeActiveContentBlock();
+            }
             lastStopReason = stopReason;
             yield {
               type: "message_delta",
@@ -195402,9 +195864,19 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, a
           hasEmittedFinalUsage = true;
         }
       }
+      if (sawDoneMarker)
+        break;
     }
+  } catch (error41) {
+    yield* closeOpenBlocksForFailure();
+    throw error41;
   } finally {
-    reader.releaseLock();
+    await pendingReaderCancellation;
+    try {
+      reader.releaseLock();
+    } catch (releaseError) {
+      logForDebugging(`Failed to release OpenAI stream reader after cancellation: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`, { level: "warn" });
+    }
   }
   const stats = getStreamStats(streamState);
   if (stats.totalChunks > 0) {
@@ -196010,6 +196482,10 @@ class OpenAIShimMessages {
   }
   _convertNonStreamingResponse(data, model2, advertisedToolNames = []) {
     const choice = data.choices?.[0];
+    const toolArgumentCharsLimit = maxBufferedToolArgumentChars2();
+    if (!choice || typeof choice.finish_reason !== "string" || !choice.finish_reason.trim()) {
+      throw new Error("Upstream non-streaming response ended without a terminal choice; no output was committed.");
+    }
     const content = [];
     const reasoningText = choice?.message?.reasoning_content;
     if (typeof reasoningText === "string" && reasoningText) {
@@ -196037,8 +196513,34 @@ class OpenAIShimMessages {
         });
       }
     }
-    if (choice?.message?.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
+    const isToolFinish = choice?.finish_reason === "tool_calls" || choice?.finish_reason === "function_call";
+    const completedToolCalls = [
+      ...choice?.message?.tool_calls ?? [],
+      ...choice?.message?.function_call ? [
+        {
+          id: `${data.id ?? makeMessageId2()}_function_call`,
+          function: choice.message.function_call
+        }
+      ] : []
+    ];
+    if (isToolFinish) {
+      if (completedToolCalls.length === 0) {
+        throw new Error("Upstream returned a tool finish reason without a tool call; no tool was committed.");
+      }
+      const completedToolCallIds = new Set;
+      let completedToolArgumentChars = 0;
+      for (const tc of completedToolCalls) {
+        const resolvedToolName = typeof tc.function?.name === "string" ? resolveToolNameByUniquePrefix(advertisedToolNames, tc.function.name) : undefined;
+        if (typeof tc.id !== "string" || !tc.id.trim() || typeof tc.function?.name !== "string" || !tc.function.name.trim() || typeof tc.function?.arguments !== "string" || tc.function.arguments.length > toolArgumentCharsLimit || advertisedToolNames.length > 0 && !resolvedToolName || hasInvalidToolArguments(tc.function.arguments, resolvedToolName ?? tc.function.name) || completedToolCallIds.has(tc.id)) {
+          throw new Error("Upstream returned malformed, incomplete, or duplicate tool calls; no tool was committed.");
+        }
+        completedToolArgumentChars += tc.function.arguments.length;
+        if (completedToolArgumentChars > toolArgumentCharsLimit) {
+          throw new Error("Upstream tool arguments exceeded the configured safety limit; no tool was committed.");
+        }
+        completedToolCallIds.add(tc.id);
+      }
+      for (const tc of completedToolCalls) {
         const toolName = resolveToolNameByUniquePrefix(advertisedToolNames, tc.function.name) ?? tc.function.name;
         const input = normalizeToolArguments(toolName, tc.function.arguments);
         content.push({
@@ -196047,11 +196549,20 @@ class OpenAIShimMessages {
           name: toolName,
           input,
           ...tc.extra_content ? { extra_content: tc.extra_content } : {},
-          ...tc.extra_content?.google?.thought_signature ? { signature: tc.extra_content.google.thought_signature } : {}
+          ...tc.extra_content?.google?.thought_signature ? {
+            signature: (tc.extra_content?.google).thought_signature
+          } : {}
         });
       }
+    } else if (completedToolCalls.length > 0) {
+      logForDebugging(JSON.stringify({
+        type: "discarded_uncommitted_tool_calls",
+        model: model2,
+        reason: `finish_reason:${choice?.finish_reason ?? "missing"}`,
+        count: completedToolCalls.length
+      }), { level: "warn" });
     }
-    const stopReason = choice?.finish_reason === "tool_calls" ? "tool_use" : choice?.finish_reason === "length" ? "max_tokens" : "end_turn";
+    const stopReason = choice?.finish_reason === "tool_calls" || choice?.finish_reason === "function_call" ? "tool_use" : choice?.finish_reason === "length" ? "max_tokens" : "end_turn";
     if (choice?.finish_reason === "content_filter" || choice?.finish_reason === "safety") {
       content.push({
         type: "text",
@@ -196093,7 +196604,7 @@ function createOpenAIShimClient(options2) {
     messages: beta.messages
   };
 }
-var GITHUB_429_MAX_RETRIES = 3, GITHUB_429_BASE_DELAY_SEC = 1, GITHUB_429_MAX_DELAY_SEC = 32, GEMINI_API_HOST = "generativelanguage.googleapis.com", VERBOO_SESSION_HEADER = "X-Verboo-Session-Id", COPILOT_HEADERS2, JSON_REPAIR_SUFFIXES, routerStatusHandler = null, routerStatusHandlerGeneration = 0, activeWarmingHints, OpenAIShimStream;
+var GITHUB_429_MAX_RETRIES = 3, GITHUB_429_BASE_DELAY_SEC = 1, GITHUB_429_MAX_DELAY_SEC = 32, GEMINI_API_HOST = "generativelanguage.googleapis.com", VERBOO_SESSION_HEADER = "X-Verboo-Session-Id", COPILOT_HEADERS2, DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS2, routerStatusHandler = null, routerStatusHandlerGeneration = 0, activeWarmingHints, OpenAIShimStream;
 var init_openaiShim = __esm(() => {
   init_sdk();
   init_Tool();
@@ -196127,18 +196638,7 @@ var init_openaiShim = __esm(() => {
     "Editor-Plugin-Version": "copilot-chat/0.26.7",
     "Copilot-Integration-Id": "vscode-chat"
   };
-  JSON_REPAIR_SUFFIXES = [
-    "}",
-    '"}',
-    "]}",
-    '"]}',
-    "}}",
-    '"}}',
-    "]}}",
-    '"]}}',
-    '"]}]}',
-    "}]}"
-  ];
+  DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS2 = 64 * 1024 * 1024;
   activeWarmingHints = new Set;
   OpenAIShimStream = class OpenAIShimStream {
     generator;
@@ -391284,7 +391784,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-08-18T16:18:48.339Z").getTime();
+  const buildTime = new Date("2026-08-25T17:16:19.335Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -405590,7 +406090,7 @@ function normalizeContentFromAPI(contentBlocks, tools, agentId) {
           normalizedInput = contentBlock.input;
         }
         const resolvedTool = findToolByNameOrUniquePrefix(tools, contentBlock.name);
-        const normalizedToolName = resolvedTool && resolvedTool.name !== contentBlock.name && !resolvedTool.aliases?.includes(contentBlock.name) && resolvedTool.name.startsWith(contentBlock.name) ? resolvedTool.name : contentBlock.name;
+        const normalizedToolName = resolvedTool && resolvedTool.name !== contentBlock.name && !resolvedTool.aliases?.includes(contentBlock.name) && resolvedTool.name.toLowerCase().startsWith(contentBlock.name.toLowerCase()) ? resolvedTool.name : contentBlock.name;
         if (typeof normalizedInput === "object" && normalizedInput !== null) {
           if (resolvedTool) {
             try {
@@ -405766,6 +406266,7 @@ function handleMessageFromStream(message, onMessage2, onUpdateLength, onSetStrea
       }
       if (isSyntheticApiErrorMessage(message)) {
         onSetStreamMode("tool-use");
+        onStreamingToolUses(() => []);
       }
     }
     onStreamingText?.(() => null);
@@ -405777,6 +406278,7 @@ function handleMessageFromStream(message, onMessage2, onUpdateLength, onSetStrea
     return;
   }
   if (message.event.type === "message_start") {
+    onStreamingToolUses(() => []);
     if (message.ttftMs != null) {
       onApiMetrics?.({ ttftMs: message.ttftMs });
     }
@@ -405802,14 +406304,28 @@ function handleMessageFromStream(message, onMessage2, onUpdateLength, onSetStrea
           onSetStreamMode("tool-input");
           const contentBlock = message.event.content_block;
           const index = message.event.index;
-          onStreamingToolUses((_) => [
-            ..._,
-            {
-              index,
-              contentBlock,
-              unparsedToolInput: ""
+          onStreamingToolUses((current) => {
+            const exactMatchIndex = current.findIndex((toolUse) => toolUse.index === index && toolUse.contentBlock.id === contentBlock.id);
+            if (exactMatchIndex !== -1) {
+              return current.map((toolUse, currentIndex) => currentIndex === exactMatchIndex ? { ...toolUse, contentBlock } : toolUse);
+            }
+            const reusedIndex = current.findIndex((toolUse) => toolUse.index === index);
+            if (reusedIndex !== -1) {
+              return current.map((toolUse, currentIndex) => currentIndex === reusedIndex ? {
+                index,
+                contentBlock,
+                unparsedToolInput: ""
+              } : toolUse);
             }
-          ]);
+            return [
+              ...current,
+              {
+                index,
+                contentBlock,
+                unparsedToolInput: ""
+              }
+            ];
+          });
           return;
         }
         case "server_tool_use":
@@ -405844,13 +406360,10 @@ function handleMessageFromStream(message, onMessage2, onUpdateLength, onSetStrea
             if (!element) {
               return _;
             }
-            return [
-              ..._.filter((_2) => _2 !== element),
-              {
-                ...element,
-                unparsedToolInput: element.unparsedToolInput + delta
-              }
-            ];
+            return _.map((toolUse) => toolUse === element ? {
+              ...toolUse,
+              unparsedToolInput: toolUse.unparsedToolInput + delta
+            } : toolUse);
           });
           return;
         }
@@ -410827,6 +411340,15 @@ import { mkdir as mkdir26 } from "fs/promises";
 import { createServer as createServer4 } from "http";
 import { join as join100 } from "path";
 import { parse as parse13 } from "url";
+function getRefreshCredentialInvalidationScope(error42) {
+  if (error42 instanceof InvalidClientError || error42 instanceof UnauthorizedClientError) {
+    return "all";
+  }
+  if (error42 instanceof InvalidGrantError) {
+    return "tokens";
+  }
+  return;
+}
 function redactSensitiveUrlParams(url3) {
   try {
     const parsedUrl = new URL(url3);
@@ -411633,7 +412155,7 @@ class ClaudeAuthProvider {
     const storage3 = getSecureStorage();
     const data = await storage3.readAsync();
     const serverKey = getServerKey(this.serverName, this.serverConfig);
-    const tokenData = data?.mcpOAuth?.[serverKey];
+    let tokenData = data?.mcpOAuth?.[serverKey];
     if (isXaaEnabled() && this.serverConfig.oauth?.xaa && !tokenData?.refreshToken && (!tokenData?.accessToken || (tokenData.expiresAt - Date.now()) / 1000 <= 300)) {
       if (!this._refreshInProgress) {
         logMCPDebug(this.serverName, tokenData ? `XAA: access_token expiring, attempting silent exchange` : `XAA: no access_token yet, attempting silent exchange`);
@@ -411678,22 +412200,31 @@ class ClaudeAuthProvider {
           logMCPDebug(this.serverName, `Token refreshed successfully`);
           return refreshed;
         }
-        logMCPDebug(this.serverName, `Token refresh failed, returning current tokens`);
+        logMCPDebug(this.serverName, `Token refresh did not return new tokens; checking stored credentials`);
+        tokenData = (await storage3.readAsync())?.mcpOAuth?.[serverKey];
+        if (!tokenData?.accessToken) {
+          logMCPDebug(this.serverName, `Refresh invalidated stored credentials; authorization required`);
+          return;
+        }
       } catch (error42) {
         logMCPDebug(this.serverName, `Token refresh error: ${errorMessage(error42)}`);
       }
     }
+    if (!tokenData) {
+      return;
+    }
+    const currentExpiresIn = (tokenData.expiresAt - Date.now()) / 1000;
     const tokens = {
       access_token: tokenData.accessToken,
       refresh_token: needsStepUp ? undefined : tokenData.refreshToken,
-      expires_in: expiresIn,
+      expires_in: currentExpiresIn,
       scope: tokenData.scope,
       token_type: "Bearer"
     };
     logMCPDebug(this.serverName, `Returning tokens`);
     logMCPDebug(this.serverName, `Token length: ${tokens.access_token?.length}`);
     logMCPDebug(this.serverName, `Has refresh token: ${!!tokens.refresh_token}`);
-    logMCPDebug(this.serverName, `Expires in: ${Math.floor(expiresIn)}s`);
+    logMCPDebug(this.serverName, `Expires in: ${Math.floor(currentExpiresIn)}s`);
     return tokens;
   }
   async saveTokens(tokens) {
@@ -412070,8 +412601,10 @@ class ClaudeAuthProvider {
         emitRefreshEvent("failure", "no_tokens_returned");
         return;
       } catch (error42) {
-        if (error42 instanceof InvalidGrantError) {
-          logMCPDebug(this.serverName, `Token refresh failed with invalid_grant: ${error42.message}`);
+        const invalidationScope = getRefreshCredentialInvalidationScope(error42);
+        if (invalidationScope) {
+          const clientRegistrationInvalid = invalidationScope === "all";
+          logMCPDebug(this.serverName, clientRegistrationInvalid ? `Token refresh rejected the OAuth client (${error42 instanceof OAuthError ? error42.errorCode : "invalid_client"}): ${errorMessage(error42)}` : `Token refresh failed with invalid_grant: ${errorMessage(error42)}`);
           clearKeychainCache();
           const storage3 = getSecureStorage();
           const data = storage3.read();
@@ -412090,9 +412623,9 @@ class ClaudeAuthProvider {
               };
             }
           }
-          logMCPDebug(this.serverName, `No valid tokens in storage, clearing stored tokens`);
-          await this.invalidateCredentials("tokens");
-          emitRefreshEvent("failure", "invalid_grant");
+          logMCPDebug(this.serverName, clientRegistrationInvalid ? `No valid tokens in storage, clearing the stale OAuth client registration` : `No valid tokens in storage, clearing stored tokens`);
+          await this.invalidateCredentials(invalidationScope);
+          emitRefreshEvent("failure", clientRegistrationInvalid ? "invalid_client" : "invalid_grant");
           return;
         }
         const isTimeoutError = error42 instanceof Error && /timeout|timed out|etimedout|econnreset/i.test(error42.message);
@@ -433087,7 +433620,7 @@ function buildPrimarySection() {
   });
   return [{
     label: "Version",
-    value: "0.15.16"
+    value: "0.15.17"
   }, {
     label: "Session name",
     value: nameValue
@@ -447017,7 +447550,7 @@ function getReleaseTagUrl(version2 = publicBuildVersion) {
   return `${VERBOO_RELEASES_URL}/tag/v${normalizePublicVersion(version2)}`;
 }
 function getPublicBuildVersion() {
-  return "0.15.16";
+  return "0.15.17";
 }
 var import_semver10, VERBOO_RELEASES_URL = "https://github.com/verbeux-ai/code/releases", fallbackBuildVersion, publicBuildVersion;
 var init_version = __esm(() => {
@@ -474015,7 +474548,7 @@ var import_react_compiler_runtime198, React97, import_react155, jsx_runtime267,
     const msg_1 = createAssistantMessage({
       content: [streamingToolUse.contentBlock]
     });
-    msg_1.uuid = deriveUUID(streamingToolUse.contentBlock.id, 0);
+    msg_1.uuid = deriveUUID(streamingToolUse.contentBlock.id, streamingToolUse.index);
     return normalizeMessages([msg_1]);
   }), [streamingToolUsesWithoutInProgress]);
   const isTranscriptMode = screen === "transcript";
@@ -498411,7 +498944,7 @@ var init_bridge_kick = __esm(() => {
 var call66 = async () => {
   return {
     type: "text",
-    value: `${"99.0.0"} (built ${"2026-08-18T16:18:48.339Z"})`
+    value: `${"99.0.0"} (built ${"2026-08-25T17:16:19.335Z"})`
   };
 }, version2, version_default;
 var init_version2 = __esm(() => {
@@ -500233,6 +500766,8 @@ var init_verbooInChrome = __esm(() => {
   VERBOO_IN_CHROME_TOOL_NAMES = [
     "navigate",
     "read_page",
+    "find",
+    "extract_page_content",
     "structured_extract",
     "click",
     "type",
@@ -522147,7 +522682,7 @@ function printStartupScreen(modelOverride) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
   const cwd2 = process.cwd();
   const displayCwd = home && cwd2.startsWith(home) ? `~${cwd2.slice(home.length)}` : cwd2;
-  const version3 = "0.15.16";
+  const version3 = "0.15.17";
   const columns = process.stdout.columns ?? STARTUP_DEFAULT_COLUMNS;
   process.stdout.write(renderStartupScreen(p, version3, displayCwd, columns));
 }
@@ -541376,7 +541911,7 @@ var init_routerRateLimitHook = __esm(() => {
 function getSemverPart(version3) {
   return `${import_semver13.major(version3, { loose: true })}.${import_semver13.minor(version3, { loose: true })}.${import_semver13.patch(version3, { loose: true })}`;
 }
-function useUpdateNotification(updatedVersion, initialVersion = "0.15.16") {
+function useUpdateNotification(updatedVersion, initialVersion = "0.15.17") {
   const [lastNotifiedSemver, setLastNotifiedSemver] = import_react226.useState(() => getSemverPart(initialVersion));
   const [pendingNotification2, setPendingNotification] = import_react226.useState(null);
   if (updatedVersion) {
@@ -541416,7 +541951,7 @@ function AutoUpdater({
       return;
     }
     if (false) {}
-    const currentVersion = "0.15.16";
+    const currentVersion = "0.15.17";
     const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
     let latestVersion = await getLatestVersion(channel2);
     const isDisabled = isAutoUpdaterDisabled();
@@ -541769,17 +542304,17 @@ function PackageManagerAutoUpdater(t0) {
       const maxVersion = await getMaxVersion();
       if (maxVersion && latest && gt(latest, maxVersion)) {
         logForDebugging(`PackageManagerAutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latest} to ${maxVersion}`);
-        if (gte("0.15.16", maxVersion)) {
-          logForDebugging(`PackageManagerAutoUpdater: current version ${"0.15.16"} is already at or above maxVersion ${maxVersion}, skipping update`);
+        if (gte("0.15.17", maxVersion)) {
+          logForDebugging(`PackageManagerAutoUpdater: current version ${"0.15.17"} is already at or above maxVersion ${maxVersion}, skipping update`);
           setUpdateAvailable(false);
           return;
         }
         latest = maxVersion;
       }
-      const hasUpdate = latest && !gte("0.15.16", latest) && !shouldSkipVersion(latest);
+      const hasUpdate = latest && !gte("0.15.17", latest) && !shouldSkipVersion(latest);
       setUpdateAvailable(!!hasUpdate);
       if (hasUpdate) {
-        logForDebugging(`PackageManagerAutoUpdater: Update available ${"0.15.16"} -> ${latest}`);
+        logForDebugging(`PackageManagerAutoUpdater: Update available ${"0.15.17"} -> ${latest}`);
       }
     };
     $2[0] = t1;
@@ -541813,7 +542348,7 @@ function PackageManagerAutoUpdater(t0) {
       wrap: "truncate",
       children: [
         "currentVersion: ",
-        "0.15.16"
+        "0.15.17"
       ]
     });
     $2[3] = verbose;
@@ -557503,10 +558038,10 @@ async function autoUpdateCliInBackground() {
       return;
     const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
     const latest = await getLatestVersion(channel2);
-    if (!latest || gte("0.15.16", latest))
+    if (!latest || gte("0.15.17", latest))
       return;
     writeToStdout(`
-Nova versão disponível: ${latest} (atual: ${"0.15.16"})
+Nova versão disponível: ${latest} (atual: ${"0.15.17"})
 `);
     writeToStdout(`Atualizando automaticamente...
 `);
@@ -574944,7 +575479,7 @@ var init_ApproveApiKey = __esm(() => {
 
 // src/components/LogoV2/WelcomeV2.tsx
 function WelcomeV2() {
-  const version3 = "0.15.16";
+  const version3 = "0.15.17";
   return /* @__PURE__ */ jsx_runtime476.jsxs(ThemedBox_default, {
     flexDirection: "column",
     marginY: 1,
@@ -593892,7 +594427,7 @@ __export(exports_update, {
 });
 async function update() {
   logEvent("tengu_update_check", {});
-  writeToStdout(`Current version: ${"0.15.16"}
+  writeToStdout(`Current version: ${"0.15.17"}
 `);
   const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
   writeToStdout(`Checking for updates to ${channel2} version...
@@ -593977,8 +594512,8 @@ async function update() {
       writeToStdout(`Verboo Code is managed by Homebrew.
 `);
       const latest = await getLatestVersion(channel2);
-      if (latest && !gte("0.15.16", latest)) {
-        writeToStdout(`Update available: ${"0.15.16"} → ${latest}
+      if (latest && !gte("0.15.17", latest)) {
+        writeToStdout(`Update available: ${"0.15.17"} → ${latest}
 `);
         writeToStdout(`
 `);
@@ -593994,8 +594529,8 @@ async function update() {
       writeToStdout(`Verboo Code is managed by winget.
 `);
       const latest = await getLatestVersion(channel2);
-      if (latest && !gte("0.15.16", latest)) {
-        writeToStdout(`Update available: ${"0.15.16"} → ${latest}
+      if (latest && !gte("0.15.17", latest)) {
+        writeToStdout(`Update available: ${"0.15.17"} → ${latest}
 `);
         writeToStdout(`
 `);
@@ -594011,8 +594546,8 @@ async function update() {
       writeToStdout(`Verboo Code is managed by apk.
 `);
       const latest = await getLatestVersion(channel2);
-      if (latest && !gte("0.15.16", latest)) {
-        writeToStdout(`Update available: ${"0.15.16"} → ${latest}
+      if (latest && !gte("0.15.17", latest)) {
+        writeToStdout(`Update available: ${"0.15.17"} → ${latest}
 `);
         writeToStdout(`
 `);
@@ -594065,11 +594600,11 @@ async function update() {
 `);
         await gracefulShutdown(1);
       }
-      if (result.latestVersion === "0.15.16") {
-        writeToStdout(source_default.green(`Verboo Code is up to date (${"0.15.16"})`) + `
+      if (result.latestVersion === "0.15.17") {
+        writeToStdout(source_default.green(`Verboo Code is up to date (${"0.15.17"})`) + `
 `);
       } else {
-        writeToStdout(source_default.green(`Successfully updated from ${"0.15.16"} to version ${result.latestVersion}`) + `
+        writeToStdout(source_default.green(`Successfully updated from ${"0.15.17"} to version ${result.latestVersion}`) + `
 `);
         await regenerateCompletionCache();
       }
@@ -594129,12 +594664,12 @@ async function update() {
 `);
     await gracefulShutdown(1);
   }
-  if (latestVersion === "0.15.16") {
-    writeToStdout(source_default.green(`Verboo Code is up to date (${"0.15.16"})`) + `
+  if (latestVersion === "0.15.17") {
+    writeToStdout(source_default.green(`Verboo Code is up to date (${"0.15.17"})`) + `
 `);
     await gracefulShutdown(0);
   }
-  writeToStdout(`New version available: ${latestVersion} (current: ${"0.15.16"})
+  writeToStdout(`New version available: ${latestVersion} (current: ${"0.15.17"})
 `);
   writeToStdout(`Installing update...
 `);
@@ -594179,7 +594714,7 @@ async function update() {
   logForDebugging(`update: Installation status: ${status2}`);
   switch (status2) {
     case "success":
-      writeToStdout(source_default.green(`Successfully updated from ${"0.15.16"} to version ${latestVersion}`) + `
+      writeToStdout(source_default.green(`Successfully updated from ${"0.15.17"} to version ${latestVersion}`) + `
 `);
       await regenerateCompletionCache();
       break;
@@ -595518,7 +596053,7 @@ ${chromeSystemPrompt}` : chromeSystemPrompt;
       is_native_binary: isInBundledMode()
     });
     logMemoryDiagnostics("start", {
-      version: "0.15.16",
+      version: "0.15.17",
       debug: debug2,
       debugToStderr,
       print: print ?? false,
@@ -596329,7 +596864,7 @@ Usage: verboo --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version(`0.15.16 (${cliDesc})`, "-v, --version", "Output the version number");
+  }).version(`0.15.17 (${cliDesc})`, "-v, --version", "Output the version number");
   program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
   program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
@@ -596944,7 +597479,7 @@ if (false) {}
 async function main2() {
   const args = process.argv.slice(2);
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
-    console.log(`${"0.15.16"} (Verboo Code)`);
+    console.log(`${"0.15.17"} (Verboo Code)`);
     return;
   }
   if (!IS_VERBOO_CLI && args.includes("--provider")) {
@@ -597118,4 +597653,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=F84B47F82CF95DAE64756E2164756E21
+//# debugId=5CD1B0C278B044C764756E2164756E21