@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
740 lines (686 loc) • 34.1 kB
text/typescript
import { randomUUID } from "node:crypto";
import type { AdapterEvent } from "../types";
import type { TranslatorBudget } from "../lib/translator-budget";
import { validatesRestoredValue } from "./command-code-restored-schema";
/**
* MiMo tool-call markup on the Command Code /alpha/generate stream.
*
* Xiaomi MiMo writes tool calls in its native chat-template grammar,
* `<tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>`, with string
* values raw, every other type as JSON, and a freeform tool's input as the raw body with no
* parameter tags (MiMo-V2.6 chat template; the `mimo` tool parsers in vLLM and SGLang read the same
* grammar). When Command Code's gateway cannot turn that markup into a call — Codex's freeform
* `exec` body is raw JavaScript, which fails the gateway's JSON parse of the lowered `{input}`
* schema — it forwards the markup as a `text-delta` block and then, in the observed case, a native
* `tool-call` marked `invalid` carrying the same input. Relaying both put the call on screen as
* assistant text (captured 2026-09-23 from `codex exec` on `xiaomi/mimo-v2.6-flash`).
* The echo can also omit `</function>` entirely (`<tool_call><function=exec>RAW</parameter></tool_call>`,
* captured the same day through the live proxy); a parameter-free body is read the same way then.
* Parameter bodies keep the canonical close, which SGLang's and vLLM's MiMo parsers require too.
*
* A text block that opens with `<tool_call>` is therefore held instead of streamed. It is dropped
* when a native call proves it is a duplicate, or restored on an eligible clean MiMo finish when
* it names a declared tool with arguments that fit its schema. Other markup is released unchanged.
* MiMo can also append the markup after ordinary prose inside one text block. A marker that
* follows prose can never become a call: its envelope is still held — a matching native call
* strips it as an echo — and otherwise it is released as the presentation text it is.
* A leading bare envelope remains eligible under the declared-tool rules.
* A malformed envelope that still opens and closes around a declared function name, but that the
* strict parser rejects, is dropped instead of released when the native call for that same function
* arrives, and on the clean-finish path, so the echo never reaches the client.
* Later text waits behind unresolved markup within the same byte bound.
*/
export const TOOL_CALL_MARKER = "<tool_call>";
/** A held block larger than this is released as text rather than buffered further. */
export const MAX_HELD_TOOL_TEXT_BYTES = 64 * 1024;
export interface CommandCodeDeclaredTool {
freeform: boolean;
schema: Record<string, unknown>;
/**
* The caller's original schema when `schema` is a normalized wire view of it. The wire view
* flattens root alternatives lossily, so restored arguments must satisfy both; a declared
* schema the restored-value validator cannot evaluate (a `$ref`, say) fails closed.
*/
declaredSchema?: Record<string, unknown>;
}
export type CommandCodeDeclaredTools = ReadonlyMap<string, CommandCodeDeclaredTool>;
export type ToolCallMarkup =
| { name: string; kind: "raw"; value: string }
| { name: string; kind: "params"; values: Record<string, string> };
/** One wrapping newline on each side is template layout, not value (vLLM `_trim_wrapping_newlines`). */
function trimWrappingNewlines(value: string): string {
return value.replace(/^\r?\n/, "").replace(/\r?\n$/, "");
}
const WRAPPER = /^<tool_call>\s*<function=([^>\s]+)>([\s\S]*)<\/tool_call>$/;
const FUNCTION_CLOSE = /<\/function>\s*$/;
const PARAMETER = /<parameter=([^>]+)>([\s\S]*?)<\/parameter>/g;
/** Parse one complete MiMo tool-call block, or undefined when the text is anything else. */
export function parseToolCallMarkup(text: string): ToolCallMarkup | undefined {
const match = WRAPPER.exec(text.trim());
if (!match) return undefined;
const name = match[1]!;
// A trailing </function> is always the close, so a body can keep a literal one only inside a closed block.
const closed = FUNCTION_CLOSE.test(match[2]!);
const body = closed ? match[2]!.replace(FUNCTION_CLOSE, "") : match[2]!;
// A second </tool_call> means two blocks with text between them, never one call.
if (body.includes(TOOL_CALL_MARKER) || body.includes("</tool_call>") || body.includes("<function=")) return undefined;
if (!body.includes("<parameter=")) {
// A parameter-free body is a freeform input. The gateway's echo can close it with a stray
// `</parameter>` that has no opening tag; that tag is markup, not input.
return { name, kind: "raw", value: trimWrappingNewlines(body.replace(/<\/parameter>\s*$/, "")) };
}
if (!closed) return undefined;
const values: Record<string, string> = {};
let consumed = "";
for (const parameter of body.matchAll(PARAMETER)) {
const key = parameter[1]!.trim();
if (!key || Object.hasOwn(values, key)) return undefined;
values[key] = trimWrappingNewlines(parameter[2]!);
consumed += parameter[0];
}
// Complete means every byte of the body belongs to a parameter; anything left over is prose.
if (body.replace(PARAMETER, "").trim() !== "" || consumed === "") return undefined;
return { name, kind: "params", values };
}
function tryJson(value: string): unknown {
try { return JSON.parse(value); } catch { return undefined; }
}
/**
* The declared function name of an envelope echo the strict parser rejected, or undefined when the
* text is anything else: malformed parameter tags, a missing `</function>`, garbage inside the body.
* Opening and closing as an envelope with a known function name is enough to keep it off the client
* once the native duplicate call for that same name — which carries the canonical execution —
* arrives; a native call for another tool says nothing about this envelope.
*/
function looseEnvelopeName(text: string, declared: CommandCodeDeclaredTools | undefined): string | undefined {
const trimmed = text.trim();
if (!trimmed.startsWith(TOOL_CALL_MARKER) || !trimmed.endsWith("</tool_call>")) return undefined;
if (trimmed.slice(TOOL_CALL_MARKER.length).includes(TOOL_CALL_MARKER)) return undefined;
const fn = /<function=([^>\s]+)>/.exec(trimmed);
return fn !== null && (declared?.has(fn[1]!) ?? false) ? fn[1]! : undefined;
}
function deepEqual(left: unknown, right: unknown): boolean {
if (Object.is(left, right)) return true;
if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
if (Array.isArray(left) !== Array.isArray(right)) return false;
const leftKeys = Object.keys(left);
const rightKeys = Object.keys(right);
if (leftKeys.length !== rightKeys.length) return false;
return leftKeys.every(key => Object.hasOwn(right, key)
&& deepEqual((left as Record<string, unknown>)[key], (right as Record<string, unknown>)[key]));
}
/** Whether a parsed block encodes exactly the input of a native call. */
export function markupMatchesInput(markup: ToolCallMarkup, input: unknown): boolean {
const value = typeof input === "string" && markup.kind === "params" ? tryJson(input) : input;
if (markup.kind === "raw") {
if (typeof value === "string") return value.trim() === markup.value.trim();
// A valid freeform call arrives as its lowered single-key object.
if (value && typeof value === "object" && !Array.isArray(value)) {
const entries = Object.entries(value);
return entries.length === 1 && typeof entries[0]![1] === "string"
&& (entries[0]![1] as string).trim() === markup.value.trim();
}
return false;
}
if (!value || typeof value !== "object" || Array.isArray(value)) return false;
const record = value as Record<string, unknown>;
const keys = Object.keys(record);
if (keys.length !== Object.keys(markup.values).length) return false;
return keys.every(key => {
if (!Object.hasOwn(markup.values, key)) return false;
const raw = markup.values[key]!;
const expected = record[key];
if (typeof expected === "string") return expected === raw;
const decoded = tryJson(raw);
return decoded !== undefined && deepEqual(decoded, expected);
});
}
function schemaTypes(schema: unknown): string[] | undefined {
if (!schema || typeof schema !== "object") return undefined;
const record = schema as Record<string, unknown>;
if (typeof record.type === "string") return [record.type];
if (Array.isArray(record.type)) return record.type.filter((entry): entry is string => typeof entry === "string");
const alternatives = Array.isArray(record.anyOf) ? record.anyOf : Array.isArray(record.oneOf) ? record.oneOf : undefined;
if (!alternatives) return undefined;
const types = alternatives.flatMap(entry => schemaTypes(entry) ?? []);
return types.length > 0 ? types : undefined;
}
const DECODE_FAILED = Symbol("decode-failed");
function decodeTyped(raw: string, type: string): unknown {
switch (type) {
case "string": return raw;
case "integer": {
// An integer past 2^53 would serialize as a different number (or null once it overflows).
const parsed = /^-?\d+$/.test(raw.trim()) ? Number(raw.trim()) : Number.NaN;
return Number.isSafeInteger(parsed) ? parsed : DECODE_FAILED;
}
case "number": {
const trimmed = raw.trim();
const parsed = trimmed === "" ? Number.NaN : Number(trimmed);
return Number.isFinite(parsed) ? parsed : DECODE_FAILED;
}
case "boolean": return raw.trim() === "true" ? true : raw.trim() === "false" ? false : DECODE_FAILED;
case "null": return raw.trim() === "null" ? null : DECODE_FAILED;
case "object": {
const parsed = tryJson(raw);
return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : DECODE_FAILED;
}
case "array": {
const parsed = tryJson(raw);
return Array.isArray(parsed) ? parsed : DECODE_FAILED;
}
default: return DECODE_FAILED;
}
}
/** Decode one parameter by its declared schema; a value that fits no declared type fails. */
function decodeParameter(raw: string, schema: unknown): unknown {
const types = schemaTypes(schema);
if (!types) {
const parsed = tryJson(raw);
if (parsed !== undefined && validatesRestoredValue(parsed, schema)) return parsed;
return validatesRestoredValue(raw, schema) ? raw : DECODE_FAILED;
}
// Non-string types first: MiMo writes them as JSON, and a string type would accept anything.
const ordered = [...types.filter(type => type !== "string"), ...types.filter(type => type === "string")];
for (const type of ordered) {
const decoded = decodeTyped(raw, type);
if (decoded !== DECODE_FAILED && validatesRestoredValue(decoded, schema)) return decoded;
}
return DECODE_FAILED;
}
/**
* Arguments for a call restored from markup, or undefined when the markup does not fit the
* declared tool. A freeform tool takes a parameter-free body as its single lowered string field; a
* function tool takes parameters that include every required key, name only declared keys, and
* decode to their declared types.
*/
export function salvagedArguments(markup: ToolCallMarkup, tool: CommandCodeDeclaredTool): string | undefined {
const properties = tool.schema.properties && typeof tool.schema.properties === "object" && !Array.isArray(tool.schema.properties)
? tool.schema.properties as Record<string, unknown>
: {};
const required = Array.isArray(tool.schema.required)
? tool.schema.required.filter((entry): entry is string => typeof entry === "string")
: [];
if (tool.freeform) {
if (markup.kind !== "raw") return undefined;
const keys = Object.keys(properties);
const output = { [keys.length === 1 ? keys[0]! : "input"]: markup.value };
return validatesRestoredValue(output, tool.schema) ? JSON.stringify(output) : undefined;
}
if (markup.kind !== "params") return undefined;
const output: Record<string, unknown> = {};
for (const [key, raw] of Object.entries(markup.values)) {
if (!Object.hasOwn(properties, key)) return undefined;
const decoded = decodeParameter(raw, properties[key]);
if (decoded === DECODE_FAILED) return undefined;
output[key] = decoded;
}
if (required.some(key => !Object.hasOwn(output, key))) return undefined;
if (!validatesRestoredValue(output, tool.schema)) return undefined;
if (tool.declaredSchema !== undefined && !validatesRestoredValue(output, tool.declaredSchema)) return undefined;
return JSON.stringify(output);
}
interface TextBlock {
id: string;
markupParts: string[];
probe: string;
bytes: number;
state: "probing" | "held" | "queued" | "dropped" | "streaming";
ended: boolean;
interrupted: boolean;
/**
* Tool inputs the block could echo: those open when it started, plus, for a post-prose tail,
* at most one later input of the envelope's own tool. The block waits only while one of them
* is still open.
*/
candidates: Set<string>;
/** The one later input a post-prose tail admitted as a candidate, if any. */
lateCandidate?: string;
}
interface TextChunk {
kind: "chunk";
block: TextBlock;
parts: string[];
bytes: number;
}
interface NativeCall {
kind: "native";
id: string;
name: string;
argumentsText: string;
/** Retained only while an earlier text block blocks delivery. */
bytes: number;
}
interface QueuedEvent {
kind: "event";
event: AdapterEvent;
bytes: number;
}
interface Terminal { kind: "finish"; restore: boolean }
type Pending = TextChunk | NativeCall | QueuedEvent | Terminal;
const DEFAULT_TEXT_ID = "\u0000default";
const encoder = new TextEncoder();
/** Stream-side state for one Command Code response. */
export class CommandCodeToolTextFilter {
private readonly openInputs = new Map<string, string>();
private readonly blocks = new Map<string, TextBlock>();
/**
* Only blocks still deciding whether their text is markup (state "probing") need boundary visits;
* a held block is deliberately absent, so no interleaved event can interrupt it.
*/
private readonly activeProbes = new Map<string, TextBlock>();
/** Held blocks in arrival order, including ended ones awaiting a verdict. */
private held: TextBlock[] = [];
/** Every output-bearing event shares this wire-order queue. */
private pending: Pending[] = [];
private head = 0;
private queuedBytes = 0;
private queueOperations = 0;
constructor(
private readonly budget: TranslatorBudget,
private readonly declared: CommandCodeDeclaredTools | undefined,
) {}
/** Counts queue item visits and appends for the bounded-work regression. */
queueOperationsForTest(): number { return this.queueOperations; }
openBlockCountForTest(): number { return this.blocks.size; }
toolInputStart(id: unknown, name: unknown): AdapterEvent[] {
const events = this.breakOpenBlocks();
if (typeof id === "string" && typeof name === "string") {
this.openInputs.set(id, name);
// A post-prose echo can precede the start of the native input it duplicates. An echo
// duplicates one call, so a complete tail admits one later input of its own tool and no
// other: unrelated or repeated starts cannot keep extending the wait. Once every candidate
// closes without a match, matchNative releases the tail as text.
for (const block of this.held) {
if (!block.interrupted || block.candidates.size === 0 || block.lateCandidate !== undefined) continue;
if (looseEnvelopeName(block.markupParts.join(""), this.declared) !== name) continue;
block.lateCandidate = id;
block.candidates.add(id);
}
}
return events;
}
boundary(): AdapterEvent[] { return this.breakOpenBlocks(); }
private breakOpenBlocks(exceptKey?: string): AdapterEvent[] {
let changed = false;
for (const [key, block] of this.activeProbes) {
this.queueOperations++;
if (key === exceptKey) continue;
// Guard only: a held block is not tracked here (textDelta adds probing blocks and drops them
// from the map on the transition to held). It must stay held until settle, in arrival order —
// interrupting it on interleaved events (reasoning deltas, other blocks, the native call
// itself) cleared complete and malformed envelopes alike and released the echoed call as text.
// The queued-byte bound (makeRoom) still caps memory and wait, flushing everything as text if a
// held envelope never resolves while the stream keeps producing.
if (block.state !== "probing") continue;
this.activeProbes.delete(key);
block.interrupted = true;
block.state = "queued";
block.markupParts = [];
changed = true;
}
if (changed) this.held = this.held.filter(block => block.state === "held");
return changed ? this.drain() : [];
}
textStart(id: unknown): AdapterEvent[] {
const key = typeof id === "string" ? id : DEFAULT_TEXT_ID;
const events = this.blocks.has(key) ? this.textEnd(key) : [];
events.push(...this.breakOpenBlocks(key));
const block: TextBlock = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: false, candidates: new Set(this.openInputs.keys()) };
this.blocks.set(key, block);
return events;
}
textDelta(id: unknown, text: string): AdapterEvent[] {
const key = typeof id === "string" ? id : DEFAULT_TEXT_ID;
const boundaryEvents = this.breakOpenBlocks(key);
let block = this.blocks.get(key);
if (!block) {
block = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: false, candidates: new Set(this.openInputs.keys()) };
this.blocks.set(key, block);
}
// Probe before retaining so the state transition precedes the marker scan: a delta that
// carries prose AND a marker must split this visit, not a later one.
if (block.state === "probing") {
this.probeBlockText(block, text);
if (block.state === "probing") this.activeProbes.set(key, block);
else this.activeProbes.delete(key);
}
// Only a bare text block can open protocol markup. Once prose has committed the block, a
// marker inside the delta starts a held tail instead: it never restores a call, but a
// matching native call still strips the echo and an unmatched one releases as text.
if (block.state === "streaming" || block.state === "queued") {
const markerStart = this.findFreshMarker(text);
if (markerStart !== undefined) {
return [
...boundaryEvents,
...this.enqueueTailProse(block, text.slice(0, markerStart)),
...this.openHeldTail(key, text.slice(markerStart)),
];
}
}
if (block.state === "streaming" && this.head === this.pending.length) {
return [...boundaryEvents, { type: "text_delta", text }];
}
// Once a duplicate is dropped, later text is a new chunk at its own wire position.
if (block.state === "dropped" || block.state === "streaming") {
block = { id: key, markupParts: [], probe: "", bytes: 0, state: "queued", ended: false, interrupted: true, candidates: new Set() };
this.blocks.set(key, block);
}
const events = this.retainChunk(block, text);
return [...boundaryEvents, ...events, ...this.limitPending()];
}
/** Find a complete marker or its trailing prefix before either can reach presentation text. */
private findFreshMarker(text: string): number | undefined {
const index = text.indexOf(TOOL_CALL_MARKER);
if (index >= 0) return index;
for (let length = Math.min(text.length, TOOL_CALL_MARKER.length - 1); length > 0; length--) {
if (text.endsWith(TOOL_CALL_MARKER.slice(0, length))) return text.length - length;
}
return undefined;
}
/** Retain a text fragment on a block and append its pending chunk. Never drains. */
private retainChunk(block: TextBlock, text: string): AdapterEvent[] {
const bytes = encoder.encode(text).byteLength;
const flushing = this.queuedBytes + bytes > MAX_HELD_TOOL_TEXT_BYTES;
const preceding = this.makeRoom(bytes);
// The new block has no pending chunk during the flush, so demote it here too.
if (flushing && (block.state === "held" || block.state === "probing")) {
block.state = "queued";
block.markupParts = [];
this.activeProbes.delete(block.id);
}
this.retain(block, text);
const tail = this.pending.at(-1);
if (tail?.kind === "chunk" && tail.block === block && this.head < this.pending.length) {
tail.parts.push(text);
tail.bytes += bytes;
this.queueOperations++;
} else {
this.pending.push({ kind: "chunk", block, parts: [text], bytes });
this.queueOperations++;
}
this.queuedBytes += bytes;
return preceding;
}
/**
* Emit or retain the prose that precedes a mid-prose marker. Streamed text takes the same
* immediate path it would have without a marker; anything queued stays on the wire order.
*/
private enqueueTailProse(block: TextBlock, text: string): AdapterEvent[] {
if (text === "") return [];
if (block.state === "streaming" && this.head === this.pending.length) {
return [{ type: "text_delta", text }];
}
return this.retainChunk(block, text);
}
/**
* Open a budgeted probing/held tail for markup or a marker prefix that followed prose. The tail shares the native-call matching of
* an ordinary held block — a same-content call drops it as an echo — but `interrupted` bars
* restoration forever: prose-prefixed markup can never mint a call, only disappear or be text.
*/
private openHeldTail(key: string, text: string): AdapterEvent[] {
const tail: TextBlock = { id: key, markupParts: [], probe: "", bytes: 0, state: "probing", ended: false, interrupted: true, candidates: new Set(this.openInputs.keys()) };
this.blocks.set(key, tail);
this.probeBlockText(tail, text);
if (tail.state === "probing") this.activeProbes.set(key, tail);
return [...this.retainChunk(tail, text), ...this.limitPending()];
}
textEnd(id: unknown): AdapterEvent[] {
const key = typeof id === "string" ? id : DEFAULT_TEXT_ID;
const block = this.blocks.get(key);
if (!block) return [];
this.blocks.delete(key);
this.activeProbes.delete(key);
block.ended = true;
// A block that never committed to the marker (whitespace, or a marker prefix) is ordinary text.
if (block.state === "probing") {
block.state = "queued";
block.markupParts = [];
return this.drain();
}
if (block.state === "queued") return this.drain();
return [];
}
/** Called before a native call is relayed; returns text that must precede it. */
toolCall(id: string, name: string, input: unknown): AdapterEvent[] {
this.matchNative(id, name, input);
return this.drain();
}
/** Put the native call at its wire position, after matching any earlier held markup. */
nativeCall(id: string, name: string, input: unknown): AdapterEvent[] {
const boundaryEvents = this.breakOpenBlocks();
this.matchNative(id, name, input);
const argumentsText = typeof input === "string" ? input : JSON.stringify(input);
const preceding = this.makeRoom(encoder.encode(argumentsText).byteLength);
const bytes = this.head < this.pending.length ? encoder.encode(argumentsText).byteLength : 0;
if (bytes > 0) this.retainQueued(bytes);
this.pending.push({ kind: "native", id, name, argumentsText, bytes });
this.queueOperations++;
this.queuedBytes += bytes;
return [...boundaryEvents, ...preceding, ...this.limitPending()];
}
/** Reasoning shares the same ordering barrier as text and native calls. */
enqueueEvent(event: AdapterEvent, textValue: string): AdapterEvent[] {
const boundaryEvents = this.breakOpenBlocks();
const preceding = this.makeRoom(encoder.encode(textValue).byteLength);
const bytes = this.head < this.pending.length ? encoder.encode(textValue).byteLength : 0;
if (bytes > 0) this.retainQueued(bytes);
this.pending.push({ kind: "event", event, bytes });
this.queueOperations++;
this.queuedBytes += bytes;
return [...boundaryEvents, ...preceding, ...this.limitPending()];
}
private matchNative(id: string, name: string, input: unknown): void {
this.openInputs.delete(id);
const remaining: TextBlock[] = [];
for (const block of this.held) {
const pairs = block.candidates.size === 0 || block.candidates.has(id);
if (!pairs) {
remaining.push(block);
continue;
}
const text = block.markupParts.join("");
const markup = parseToolCallMarkup(text);
if (markup && markup.name === name && markupMatchesInput(markup, input)) {
this.drop(block);
block.state = "dropped";
this.activeProbes.delete(block.id);
continue;
}
block.candidates.delete(id);
if (block.candidates.size === 0) {
// A malformed envelope cannot match a native input, but it is still an envelope: when the
// native call is for the function it declares, that call carries the execution, so drop the
// echo rather than releasing it as text. A native call for any other tool proves nothing
// about this envelope, so it keeps the release-as-text path below.
// A held tail (markup after prose) never drops on name alone — its context is ordinary
// prose the model wrote, so only an exact input match can prove it is an echo.
if (!block.interrupted && markup === undefined && looseEnvelopeName(text, this.declared) === name) {
this.drop(block);
block.state = "dropped";
this.activeProbes.delete(block.id);
continue;
}
block.state = "queued";
block.markupParts = [];
this.activeProbes.delete(block.id);
} else {
remaining.push(block);
}
}
this.held = remaining;
}
/** Release every held block as text, without restoring any call (used when the turn failed). */
releaseAll(): AdapterEvent[] {
return this.settle(false).events;
}
/** Terminal verdict for every block still held: restore it as a call when it qualifies, else release it. */
finish(): { events: AdapterEvent[]; salvaged: boolean } {
return this.settle(true);
}
private settle(restore: boolean): { events: AdapterEvent[]; salvaged: boolean } {
const events: AdapterEvent[] = [];
let salvaged = false;
let lastTextBlock: TextBlock | undefined;
this.pending.push({ kind: "finish", restore });
const pending = this.pending.slice(this.head);
this.queueOperations += pending.length;
this.held = [];
this.pending = [];
this.head = 0;
this.queuedBytes = 0;
this.blocks.clear();
this.activeProbes.clear();
for (const item of pending) {
this.queueOperations++;
if (item.kind === "finish") break;
if (item.kind === "native") { events.push(...this.emitNative(item)); lastTextBlock = undefined; continue; }
if (item.kind === "event") { this.releaseQueued(item.bytes); events.push(item.event); lastTextBlock = undefined; continue; }
const block = item.block;
if (block.state === "held") {
const markup = restore && !block.interrupted ? parseToolCallMarkup(block.markupParts.join("")) : undefined;
const tool = markup ? this.declared?.get(markup.name) : undefined;
const args = markup && tool ? salvagedArguments(markup, tool) : undefined;
if (markup && args !== undefined) {
this.drop(block);
block.state = "dropped";
const callId = `call_ocx_${randomUUID().replace(/-/g, "")}`;
events.push({ type: "tool_call_start", id: callId, name: markup.name });
events.push({ type: "tool_call_delta", arguments: args });
events.push({ type: "tool_call_end" });
salvaged = true;
lastTextBlock = undefined;
} else if (restore && !block.interrupted && markup === undefined
&& looseEnvelopeName(block.markupParts.join(""), this.declared) !== undefined) {
// A malformed envelope is still an envelope: the native duplicate (observed in every
// capture) carries the call, so the echo is dropped rather than rendered as text.
// Releasing it would put the raw markup back on screen; restoring it could execute a
// second time alongside the native call. The parser must have rejected the text, so an
// envelope that parses but does not fit its schema keeps the release-as-text contract.
this.drop(block);
block.state = "dropped";
lastTextBlock = undefined;
} else {
block.state = "queued";
block.markupParts = [];
}
} else if (block.state === "probing") {
block.state = "queued";
block.markupParts = [];
}
if (block.state === "dropped") {
lastTextBlock = undefined;
continue;
}
const emitted = this.releaseChunk(item);
if (emitted && lastTextBlock === block && events.at(-1)?.type === "text_delta") {
(events.at(-1) as { type: "text_delta"; text: string }).text += emitted.text;
} else if (emitted) events.push(emitted);
lastTextBlock = block;
}
return { events, salvaged };
}
private retain(block: TextBlock, text: string): void {
const bytes = encoder.encode(text).byteLength;
const reservation = this.budget.reserveTransient(bytes, { kind: "live_transient" });
reservation.commitRetained();
if (block.state === "probing" || block.state === "held") block.markupParts.push(text);
block.bytes += bytes;
}
/** The incremental open-of-block probe: decide whether the block's text is tool-call markup. */
private probeBlockText(block: TextBlock, text: string): void {
if (block.state !== "probing") return;
for (const char of text) {
if (!block.probe && char.trim() === "") continue;
block.probe += char;
if (!TOOL_CALL_MARKER.startsWith(block.probe)) {
block.state = "queued";
block.markupParts = [];
break;
}
if (block.probe === TOOL_CALL_MARKER) {
block.state = "held";
block.probe = "";
this.held.push(block);
break;
}
}
}
private drop(block: TextBlock): void {
this.budget.releaseRetained(block.bytes, { kind: "live_transient" });
this.queuedBytes = Math.max(0, this.queuedBytes - block.bytes);
block.bytes = 0;
block.markupParts = [];
}
private releaseChunk(chunk: TextChunk): { type: "text_delta"; text: string } | undefined {
if (chunk.block.state === "dropped") return undefined;
this.budget.releaseRetained(chunk.bytes, { kind: "live_transient" });
this.queuedBytes = Math.max(0, this.queuedBytes - chunk.bytes);
chunk.block.bytes = Math.max(0, chunk.block.bytes - chunk.bytes);
const text = chunk.parts.join("");
return text ? { type: "text_delta", text } : undefined;
}
private retainQueued(bytes: number): void {
this.budget.reserveTransient(bytes, { kind: "live_transient" }).commitRetained();
}
private releaseQueued(bytes: number): void {
if (bytes > 0) {
this.budget.releaseRetained(bytes, { kind: "live_transient" });
this.queuedBytes = Math.max(0, this.queuedBytes - bytes);
}
}
private emitNative(call: NativeCall): AdapterEvent[] {
this.releaseQueued(call.bytes);
return [
{ type: "tool_call_start", id: call.id, name: call.name },
{ type: "tool_call_delta", arguments: call.argumentsText },
{ type: "tool_call_end" },
];
}
private drain(): AdapterEvent[] {
const events: AdapterEvent[] = [];
let lastTextBlock: TextBlock | undefined;
while (this.head < this.pending.length) {
const item = this.pending[this.head]!;
this.queueOperations++;
if (item.kind === "finish" || (item.kind === "chunk" && (item.block.state === "held" || item.block.state === "probing"))) break;
this.head++;
if (item.kind === "chunk") {
const emitted = this.releaseChunk(item);
if (emitted && lastTextBlock === item.block && events.at(-1)?.type === "text_delta") {
(events.at(-1) as { type: "text_delta"; text: string }).text += emitted.text;
} else if (emitted) events.push(emitted);
if (item.block.state === "queued" && item.block.bytes === 0 && !item.block.ended) item.block.state = "streaming";
lastTextBlock = item.block.state === "dropped" ? undefined : item.block;
} else if (item.kind === "native") { events.push(...this.emitNative(item)); lastTextBlock = undefined; }
else { this.releaseQueued(item.bytes); events.push(item.event); lastTextBlock = undefined; }
}
if (this.head === this.pending.length) { this.pending = []; this.head = 0; }
else if (this.head >= 1024 && this.head * 2 >= this.pending.length) {
this.queueOperations += this.pending.length - this.head;
this.pending = this.pending.slice(this.head);
this.head = 0;
}
return events;
}
private limitPending(): AdapterEvent[] {
if (this.queuedBytes <= MAX_HELD_TOOL_TEXT_BYTES) return this.drain();
return this.flushPendingAsText();
}
private makeRoom(additionalBytes: number): AdapterEvent[] {
return this.queuedBytes + additionalBytes > MAX_HELD_TOOL_TEXT_BYTES ? this.flushPendingAsText() : [];
}
private flushPendingAsText(): AdapterEvent[] {
// Drop restoration once the ordered queue fills, then release all text in arrival order.
this.held = [];
this.activeProbes.clear();
for (let index = this.head; index < this.pending.length; index++) {
const item = this.pending[index]!;
this.queueOperations++;
if (item.kind !== "chunk" || (item.block.state !== "held" && item.block.state !== "probing")) continue;
item.block.state = "queued";
item.block.markupParts = [];
}
return this.drain();
}
}