@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
125 lines (119 loc) • 6.49 kB
text/typescript
import { freeformFallbackKeys } from "./apply-patch-envelope";
import { JSON_ESCAPES, scanFreeformWrapper } from "./freeform-wrapper-scan";
/**
* Whether a body could still grow into one complete outer Markdown fence.
*
* `stripMarkdownCodeFence` removes such a fence at completion for exactly the two tools that
* own the grammar, so a fenced body's streamed bytes and its completed input disagree unless
* the stream holds. A buffer that does not open with a fence can never acquire one, so
* ordinary bodies are unaffected; a buffer that does keeps its preview suppressed for the
* whole call, because a closing fence can still be followed by more text that withdraws it.
*/
function mayBecomeFencedBody(text: string, toolName: string): boolean {
if (toolName !== "exec" && toolName !== "apply_patch") return false;
const head = text.trimStart();
if (head === "") return true;
return head.startsWith("```") || "```".startsWith(head);
}
const LOW_SURROGATE_ESCAPE = /^\\u[dD][c-fC-F][0-9a-fA-F]{2}$/;
/**
* The decoded prefix of a JSON string body, stopping at the first byte it cannot resolve.
*
* Every stop is a hold rather than a guess, because `JSON.parse` decides the completed value
* and anything invented here would be retracted. Three of them are not obvious:
*
* An escape JSON does not define makes the whole wrapper unparseable no matter what arrives
* next, so completion falls back to the raw text. Returning `null` for that case stops the
* preview rather than continuing to decode a value the completed item will never carry.
* `\\b` and `\\f` are defined, and were previously decoded to the letters b and f.
*
* A lone high surrogate is not a character. Emitting one alone puts an unpaired code unit in a
* delta the client has to decode by itself, so the pair is emitted together or not at all.
*/
function decodeJsonStringPrefix(body: string): string | null {
let out = "";
for (let i = 0; i < body.length; i++) {
const c = body[i];
if (c === '"') break; // unescaped closing quote: value complete
if (c !== "\\") {
// A literal control character is not legal inside a JSON string, so `JSON.parse` will
// reject this wrapper and completion will return the raw text. Emitting the decoded value
// first is the disagreement this decoder exists to prevent, so stop instead.
if (c!.charCodeAt(0) <= 0x1f) return null;
out += c;
continue;
}
const n = body[i + 1];
if (n === undefined) break; // escape split across chunks: wait for more
if (n === "u") {
const hex = body.slice(i + 2, i + 6);
if (hex.length < 4) break; // split across chunks: wait for more
if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null; // never parses
const code = parseInt(hex, 16);
if (code >= 0xd800 && code <= 0xdbff) {
const low = body.slice(i + 6, i + 12);
if (!LOW_SURROGATE_ESCAPE.test(low)) break;
out += String.fromCharCode(code, parseInt(low.slice(2), 16));
i += 11;
continue;
}
out += String.fromCharCode(code);
i += 5;
continue;
}
const escaped = JSON_ESCAPES.get(n);
if (escaped === undefined) return null; // never parses
out += escaped;
i += 1;
}
return out;
}
/**
* The value to stream so far, or `null` to HOLD because nothing can be decided yet.
*
* `input` is decidable from its prefix: `unwrapFreeformToolInput` returns it whenever the
* key is present, whatever else the object carries, so its value can be unescaped
* progressively and never retracted.
*
* One case escapes that claim and is accepted rather than fixed: a duplicate `input` key.
* `JSON.parse` keeps the last one, so `{"input":"a","input":"b"}` streams a and completes with
* b. Closing it means holding every canonical wrapper until its object parses, which is the
* progressive streaming this path exists to provide. The completed item stays authoritative,
* and no model emits a duplicate key in practice.
*
* A wrapper that turns invalid AFTER streaming has committed has the same shape and the same
* answer. `{"input":"a` followed by `\\qb"}` has already published a when the undefined escape
* arrives, and completion returns the raw text because nothing parses. The preview stops
* there: no rewind, and no decoded text the completed item does not contain. Bounding the
* damage is what is available without giving up progressive streaming, and the args are
* unusable in that case whichever representation wins.
*
* A fallback key decides only at the object's close. It unwraps as the SINGLE string field,
* and a second key can still arrive while the object is open — so a value emitted early would
* have to be taken back. The scan therefore keeps a member table and consults it at the
* close, publishing the wrapped value (or the raw text) without ever reparsing the buffer.
* The routed passthrough in `responses-custom-tool-repair.ts` already holds any object prefix
* for the same reason (#5047).
*
* An object that has not reached a canonical key YET is in exactly that position, and used to
* be treated as raw because it did not match the literal `{"input":"`. It holds now: `input`
* can still arrive after other properties, or wearing an escaped spelling, and completion would
* then unwrap a body whose wrapper syntax had already been published as deltas (#5151). The
* cost of holding is preview on an object body that turns out not to be a wrapper; the cost of
* not holding was publishing bytes the completed item removes.
*/
export function progressiveFreeformInput(args: string, toolName: string): string | null {
const scan = scanFreeformWrapper(args, freeformFallbackKeys(toolName));
if (scan.kind === "input") {
const decoded = decodeJsonStringPrefix(args.slice(scan.valueStart));
if (decoded === null) return null;
return mayBecomeFencedBody(decoded, toolName) ? null : decoded;
}
if (scan.kind === "raw") return mayBecomeFencedBody(args, toolName) ? null : args;
// Undecided: an incomplete object, or a close whose tail is clamped out of view. Both stay
// held — the first is provably incomplete, and re-walking a budget-exhausted buffer on every
// delta is work for a preview that arrives in the same instant as the authoritative
// completion behind it. A closed object the scan could see whole never reaches here: its
// member table already resolved it to `input` or `raw`.
return null;
}