@verboo/code 0.15.15 → 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.15";
+  const version2 = "0.15.17";
   return `verboo-code/${version2}`;
 }
 
@@ -152397,19 +152397,34 @@ function toolMatchesName(tool, name) {
 function findToolByName(tools, name) {
   return tools.find((t) => toolMatchesName(t, name));
 }
-function findToolByNameOrUniquePrefix(tools, name) {
-  const exactMatch = findToolByName(tools, name);
-  if (exactMatch)
-    return exactMatch;
-  if (name.length < 3 || name.startsWith("mcp__"))
+function resolveToolNameByUniquePrefix(toolNames, name) {
+  const uniqueToolNames = [...new Set(toolNames)];
+  if (uniqueToolNames.includes(name))
+    return name;
+  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 = tools.filter((tool) => tool.name.startsWith(name));
-  const oneCharacterCompletions = prefixMatches.filter((tool) => tool.name.length === name.length + 1);
+  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];
   }
   return prefixMatches.length === 1 ? prefixMatches[0] : undefined;
 }
+function findToolByNameOrUniquePrefix(tools, name) {
+  const exactMatch = findToolByName(tools, name);
+  if (exactMatch)
+    return exactMatch;
+  const resolvedName = resolveToolNameByUniquePrefix(tools.map((tool) => tool.name), name);
+  return resolvedName ? tools.find((tool) => tool.name === resolvedName) : undefined;
+}
 function buildTool(def) {
   return {
     ...TOOL_DEFAULTS,
@@ -191373,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();
@@ -191381,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(),
@@ -191394,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(),
@@ -192802,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);
 }
@@ -193164,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;
       }
-      yield { event, data };
+      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;
+      }
+    }
+  } 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;
@@ -193253,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;
     }
   }
@@ -193263,22 +193419,30 @@ async function collectCodexCompletedResponse(response, signal) {
   }
   return completedResponse;
 }
-async function* codexStreamToAnthropic(response, model2, signal) {
+async function* codexStreamToAnthropic(response, model2, signal, advertisedToolNames = []) {
   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
@@ -193287,9 +193451,8 @@ async function* codexStreamToAnthropic(response, model2, signal) {
     }
     yield {
       type: "content_block_stop",
-      index: activeTextBlockIndex
+      index: textBlockIndex
     };
-    activeTextBlockIndex = null;
   };
   const startTextBlockIfNeeded = async function* () {
     if (activeTextBlockIndex !== null)
@@ -193301,6 +193464,129 @@ async function* codexStreamToAnthropic(response, model2, signal) {
       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)
+        continue;
+      const itemId = String(candidate);
+      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 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;
+  };
+  const applyFinalToolItem = (toolBlock, item) => {
+    if (typeof item.name === "string" && item.name) {
+      toolBlock.name = item.name;
+    }
+    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);
+  };
+  const emitPendingToolArguments = async function* (toolBlock) {
+    if (!toolBlock.hasStarted || toolBlock.emittedArgumentsLength >= toolBlock.argumentsBuffer.length) {
+      return;
+    }
+    yield {
+      type: "content_block_delta",
+      index: toolBlock.index,
+      delta: {
+        type: "input_json_delta",
+        partial_json: toolBlock.argumentsBuffer.slice(toolBlock.emittedArgumentsLength)
+      }
+    };
+    toolBlock.emittedArgumentsLength = toolBlock.argumentsBuffer.length;
+  };
+  const startToolBlock = async function* (toolBlock) {
+    if (toolBlock.hasStarted)
+      return;
+    canonicalizeFinalToolName(toolBlock);
+    toolBlock.hasStarted = true;
+    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);
+  };
+  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) {
+        if (!toolBlock.isDone)
+          break;
+        yield* startToolBlock(toolBlock);
+        if (!toolBlock.hasStarted)
+          break;
+      }
+      yield* emitPendingToolArguments(toolBlock);
+      if (toolBlock.isDone) {
+        toolBlock.hasStopped = true;
+        yield {
+          type: "content_block_stop",
+          index: toolBlock.index
+        };
+      }
+    }
+  };
+  const removeStoppedToolBlocks = () => {
+    for (const [itemId, toolBlock] of toolBlocksByItemId) {
+      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: {
@@ -193314,124 +193600,244 @@ async function* codexStreamToAnthropic(response, model2, signal) {
       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();
-        const blockIndex = nextContentBlockIndex++;
-        const toolUseId = item.call_id ?? item.id ?? `call_${blockIndex}`;
-        toolBlocksByItemId.set(String(item.id ?? toolUseId), {
-          index: blockIndex,
-          toolUseId
-        });
-        sawToolUse = true;
-        yield {
-          type: "content_block_start",
-          index: blockIndex,
-          content_block: {
-            type: "tool_use",
-            id: toolUseId,
-            name: item.name ?? "tool",
-            input: {}
-          }
-        };
-        if (item.arguments) {
-          yield {
-            type: "content_block_delta",
+  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,
-            delta: {
-              type: "input_json_delta",
-              partial_json: item.arguments
-            }
+            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;
       }
-      continue;
-    }
-    if (event.event === "response.content_part.added") {
-      if (payload.part?.type === "output_text") {
+      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;
       }
-      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
-            }
-          };
+      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;
       }
-      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 (event.event === "response.function_call_arguments.delta") {
-      const toolBlock = toolBlocksByItemId.get(String(payload.item_id ?? ""));
-      if (toolBlock) {
+    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: toolBlock.index,
-          delta: {
-            type: "input_json_delta",
-            partial_json: payload.delta ?? ""
-          }
+          index: activeTextBlockIndex,
+          delta: { type: "text_delta", text: missingSuffix }
         };
       }
-      continue;
+      yield* closeActiveTextBlock();
     }
-    if (event.event === "response.output_item.done") {
-      const item = payload.item;
-      if (item?.type === "function_call") {
-        const toolBlock = toolBlocksByItemId.get(String(item.id ?? ""));
-        if (toolBlock) {
-          yield {
-            type: "content_block_stop",
-            index: toolBlock.index
-          };
-          toolBlocksByItemId.delete(String(item.id));
-        }
-      } else if (item?.type === "message") {
-        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);
       }
-      continue;
+      let toolBlockEntry = findToolBlockEntry(item);
+      if (!toolBlockEntry) {
+        const blockIndex = nextContentBlockIndex++;
+        const { toolUseId } = parseCompletedCodexTool(item);
+        const toolBlock = {
+          index: blockIndex,
+          toolUseId,
+          name: "",
+          argumentsBuffer: "",
+          emittedArgumentsLength: 0,
+          hasStarted: false,
+          isDone: false,
+          hasStopped: false
+        };
+        const itemKey = String(item.id ?? item.call_id ?? toolUseId);
+        toolBlocksByItemId.set(itemKey, toolBlock);
+        toolBlockEntry = [itemKey, toolBlock];
+      }
+      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);
+      }
+      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);
+      }
+      completedToolCallIds.add(toolBlockEntry[1].toolUseId);
+      toolBlockEntry[1].isDone = true;
+      completedToolBlocks.add(toolBlockEntry[1]);
     }
