UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

252 lines (230 loc) • 9.76 kB
import type { AdapterEvent } from "../types"; import { modelInList } from "../types"; import type { TranslatorBudget } from "../lib/translator-budget"; type ThinkingTag = "<thinking>" | "<think>" | "<reasoning>"; type ParserState = "pre" | "thinking" | "scanning" | "streaming"; const OPEN_TAGS: ThinkingTag[] = ["<thinking>", "<think>", "<reasoning>"]; const MAX_OPEN_TAG = Math.max(...OPEN_TAGS.map(t => t.length)); const MAX_CLOSE_TAG = Math.max(...OPEN_TAGS.map(t => `</${t.slice(1)}`.length)); function closeTagFor(openTag: ThinkingTag): string { return `</${openTag.slice(1)}`; } function isPossibleOpenTagPrefix(text: string): boolean { return OPEN_TAGS.some(tag => tag.startsWith(text) && text.length < tag.length); } /** Move a send boundary back one unit rather than splitting a surrogate pair into U+FFFD. */ function surrogateSafeCut(text: string, cut: number): number { if (cut <= 0 || cut >= text.length) return Math.max(0, Math.min(cut, text.length)); const atCut = text.charCodeAt(cut - 1); return atCut >= 0xd800 && atCut <= 0xdbff ? cut - 1 : cut; } export interface InlineThinkTagOptions { /** * Keep scanning for further think blocks after the first one closes. Kiro emits a single * leading block, so it leaves this off and streams the rest verbatim. MiniMax M-series * interleaves several blocks with answer segments, so a reusing adapter opts in. */ interleaved?: boolean; } /** * Recovers thinking that a gateway left inline in visible content as `<think>` blocks instead of * a separate `reasoning_content` / `reasoning_details` field. Shared by the Kiro adapter and by * the openai-chat adapter's opt-in `inlineThinkTagModels`. */ export class InlineThinkTagParser { private state: ParserState = "pre"; private preWhitespaceChunks: string[] = []; private preWhitespaceLength = 0; private preWhitespaceBytes = 0; private preBuffer = ""; private thinkingBuffer = ""; private closeTag = ""; private readonly interleaved: boolean; constructor(private readonly budget?: TranslatorBudget, options?: InlineThinkTagOptions) { this.interleaved = options?.interleaved === true; } private replaceCarry(field: "preBuffer" | "thinkingBuffer", next: string): void { const previous = this[field]; if (previous === next) return; const previousBytes = Buffer.byteLength(previous); const nextBytes = Buffer.byteLength(next); const reservation = this.budget?.reserveTransient(nextBytes, { kind: "reasoning" }); this[field] = next; reservation?.commitRetained(); this.budget?.releaseRetained(previousBytes, { kind: "reasoning" }); } private appendPreWhitespace(text: string): void { if (!text) return; const bytes = Buffer.byteLength(text); const reservation = this.budget?.reserveTransient(bytes, { kind: "reasoning" }); this.preWhitespaceChunks.push(text); this.preWhitespaceLength += text.length; this.preWhitespaceBytes += bytes; reservation?.commitRetained(); } private finishPreWhitespace(emit: boolean): string { if (this.preWhitespaceLength === 0) return ""; const reservation = emit ? this.budget?.reserveTransient(this.preWhitespaceBytes, { kind: "reasoning" }) : undefined; try { return emit ? this.preWhitespaceChunks.join("") : ""; } finally { this.preWhitespaceChunks.length = 0; this.preWhitespaceLength = 0; this.budget?.releaseRetained(this.preWhitespaceBytes, { kind: "reasoning" }); this.preWhitespaceBytes = 0; reservation?.release(); } } feed(text: string): AdapterEvent[] { if (!text) return []; if (this.state === "streaming") return [{ type: "text_delta", text }]; let input = text; if (this.state === "pre") { if (this.preBuffer) { input = this.preBuffer + text; this.replaceCarry("preBuffer", ""); } else { const stripped = text.trimStart(); const leadingLength = text.length - stripped.length; if (leadingLength > 0) this.appendPreWhitespace(text.slice(0, leadingLength)); if (!stripped) return []; input = stripped; } const openTag = OPEN_TAGS.find(tag => input.startsWith(tag)); if (openTag) { const leading = this.finishPreWhitespace(this.interleaved); this.state = "thinking"; this.closeTag = closeTagFor(openTag); const events: AdapterEvent[] = leading ? [{ type: "text_delta", text: leading }] : []; return this.drainChunk(input, openTag.length, events); } if (input.length <= MAX_OPEN_TAG && isPossibleOpenTagPrefix(input)) { this.replaceCarry("preBuffer", input); return []; } this.state = "streaming"; return [{ type: "text_delta", text: this.finishPreWhitespace(true) + input }]; } if (this.state === "thinking") { input = this.thinkingBuffer + text; this.replaceCarry("thinkingBuffer", ""); } else { input = this.preBuffer + text; this.replaceCarry("preBuffer", ""); } return this.drainChunk(input, 0, []); } flush(): AdapterEvent[] { if (this.state === "thinking") { const out = this.thinkingBuffer; this.replaceCarry("thinkingBuffer", ""); this.state = "streaming"; return out ? [{ type: "reasoning_raw_delta", text: out }] : []; } if (this.preWhitespaceLength > 0 || this.preBuffer) { const out = this.finishPreWhitespace(true) + this.preBuffer; this.replaceCarry("preBuffer", ""); this.state = "streaming"; return [{ type: "text_delta", text: out }]; } return []; } /** Release any partial tag/content carry when the owning stream stops early. */ dispose(): void { this.finishPreWhitespace(false); this.replaceCarry("preBuffer", ""); this.replaceCarry("thinkingBuffer", ""); this.closeTag = ""; this.state = "streaming"; } private drainChunk(input: string, start: number, events: AdapterEvent[]): AdapterEvent[] { let offset = start; for (;;) { if (this.state === "thinking") { const idx = input.indexOf(this.closeTag, offset); if (idx >= 0) { if (idx > offset) events.push({ type: "reasoning_raw_delta", text: input.slice(offset, idx) }); offset = idx + this.closeTag.length; if (!this.interleaved) { // Opt-in Chat answers are byte-preserving; keep Kiro's legacy normalization. const after = input.slice(offset).trimStart(); this.state = "streaming"; if (after) events.push({ type: "text_delta", text: after }); return events; } this.state = "scanning"; continue; } // Keep only a possible close tag, and do not split a surrogate pair. const cut = Math.max(offset, surrogateSafeCut(input, input.length - MAX_CLOSE_TAG)); if (cut > offset) events.push({ type: "reasoning_raw_delta", text: input.slice(offset, cut) }); this.replaceCarry("thinkingBuffer", input.slice(cut)); return events; } // Interleaved mode has already seen a leading tag; later tags delimit anywhere. let openIndex = input.indexOf("<", offset); let openTag: ThinkingTag | undefined; while (openIndex >= 0) { openTag = OPEN_TAGS.find(tag => input.startsWith(tag, openIndex)); if (openTag) break; openIndex = input.indexOf("<", openIndex + 1); } if (openIndex >= 0 && openTag) { if (openIndex > offset) events.push({ type: "text_delta", text: input.slice(offset, openIndex) }); offset = openIndex + openTag.length; this.state = "thinking"; this.closeTag = closeTagFor(openTag); continue; } // Hold back only a possible open-tag prefix, with a surrogate-safe boundary. const cut = Math.max(offset, surrogateSafeCut(input, input.length - (MAX_OPEN_TAG - 1))); if (cut > offset) events.push({ type: "text_delta", text: input.slice(offset, cut) }); this.replaceCarry("preBuffer", input.slice(cut)); return events; } } } /** Visible-content splitter the openai-chat adapter holds for the life of one response. */ export interface InlineThinkContentSplitter { feed(text: string): AdapterEvent[]; flush(): AdapterEvent[]; dispose(): void; } const PASSTHROUGH: InlineThinkContentSplitter = { feed: text => [{ type: "text_delta", text }], flush: () => [], dispose: () => { /* nothing carried */ }, }; /** * Opt-in recovery for `inlineThinkTagModels`. A model that is not listed gets a passthrough that * never inspects or rewrites visible content, so the 66 registry providers sharing the openai-chat * adapter keep byte-exact behavior. */ export function createInlineThinkContentSplitter( models: string[] | undefined, modelId: string | undefined, budget?: TranslatorBudget, ): InlineThinkContentSplitter { if (!modelInList(models, modelId ?? "")) return PASSTHROUGH; const parser = new InlineThinkTagParser(budget, { interleaved: true }); return { // An empty content delta stays an empty delta: it is a wire signal, not thinking. feed: text => (text.length === 0 ? [{ type: "text_delta", text }] : parser.feed(text)), flush: () => parser.flush(), dispose: () => parser.dispose(), }; } /** One-shot form for a non-streaming response body. */ export function splitInlineThinkContent( models: string[] | undefined, modelId: string | undefined, budget: TranslatorBudget | undefined, content: string, ): AdapterEvent[] { const splitter = createInlineThinkContentSplitter(models, modelId, budget); try { return [...splitter.feed(content), ...splitter.flush()]; } finally { splitter.dispose(); } }