@bitkyc08/opencodex 2.88.0 → 2.90.0

package/src/adapters/openai-chat/serialized-tool-call-content.ts

@@ -1,10 +1,9 @@
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import type { AdapterEvent } from "../../types";
 import { repairFreeformToolInput } from "../../responses/apply-patch-envelope";
+import { contextAfter, deferredContinuationBreak, splitAtPossibleSerializedToolCall, MAX_TAG_LENGTH, TAG_SUFFIX, type TextContext } from "./serialized-tool-call-markup";
+export { splitAtPossibleSerializedToolCall } from "./serialized-tool-call-markup";
 
-const OPEN_TAG = "<tool_call>";
-const CLOSE_TAG = "</tool_call>";
-const FUNCTION_TAG = "<function=";
 /**
  * Streaming bounds (ingestStreaming only; buffered reconciliation already knows its structured calls).
  * MAX_HELD_BYTES is a runaway guard on held text plus queued events, far below the translator budget,
@@ -14,12 +13,7 @@ const FUNCTION_TAG = "<function=";
  */
 const MAX_HELD_BYTES = 4 * 1024 * 1024;
 const MAX_TRAILING_CHARS = 8 * 1024;
-
-interface TextContext {
-  fence: string | null;
-  lineStart: boolean;
-  inlineTicks?: number;
-}
+export const MAX_STANDALONE_CANDIDATES = 128;
 
 export interface SerializedToolCall {
   name: string;
@@ -49,9 +43,9 @@ export interface StructuredToolCallReference {
   recoveredParameterWrapper?: boolean;
 }
 
-const BLOCK_HEADER = /<tool_call>\s*<function=([^>\r\n]+)>/y;
+const BLOCK_HEADER = new RegExp(`<tool_call(${TAG_SUFFIX})>\\s*<function=([^>\\r\\n]+)>`, "y");
 /** A separate bare block starts a line (see `splitAtPossibleSerializedToolCall`); a header mid-line is body text. */
-const NEXT_BLOCK_HEADER = /\n<tool_call>\s*<function=[^>\r\n]+>/g;
+const NEXT_BLOCK_HEADER = new RegExp(`\\n<tool_call${TAG_SUFFIX}>\\s*<function=[^>\\r\\n]+>`, "g");
 const FUNCTION_CLOSE = "</function>";
 const PARAMETER_CLOSE = "</parameter>";
 
@@ -73,26 +67,25 @@ function endsWithAt(text: string, from: number, to: number, suffix: string): boo
  * bounds an unclosed candidate: with no close at all before it, it is body text, and a closed
  * `</function></tool_call>` after it still ends the block.
  */
-function blockAt(text: string, offset: number): SerializedToolCall | undefined {
+function blockAt(text: string, offset: number, nextHeaderAt: (from: number) => number): SerializedToolCall | undefined {
   BLOCK_HEADER.lastIndex = offset;
   const header = BLOCK_HEADER.exec(text);
   if (!header) return undefined;
+  const closeTag = `</tool_call${header[1]}>`;
   const bodyStart = offset + header[0].length;
-  NEXT_BLOCK_HEADER.lastIndex = bodyStart;
-  const next = NEXT_BLOCK_HEADER.exec(text);
-  const limit = next ? next.index + 1 : text.length;
+  const limit = nextHeaderAt(bodyStart);
   let unclosed: SerializedToolCall | undefined;
-  for (let close = text.indexOf(CLOSE_TAG, bodyStart); close >= 0 && (close < limit || !unclosed);
-    close = text.indexOf(CLOSE_TAG, close + CLOSE_TAG.length)) {
+  for (let close = text.indexOf(closeTag, bodyStart); close >= 0 && (close < limit || !unclosed);
+    close = text.indexOf(closeTag, close + closeTag.length)) {
     let bodyEnd = trimmedEnd(text, bodyStart, close);
     const closed = endsWithAt(text, bodyStart, bodyEnd, FUNCTION_CLOSE);
     if (closed) bodyEnd = trimmedEnd(text, bodyStart, bodyEnd - FUNCTION_CLOSE.length);
     if (endsWithAt(text, bodyStart, bodyEnd, PARAMETER_CLOSE)) bodyEnd -= PARAMETER_CLOSE.length;
     const call = {
-      name: header[1]!.trim(),
+      name: header[2]!.trim(),
       body: text.slice(bodyStart, bodyEnd),
       start: offset,
-      end: close + CLOSE_TAG.length,
+      end: close + closeTag.length,
     };
     if (closed) return call;
     if (close < limit) unclosed ??= call;
@@ -100,21 +93,64 @@ function blockAt(text: string, offset: number): SerializedToolCall | undefined {
   return unclosed;
 }
 
-/** Finds complete bare blocks outside literal Markdown; ambiguous outer blocks stop the scan. */
-function callsIn(text: string, context: TextContext = { fence: null, lineStart: true }): SerializedToolCall[] {
+/** Finds outer blocks outside literal Markdown, reporting an unresolved enclosing header. */
+export function scanSerializedToolCalls(
+  text: string, context: TextContext = { fence: null, lineStart: true }, allowMidLineBare = false,
+  maxCandidates = allowMidLineBare ? MAX_STANDALONE_CANDIDATES : Infinity,
+): { calls: SerializedToolCall[]; incomplete: boolean; overflow: boolean } {
   const calls: SerializedToolCall[] = [];
+  // Adjacent same-line blocks share one forward-only newline-header search, including EOF.
+  const headers = new RegExp(NEXT_BLOCK_HEADER.source, "g");
+  let next = headers.exec(text);
+  const nextHeaderAt = (from: number): number => {
+    while (next && next.index + 1 < from) next = headers.exec(text);
+    return next ? next.index + 1 : text.length;
+  };
   let offset = 0;
   while (offset < text.length) {
-    const split = splitAtPossibleSerializedToolCall(text.slice(offset), context, true);
+    const split = splitAtPossibleSerializedToolCall(text.slice(offset), context, true, allowMidLineBare);
     offset += split.emit.length;
     if (!split.hasOpenTag) break;
-    const match = blockAt(text, offset);
-    if (!match) break; // An incomplete/ambiguous outer block cannot authorize an inner call.
+    if (calls.length >= maxCandidates) return { calls, incomplete: false, overflow: true };
+    const match = blockAt(text, offset, nextHeaderAt);
+    if (!match) return { calls, incomplete: true, overflow: false }; // An unresolved outer block cannot authorize an inner call.
     calls.push(match);
     offset = match.end;
     context = { fence: null, lineStart: false };
   }
-  return calls;
+  return { calls, incomplete: false, overflow: false };
+}
+
+function callsIn(text: string, context?: TextContext, allowMidLineBare = false): SerializedToolCall[] {
+  return scanSerializedToolCalls(text, context, allowMidLineBare).calls;
+}
+
+/** Standalone recovery is separate from identified-wrapper/empty-structured-input reconciliation. */
+export function hasNestedSerializedToolCallHeader(body: string): boolean {
+  return /<(?:tool_call(?:_[a-fA-F0-9]{1,64})?|function=[^>\r\n]+)>/.test(body);
+}
+
+export function recoverStandaloneBareBlocks(
+  text: string,
+  freeformTools: ReadonlyMap<string, FreeformToolIdentity>,
+  context?: TextContext,
+): { name: string; input: string; start: number; end: number }[] {
+  if (freeformTools.size === 0) return [];
+  const scan = scanSerializedToolCalls(text, context, true);
+  if (scan.overflow) return [];
+  const blocks = scan.calls;
+  // A nested header makes delimiter ownership ambiguous; no later apparent sibling is safe.
+  if (blocks.some(call => hasNestedSerializedToolCallHeader(call.body))) return [];
+  return blocks.flatMap(call => {
+    if (!text.startsWith("<tool_call>", call.start) || !freeformTools.has(call.name)) return [];
+    const wrapped = freeformBody(call.body);
+    const recoveredParameterWrapper = wrapped.startsWith("<parameter=");
+    const input = recoveredParameterWrapper ? freeformBody(wrapped.slice("<parameter=".length)) : wrapped;
+    if (!input.trim()
+        || (recoveredParameterWrapper && /^<parameter=[A-Za-z_$][\w$.-]*>/.test(wrapped))
+        || input.includes("<parameter=") || input.includes("</parameter>")) return [];
+    return [{ name: call.name, input, start: call.start, end: call.end }];
+  });
 }
 
 /**
@@ -128,94 +164,6 @@ function repeatedCallIn(text: string, context?: TextContext): SerializedToolCall
   return { ...first, end: text.length };
 }
 
-/** Splits safe visible text from a possible control block while carrying Markdown context across chunks. */
-export function splitAtPossibleSerializedToolCall(
-  text: string,
-  initialContext: TextContext = { fence: null, lineStart: true },
-  final = false,
-): {
-  emit: string;
-  defer: string;
-  hasOpenTag: boolean;
-  context: TextContext;
-} {
-  const context = { ...initialContext };
-  const split = (at: number, hasOpenTag = false) => ({
-    emit: text.slice(0, at), defer: text.slice(at), hasOpenTag, context,
-  });
-  for (let index = 0; index < text.length; index++) {
-    if (context.lineStart) {
-      const rest = text.slice(index);
-      const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)/.exec(rest);
-      if (!context.inlineTicks && fence && (!context.fence || (fence[1]![0] === context.fence[0]
-          && fence[1]!.length >= context.fence.length && /^[ \t\r]*$/.test(fence[2]!)))) {
-        if (!final && !rest.includes("\n")) return split(index);
-        context.fence = context.fence ? null : fence[1]!;
-        index += fence[0].length - 1;
-        context.lineStart = false;
-        continue;
-      }
-      if (!final && /^ {0,3}(`*|~*)$/.test(rest)) return split(index);
-      // Only bare control markup qualifies. Prose, quotes, indented examples and
-      // fenced code stay user-visible even when their body matches a real call.
-      if (!context.fence && !context.inlineTicks) {
-        if (rest.startsWith(OPEN_TAG)) {
-          const header = rest.slice(OPEN_TAG.length).trimStart();
-          if (/^<function=[^>\r\n]+>/.test(header)) return split(index, true);
-          if (!final && (FUNCTION_TAG.startsWith(header)
-              || (header.startsWith(FUNCTION_TAG) && !/[>\r\n]/.test(header.slice(FUNCTION_TAG.length))))) {
-            return split(index);
-          }
-        } else if (!final && OPEN_TAG.startsWith(rest)) return split(index);
-      }
-    }
-    if (!context.fence && text[index] === "`") {
-      let end = index + 1;
-      while (text[end] === "`") end++;
-      if (!final && end === text.length) return split(index);
-      const ticks = end - index;
-      if (!context.inlineTicks) context.inlineTicks = ticks;
-      else if (context.inlineTicks === ticks) context.inlineTicks = undefined;
-      index = end - 1;
-    }
-    context.lineStart = text[index] === "\n";
-  }
-  return split(text.length);
-}
-
-/**
- * The line, fence and inline-code state after `text`. Serialized blocks are neutralised first so
- * the scan runs through the whole text instead of stopping at the first opening tag; a block ends
- * mid-line, which is exactly what the neutral spelling reports too.
- */
-function contextAfter(text: string, context: TextContext): TextContext {
-  if (text.length === 0) return context;
-  return splitAtPossibleSerializedToolCall(text.replaceAll(OPEN_TAG, "<tool-call>"), context, true).context;
-}
-
-/**
- * A deferred header/fence can itself be long. While its unresolved portion only grows, a
- * chunk-local check suffices; the first resolving character goes back through the full splitter.
- * Each unbounded phase is scanned once on entry and once on exit, preserving its Markdown rules.
- */
-function deferredContinuationBreak(text: string, context: TextContext): RegExp | undefined {
-  if (text.startsWith(OPEN_TAG)) {
-    if (/^<tool_call>\s*$/.test(text)) return /\S/;
-    if (/^<tool_call>\s*<function=[^>\r\n]*$/.test(text)) return /[>\r\n]/;
-  }
-  if (!context.inlineTicks && context.lineStart) {
-    const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/.exec(text);
-    if (fence) {
-      if (!context.fence) return /\n/;
-      // Closing-fence ticks may grow only before its optional whitespace suffix.
-      if (!fence[2]) return fence[1]![0] === "`" ? /[^`]/ : /[^~]/;
-      return /[^ \t\r]/;
-    }
-  }
-  if (/^`+$/.test(text)) return /[^`]/;
-  return undefined;
-}
-
 /**
  * Holds possible duplicate text within the shared translator budget until the dispatch outcome is
  * known. While a block candidate is open, any other event (reasoning) is queued at its position in
@@ -232,10 +180,13 @@ export class SerializedToolCallContentBuffer {
   private sawCloser = false;
   private openAfterCloser = false;
   private trailingProseChars = 0;
-  private context: TextContext = { fence: null, lineStart: true };
+  protected context: TextContext = { fence: null, lineStart: true };
   private queued: { offset: number; event: AdapterEvent }[] = [];
 
-  constructor(private readonly budget: TranslatorBudget) {}
+  constructor(private readonly budget: TranslatorBudget, private readonly allowMidLineBare = false) {}
+
+  /** Optional recovery retains bounded candidates before prose is released, never the prose itself. */
+  protected releaseBounded(): AdapterEvent[] { return this.drain([]); }
 
   /** Remembers visible text released before a later structured call can be reconciled. */
   private observeText(events: AdapterEvent[]): AdapterEvent[] {
@@ -291,19 +242,22 @@ export class SerializedToolCallContentBuffer {
   /** Scan new text plus a fixed overlap, never the retained body (which may be a large rope). */
   private observeDelimiters(delta: string): void {
     const scan = this.delimiterSuffix + delta;
-    const closer = scan.lastIndexOf(CLOSE_TAG);
-    const afterCloser = closer + CLOSE_TAG.length;
-    if (closer >= 0) {
-      this.sawCloser = true;
-      this.openAfterCloser = false;
-      this.trailingProseChars = 0;
-    }
-    if (scan.lastIndexOf(OPEN_TAG) >= (closer >= 0 ? afterCloser : 0)) {
-      this.openAfterCloser = true;
+    const tags = scan.matchAll(new RegExp(`<(/?)tool_call${TAG_SUFFIX}>`, "g"));
+    let afterCloser = -1;
+    for (const tag of tags) {
+      if (tag.index! + tag[0].length <= this.delimiterSuffix.length) continue;
+      if (tag[1]) {
+        this.sawCloser = true;
+        this.openAfterCloser = false;
+        this.trailingProseChars = 0;
+        afterCloser = tag.index! + tag[0].length;
+      } else {
+        this.openAfterCloser = true;
+      }
     }
-    const tail = closer >= 0 ? scan.slice(afterCloser) : delta;
+    const tail = afterCloser >= 0 ? scan.slice(afterCloser) : delta;
     if (this.sawCloser) this.trailingProseChars += tail.replace(/\s+/g, "").length;
-    this.delimiterSuffix = scan.slice(-(Math.max(OPEN_TAG.length, CLOSE_TAG.length) - 1));
+    this.delimiterSuffix = scan.slice(-(MAX_TAG_LENGTH - 1));
   }
 
   /** Returns immediately safe text and retains only the suffix that still needs reconciliation. */
@@ -312,7 +266,7 @@ export class SerializedToolCallContentBuffer {
       this.append(delta);
       return "";
     }
-    const split = splitAtPossibleSerializedToolCall(this.text + delta, this.context);
+    const split = splitAtPossibleSerializedToolCall(this.text + delta, this.context, false, this.allowMidLineBare);
     this.replace(split.defer, split.hasOpenTag);
     this.context = split.context;
     if (!split.hasOpenTag) this.continuationBreak = deferredContinuationBreak(split.defer, split.context);
@@ -328,7 +282,7 @@ export class SerializedToolCallContentBuffer {
   ingestStreaming(delta: string): AdapterEvent[] {
     const deltaBytes = this.appendedByteLength(delta);
     if (this.hasOpenTag && this.bytes + deltaBytes > MAX_HELD_BYTES) {
-      const released = this.drain([]);
+      const released = this.releaseBounded();
       // A delta that alone passes the bound is delivered as text rather than retained.
       if (Buffer.byteLength(delta) > MAX_HELD_BYTES) {
         this.context = contextAfter(delta, this.context);
@@ -339,7 +293,7 @@ export class SerializedToolCallContentBuffer {
     const text = this.ingest(delta);
     // Checked after ingest too: one delta can open a block and already carry more than a bound.
     if (this.hasOpenTag && (this.bytes > MAX_HELD_BYTES || (this.sawCloser && !this.openAfterCloser && this.trailingProseChars > MAX_TRAILING_CHARS))) {
-      return this.observeText([...textEvents(text), ...this.drain([])]);
+      return this.observeText([...textEvents(text), ...this.releaseBounded()]);
     }
     return this.observeText(textEvents(text));
   }
@@ -358,7 +312,7 @@ export class SerializedToolCallContentBuffer {
     if (!this.hasOpenTag) return [...this.drain([]), event];
     const eventBytes = Buffer.byteLength(JSON.stringify(event));
     // Queued events count toward the same runaway bound as held text.
-    if (this.bytes + eventBytes > MAX_HELD_BYTES) return [...this.drain([]), event];
+    if (this.bytes + eventBytes > MAX_HELD_BYTES) return [...this.releaseBounded(), event];
     this.budget.reserveTransient(eventBytes, { kind: "live_transient" }).commitRetained();
     this.bytes += eventBytes;
     this.queued.push({ offset: this.text.length, event });
@@ -371,7 +325,11 @@ export class SerializedToolCallContentBuffer {
    * duplicate a dispatched call; pass an empty list on failure to preserve everything.
    */
   drain(structuredCalls: readonly StructuredToolCallReference[]): AdapterEvent[] {
-    const removed = duplicatedSerializedToolCallRanges(this.text, structuredCalls, this.context);
+    return this.drainRanges(duplicatedSerializedToolCallRanges(this.text, structuredCalls, this.context));
+  }
+
+  /** Standalone recovery supplies only its own accepted bare ranges, never identified wrappers. */
+  protected drainRanges(removed: readonly { start: number; end: number }[]): AdapterEvent[] {
     const kept = (from: number, to: number): string => {
       let piece = "";
       let cursor = from;
@@ -390,8 +348,11 @@ export class SerializedToolCallContentBuffer {
       if (boundary.event) out.push(boundary.event);
       cursor = boundary.offset;
     }
-    // Later text continues after what was drained, so its line and fence state carry forward.
-    this.context = contextAfter(this.text, this.context);
+    // Control bodies are opaque on every provider, regardless of standalone recovery eligibility.
+    // Context still traverses the whole released text when recovery hit its candidate limit.
+    const last = scanSerializedToolCalls(this.text, this.context, this.allowMidLineBare, Infinity).calls.at(-1);
+    this.context = last ? contextAfter(this.text.slice(last.end), { fence: null, lineStart: false })
+      : contextAfter(this.text, this.context);
     this.queued = [];
     this.replace("", false);
     return this.observeText(out);
@@ -609,7 +570,7 @@ export function reconcileStructuredToolCalls(
       const body = hasParameterOpener
         ? freeformBody(wrappedBody.slice("<parameter=".length)) : wrappedBody;
       if (block.name === calls[0]!.wireName && body.trim() !== ""
-          && !/(?:^|\n)<tool_call>\s*<function=[^>\r\n]+>/.test(block.body)
+          && !new RegExp(`(?:^|\\n)<tool_call${TAG_SUFFIX}>\\s*<function=[^>\\r\\n]+>`).test(block.body)
           && !(hasParameterOpener && /^<parameter=[A-Za-z_$][\w$.-]*>/.test(wrappedBody))
           && !body.includes("<parameter=") && !body.includes("</parameter>")) {
         references[0] = { ...references[0]!, argumentsText: JSON.stringify({ input: body }),

package/src/adapters/openai-chat/serialized-tool-call-markup.ts

@@ -0,0 +1,108 @@
+const OPEN_TAG = "<tool_call>";
+const FUNCTION_TAG = "<function=";
+// MiMo gateways append an opaque hexadecimal identity to both delimiters.
+export const TAG_SUFFIX = "(?:_[a-fA-F0-9]{1,64})?";
+export const MAX_TAG_LENGTH = "</tool_call_".length + 64 + 1;
+const OPENING = new RegExp(`^<tool_call${TAG_SUFFIX}>`);
+const OPEN_PREFIX = /^<tool_call(?:_[a-fA-F0-9]{0,64})?$/;
+
+export interface TextContext {
+  fence: string | null;
+  lineStart: boolean;
+  inlineTicks?: number;
+  literalLine?: boolean;
+}
+
+/** Splits safe visible text from a possible control block while carrying Markdown context across chunks. */
+export function splitAtPossibleSerializedToolCall(
+  text: string,
+  initialContext: TextContext = { fence: null, lineStart: true },
+  final = false,
+  allowMidLineBare = false,
+): {
+  emit: string;
+  defer: string;
+  hasOpenTag: boolean;
+  context: TextContext;
+} {
+  const context = { ...initialContext };
+  const split = (at: number, hasOpenTag = false) => ({
+    emit: text.slice(0, at), defer: text.slice(at), hasOpenTag, context,
+  });
+  for (let index = 0; index < text.length; index++) {
+    if (context.lineStart) {
+      const rest = text.slice(index);
+      const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)/.exec(rest);
+      if (!context.inlineTicks && fence && (!context.fence || (fence[1]![0] === context.fence[0]
+          && fence[1]!.length >= context.fence.length && /^[ \t\r]*$/.test(fence[2]!)))) {
+        if (!final && !rest.includes("\n")) return split(index);
+        context.fence = context.fence ? null : fence[1]!;
+        index += fence[0].length - 1;
+        context.lineStart = false;
+        continue;
+      }
+      if (!final && /^ {0,3}(`*|~*)$/.test(rest)) return split(index);
+      context.literalLine = /[ \t>]/.test(text[index]!);
+    }
+    // Plain wrappers retain their bare-line rule. Nonced wrappers also occur after prose;
+    // quotes, indentation and Markdown code remain literal, even beside a matching call.
+    if (!context.fence && !context.inlineTicks && !context.literalLine && text[index] === "<") {
+      const rest = text.slice(index);
+      const opening = OPENING.exec(rest)?.[0];
+      if (opening && (context.lineStart || opening !== OPEN_TAG || allowMidLineBare)) {
+        const header = rest.slice(opening.length).trimStart();
+        if (/^<function=[^>\r\n]+>/.test(header)) return split(index, true);
+        if (!final && (FUNCTION_TAG.startsWith(header)
+            || (header.startsWith(FUNCTION_TAG) && !/[>\r\n]/.test(header.slice(FUNCTION_TAG.length))))) {
+          return split(index);
+        }
+      } else if (!final && (OPEN_TAG.startsWith(rest) || OPEN_PREFIX.test(rest))) return split(index);
+    }
+    if (!context.fence && text[index] === "`") {
+      let end = index + 1;
+      while (text[end] === "`") end++;
+      if (!final && end === text.length) return split(index);
+      const ticks = end - index;
+      if (!context.inlineTicks) context.inlineTicks = ticks;
+      else if (context.inlineTicks === ticks) context.inlineTicks = undefined;
+      index = end - 1;
+    }
+    context.lineStart = text[index] === "\n";
+  }
+  return split(text.length);
+}
+
+/**
+ * The line, fence and inline-code state after `text`. Serialized blocks are neutralised first so
+ * the scan runs through the whole text instead of stopping at the first opening tag; a block ends
+ * mid-line, which is exactly what the neutral spelling reports too.
+ */
+export function contextAfter(text: string, context: TextContext): TextContext {
+  if (text.length === 0) return context;
+  return splitAtPossibleSerializedToolCall(text.replace(new RegExp(`<tool_call${TAG_SUFFIX}>`, "g"), "<tool-call>"), context, true).context;
+}
+
+/**
+ * A deferred header/fence can itself be long. While its unresolved portion only grows, a
+ * chunk-local check suffices; the first resolving character goes back through the full splitter.
+ * Each unbounded phase is scanned once on entry and once on exit, preserving its Markdown rules.
+ */
+export function deferredContinuationBreak(text: string, context: TextContext): RegExp | undefined {
+  const opening = OPENING.exec(text)?.[0];
+  if (opening) {
+    const header = text.slice(opening.length);
+    if (/^\s*$/.test(header)) return /\S/;
+    if (/^\s*<function=[^>\r\n]*$/.test(header)) return /[>\r\n]/;
+  }
+  if (!context.inlineTicks && context.lineStart) {
+    const fence = /^ {0,3}(`{3,}|~{3,})([^\n]*)$/.exec(text);
+    if (fence) {
+      if (!context.fence) return /\n/;
+      // Closing-fence ticks may grow only before its optional whitespace suffix.
+      if (!fence[2]) return fence[1]![0] === "`" ? /[^`]/ : /[^~]/;
+      return /[^ \t\r]/;
+    }
+  }
+  if (/^`+$/.test(text)) return /[^`]/;
+  return undefined;
+}

package/src/adapters/openai-chat/standalone-bare-tool-calls.ts

@@ -0,0 +1,136 @@
+import { TRANSLATOR_MAX_CALL_ARGUMENT_BYTES, type TranslatorBudget } from "../../lib/translator-budget";
+import { jsonUtf8Bytes } from "../../lib/json-byte-size";
+import type { AdapterEvent } from "../../types";
+import {
+  hasNestedSerializedToolCallHeader, MAX_STANDALONE_CANDIDATES, recoverStandaloneBareBlocks, reconcileSerializedToolCallEvents, scanSerializedToolCalls, SerializedToolCallContentBuffer,
+  type FreeformToolIdentity, type StructuredToolCallReference,
+} from "./serialized-tool-call-content";
+
+const MAX_CANDIDATE_BYTES = 4 * 1024 * 1024;
+type BareCall = Pick<ReturnType<typeof recoverStandaloneBareBlocks>[number], "name" | "input">;
+const isMiMo = (model: string | undefined) => /(?:^|[/-])mimo-v2(?:\.|$)/i.test(model ?? "");
+const argumentsFor = (call: BareCall) => JSON.stringify({ input: call.input });
+function* callEvents(call: BareCall, id: string, restore: (name: string) => string): Generator<AdapterEvent> {
+  yield { type: "tool_call_start", id, name: restore(call.name) };
+  yield { type: "tool_call_delta", arguments: argumentsFor(call) };
+  yield { type: "tool_call_end" };
+}
+
+/** An explicitly separate policy for bare blocks with NO structured calls, never identified wrappers. */
+export class StandaloneBareToolCallBuffer extends SerializedToolCallContentBuffer {
+  private candidates: BareCall[] = [];
+  private candidateBytes = 0;
+  private disabled = false;
+  private readonly eligible: boolean;
+
+  constructor(
+    private readonly recoveryBudget: TranslatorBudget,
+    model: string | undefined,
+    private readonly freeformTools: ReadonlyMap<string, FreeformToolIdentity>,
+  ) {
+    super(recoveryBudget, isMiMo(model) && freeformTools.size > 0);
+    this.eligible = isMiMo(model) && freeformTools.size > 0;
+  }
+
+  /** Retain candidate inputs only, with aggregate and per-call limits; overflow disables the batch. */
+  private remember(calls: BareCall[]): void {
+    if (this.disabled || calls.length === 0) return;
+    const sizes = calls.map(call => jsonUtf8Bytes({ name: call.name, input: call.input }));
+    const bytes = sizes.reduce((sum, size) => sum + size, 0);
+    if (sizes.some(size => size > TRANSLATOR_MAX_CALL_ARGUMENT_BYTES)
+        || this.candidateBytes + bytes > MAX_CANDIDATE_BYTES || this.candidates.length + calls.length > MAX_STANDALONE_CANDIDATES) {
+      this.clearCandidates();
+      this.disabled = true;
+      return;
+    }
+    const retained = this.recoveryBudget.reserveTransient(bytes, { kind: "live_transient" });
+    try {
+      const temporary = this.recoveryBudget.reserveTransient(bytes, { kind: "live_transient" });
+      try {
+        // Detach small inputs from a large released answer's backing string.
+        const copies = calls.map(({ name, input }) => JSON.parse(JSON.stringify({ name, input })) as BareCall);
+        this.candidates.push(...copies);
+        this.candidateBytes += bytes;
+        retained.commitRetained();
+      } finally { temporary.release(); }
+    } catch (error) {
+      retained.release();
+      throw error;
+    }
+  }
+
+  protected override releaseBounded(): AdapterEvent[] {
+    if (!this.eligible || this.disabled) return super.releaseBounded();
+    const text = this.current();
+    const scan = scanSerializedToolCalls(text, this.context, true);
+    if (scan.overflow || scan.incomplete || scan.calls.some(call => hasNestedSerializedToolCallHeader(call.body))) {
+      // We cannot safely recognize a later inner block after losing its unresolved outer body.
+      this.clearCandidates();
+      this.disabled = true;
+      return super.releaseBounded();
+    }
+    this.remember(recoverStandaloneBareBlocks(text, this.freeformTools, this.context));
+    return super.releaseBounded();
+  }
+
+  *recoverStandalone(noStructuredCalls: boolean, nextId: () => string, restore: (name: string) => string): Generator<AdapterEvent> {
+    if (!noStructuredCalls) {
+      this.clearCandidates();
+      this.disabled = true;
+      return;
+    }
+    if (!this.eligible || this.disabled) return;
+    if (scanSerializedToolCalls(this.current(), this.context, true).overflow) {
+      this.clearCandidates();
+      this.disabled = true;
+      return;
+    }
+    const held = recoverStandaloneBareBlocks(this.current(), this.freeformTools, this.context);
+    this.remember(held);
+    // The first terminal flush is the only recovery decision; content after it cannot authorize a call.
+    if (this.disabled || this.candidates.length === 0) { this.disabled = true; return; }
+    yield* this.drainRanges(held);
+    for (const call of this.candidates) yield* callEvents(call, nextId(), restore);
+    this.clearCandidates();
+    this.disabled = true;
+  }
+
+  private clearCandidates(): void {
+    this.recoveryBudget.releaseRetained(this.candidateBytes, { kind: "live_transient" });
+    this.candidateBytes = 0;
+    this.candidates = [];
+  }
+
+  override dispose(): void {
+    this.clearCandidates();
+    super.dispose();
+  }
+}
+
+/** Buffered counterpart; the existing structured-call/identified-wrapper reconciler owns its path. */
+export function reconcileStandaloneBareToolCallEvents(
+  events: AdapterEvent[], start: number, end: number,
+  structuredCalls: readonly StructuredToolCallReference[], budget: TranslatorBudget,
+  model: string | undefined, freeformTools: ReadonlyMap<string, FreeformToolIdentity>, restore: (name: string) => string,
+): void {
+  if (structuredCalls.length > 0 || !isMiMo(model) || freeformTools.size === 0) {
+    reconcileSerializedToolCallEvents(events, start, end, structuredCalls, budget);
+    return;
+  }
+  const buffer = new StandaloneBareToolCallBuffer(budget, model, freeformTools);
+  const reconciled: AdapterEvent[] = [];
+  try {
+    for (const event of events.slice(start, end)) {
+      if (event.type !== "text_delta") reconciled.push(...buffer.hold(event).filter(held => held.type !== "heartbeat"));
+      else {
+        const text = buffer.ingest(event.text);
+        if (text) reconciled.push({ type: "text_delta", text });
+      }
+    }
+    let sequence = 0;
+    reconciled.push(...buffer.recoverStandalone(true, () => `call_${++sequence}`, restore), ...buffer.drain([]));
+  } finally {
+    buffer.dispose();
+  }
+  events.splice(start, end - start, ...reconciled);
+}

package/src/adapters/openai-chat.ts

@@ -47,7 +47,8 @@ import { messagesToChatFormat } from "./openai-chat/messages";
 import { withOpenAIChatToolNames } from "./openai-chat/tool-name-registry";
 import { openAIChatTransport, stripBracketedModelSuffix } from "./openai-chat/wire";
 import { toolChoiceToChatFormat, toolsToChatFormatForProvider } from "./openai-chat/tool-schema";
-import { freeformToolsByWireName, type FreeformToolIdentity, reconcileSerializedToolCallEvents, reconcileStructuredToolCall, reconcileStructuredToolCalls, SerializedToolCallContentBuffer } from "./openai-chat/serialized-tool-call-content";
+import { freeformToolsByWireName, type FreeformToolIdentity, reconcileStructuredToolCall, reconcileStructuredToolCalls } from "./openai-chat/serialized-tool-call-content";
+import { StandaloneBareToolCallBuffer, reconcileStandaloneBareToolCallEvents } from "./openai-chat/standalone-bare-tool-calls";
 
 export { stripBracketedModelSuffix } from "./openai-chat/wire";
 export { buildOpenAIChatPassthroughRequest } from "./openai-chat/passthrough";
@@ -300,7 +301,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         sawArgumentsString: boolean;
       }
       const pendingToolCalls: PendingToolCall[] = [];
-      const toolCallContent = new SerializedToolCallContentBuffer(budget);
+      const toolCallContent = new StandaloneBareToolCallBuffer(budget, lastRequestedModelId, freeformTools);
       const heldText = (): AdapterEvent[] => toolCallContent.drain([]);
       let toolCallSeq = 0;
       const closeToolCalls = (): PendingToolCall[] => {
@@ -322,7 +323,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       // Returns "terminate" when a pending call cannot be dispatched, so every flush site
       // stops the turn instead of emitting an unusable call. `closeToolCalls()` runs first,
       // so budget reservations are released for every pending call even on the early return.
-      const flushToolCalls = function* (): Generator<AdapterEvent, "continue" | "terminate"> {
+      const flushToolCalls = function* (terminal = true): Generator<AdapterEvent, "continue" | "terminate"> {
         const calls = closeToolCalls();
         for (const call of calls) {
           // Ingest already proved `name` is a string; the typeof guard keeps this branch
@@ -335,9 +336,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             return yield* terminateWithError(unnamedToolCallEvent(pendingUsage));
           }
         }
-        // Held markup is released only now, as one batch per response: the doubled-input repair needs every call.
         const references = reconcileStructuredToolCalls(calls.map(call => ({ wireName: call.name, restoredName: toolNames.restore(call.name), argumentsText: call.args, freeformTool: freeformTools.get(call.name) })), toolCallContent.current(), !toolCallContent.releasedAnswerText && /(?:^|[/-])mimo-v2(?:\.|$)/i.test(lastRequestedModelId ?? ""));
         calls.forEach((call, index) => { call.args = references[index]!.argumentsText; });
+        yield* toolCallContent.recoverStandalone(calls.length === 0 && terminal, () => `call_${++toolCallSeq}`, name => toolNames.restore(name));
         yield* toolCallContent.drain(references);
         for (const call of calls) {
           if (!call.id) call.id = `call_${++toolCallSeq}`;
@@ -657,7 +658,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           yield* terminateWithError({ type: "error", message: "upstream stream ended without a terminal signal ([DONE] or finish_reason) — possible truncation" });
           return;
         }
-        if ((yield* flushToolCalls()) === "terminate") return;
+        if ((yield* flushToolCalls(sawFinish)) === "terminate") return; // A cut stream never synthesizes a bare call.
         const stopReason = stopReasonFor(finishReason);
         yield { type: "done", usage: pendingUsage, ...(stopReason ? { stopReason } : {}) };
       } catch (error) {
@@ -804,7 +805,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         }
         const references = reconcileStructuredToolCalls(structuredCalls, answerText, /(?:^|[/-])mimo-v2(?:\.|$)/i.test(lastRequestedModelId ?? ""));
         structuredCalls.forEach((call, index) => { call.delta.arguments = references[index]!.argumentsText; });
-        reconcileSerializedToolCallEvents(events, contentStart, contentEnd, references, budget);
+        reconcileStandaloneBareToolCallEvents(events, contentStart, contentEnd, references, budget, lastRequestedModelId, freeformTools, name => toolNames.restore(name));
         const stopReason = stopReasonFor(choice.finish_reason);
         events.push({
           type: "done",