-    if (event.event === "response.completed" || event.event === "response.incomplete") {
-      finalResponse = payload.response;
-      break;
+    let authoritativeToolOffset = 0;
+    for (const toolBlock of completedToolBlocks) {
+      toolBlock.index = firstFinalToolIndex + authoritativeToolOffset++;
     }
-    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);
+    if (completedToolBlocks.size > 0) {
+      nextContentBlockIndex = firstFinalToolIndex + completedToolBlocks.size;
     }
-  }
-  yield* closeActiveTextBlock();
-  for (const toolBlock of toolBlocksByItemId.values()) {
+    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: "content_block_stop",
-      index: toolBlock.index
+      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 {
-    type: "message_delta",
-    delta: {
-      stop_reason: determineStopReason(finalResponse, sawToolUse),
-      stop_sequence: null
-    },
-    usage: makeUsage(finalResponse?.usage)
-  };
-  yield { type: "message_stop" };
 }
-function convertCodexResponseToAnthropicMessage(data, model2) {
+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) {
@@ -193444,17 +193850,24 @@ function convertCodexResponseToAnthropicMessage(data, model2) {
       }
       continue;
     }
-    if (item?.type === "function_call") {
-      let input;
-      try {
-        input = JSON.parse(item.arguments ?? "{}");
-      } catch {
-        input = { raw: item.arguments ?? "" };
+    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";
+      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(),
-        name: item.name ?? "tool",
+        id: toolUseId,
+        name: toolName,
         input
       });
     }
@@ -193470,13 +193883,16 @@ function convertCodexResponseToAnthropicMessage(data, model2) {
     usage: makeUsage(data.usage)
   };
 }
+var DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS;
 var init_codexShim = __esm(() => {
   init_sdk();
+  init_Tool();
   init_cacheMetrics();
   init_compressToolHistory();
   init_fetchWithProxyRetry();
   init_openaiSchemaSanitizer();
   init_thinkTagSanitizer();
+  DEFAULT_MAX_BUFFERED_TOOL_ARGUMENT_CHARS = 64 * 1024 * 1024;
 });
 
 // src/services/api/visionDelegate.ts
@@ -194718,22 +195134,87 @@ 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 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] : []);
 }
 function setOpenAIShimRouterStatusHandler(fn) {
   if (routerStatusHandler && activeWarmingHints.size > 0) {
@@ -194800,7 +195281,7 @@ function createWarmingHintController(signal) {
   }
   return { schedule, showNow, resolve: resolve19 };
 }
-async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
+async function* openaiStreamToAnthropic(response, model2, signal, warmingHint, advertisedToolNames = []) {
   const messageId = makeMessageId2();
   let contentBlockIndex = 0;
   const activeToolCalls = new Map;
@@ -194811,7 +195292,11 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
   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: {
@@ -194830,9 +195315,11 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
       }
     }
   };
-  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 = (() => {
@@ -194842,32 +195329,61 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
   })();
   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* () {
@@ -194888,6 +195404,149 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
     contentBlockIndex++;
     hasEmittedContentStart = false;
   };
+  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) {
+    if (toolCall.hasStarted || toolCall.index === null || !toolCall.id || !toolCall.name)
+      return;
+    const blockIndex = toolCall.index;
+    toolCall.normalizeAtStop = hasToolFieldMapping(toolCall.name);
+    toolCall.hasStarted = true;
+    yield {
+      type: "content_block_start",
+      index: blockIndex,
+      content_block: {
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.name,
+        input: {},
+        ...toolCall.extra_content ? { extra_content: toolCall.extra_content } : {},
+        ...toolCall.extra_content?.google?.thought_signature ? {
+          signature: (toolCall.extra_content?.google).thought_signature
+        } : {}
+      }
+    };
+    if (!toolCall.normalizeAtStop && toolCall.jsonBuffer) {
+      yield {
+        type: "content_block_delta",
+        index: blockIndex,
+        delta: {
+          type: "input_json_delta",
+          partial_json: toolCall.jsonBuffer
+        }
+      };
+      toolCall.emittedJsonLength = toolCall.jsonBuffer.length;
+    }
+  };
+  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) {
+        yield* startToolCall(toolCall);
+        if (!toolCall.hasStarted) {
+          continue;
+        }
+      }
+      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,
+          delta: {
+            type: "input_json_delta",
+            partial_json: toolCall.jsonBuffer.slice(toolCall.emittedJsonLength)
+          }
+        };
+        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) {
       const { done, value } = await readWithTimeout();
@@ -194901,16 +195560,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
             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) {
-            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;
@@ -194921,15 +195571,23 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
       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") {
@@ -194941,16 +195599,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
         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) {
-            yield { type: "content_block_stop", index: toolCall.index };
-          }
-          activeToolCalls.clear();
+          discardActiveToolCalls("in_stream_error");
           const errorPayload = {
             error: {
               message,
@@ -194962,8 +195611,33 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
         }
         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",
@@ -194974,7 +195648,7 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
             }
             yield {
               type: "content_block_delta",
-              index: hasClosedThinking ? contentBlockIndex - 1 : contentBlockIndex,
+              index: contentBlockIndex,
               delta: {
                 type: "thinking_delta",
                 thinking: delta.reasoning_content
@@ -195005,9 +195679,32 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
             }
             processStreamChunk(streamState, delta.content);
           }
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              if (tc.id && tc.function?.name) {
+          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 {
                     type: "content_block_stop",
@@ -195019,81 +195716,53 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
                 if (hasEmittedContentStart) {
                   yield* closeActiveContentBlock();
                 }
-                const toolBlockIndex = contentBlockIndex;
-                const initialArguments = tc.function.arguments ?? "";
-                const normalizeAtStop = hasToolFieldMapping(tc.function.name);
-                processStreamChunk(streamState, tc.function.arguments ?? "");
-                const topLevelSig = tc.thought_signature;
-                const initEC = tc.extra_content ? { ...tc.extra_content } : topLevelSig ? { google: { thought_signature: topLevelSig } } : undefined;
-                activeToolCalls.set(tc.index, {
-                  id: tc.id,
-                  name: tc.function.name,
-                  index: toolBlockIndex,
-                  jsonBuffer: initialArguments,
-                  normalizeAtStop,
-                  extra_content: initEC
-                });
-                yield {
-                  type: "content_block_start",
-                  index: toolBlockIndex,
-                  content_block: {
-                    type: "tool_use",
-                    id: tc.id,
-                    name: tc.function.name,
-                    input: {},
-                    ...initEC ? { extra_content: initEC } : {},
-                    ...initEC?.google?.thought_signature ? { signature: initEC.google.thought_signature } : {}
-                  }
+                active = {
+                  id: "",
+                  name: "",
+                  idFragments: [],
+                  nameFragments: [],
+                  index: null,
+                  jsonBuffer: "",
+                  ambiguousArgumentFraming: false,
+                  emittedJsonLength: 0,
+                  normalizeAtStop: false,
+                  hasStarted: false,
+                  hasStopped: false
                 };
-                contentBlockIndex++;
-                if (tc.function.arguments && !normalizeAtStop) {
-                  yield {
-                    type: "content_block_delta",
-                    index: toolBlockIndex,
-                    delta: {
-                      type: "input_json_delta",
-                      partial_json: tc.function.arguments
-                    }
-                  };
-                }
-              } else if (tc.function?.arguments) {
-                const active = activeToolCalls.get(tc.index);
-                if (active) {
-                  if (tc.function.arguments) {
-                    active.jsonBuffer += tc.function.arguments;
-                  }
-                  const contSig = tc.thought_signature;
-                  const contEC = tc.extra_content ? { ...tc.extra_content } : contSig ? { google: { thought_signature: contSig } } : undefined;
-                  if (contEC) {
-                    active.extra_content = {
-                      ...active.extra_content ?? {},
-                      ...contEC
-                    };
-                  }
-                  if (active.normalizeAtStop) {
-                    continue;
-                  }
-                  yield {
-                    type: "content_block_delta",
-                    index: active.index,
-                    delta: {
-                      type: "input_json_delta",
-                      partial_json: tc.function.arguments
-                    }
-                  };
+                activeToolCalls.set(protocolIndex, active);
+              }
+              if (tc.id) {
+                active.idFragments.push(tc.id);
+              }
+              const nameFragment = tc.function?.name;
+              if (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;
                 }
-              } else {
-                const active = activeToolCalls.get(tc.index);
-                if (active) {
-                  const lateSig = tc.thought_signature;
-                  const lateEC = tc.extra_content ? { ...tc.extra_content } : lateSig ? { google: { thought_signature: lateSig } } : undefined;
-                  if (lateEC) {
-                    active.extra_content = {
-                      ...active.extra_content ?? {},
-                      ...lateEC
-                    };
-                  }
+                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;
+              let extraContent;
+              if (typeof thoughtSignature === "string" && thoughtSignature) {
+                extraContent = {
+                  google: { thought_signature: thoughtSignature }
+                };
+              }
+              if (tc.extra_content) {
+                extraContent = mergeOpaqueMetadata(extraContent, tc.extra_content);
+              }
+              if (extraContent) {
+                active.extra_content = mergeOpaqueMetadata(active.extra_content, extraContent);
               }
             }
           }
@@ -195107,74 +195776,32 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
             if (hasEmittedContentStart) {
               yield* closeActiveContentBlock();
             }
-            for (const [, tc] of activeToolCalls) {
-              if (tc.extra_content) {
-                yield {
-                  type: "content_block_start",
-                  index: tc.index,
-                  content_block: {
-                    type: "tool_use",
-                    id: tc.id,
-                    name: tc.name,
-                    input: {},
-                    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;
-              }
-              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 {
@@ -195214,6 +195841,9 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
                 }
               };
             }
+            if (hasEmittedContentStart) {
+              yield* closeActiveContentBlock();
+            }
             lastStopReason = stopReason;
             yield {
               type: "message_delta",
@@ -195234,9 +195864,19 @@ async function* openaiStreamToAnthropic(response, model2, signal, warmingHint) {
           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) {
@@ -195303,6 +195943,7 @@ class OpenAIShimMessages {
   }
   create(params, options2) {
     const self2 = this;
+    const advertisedToolNames = getAdvertisedToolNames(params);
     let httpResponse;
     const promise3 = (async () => {
       const request = resolveProviderRequest({
@@ -195323,12 +195964,12 @@ class OpenAIShimMessages {
       httpResponse = response;
       if (params.stream) {
         const isResponsesStream = response.url?.includes("/responses");
-        return new OpenAIShimStream(request.transport === "codex_responses" || request.transport === "responses" || isResponsesStream ? codexStreamToAnthropic(response, request.resolvedModel, options2?.signal) : openaiStreamToAnthropic(response, request.resolvedModel, options2?.signal, warmingHint), warmingHint);
+        return new OpenAIShimStream(request.transport === "codex_responses" || request.transport === "responses" || isResponsesStream ? codexStreamToAnthropic(response, request.resolvedModel, options2?.signal, advertisedToolNames) : openaiStreamToAnthropic(response, request.resolvedModel, options2?.signal, warmingHint, advertisedToolNames), warmingHint);
       }
       warmingHint.resolve();
       if (request.transport === "codex_responses") {
         const data = await collectCodexCompletedResponse(response, options2?.signal);
-        return convertCodexResponseToAnthropicMessage(data, request.resolvedModel);
+        return convertCodexResponseToAnthropicMessage(data, request.resolvedModel, advertisedToolNames);
       }
       const isResponsesNonStream = response.url?.includes("/responses");
       if (request.transport === "responses" || isResponsesNonStream || request.transport === "chat_completions" && isGithubModelsMode()) {
@@ -195336,15 +195977,15 @@ class OpenAIShimMessages {
         if (contentType2.includes("application/json")) {
           const parsed = await response.json();
           if (parsed && typeof parsed === "object" && (("output" in parsed) || ("incomplete_details" in parsed))) {
-            return convertCodexResponseToAnthropicMessage(parsed, request.resolvedModel);
+            return convertCodexResponseToAnthropicMessage(parsed, request.resolvedModel, advertisedToolNames);
           }
-          return self2._convertNonStreamingResponse(parsed, request.resolvedModel);
+          return self2._convertNonStreamingResponse(parsed, request.resolvedModel, advertisedToolNames);
         }
       }
       const contentType = response.headers.get("content-type") ?? "";
       if (contentType.includes("application/json")) {
         const data = await response.json();
-        return self2._convertNonStreamingResponse(data, request.resolvedModel);
+        return self2._convertNonStreamingResponse(data, request.resolvedModel, advertisedToolNames);
       }
       const textBody = await response.text().catch(() => "");
       throw APIError.generate(response.status, undefined, `OpenAI API error ${response.status}: unexpected response: ${textBody.slice(0, 500)}`, response.headers);
@@ -195839,8 +196480,12 @@ class OpenAIShimMessages {
     }
     throw APIError.generate(500, undefined, "OpenAI shim: request loop exited unexpectedly", new Headers);
   }
-  _convertNonStreamingResponse(data, model2) {
+  _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) {
@@ -195868,20 +196513,56 @@ class OpenAIShimMessages {
         });
       }
     }
-    if (choice?.message?.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
-        const input = normalizeToolArguments(tc.function.name, tc.function.arguments);
+    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({
           type: "tool_use",
           id: tc.id,
-          name: tc.function.name,
+          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",
@@ -195923,9 +196604,10 @@ 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();
   init_state();
   init_oauth();
   init_codexCredentials();
@@ -195956,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;
@@ -297859,7 +298530,7 @@ async function* runTools(toolUseMessages, assistantMessages, canUseTool, toolUse
 }
 function partitionToolCalls(toolUseMessages, toolUseContext) {
   return toolUseMessages.reduce((acc, toolUse) => {
-    const tool = findToolByName(toolUseContext.options.tools, toolUse.name);
+    const tool = findToolByNameOrUniquePrefix(toolUseContext.options.tools, toolUse.name);
     const parsedInput = tool?.inputSchema.safeParse(toolUse.input);
     const isConcurrencySafe = parsedInput?.success ? (() => {
       try {
@@ -298044,7 +298715,7 @@ async function* handleOrphanedPermission(orphanedPermission, tools, mutableMessa
   }
   const toolName = toolUseBlock.name;
   const toolInput = toolUseBlock.input;
-  const toolDefinition = findToolByName(tools, toolName);
+  const toolDefinition = findToolByNameOrUniquePrefix(tools, toolName);
   if (!toolDefinition) {
     return;
   }
@@ -300196,7 +300867,7 @@ function getToolSearchOrReadInfo(toolName, toolInput, tools) {
       isAbsorbedSilently: true
     };
   }
-  const tool = findToolByName(tools, toolName) ?? findToolByName(getReplPrimitiveTools(), toolName);
+  const tool = findToolByNameOrUniquePrefix(tools, toolName) ?? findToolByNameOrUniquePrefix(getReplPrimitiveTools(), toolName);
   if (!tool?.isSearchOrReadCommand) {
     return {
       isCollapsible: false,
@@ -300775,7 +301446,7 @@ function getProgressUpdate(tracker) {
 }
 function createActivityDescriptionResolver(tools) {
   return (toolName, input) => {
-    const tool = findToolByName(tools, toolName);
+    const tool = findToolByNameOrUniquePrefix(tools, toolName);
     return tool?.getActivityDescription?.(input) ?? undefined;
   };
 }
@@ -323064,7 +323735,17 @@ async function resendCardlessTrialCode(accessToken, verificationId) {
 }
 async function isGroupSubscriptionActive(accessToken, groupId, opts = {}) {
   const subscriptions = await fetchSubscriptions(accessToken, opts);
-  return subscriptions.some((sub) => sub.groupId === groupId && (sub.status === "active" || sub.status === "trialing"));
+  return hasGroupSubscriptionEntitlement(subscriptions, groupId, opts.requirement ?? "access");
+}
+function hasGroupSubscriptionEntitlement(subscriptions, groupId, requirement) {
+  return subscriptions.some((subscription) => {
+    if (subscription.groupId !== groupId)
+      return false;
+    if (requirement === "access") {
+      return subscription.status === "active" || subscription.status === "trialing";
+    }
+    return subscription.status === "active" && (subscription.source === "stripe" || subscription.source === "stripe_trial" || subscription.source === "woovi");
+  });
 }
 var httpUrlSchema, checkoutResultSchema, checkoutInputSchema, whatsappProfileSchema, cardlessTrialInputSchema, verificationRequiredSchema, trialActivatedSchema, cardlessTrialResultSchema;
 var init_verbooCheckout = __esm(() => {
@@ -323077,9 +323758,14 @@ var init_verbooCheckout = __esm(() => {
   init_verbooSubscriptions();
   httpUrlSchema = exports_external2.string().url().refine((value) => value.startsWith("https://") || value.startsWith("http://"));
   checkoutResultSchema = exports_external2.discriminatedUnion("mode", [
-    exports_external2.object({ mode: exports_external2.literal("stripe"), url: httpUrlSchema }).passthrough(),
+    exports_external2.object({
+      mode: exports_external2.literal("stripe"),
+      attemptId: exports_external2.string().uuid(),
+      url: httpUrlSchema
+    }).passthrough(),
     exports_external2.object({
       mode: exports_external2.literal("woovi"),
+      attemptId: exports_external2.string().uuid(),
       wooviQrCode: exports_external2.string().min(1),
       wooviSubscriptionId: exports_external2.string().min(1)
     }).passthrough(),
@@ -323320,6 +324006,9 @@ function movePlanFocus(index, direction, count3, columns) {
 function isCurrentLocalTrial(subscription) {
   return subscription?.status === "trialing" && ["trial", "stripe_trial"].includes(subscription.source ?? "");
 }
+function getStripeTrialConversionUrl(subscriptionId, billingInterval) {
+  return `${VERBOO_FRONT_BASE_URL}/pt/settings/billing?subscription=${encodeURIComponent(subscriptionId)}&action=convert&billingInterval=${encodeURIComponent(billingInterval)}`;
+}
 function filterCliPurchasablePlans(groups, subscriptions) {
   const subscriptionsByGroup = new Map(subscriptions.filter((subscription) => ["active", "trialing", "past_due"].includes(subscription.status)).map((subscription) => [subscription.groupId, subscription]));
   return groups.filter((group) => {
@@ -323377,10 +324066,10 @@ function paymentProviderLabel(group) {
   }
 }
 function hasCardlessTrial(group) {
-  return Boolean(group.trialEligible && group.trialDays && group.trialPaymentMethodRequired === false && group.paymentProvider !== "woovi");
+  return Boolean(group.trialEligible && group.trialDays && group.billingInterval === "month" && group.trialPaymentMethodRequired === false && group.paymentProvider !== "woovi");
 }
 function hasCardTrial(group) {
-  return Boolean(group.trialEligible && group.trialDays && group.trialPaymentMethodRequired !== false && group.paymentProvider !== "woovi");
+  return Boolean(group.trialEligible && group.trialDays && group.billingInterval === "month" && group.trialPaymentMethodRequired !== false && group.paymentProvider !== "woovi");
 }
 function getPlanDetailOptions(plan) {
   if (hasCardlessTrial(plan)) {
@@ -323831,12 +324520,15 @@ function PurchaseFlowView({
   const columnCount = getPlanColumnCount(terminalColumns);
   const [step, setStep] = import_react66.useState("splash");
   const [plans, setPlans] = import_react66.useState([]);
+  const [subscriptionsByGroup, setSubscriptionsByGroup] = import_react66.useState(new Map);
   const [selectedPlan, setSelectedPlan] = import_react66.useState(null);
   const [focusIndex, setFocusIndex] = import_react66.useState(0);
   const [inlineMessage, setInlineMessage] = import_react66.useState(null);
   const [flowError, setFlowError] = import_react66.useState(null);
   const [wooviPayment, setWooviPayment] = import_react66.useState(null);
   const [manualCheckoutUrl, setManualCheckoutUrl] = import_react66.useState(null);
+  const [manualEntitlementRequirement, setManualEntitlementRequirement] = import_react66.useState("paid");
+  const [successRequirement, setSuccessRequirement] = import_react66.useState("paid");
   const [whatsappProfile, setWhatsAppProfile] = import_react66.useState(null);
   const [cardlessVerification, setCardlessVerification] = import_react66.useState(null);
   const plansRequestRef = import_react66.default.useRef(null);
@@ -323853,7 +324545,8 @@ function PurchaseFlowView({
     setFlowError({ message, backStep, retryLabel: retry?.label });
     setStep("error");
   }, []);
-  const complete = import_react66.useCallback(() => {
+  const complete = import_react66.useCallback((requirement) => {
+    setSuccessRequirement(requirement);
     setStep("success");
     if (successTimerRef.current)
       clearTimeout(successTimerRef.current);
@@ -323883,6 +324576,7 @@ function PurchaseFlowView({
       if (plansRequestRef.current !== controller)
         return;
       const eligible2 = filterCliPurchasablePlans(groups, subscriptions);
+      setSubscriptionsByGroup(new Map(subscriptions.filter((subscription) => ["active", "trialing", "past_due"].includes(subscription.status)).map((subscription) => [subscription.groupId, subscription])));
       if (eligible2.length === 0) {
         const message = groups.length === 0 ? "Nenhum plano está disponível no momento." : "Não há novos planos compatíveis com a CLI para esta conta.";
         showError(message, "splash", {
@@ -323907,7 +324601,7 @@ function PurchaseFlowView({
         plansRequestRef.current = null;
     }
   }, [accessToken, showError]);
-  const startEntitlementPolling = import_react66.useCallback(async function pollEntitlement(groupId, displayStep = "polling") {
+  const startEntitlementPolling = import_react66.useCallback(async function pollEntitlement(groupId, displayStep = "polling", requirement = "paid") {
     pollingRef.current?.abort();
     const controller = new AbortController;
     pollingRef.current = controller;
@@ -323916,11 +324610,12 @@ function PurchaseFlowView({
     while (!controller.signal.aborted && Date.now() - startedAt < POLL_TIMEOUT_MS) {
       try {
         const active = await isGroupSubscriptionActive(accessToken, groupId, {
-          signal: controller.signal
+          signal: controller.signal,
+          requirement
         });
         if (active) {
           if (pollingRef.current === controller)
-            complete();
+            complete(requirement);
           return;
         }
       } catch (error42) {
@@ -323941,7 +324636,7 @@ function PurchaseFlowView({
     if (pollingRef.current === controller && !controller.signal.aborted) {
       showError("A assinatura foi iniciada, mas os modelos ainda não foram liberados.", "plan-detail", {
         label: "Verificar novamente",
-        run: () => void pollEntitlement(groupId, displayStep)
+        run: () => void pollEntitlement(groupId, displayStep, requirement)
       });
     }
   }, [accessToken, complete, showError]);
@@ -323980,7 +324675,7 @@ function PurchaseFlowView({
         setCardlessVerification(result);
         setStep("whatsapp-code");
       } else {
-        startEntitlementPolling(group.id, "cardless-polling");
+        startEntitlementPolling(group.id, "cardless-polling", "access");
       }
     } catch (error42) {
       const presentation = describePurchaseError(error42, "Não foi possível iniciar o teste sem cartão.");
@@ -324016,7 +324711,7 @@ function PurchaseFlowView({
     try {
       const result = await confirmCardlessTrial(accessToken, cardlessVerification.verificationId, code);
       if (result.mode === "trial_activated") {
-        startEntitlementPolling(group.id, "cardless-polling");
+        startEntitlementPolling(group.id, "cardless-polling", "access");
       } else {
         setCardlessVerification(result);
         setStep("whatsapp-code");
@@ -324064,7 +324759,7 @@ function PurchaseFlowView({
       setStep("whatsapp-code");
     }
   }, [accessToken, cardlessVerification, verificationWaitSeconds]);
-  const handleCheckout = import_react66.useCallback(async function runCheckout(group, paymentMethod, woovi) {
+  const handleCheckout = import_react66.useCallback(async function runCheckout(group, paymentMethod, woovi, requirement = "paid") {
     setInlineMessage(null);
     setStep("checkout");
     try {
@@ -324073,7 +324768,7 @@ function PurchaseFlowView({
         woovi
       });
       if (result.mode === "reactivated") {
-        startEntitlementPolling(group.id);
+        startEntitlementPolling(group.id, "polling", requirement);
         return;
       }
       if (result.mode === "woovi") {
@@ -324085,8 +324780,9 @@ function PurchaseFlowView({
         return;
       }
       setManualCheckoutUrl(result.url);
+      setManualEntitlementRequirement(requirement);
       if (await openBrowser(result.url)) {
-        startEntitlementPolling(group.id);
+        startEntitlementPolling(group.id, "polling", requirement);
       } else {
         setStep("manual-browser");
       }
@@ -324107,7 +324803,7 @@ function PurchaseFlowView({
       }
       if (presentation.code === "already_subscribed" || presentation.code === "manual_access_active") {
         setInlineMessage(presentation.message);
-        startEntitlementPolling(group.id);
+        startEntitlementPolling(group.id, "polling", requirement);
         return;
       }
       if (presentation.code === "payment_method_required" || presentation.code === "payment_method_unavailable") {
@@ -324117,20 +324813,33 @@ function PurchaseFlowView({
       }
       showError(presentation.message, "plan-detail", {
         label: "Tentar checkout novamente",
-        run: () => void runCheckout(group, paymentMethod, woovi)
+        run: () => void runCheckout(group, paymentMethod, woovi, requirement)
       });
     }
   }, [accessToken, fetchPlans, showError, startEntitlementPolling]);
-  const startPaidPurchase = import_react66.useCallback((group) => {
+  const startPaidPurchase = import_react66.useCallback(async (group) => {
     setSelectedPlan(group);
     setInlineMessage(null);
+    const currentSubscription = subscriptionsByGroup.get(group.id);
+    if (currentSubscription?.source === "stripe_trial" && currentSubscription.status === "trialing") {
+      const conversionUrl = getStripeTrialConversionUrl(currentSubscription.id, group.billingInterval);
+      setManualCheckoutUrl(conversionUrl);
+      setManualEntitlementRequirement("paid");
+      setStep("checkout");
+      if (await openBrowser(conversionUrl)) {
+        startEntitlementPolling(group.id, "polling", "paid");
+      } else {
+        setStep("manual-browser");
+      }
+      return;
+    }
     if (group.paymentProvider === "both")
       setStep("payment-method");
     else if (group.paymentProvider === "woovi")
       setStep("woovi-form");
     else
       handleCheckout(group, "stripe");
-  }, [handleCheckout]);
+  }, [handleCheckout, startEntitlementPolling, subscriptionsByGroup]);
   const cancelPlansLoading = import_react66.useCallback(() => {
     plansRequestRef.current?.abort();
     plansRequestRef.current = null;
@@ -324281,7 +324990,7 @@ function PurchaseFlowView({
                         dimColor: true,
                         children: paymentProviderLabel(plan)
                       }),
-                      plan.trialEligible && plan.trialDays ? /* @__PURE__ */ jsx_runtime86.jsxs(ThemedText, {
+                      (hasCardlessTrial(plan) || hasCardTrial(plan)) && plan.trialDays ? /* @__PURE__ */ jsx_runtime86.jsxs(ThemedText, {
                         color: "success",
                         children: [
                           plan.trialDays,
@@ -324347,7 +325056,7 @@ function PurchaseFlowView({
                   paymentProviderLabel(plan)
                 ]
               }),
-              plan.trialEligible && plan.trialDays ? /* @__PURE__ */ jsx_runtime86.jsxs(ThemedText, {
+              (hasCardlessTrial(plan) || hasCardTrial(plan)) && plan.trialDays ? /* @__PURE__ */ jsx_runtime86.jsxs(ThemedText, {
                 color: "success",
                 children: [
                   "Teste: ",
@@ -324368,7 +325077,7 @@ function PurchaseFlowView({
               if (value === "trial")
                 prepareCardlessTrial(plan);
               else if (value === "card-trial")
-                handleCheckout(plan, "stripe");
+                handleCheckout(plan, "stripe", undefined, "access");
               else if (value === "pix")
                 setStep("woovi-form");
               else if (value === "buy")
@@ -324602,7 +325311,7 @@ function PurchaseFlowView({
             ],
             onChange: (value) => {
               if (value === "verify" && selectedPlan) {
-                startEntitlementPolling(selectedPlan.id);
+                startEntitlementPolling(selectedPlan.id, "polling", manualEntitlementRequirement);
               } else if (value === "back")
                 setStep("plan-detail");
               else
@@ -324626,7 +325335,7 @@ function PurchaseFlowView({
     case "success":
       return /* @__PURE__ */ jsx_runtime86.jsx(ThemedText, {
         color: "success",
-        children: "Assinatura confirmada! Modelos disponíveis."
+        children: successRequirement === "access" ? "Trial ativado! Modelos disponíveis." : "Assinatura paga confirmada! Modelos disponíveis."
       });
     case "error":
       return /* @__PURE__ */ jsx_runtime86.jsxs(ThemedBox_default, {
@@ -324698,6 +325407,7 @@ var init_purchaseFlow = __esm(() => {
   init_select();
   init_Spinner2();
   init_TextInput();
+  init_oauth();
   init_useTerminalSize();
   init_ink2();
   init_AppState();
@@ -334198,7 +334908,7 @@ function AssistantToolUseMessage(t0) {
         t1 = null;
         break bb0;
       }
-      const tool = findToolByName(tools, param.name);
+      const tool = findToolByNameOrUniquePrefix(tools, param.name);
       if (!tool) {
         t1 = null;
         break bb0;
@@ -338231,7 +338941,7 @@ function VerboseToolUse(t0) {
   if ($2[0] !== bg || $2[1] !== content.id || $2[2] !== content.input || $2[3] !== content.name || $2[4] !== inProgressToolUseIDs || $2[5] !== lookups || $2[6] !== shouldAnimate || $2[7] !== theme || $2[8] !== tools) {
     t2 = Symbol.for("react.early_return_sentinel");
     bb0: {
-      const tool = findToolByName(tools, content.name) ?? findToolByName(getReplPrimitiveTools(), content.name);
+      const tool = findToolByNameOrUniquePrefix(tools, content.name) ?? findToolByNameOrUniquePrefix(getReplPrimitiveTools(), content.name);
       if (!tool) {
         t2 = null;
         break bb0;
@@ -338912,7 +339622,7 @@ function GroupedToolUseContent({
   inProgressToolUseIDs,
   shouldAnimate
 }) {
-  const tool = findToolByName(tools, message.toolName);
+  const tool = findToolByNameOrUniquePrefix(tools, message.toolName);
   if (!tool?.renderGroupedToolUse) {
     return null;
   }
@@ -340746,7 +341456,7 @@ function useGetToolFromMessages(toolUseID, tools, lookups) {
         t0 = null;
         break bb0;
       }
-      const tool = findToolByName(tools, toolUse.name);
+      const tool = findToolByNameOrUniquePrefix(tools, toolUse.name);
       if (!tool) {
         t0 = null;
         break bb0;
@@ -342406,7 +343116,7 @@ function extractLastToolInfo(progressMessages, tools) {
     if (toolResultBlock?.type === "tool_result") {
       const toolUseBlock = toolUseByID.get(toolResultBlock.tool_use_id);
       if (toolUseBlock) {
-        const tool = findToolByName(tools, toolUseBlock.name);
+        const tool = findToolByNameOrUniquePrefix(tools, toolUseBlock.name);
         if (!tool) {
           return toolUseBlock.name;
         }
@@ -387889,6 +388599,7 @@ class StreamingToolExecutor {
       this.tools.push({
         id: block2.id,
         block: block2,
+        canonicalName: block2.name,
         assistantMessage: assistantMessage2,
         status: "completed",
         isConcurrencySafe: true,
@@ -387921,6 +388632,7 @@ class StreamingToolExecutor {
     this.tools.push({
       id: block2.id,
       block: block2,
+      canonicalName: toolDefinition.name,
       assistantMessage: assistantMessage2,
       status: "queued",
       isConcurrencySafe,
@@ -388013,7 +388725,7 @@ class StreamingToolExecutor {
     return null;
   }
   getToolInterruptBehavior(tool) {
-    const definition = findToolByName(this.toolDefinitions, tool.block.name);
+    const definition = findToolByNameOrUniquePrefix(this.toolDefinitions, tool.canonicalName);
     if (!definition?.interruptBehavior)
       return "block";
     try {
@@ -388027,9 +388739,9 @@ class StreamingToolExecutor {
     const summary = input?.command ?? input?.file_path ?? input?.pattern ?? "";
     if (typeof summary === "string" && summary.length > 0) {
       const truncated = summary.length > 40 ? summary.slice(0, 40) + "…" : summary;
-      return `${tool.block.name}(${truncated})`;
+      return `${tool.canonicalName}(${truncated})`;
     }
-    return tool.block.name;
+    return tool.canonicalName;
   }
   updateInterruptibleState() {
     const executing = this.tools.filter((t) => t.status === "executing");
@@ -388068,7 +388780,7 @@ class StreamingToolExecutor {
         const isErrorResult = update.message.type === "user" && Array.isArray(update.message.message.content) && update.message.message.content.some((_) => _.type === "tool_result" && _.is_error === true);
         if (isErrorResult) {
           thisToolErrored = true;
-          if (tool.block.name === BASH_TOOL_NAME) {
+          if (tool.canonicalName === BASH_TOOL_NAME) {
             this.hasErrored = true;
             this.erroredToolDescription = this.getToolDescription(tool);
             this.siblingAbortController.abort("sibling_error");
@@ -390295,7 +391007,7 @@ async function* queryLoop(params, consumedCommandUuids) {
                 for (let i3 = 0;i3 < message.message.content.length; i3++) {
                   const block2 = message.message.content[i3];
                   if (block2.type === "tool_use" && typeof block2.input === "object" && block2.input !== null) {
-                    const tool = findToolByName(toolUseContext.options.tools, block2.name);
+                    const tool = findToolByNameOrUniquePrefix(toolUseContext.options.tools, block2.name);
                     if (tool?.backfillObservableInput) {
                       const originalInput = block2.input;
                       const inputCopy = { ...originalInput };
@@ -391072,7 +391784,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-08-16T02:41:36.697Z").getTime();
+  const buildTime = new Date("2026-08-25T17:16:19.335Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -405139,7 +405851,7 @@ function normalizeMessagesForAPI(messages, tools = []) {
             ...message.message,
             content: message.message.content.map((block2) => {
               if (block2.type === "tool_use") {
-                const tool = tools.find((t) => toolMatchesName(t, block2.name));
+                const tool = findToolByNameOrUniquePrefix(tools, block2.name);
                 const normalizedInput = tool ? normalizeToolInputForAPI(tool, block2.input) : block2.input;
                 const canonicalName = tool?.name ?? block2.name;
                 if (toolSearchEnabled) {
@@ -405377,11 +406089,12 @@ function normalizeContentFromAPI(contentBlocks, tools, agentId) {
         } else {
           normalizedInput = contentBlock.input;
         }
+        const resolvedTool = findToolByNameOrUniquePrefix(tools, 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) {
-          const tool = findToolByName(tools, contentBlock.name);
-          if (tool) {
+          if (resolvedTool) {
             try {
-              normalizedInput = normalizeToolInput(tool, normalizedInput, agentId);
+              normalizedInput = normalizeToolInput(resolvedTool, normalizedInput, agentId);
             } catch (error42) {
               logError2(new Error("Error normalizing tool input: " + error42));
             }
@@ -405389,6 +406102,7 @@ function normalizeContentFromAPI(contentBlocks, tools, agentId) {
         }
         return {
           ...contentBlock,
+          name: normalizedToolName,
           input: normalizedInput
         };
       }
@@ -405552,6 +406266,7 @@ function handleMessageFromStream(message, onMessage2, onUpdateLength, onSetStrea
       }
       if (isSyntheticApiErrorMessage(message)) {
         onSetStreamMode("tool-use");
+        onStreamingToolUses(() => []);
       }
     }
     onStreamingText?.(() => null);
@@ -405563,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 });
     }
@@ -405588,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":
@@ -405630,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;
         }
@@ -410613,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);
@@ -411419,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`);
@@ -411464,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) {
@@ -411856,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();
@@ -411876,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);
@@ -432873,7 +433620,7 @@ function buildPrimarySection() {
   });
   return [{
     label: "Version",
-    value: "0.15.15"
+    value: "0.15.17"
   }, {
     label: "Session name",
     value: nameValue
@@ -446803,7 +447550,7 @@ function getReleaseTagUrl(version2 = publicBuildVersion) {
   return `${VERBOO_RELEASES_URL}/tag/v${normalizePublicVersion(version2)}`;
 }
 function getPublicBuildVersion() {
-  return "0.15.15";
+  return "0.15.17";
 }
 var import_semver10, VERBOO_RELEASES_URL = "https://github.com/verbeux-ai/code/releases", fallbackBuildVersion, publicBuildVersion;
 var init_version = __esm(() => {
@@ -473801,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";
@@ -473882,7 +474629,7 @@ var import_react_compiler_runtime198, React97, import_react155, jsx_runtime267,
     if (b_0?.type !== "tool_result" || b_0.is_error || !msg_6.toolUseResult)
       return false;
     const name = lookupsRef.current.toolUseByToolUseID.get(b_0.tool_use_id)?.name;
-    const tool = name ? findToolByName(tools, name) : undefined;
+    const tool = name ? findToolByNameOrUniquePrefix(tools, name) : undefined;
     return tool?.isResultTruncated?.(msg_6.toolUseResult) ?? false;
   }, [tools]);
   const canAnimate = (!toolJSX || !!toolJSX.shouldContinueAnimation) && !toolUseConfirmQueue.length && !isMessageSelectorVisible;
@@ -473952,7 +474699,7 @@ var import_react_compiler_runtime198, React97, import_react155, jsx_runtime267,
       const tr = msg_9.message.content.find((b_1) => b_1.type === "tool_result");
       if (tr && "tool_use_id" in tr) {
         const tu = lookups_0.toolUseByToolUseID.get(tr.tool_use_id);
-        const tool_0 = tu && findToolByName(tools, tu.name);
+        const tool_0 = tu && findToolByNameOrUniquePrefix(tools, tu.name);
         const extracted = tool_0?.extractSearchText?.(msg_9.toolUseResult);
         if (extracted !== undefined)
           text_0 = extracted;
@@ -478860,7 +479607,7 @@ var init_ultraplan = __esm(() => {
 
 // src/components/tasks/renderToolActivity.tsx
 function renderToolActivity(activity, tools, theme) {
-  const tool = findToolByName(tools, activity.toolName);
+  const tool = findToolByNameOrUniquePrefix(tools, activity.toolName);
   if (!tool) {
     return activity.toolName;
   }
@@ -498197,7 +498944,7 @@ var init_bridge_kick = __esm(() => {
 var call66 = async () => {
   return {
     type: "text",
-    value: `${"99.0.0"} (built ${"2026-08-16T02:41:36.697Z"})`
+    value: `${"99.0.0"} (built ${"2026-08-25T17:16:19.335Z"})`
   };
 }, version2, version_default;
 var init_version2 = __esm(() => {
@@ -500019,6 +500766,8 @@ var init_verbooInChrome = __esm(() => {
   VERBOO_IN_CHROME_TOOL_NAMES = [
     "navigate",
     "read_page",
+    "find",
+    "extract_page_content",
     "structured_extract",
     "click",
     "type",
@@ -517800,8 +518549,8 @@ async function prepareIfConditionMatcher(hookInput, tools) {
   if (hookInput.hook_event_name !== "PreToolUse" && hookInput.hook_event_name !== "PostToolUse" && hookInput.hook_event_name !== "PostToolUseFailure" && hookInput.hook_event_name !== "PermissionRequest") {
     return;
   }
-  const toolName = normalizeLegacyToolName(hookInput.tool_name);
-  const tool = tools && findToolByName(tools, hookInput.tool_name);
+  const tool = tools && findToolByNameOrUniquePrefix(tools, hookInput.tool_name);
+  const toolName = normalizeLegacyToolName(tool?.name ?? hookInput.tool_name);
   const input = tool?.inputSchema.safeParse(hookInput.tool_input);
   const patternMatcher = input?.success && tool?.preparePermissionMatcher ? await tool.preparePermissionMatcher(input.data) : undefined;
   return (ifCondition) => {
@@ -521933,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.15";
+  const version3 = "0.15.17";
   const columns = process.stdout.columns ?? STARTUP_DEFAULT_COLUMNS;
   process.stdout.write(renderStartupScreen(p, version3, displayCwd, columns));
 }
@@ -541162,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.15") {
+function useUpdateNotification(updatedVersion, initialVersion = "0.15.17") {
   const [lastNotifiedSemver, setLastNotifiedSemver] = import_react226.useState(() => getSemverPart(initialVersion));
   const [pendingNotification2, setPendingNotification] = import_react226.useState(null);
   if (updatedVersion) {
@@ -541202,7 +541951,7 @@ function AutoUpdater({
       return;
     }
     if (false) {}
-    const currentVersion = "0.15.15";
+    const currentVersion = "0.15.17";
     const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
     let latestVersion = await getLatestVersion(channel2);
     const isDisabled = isAutoUpdaterDisabled();
@@ -541555,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.15", maxVersion)) {
-          logForDebugging(`PackageManagerAutoUpdater: current version ${"0.15.15"} 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.15", latest) && !shouldSkipVersion(latest);
+      const hasUpdate = latest && !gte("0.15.17", latest) && !shouldSkipVersion(latest);
       setUpdateAvailable(!!hasUpdate);
       if (hasUpdate) {
-        logForDebugging(`PackageManagerAutoUpdater: Update available ${"0.15.15"} -> ${latest}`);
+        logForDebugging(`PackageManagerAutoUpdater: Update available ${"0.15.17"} -> ${latest}`);
       }
     };
     $2[0] = t1;
@@ -541599,7 +542348,7 @@ function PackageManagerAutoUpdater(t0) {
       wrap: "truncate",
       children: [
         "currentVersion: ",
-        "0.15.15"
+        "0.15.17"
       ]
     });
     $2[3] = verbose;
@@ -556135,7 +556884,7 @@ function useRemoteSession({
       },
       onPermissionRequest: (request, requestId) => {
         logForDebugging(`[useRemoteSession] Permission request for tool: ${request.tool_name}`);
-        const tool = findToolByName(toolsRef.current, request.tool_name) ?? createToolStub(request.tool_name);
+        const tool = findToolByNameOrUniquePrefix(toolsRef.current, request.tool_name) ?? createToolStub(request.tool_name);
         const syntheticMessage = createSyntheticAssistantMessage(request, requestId);
         const permissionResult = {
           behavior: "ask",
@@ -556486,7 +557235,7 @@ function useDirectConnect({
       },
       onPermissionRequest: (request, requestId) => {
         logForDebugging(`[useDirectConnect] Permission request for tool: ${request.tool_name}`);
-        const tool = findToolByName(toolsRef.current, request.tool_name) ?? createToolStub(request.tool_name);
+        const tool = findToolByNameOrUniquePrefix(toolsRef.current, request.tool_name) ?? createToolStub(request.tool_name);
         const syntheticMessage = createSyntheticAssistantMessage(request, requestId);
         const permissionResult = {
           behavior: "ask",
@@ -556636,7 +557385,7 @@ function useSSHSession({
       },
       onPermissionRequest: (request, requestId) => {
         logForDebugging(`[useSSHSession] permission request: ${request.tool_name}`);
-        const tool = findToolByName(toolsRef.current, request.tool_name) ?? createToolStub(request.tool_name);
+        const tool = findToolByNameOrUniquePrefix(toolsRef.current, request.tool_name) ?? createToolStub(request.tool_name);
         const syntheticMessage = createSyntheticAssistantMessage(request, requestId);
         const permissionResult = {
           behavior: "ask",
@@ -557289,10 +558038,10 @@ async function autoUpdateCliInBackground() {
       return;
     const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
     const latest = await getLatestVersion(channel2);
-    if (!latest || gte("0.15.15", latest))
+    if (!latest || gte("0.15.17", latest))
       return;
     writeToStdout(`
-Nova versão disponível: ${latest} (atual: ${"0.15.15"})
+Nova versão disponível: ${latest} (atual: ${"0.15.17"})
 `);
     writeToStdout(`Atualizando automaticamente...
 `);
@@ -560943,7 +561692,7 @@ function useInboxPoller({
         if (!parsed)
           continue;
         if (setToolUseConfirmQueue) {
-          const tool = findToolByName(getAllBaseTools(), parsed.tool_name);
+          const tool = findToolByNameOrUniquePrefix(getAllBaseTools(), parsed.tool_name);
           if (!tool) {
             logForDebugging(`[InboxPoller] Unknown tool ${parsed.tool_name}, skipping permission request`);
             continue;
@@ -574730,7 +575479,7 @@ var init_ApproveApiKey = __esm(() => {
 
 // src/components/LogoV2/WelcomeV2.tsx
 function WelcomeV2() {
-  const version3 = "0.15.15";
+  const version3 = "0.15.17";
   return /* @__PURE__ */ jsx_runtime476.jsxs(ThemedBox_default, {
     flexDirection: "column",
     marginY: 1,
@@ -593678,7 +594427,7 @@ __export(exports_update, {
 });
 async function update() {
   logEvent("tengu_update_check", {});
-  writeToStdout(`Current version: ${"0.15.15"}
+  writeToStdout(`Current version: ${"0.15.17"}
 `);
   const channel2 = getInitialSettings()?.autoUpdatesChannel ?? "latest";
   writeToStdout(`Checking for updates to ${channel2} version...
@@ -593763,8 +594512,8 @@ async function update() {
       writeToStdout(`Verboo Code is managed by Homebrew.
 `);
       const latest = await getLatestVersion(channel2);
-      if (latest && !gte("0.15.15", latest)) {
-        writeToStdout(`Update available: ${"0.15.15"} → ${latest}
+      if (latest && !gte("0.15.17", latest)) {
+        writeToStdout(`Update available: ${"0.15.17"} → ${latest}
 `);
         writeToStdout(`
 `);
@@ -593780,8 +594529,8 @@ async function update() {
       writeToStdout(`Verboo Code is managed by winget.
 `);
       const latest = await getLatestVersion(channel2);
-      if (latest && !gte("0.15.15", latest)) {
-        writeToStdout(`Update available: ${"0.15.15"} → ${latest}
+      if (latest && !gte("0.15.17", latest)) {
+        writeToStdout(`Update available: ${"0.15.17"} → ${latest}
 `);
         writeToStdout(`
 `);
@@ -593797,8 +594546,8 @@ async function update() {
       writeToStdout(`Verboo Code is managed by apk.
 `);
       const latest = await getLatestVersion(channel2);
-      if (latest && !gte("0.15.15", latest)) {
-        writeToStdout(`Update available: ${"0.15.15"} → ${latest}
+      if (latest && !gte("0.15.17", latest)) {
+        writeToStdout(`Update available: ${"0.15.17"} → ${latest}
 `);
         writeToStdout(`
 `);
@@ -593851,11 +594600,11 @@ async function update() {
 `);
         await gracefulShutdown(1);
       }
-      if (result.latestVersion === "0.15.15") {
-        writeToStdout(source_default.green(`Verboo Code is up to date (${"0.15.15"})`) + `
+      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.15"} to version ${result.latestVersion}`) + `
+        writeToStdout(source_default.green(`Successfully updated from ${"0.15.17"} to version ${result.latestVersion}`) + `
 `);
         await regenerateCompletionCache();
       }
@@ -593915,12 +594664,12 @@ async function update() {
 `);
     await gracefulShutdown(1);
   }
-  if (latestVersion === "0.15.15") {
-    writeToStdout(source_default.green(`Verboo Code is up to date (${"0.15.15"})`) + `
+  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.15"})
+  writeToStdout(`New version available: ${latestVersion} (current: ${"0.15.17"})
 `);
   writeToStdout(`Installing update...
 `);
@@ -593965,7 +594714,7 @@ async function update() {
   logForDebugging(`update: Installation status: ${status2}`);
   switch (status2) {
     case "success":
-      writeToStdout(source_default.green(`Successfully updated from ${"0.15.15"} to version ${latestVersion}`) + `
+      writeToStdout(source_default.green(`Successfully updated from ${"0.15.17"} to version ${latestVersion}`) + `
 `);
       await regenerateCompletionCache();
       break;
@@ -595304,7 +596053,7 @@ ${chromeSystemPrompt}` : chromeSystemPrompt;
       is_native_binary: isInBundledMode()
     });
     logMemoryDiagnostics("start", {
-      version: "0.15.15",
+      version: "0.15.17",
       debug: debug2,
       debugToStderr,
       print: print ?? false,
@@ -596115,7 +596864,7 @@ Usage: verboo --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version(`0.15.15 (${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()) {
@@ -596730,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.15"} (Verboo Code)`);
+    console.log(`${"0.15.17"} (Verboo Code)`);
     return;
   }
   if (!IS_VERBOO_CLI && args.includes("--provider")) {
@@ -596904,4 +597653,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=BA1810B7F2F5F50A64756E2164756E21
+//# debugId=5CD1B0C278B044C764756E2164756E21