@sentropic/h2a-runtime 0.91.1 → 0.92.0

package/dist/llm-gateway-runtime/proxy-openai.js

@@ -1,1305 +0,0 @@
-/**
- * Anthropic Messages API → OpenAI Chat Completions proxy.
- *
- * Activated when the account's provider is "openai" or "codex". Translates
- * requests and responses between the two formats so Claude Code (which speaks
- * Anthropic) can transparently use OpenAI/Codex models.
- *
- * Model routing comes from @sentropic/llm-gateway's canonical descriptions,
- * with OPENAI_MODEL_MAP retained only as an explicit operator override.
- *
- * Thinking budget_tokens → reasoning effort:
- *   ≥ 50 000 (xhigh) → "xhigh"
- *   ≥ 25 000 (high)  → "high"
- *   ≥  8 000 (med)   → "medium"
- *   < 8 000 / none   → "low"
- */
-import { CODEX_RESPONSES_URL } from "@sentropic/llm-gateway";
-import { isCodexOAuthToken, refreshOAuthToken, } from "./accounts.js";
-import { routeModelOrThrow } from "./model-catalog.js";
-const OPENAI_BASE = process.env.OPENAI_UPSTREAM_URL ?? "https://api.openai.com";
-const DEFAULT_CODEX_MAX_INPUT_CHARS = 200_000;
-const CODEX_CONTEXT_TRUNCATION_NOTICE = "[llm-gateway: older Claude Code transcript omitted to fit the Codex upstream context window.]";
-const TRANSIENT_UPSTREAM_ERROR_CODES = new Set([
-    "EAI_AGAIN",
-    "ECONNRESET",
-    "ETIMEDOUT",
-    "UND_ERR_CONNECT_TIMEOUT",
-    "UND_ERR_HEADERS_TIMEOUT",
-    "UND_ERR_SOCKET",
-]);
-const UPSTREAM_RETRY_DELAYS_MS = process.env.NODE_ENV === "test" ? [0, 0] : [250, 1000];
-function abortError(err) {
-    return err.name === "AbortError";
-}
-function upstreamErrorCause(err) {
-    const candidate = err;
-    if (candidate.code || candidate.hostname)
-        return candidate;
-    return candidate.cause;
-}
-function upstreamFetchErrorMessage(err) {
-    const cause = upstreamErrorCause(err);
-    if (cause?.code && cause.hostname)
-        return `${cause.code} ${cause.hostname}`;
-    if (cause?.code)
-        return cause.code;
-    if (err instanceof Error && err.message)
-        return err.message;
-    return "unknown upstream fetch error";
-}
-function isTransientUpstreamError(err) {
-    const code = upstreamErrorCause(err)?.code;
-    return !!code && TRANSIENT_UPSTREAM_ERROR_CODES.has(code);
-}
-function anthropicGatewayError(message) {
-    return { type: "error", error: { type: "api_error", message } };
-}
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function prepareCodexResponsesRequest(request) {
-    const { max_output_tokens: _maxOutputTokens, ...rest } = request;
-    return {
-        url: CODEX_RESPONSES_URL,
-        body: {
-            ...rest,
-            store: false,
-        },
-    };
-}
-function codexRequestEffort(body) {
-    const reasoning = asRecord(body.reasoning);
-    const effort = reasoning?.effort;
-    return typeof effort === "string" ? effort : undefined;
-}
-async function refreshOAuthTokenForRetry(accountId) {
-    try {
-        return await refreshOAuthToken(accountId);
-    }
-    catch (err) {
-        console.error(`[llm-gateway] OAuth refresh failed for ${accountId}:`, err);
-        return null;
-    }
-}
-async function sleep(ms) {
-    if (ms <= 0)
-        return;
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function fetchUpstreamWithRetry(fetcher) {
-    for (let attempt = 0;; attempt += 1) {
-        try {
-            return await fetcher();
-        }
-        catch (err) {
-            if (abortError(err) ||
-                !isTransientUpstreamError(err) ||
-                attempt >= UPSTREAM_RETRY_DELAYS_MS.length) {
-                throw err;
-            }
-            await sleep(UPSTREAM_RETRY_DELAYS_MS[attempt] ?? 0);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Model mapping
-// ---------------------------------------------------------------------------
-export function mapModel(anthropicModel) {
-    return routeModelOrThrow(anthropicModel).upstreamModel ?? anthropicModel;
-}
-/**
- * Anthropic thinking budget_tokens → OpenAI reasoning_effort.
- * Covers all 4 Claude effort tiers:
- *   xhigh (≥ 50 k) → "xhigh" (pass-through; upstream rejection stays explicit)
- *   high  (≥ 25 k) → "high"
- *   med   (≥  8 k) → "medium"
- *   low   (<  8 k) → "low"
- */
-export function budgetToEffort(budgetTokens) {
-    if (budgetTokens >= 50_000)
-        return "xhigh";
-    if (budgetTokens >= 25_000)
-        return "high";
-    if (budgetTokens >= 8_000)
-        return "medium";
-    return "low";
-}
-const EMPTY_TOOL_RESULT_PLACEHOLDER = "[llm-gateway: empty tool result omitted.]";
-function unsupportedContentPlaceholder(block) {
-    const record = block;
-    const source = asRecord(record.source);
-    const mediaType = typeof source?.media_type === "string"
-        ? source.media_type
-        : typeof record.media_type === "string"
-            ? record.media_type
-            : undefined;
-    const label = mediaType ? `${block.type} ${mediaType}` : block.type;
-    return `[llm-gateway: unsupported ${label} content omitted.]`;
-}
-function normalizeUnsupportedContentBlocks(content) {
-    if (typeof content === "string")
-        return content;
-    return content.map((block) => {
-        if (block.type === "text" ||
-            block.type === "tool_use" ||
-            block.type === "thinking") {
-            return block;
-        }
-        if (block.type === "tool_result") {
-            const tr = block;
-            return {
-                ...tr,
-                content: typeof tr.content === "string"
-                    ? tr.content
-                    : normalizeUnsupportedContentBlocks(tr.content),
-            };
-        }
-        return {
-            type: "text",
-            text: unsupportedContentPlaceholder(block),
-        };
-    });
-}
-function normalizeUnsupportedRequestContent(body) {
-    const normalized = {
-        ...body,
-        messages: body.messages.map((message) => ({
-            ...message,
-            content: normalizeUnsupportedContentBlocks(message.content),
-        })),
-    };
-    if (Array.isArray(body.system)) {
-        normalized.system = normalizeUnsupportedContentBlocks(body.system);
-    }
-    else if (body.system !== undefined) {
-        normalized.system = body.system;
-    }
-    return normalized;
-}
-function toolResultContentToText(content) {
-    const text = typeof content === "string"
-        ? content
-        : normalizeUnsupportedContentBlocks(content)
-            .map((block) => block.type === "text"
-            ? block.text
-            : unsupportedContentPlaceholder(block))
-            .join("");
-    return text.length > 0 ? text : EMPTY_TOOL_RESULT_PLACEHOLDER;
-}
-function extractAssistantContent(content) {
-    if (typeof content === "string")
-        return { text: content || null, toolCalls: [] };
-    const texts = [];
-    const toolCalls = [];
-    for (const item of content) {
-        if (item.type === "text") {
-            texts.push(item.text);
-        }
-        else if (item.type === "tool_use") {
-            const tc = item;
-            toolCalls.push({
-                id: tc.id,
-                type: "function",
-                function: { name: tc.name, arguments: JSON.stringify(tc.input) },
-            });
-        }
-        // thinking blocks: dropped (OpenAI reasons internally)
-    }
-    return { text: texts.join("") || null, toolCalls };
-}
-function toOAIMessages(messages) {
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant") {
-            const { text, toolCalls } = extractAssistantContent(msg.content);
-            const entry = { role: "assistant", content: text };
-            if (toolCalls.length > 0)
-                entry.tool_calls = toolCalls;
-            result.push(entry);
-        }
-        else {
-            // user: may contain tool_result blocks
-            if (Array.isArray(msg.content)) {
-                for (const item of msg.content) {
-                    if (item.type === "tool_result") {
-                        const tr = item;
-                        result.push({
-                            role: "tool",
-                            tool_call_id: tr.tool_use_id,
-                            content: toolResultContentToText(tr.content),
-                        });
-                    }
-                }
-                const textItems = msg.content.filter((c) => c.type === "text");
-                if (textItems.length > 0) {
-                    result.push({
-                        role: "user",
-                        content: textItems.map((t) => ({
-                            type: "text",
-                            text: t.text,
-                        })),
-                    });
-                }
-            }
-            else {
-                result.push({ role: "user", content: msg.content });
-            }
-        }
-    }
-    return result;
-}
-function systemToText(system) {
-    if (typeof system === "string")
-        return system || undefined;
-    if (!Array.isArray(system))
-        return undefined;
-    const parts = [];
-    for (const block of system) {
-        if (block.type === "text") {
-            parts.push(block.text);
-        }
-    }
-    return parts.join("\n\n") || undefined;
-}
-// ---------------------------------------------------------------------------
-// Request translation: Anthropic → OpenAI Responses API (Codex OAuth path)
-// ---------------------------------------------------------------------------
-function toCodexInput(messages) {
-    const items = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant") {
-            const texts = [];
-            const toolCalls = [];
-            if (typeof msg.content === "string") {
-                if (msg.content)
-                    texts.push(msg.content);
-            }
-            else {
-                for (const block of msg.content) {
-                    if (block.type === "text")
-                        texts.push(block.text);
-                    else if (block.type === "tool_use")
-                        toolCalls.push(block);
-                    // thinking blocks: skip
-                }
-            }
-            const text = texts.join("");
-            if (text || toolCalls.length === 0) {
-                items.push({ type: "message", role: "assistant", content: text });
-            }
-            for (const tc of toolCalls) {
-                items.push({
-                    type: "function_call",
-                    call_id: tc.id,
-                    name: tc.name,
-                    arguments: JSON.stringify(tc.input),
-                });
-            }
-        }
-        else {
-            const texts = [];
-            const toolResults = [];
-            if (typeof msg.content === "string") {
-                if (msg.content)
-                    texts.push(msg.content);
-            }
-            else {
-                for (const block of msg.content) {
-                    if (block.type === "text")
-                        texts.push(block.text);
-                    else if (block.type === "tool_result")
-                        toolResults.push(block);
-                }
-            }
-            for (const tr of toolResults) {
-                items.push({
-                    type: "function_call_output",
-                    call_id: tr.tool_use_id,
-                    output: toolResultContentToText(tr.content),
-                });
-            }
-            const text = texts.join("");
-            if (text)
-                items.push({ type: "message", role: "user", content: text });
-        }
-    }
-    return items;
-}
-function codexEffort(budgetTokens) {
-    return budgetToEffort(budgetTokens);
-}
-export function toCodexRequest(body, canonicalEffort) {
-    body = normalizeUnsupportedRequestContent(body);
-    const req = {
-        model: mapModel(body.model),
-        input: toCodexInput(body.messages),
-        store: false,
-        stream: true,
-    };
-    const instructions = systemToText(body.system);
-    if (instructions)
-        req.instructions = instructions;
-    const effort = canonicalEffort ??
-        (body.thinking?.type === "enabled"
-            ? codexEffort(body.thinking.budget_tokens)
-            : undefined);
-    if (effort) {
-        req.reasoning = { effort };
-    }
-    if (body.tools && body.tools.length > 0) {
-        req.tools = body.tools.map((t) => ({
-            type: "function",
-            name: t.name,
-            ...(t.description !== undefined ? { description: t.description } : {}),
-            parameters: t.input_schema,
-            strict: false,
-        }));
-    }
-    return req;
-}
-function codexMaxInputChars() {
-    const configured = Number.parseInt(process.env.CODEX_MAX_INPUT_CHARS ?? "", 10);
-    return Number.isFinite(configured) && configured > 0
-        ? configured
-        : DEFAULT_CODEX_MAX_INPUT_CHARS;
-}
-function anthropicInputChars(body) {
-    return JSON.stringify({ system: body.system, messages: body.messages })
-        .length;
-}
-function trimTextTail(text, budget) {
-    if (text.length <= budget)
-        return text;
-    if (budget <= CODEX_CONTEXT_TRUNCATION_NOTICE.length + 8) {
-        return CODEX_CONTEXT_TRUNCATION_NOTICE.slice(0, Math.max(0, budget));
-    }
-    const prefix = `${CODEX_CONTEXT_TRUNCATION_NOTICE}\n\n`;
-    return prefix + text.slice(-(budget - prefix.length));
-}
-function trimContentTail(content, budget) {
-    if (typeof content === "string")
-        return trimTextTail(content, budget);
-    const kept = [];
-    let remaining = budget;
-    for (let i = content.length - 1; i >= 0; i -= 1) {
-        const block = content[i];
-        const size = JSON.stringify(block).length;
-        if (size <= remaining) {
-            kept.unshift(block);
-            remaining -= size;
-            continue;
-        }
-        if (block.type === "text" &&
-            remaining > CODEX_CONTEXT_TRUNCATION_NOTICE.length + 32) {
-            kept.unshift({
-                ...block,
-                text: trimTextTail(block.text, remaining),
-            });
-        }
-        break;
-    }
-    return kept.length > 0
-        ? kept
-        : [{ type: "text", text: CODEX_CONTEXT_TRUNCATION_NOTICE }];
-}
-function stripLeadingOrphanToolResults(messages) {
-    if (messages.length === 0)
-        return messages;
-    const first = messages[0];
-    if (first.role !== "user" || !Array.isArray(first.content))
-        return messages;
-    const filtered = first.content.filter((block) => block.type !== "tool_result");
-    if (filtered.length === first.content.length)
-        return messages;
-    if (filtered.length === 0)
-        return messages.slice(1);
-    return [{ ...first, content: filtered }, ...messages.slice(1)];
-}
-export function trimCodexBodyForContext(body, maxChars = codexMaxInputChars()) {
-    body = normalizeUnsupportedRequestContent(body);
-    const beforeChars = anthropicInputChars(body);
-    if (beforeChars <= maxChars) {
-        return { body, trimmed: false, beforeChars, afterChars: beforeChars };
-    }
-    const notice = {
-        role: "user",
-        content: CODEX_CONTEXT_TRUNCATION_NOTICE,
-    };
-    const systemChars = JSON.stringify(body.system ?? "").length;
-    const noticeChars = JSON.stringify(notice).length;
-    let remaining = Math.max(1024, maxChars - systemChars - noticeChars);
-    const kept = [];
-    for (let i = body.messages.length - 1; i >= 0; i -= 1) {
-        const message = body.messages[i];
-        const messageChars = JSON.stringify(message).length;
-        if (messageChars <= remaining) {
-            kept.unshift(message);
-            remaining -= messageChars;
-            continue;
-        }
-        if (kept.length === 0 && remaining > 1024) {
-            kept.unshift({
-                ...message,
-                content: trimContentTail(message.content, remaining),
-            });
-        }
-        break;
-    }
-    const trimmedMessages = stripLeadingOrphanToolResults(kept);
-    const trimmedBody = {
-        ...body,
-        messages: [notice, ...trimmedMessages],
-    };
-    const afterChars = anthropicInputChars(trimmedBody);
-    return { body: trimmedBody, trimmed: true, beforeChars, afterChars };
-}
-// ---------------------------------------------------------------------------
-// Request translation: Anthropic → OpenAI Chat Completions (standard sk- key)
-// ---------------------------------------------------------------------------
-export function toOpenAIRequest(body, canonicalEffort) {
-    body = normalizeUnsupportedRequestContent(body);
-    const messages = [];
-    const system = systemToText(body.system);
-    if (system)
-        messages.push({ role: "system", content: system });
-    messages.push(...toOAIMessages(body.messages));
-    const req = {
-        model: mapModel(body.model),
-        messages,
-        max_completion_tokens: body.max_tokens,
-    };
-    if (body.stream) {
-        req.stream = true;
-        req.stream_options = { include_usage: true };
-    }
-    const effort = canonicalEffort ??
-        (body.thinking?.type === "enabled"
-            ? budgetToEffort(body.thinking.budget_tokens)
-            : undefined);
-    if (effort) {
-        req.reasoning_effort = effort;
-    }
-    if (body.tools && body.tools.length > 0) {
-        req.tools = body.tools.map((t) => ({
-            type: "function",
-            function: {
-                name: t.name,
-                ...(t.description !== undefined ? { description: t.description } : {}),
-                parameters: t.input_schema,
-            },
-        }));
-    }
-    return req;
-}
-export function toAnthropicResponse(openai, originalModel) {
-    const choice = openai.choices[0];
-    const message = choice?.message;
-    const content = [];
-    if (message?.content) {
-        content.push({ type: "text", text: message.content });
-    }
-    for (const tc of message?.tool_calls ?? []) {
-        let input = {};
-        try {
-            input = JSON.parse(tc.function.arguments);
-        }
-        catch {
-            /* leave empty */
-        }
-        content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.function.name,
-            input,
-        });
-    }
-    const stopReason = choice?.finish_reason === "tool_calls"
-        ? "tool_use"
-        : choice?.finish_reason === "length"
-            ? "max_tokens"
-            : "end_turn";
-    return {
-        id: openai.id ?? `msg_${Date.now().toString(36)}`,
-        type: "message",
-        role: "assistant",
-        content,
-        model: originalModel,
-        stop_reason: stopReason,
-        stop_sequence: null,
-        usage: {
-            input_tokens: openai.usage?.prompt_tokens ?? 0,
-            output_tokens: openai.usage?.completion_tokens ?? 0,
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Streaming translation: OpenAI SSE → Anthropic SSE
-// ---------------------------------------------------------------------------
-function sseEvent(event, data) {
-    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
-}
-function closeStreamWithGatewayError(controller, enc, message) {
-    try {
-        controller.enqueue(enc.encode(sseEvent("error", anthropicGatewayError(message))));
-    }
-    catch {
-        // The downstream client may already be gone.
-    }
-    try {
-        controller.close();
-    }
-    catch {
-        // The stream may already be closed or errored.
-    }
-}
-export function translateOpenAIStreamToAnthropic(openaiStream, originalModel, messageId, estimatedInputTokens) {
-    const enc = new TextEncoder();
-    return new ReadableStream({
-        async start(controller) {
-            const emit = (s) => controller.enqueue(enc.encode(s));
-            // Anthropic content block state
-            let nextBlockIdx = 0;
-            let textBlockIdx = -1;
-            let textBlockOpen = false;
-            // OpenAI tool_call index → Anthropic block index
-            const toolBlockMap = new Map();
-            let outputTokens = 0;
-            let stopReason = "end_turn";
-            emit(sseEvent("message_start", {
-                type: "message_start",
-                message: {
-                    id: messageId,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model: originalModel,
-                    stop_reason: null,
-                    stop_sequence: null,
-                    usage: { input_tokens: estimatedInputTokens, output_tokens: 0 },
-                },
-            }));
-            emit(sseEvent("ping", { type: "ping" }));
-            const reader = openaiStream.getReader();
-            let buf = "";
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buf += new TextDecoder().decode(value);
-                    const lines = buf.split("\n");
-                    buf = lines.pop() ?? "";
-                    for (const line of lines) {
-                        if (!line.startsWith("data: "))
-                            continue;
-                        const raw = line.slice(6).trim();
-                        if (raw === "[DONE]") {
-                            // Close any open blocks
-                            if (textBlockOpen) {
-                                emit(sseEvent("content_block_stop", {
-                                    type: "content_block_stop",
-                                    index: textBlockIdx,
-                                }));
-                            }
-                            for (const [, blockIdx] of toolBlockMap) {
-                                emit(sseEvent("content_block_stop", {
-                                    type: "content_block_stop",
-                                    index: blockIdx,
-                                }));
-                            }
-                            emit(sseEvent("message_delta", {
-                                type: "message_delta",
-                                delta: { stop_reason: stopReason, stop_sequence: null },
-                                usage: { output_tokens: outputTokens },
-                            }));
-                            emit(sseEvent("message_stop", { type: "message_stop" }));
-                            controller.close();
-                            return;
-                        }
-                        let chunk;
-                        try {
-                            chunk = JSON.parse(raw);
-                        }
-                        catch {
-                            continue;
-                        }
-                        // Trailing usage (stream_options: {include_usage: true})
-                        if (chunk.usage?.completion_tokens)
-                            outputTokens = chunk.usage.completion_tokens;
-                        const choice = chunk.choices?.[0];
-                        if (!choice)
-                            continue;
-                        if (choice.finish_reason) {
-                            stopReason =
-                                choice.finish_reason === "tool_calls"
-                                    ? "tool_use"
-                                    : choice.finish_reason === "length"
-                                        ? "max_tokens"
-                                        : "end_turn";
-                        }
-                        const delta = choice.delta;
-                        if (!delta)
-                            continue;
-                        // Text content
-                        if (typeof delta.content === "string" && delta.content.length > 0) {
-                            if (!textBlockOpen) {
-                                textBlockIdx = nextBlockIdx++;
-                                textBlockOpen = true;
-                                emit(sseEvent("content_block_start", {
-                                    type: "content_block_start",
-                                    index: textBlockIdx,
-                                    content_block: { type: "text", text: "" },
-                                }));
-                            }
-                            emit(sseEvent("content_block_delta", {
-                                type: "content_block_delta",
-                                index: textBlockIdx,
-                                delta: { type: "text_delta", text: delta.content },
-                            }));
-                        }
-                        // Tool calls
-                        for (const tc of delta.tool_calls ?? []) {
-                            // Close text block when tool calls start
-                            if (textBlockOpen) {
-                                emit(sseEvent("content_block_stop", {
-                                    type: "content_block_stop",
-                                    index: textBlockIdx,
-                                }));
-                                textBlockOpen = false;
-                            }
-                            if (!toolBlockMap.has(tc.index)) {
-                                const blockIdx = nextBlockIdx++;
-                                toolBlockMap.set(tc.index, blockIdx);
-                                emit(sseEvent("content_block_start", {
-                                    type: "content_block_start",
-                                    index: blockIdx,
-                                    content_block: {
-                                        type: "tool_use",
-                                        id: tc.id ?? `toolu_${tc.index}`,
-                                        name: tc.function?.name ?? "",
-                                        input: {},
-                                    },
-                                }));
-                            }
-                            const blockIdx = toolBlockMap.get(tc.index);
-                            if (tc.function?.arguments) {
-                                emit(sseEvent("content_block_delta", {
-                                    type: "content_block_delta",
-                                    index: blockIdx,
-                                    delta: {
-                                        type: "input_json_delta",
-                                        partial_json: tc.function.arguments,
-                                    },
-                                }));
-                            }
-                        }
-                    }
-                }
-                // Stream ended without [DONE] — close gracefully
-                if (textBlockOpen) {
-                    emit(sseEvent("content_block_stop", {
-                        type: "content_block_stop",
-                        index: textBlockIdx,
-                    }));
-                }
-                for (const [, blockIdx] of toolBlockMap) {
-                    emit(sseEvent("content_block_stop", {
-                        type: "content_block_stop",
-                        index: blockIdx,
-                    }));
-                }
-                emit(sseEvent("message_delta", {
-                    type: "message_delta",
-                    delta: { stop_reason: stopReason, stop_sequence: null },
-                    usage: { output_tokens: outputTokens },
-                }));
-                emit(sseEvent("message_stop", { type: "message_stop" }));
-                controller.close();
-            }
-            catch (err) {
-                closeStreamWithGatewayError(controller, enc, `Upstream stream failed: ${upstreamFetchErrorMessage(err)}`);
-            }
-            finally {
-                reader.releaseLock();
-            }
-        },
-    });
-}
-// ---------------------------------------------------------------------------
-// Streaming translation: Codex Responses API SSE → Anthropic SSE
-// ---------------------------------------------------------------------------
-export function translateCodexStreamToAnthropic(codexStream, originalModel, messageId, estimatedInputTokens) {
-    const enc = new TextEncoder();
-    return new ReadableStream({
-        async start(controller) {
-            const emit = (s) => controller.enqueue(enc.encode(s));
-            let nextBlockIdx = 0;
-            // output_index → {type, idx}. `argsSent` accumulates the tool-argument
-            // JSON already relayed to the client, so the terminal arguments can be
-            // reconciled against it rather than blindly appended or blindly skipped.
-            const blockMap = new Map();
-            let textBlockOpen = false;
-            let outputTokens = 0;
-            let stopReason = "end_turn";
-            emit(sseEvent("message_start", {
-                type: "message_start",
-                message: {
-                    id: messageId,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model: originalModel,
-                    stop_reason: null,
-                    stop_sequence: null,
-                    usage: { input_tokens: estimatedInputTokens, output_tokens: 0 },
-                },
-            }));
-            emit(sseEvent("ping", { type: "ping" }));
-            const reader = codexStream.getReader();
-            let buf = "";
-            let currentEvent = "";
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buf += new TextDecoder().decode(value);
-                    const lines = buf.split("\n");
-                    buf = lines.pop() ?? "";
-                    for (const line of lines) {
-                        if (line.startsWith("event: ")) {
-                            currentEvent = line.slice(7).trim();
-                            continue;
-                        }
-                        if (!line.startsWith("data: ")) {
-                            if (line === "")
-                                currentEvent = "";
-                            continue;
-                        }
-                        const raw = line.slice(6).trim();
-                        if (raw === "[DONE]")
-                            continue;
-                        let data;
-                        try {
-                            data = JSON.parse(raw);
-                        }
-                        catch {
-                            continue;
-                        }
-                        const evType = data.type ?? currentEvent;
-                        const outputIndex = data.output_index ?? 0;
-                        switch (evType) {
-                            case "response.output_item.added": {
-                                const item = data.item;
-                                if (!item)
-                                    break;
-                                if (item.type === "function_call") {
-                                    const blockIdx = nextBlockIdx++;
-                                    blockMap.set(outputIndex, { type: "tool", idx: blockIdx });
-                                    emit(sseEvent("content_block_start", {
-                                        type: "content_block_start",
-                                        index: blockIdx,
-                                        content_block: {
-                                            type: "tool_use",
-                                            id: item.call_id ??
-                                                `toolu_${outputIndex}`,
-                                            name: item.name ?? "",
-                                            input: {},
-                                        },
-                                    }));
-                                }
-                                break;
-                            }
-                            case "response.output_text.delta": {
-                                const delta = data.delta;
-                                if (!delta)
-                                    break;
-                                if (!blockMap.has(outputIndex)) {
-                                    const blockIdx = nextBlockIdx++;
-                                    blockMap.set(outputIndex, { type: "text", idx: blockIdx });
-                                    textBlockOpen = true;
-                                    emit(sseEvent("content_block_start", {
-                                        type: "content_block_start",
-                                        index: blockIdx,
-                                        content_block: { type: "text", text: "" },
-                                    }));
-                                }
-                                const tBlock = blockMap.get(outputIndex);
-                                emit(sseEvent("content_block_delta", {
-                                    type: "content_block_delta",
-                                    index: tBlock.idx,
-                                    delta: { type: "text_delta", text: delta },
-                                }));
-                                break;
-                            }
-                            case "response.function_call_arguments.delta": {
-                                const delta = data.delta;
-                                if (!delta)
-                                    break;
-                                const fBlock = blockMap.get(outputIndex);
-                                if (fBlock?.type === "tool") {
-                                    fBlock.argsSent = (fBlock.argsSent ?? "") + delta;
-                                    emit(sseEvent("content_block_delta", {
-                                        type: "content_block_delta",
-                                        index: fBlock.idx,
-                                        delta: { type: "input_json_delta", partial_json: delta },
-                                    }));
-                                }
-                                break;
-                            }
-                            case "response.output_item.done": {
-                                const block = blockMap.get(outputIndex);
-                                const item = data.item;
-                                if (block) {
-                                    // The Codex Responses upstream delivers function-call
-                                    // arguments here, as one complete string; today it never emits
-                                    // response.function_call_arguments.delta. Relaying them as an
-                                    // input_json_delta before closing the block is what lets a
-                                    // client reconstruct the tool input; without it every tool
-                                    // call reaches the client with an empty input.
-                                    //
-                                    // The terminal value is authoritative, so it is reconciled
-                                    // against what was already relayed instead of being skipped
-                                    // whenever any delta arrived: an upstream that streamed only
-                                    // PART of the arguments would otherwise leave the client with
-                                    // a silently truncated input. Only the missing suffix is sent.
-                                    // If what we relayed is not a prefix of the terminal value the
-                                    // two cannot be reconciled inside an append-only stream, so
-                                    // nothing is emitted rather than corrupting the JSON.
-                                    if (block.type === "tool" &&
-                                        typeof item?.arguments === "string" &&
-                                        item.arguments !== "") {
-                                        const sent = block.argsSent ?? "";
-                                        if (item.arguments.startsWith(sent)) {
-                                            const remainder = item.arguments.slice(sent.length);
-                                            if (remainder !== "") {
-                                                emit(sseEvent("content_block_delta", {
-                                                    type: "content_block_delta",
-                                                    index: block.idx,
-                                                    delta: {
-                                                        type: "input_json_delta",
-                                                        partial_json: remainder,
-                                                    },
-                                                }));
-                                            }
-                                        }
-                                        else {
-                                            // Irreconcilable: what was relayed is not a prefix of the
-                                            // authoritative terminal value, and an append-only stream
-                                            // cannot retract it. Emitting anything would corrupt the
-                                            // JSON, so nothing is emitted — but the client is then
-                                            // holding a tool input that CONTRADICTS the upstream, and
-                                            // that must never be a silent outcome. Announce it, with
-                                            // the call identity, so it is attributable in a log.
-                                            console.warn(`[llm-gateway] tool-call arguments could not be reconciled for ` +
-                                                `${item.name ?? "?"} ` +
-                                                `(${item.call_id ?? "?"}): ` +
-                                                `${sent.length} relayed chars are not a prefix of the ` +
-                                                `${item.arguments.length}-char terminal value; the client ` +
-                                                `input differs from upstream`);
-                                        }
-                                    }
-                                    emit(sseEvent("content_block_stop", {
-                                        type: "content_block_stop",
-                                        index: block.idx,
-                                    }));
-                                    if (block.type === "text")
-                                        textBlockOpen = false;
-                                }
-                                if (item?.type === "function_call")
-                                    stopReason = "tool_use";
-                                break;
-                            }
-                            case "response.completed": {
-                                const response = data.response;
-                                const usage = response?.usage;
-                                if (typeof usage?.output_tokens === "number")
-                                    outputTokens = usage.output_tokens;
-                                // Close any unclosed blocks (shouldn't happen but be safe)
-                                for (const [, block] of blockMap) {
-                                    if (block.type === "text" && textBlockOpen) {
-                                        emit(sseEvent("content_block_stop", {
-                                            type: "content_block_stop",
-                                            index: block.idx,
-                                        }));
-                                        textBlockOpen = false;
-                                    }
-                                }
-                                emit(sseEvent("message_delta", {
-                                    type: "message_delta",
-                                    delta: { stop_reason: stopReason, stop_sequence: null },
-                                    usage: { output_tokens: outputTokens },
-                                }));
-                                emit(sseEvent("message_stop", { type: "message_stop" }));
-                                controller.close();
-                                return;
-                            }
-                            case "response.failed": {
-                                emit(sseEvent("error", {
-                                    type: "error",
-                                    error: {
-                                        type: "api_error",
-                                        message: codexFailureMessage(data),
-                                    },
-                                }));
-                                controller.close();
-                                return;
-                            }
-                        }
-                    }
-                }
-                // Stream ended without response.completed — close gracefully
-                if (textBlockOpen) {
-                    for (const [, block] of blockMap) {
-                        if (block.type === "text") {
-                            emit(sseEvent("content_block_stop", {
-                                type: "content_block_stop",
-                                index: block.idx,
-                            }));
-                        }
-                    }
-                }
-                for (const [, block] of blockMap) {
-                    if (block.type === "tool") {
-                        emit(sseEvent("content_block_stop", {
-                            type: "content_block_stop",
-                            index: block.idx,
-                        }));
-                    }
-                }
-                emit(sseEvent("message_delta", {
-                    type: "message_delta",
-                    delta: { stop_reason: stopReason, stop_sequence: null },
-                    usage: { output_tokens: outputTokens },
-                }));
-                emit(sseEvent("message_stop", { type: "message_stop" }));
-                controller.close();
-            }
-            catch (err) {
-                closeStreamWithGatewayError(controller, enc, `Upstream stream failed: ${upstreamFetchErrorMessage(err)}`);
-            }
-            finally {
-                reader.releaseLock();
-            }
-        },
-    });
-}
-function codexFailureMessage(data) {
-    const response = data.response;
-    const error = data.error ??
-        response?.error;
-    const message = error?.message ?? error?.code ?? response?.status;
-    return typeof message === "string" && message
-        ? message
-        : "Codex upstream response failed";
-}
-export async function codexStreamToAnthropicResponse(codexStream, originalModel, messageId, estimatedInputTokens) {
-    const reader = codexStream.getReader();
-    const blockMap = new Map();
-    let nextBlockIdx = 0;
-    let outputTokens = 0;
-    let buf = "";
-    let currentEvent = "";
-    const ensureTextBlock = (outputIndex) => {
-        const existing = blockMap.get(outputIndex);
-        if (existing?.type === "text")
-            return existing;
-        const block = {
-            type: "text",
-            idx: nextBlockIdx++,
-            text: "",
-        };
-        blockMap.set(outputIndex, block);
-        return block;
-    };
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += new TextDecoder().decode(value);
-            const lines = buf.split("\n");
-            buf = lines.pop() ?? "";
-            for (const line of lines) {
-                if (line.startsWith("event: ")) {
-                    currentEvent = line.slice(7).trim();
-                    continue;
-                }
-                if (!line.startsWith("data: ")) {
-                    if (line === "")
-                        currentEvent = "";
-                    continue;
-                }
-                const raw = line.slice(6).trim();
-                if (raw === "[DONE]")
-                    continue;
-                let data;
-                try {
-                    data = JSON.parse(raw);
-                }
-                catch {
-                    continue;
-                }
-                const evType = data.type ?? currentEvent;
-                const outputIndex = data.output_index ?? 0;
-                switch (evType) {
-                    case "response.output_item.added": {
-                        const item = data.item;
-                        if (item?.type === "function_call") {
-                            blockMap.set(outputIndex, {
-                                type: "tool",
-                                idx: nextBlockIdx++,
-                                id: item.call_id ??
-                                    `toolu_${outputIndex}`,
-                                name: item.name ?? "",
-                                args: "",
-                            });
-                        }
-                        break;
-                    }
-                    case "response.output_text.delta": {
-                        const delta = data.delta;
-                        if (delta)
-                            ensureTextBlock(outputIndex).text += delta;
-                        break;
-                    }
-                    case "response.output_text.done": {
-                        const text = data.text;
-                        if (text !== undefined)
-                            ensureTextBlock(outputIndex).text = text;
-                        break;
-                    }
-                    case "response.function_call_arguments.delta": {
-                        const delta = data.delta;
-                        const block = blockMap.get(outputIndex);
-                        if (delta && block?.type === "tool")
-                            block.args += delta;
-                        break;
-                    }
-                    case "response.output_item.done": {
-                        const item = data.item;
-                        const block = blockMap.get(outputIndex);
-                        if (item?.type === "function_call" && block?.type === "tool") {
-                            if (typeof item.call_id === "string")
-                                block.id = item.call_id;
-                            if (typeof item.name === "string")
-                                block.name = item.name;
-                            if (typeof item.arguments === "string")
-                                block.args = item.arguments;
-                        }
-                        break;
-                    }
-                    case "response.completed": {
-                        const response = data.response;
-                        const usage = response?.usage;
-                        if (typeof usage?.output_tokens === "number")
-                            outputTokens = usage.output_tokens;
-                        break;
-                    }
-                    case "response.failed":
-                        throw new Error(codexFailureMessage(data));
-                }
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const content = [...blockMap.values()]
-        .sort((a, b) => a.idx - b.idx)
-        .map((block) => {
-        if (block.type === "text")
-            return { type: "text", text: block.text };
-        let input = {};
-        try {
-            input = block.args ? JSON.parse(block.args) : {};
-        }
-        catch {
-            input = {};
-        }
-        return { type: "tool_use", id: block.id, name: block.name, input };
-    });
-    return {
-        id: messageId,
-        type: "message",
-        role: "assistant",
-        content,
-        model: originalModel,
-        stop_reason: content.some((block) => block.type === "tool_use")
-            ? "tool_use"
-            : "end_turn",
-        stop_sequence: null,
-        usage: { input_tokens: estimatedInputTokens, output_tokens: outputTokens },
-    };
-}
-// ---------------------------------------------------------------------------
-// Route handler
-// ---------------------------------------------------------------------------
-export async function handleMessagesViaOpenAI(c, session, requestBody) {
-    const rawBody = requestBody ?? (await c.req.arrayBuffer());
-    let body;
-    try {
-        body = JSON.parse(new TextDecoder().decode(rawBody));
-    }
-    catch {
-        return c.json({ error: "invalid JSON" }, 400);
-    }
-    const originalModel = body.model;
-    let route;
-    try {
-        route = routeModelOrThrow(originalModel);
-    }
-    catch (err) {
-        return c.json(anthropicGatewayError(err instanceof Error ? err.message : String(err)), 400);
-    }
-    const tokenTransport = isCodexOAuthToken(session.token)
-        ? "codex-responses"
-        : "openai-chat-completions";
-    if (session.requiredTransport &&
-        tokenTransport !== session.requiredTransport) {
-        return c.json({ error: "gateway credential no longer satisfies session transport" }, 503);
-    }
-    const isCodex = tokenTransport === "codex-responses";
-    const codexContext = isCodex ? trimCodexBodyForContext(body) : null;
-    const upstreamBody = codexContext?.body ?? body;
-    if (codexContext?.trimmed) {
-        console.warn(`[llm-gateway] Codex context trimmed for ${originalModel}: ` +
-            `${codexContext.beforeChars} -> ${codexContext.afterChars} chars`);
-    }
-    const upstreamReq = isCodex
-        ? toCodexRequest(upstreamBody, route.effort)
-        : toOpenAIRequest(upstreamBody, route.effort);
-    // Build the Codex request ONCE. Response attestation is derived from this
-    // exact post-mapping payload, never copied from the Anthropic input.
-    const codexRequest = isCodex
-        ? prepareCodexResponsesRequest(upstreamReq)
-        : undefined;
-    const attestedModel = codexRequest?.body.model;
-    const attestedEffort = codexRequest
-        ? codexRequestEffort(codexRequest.body)
-        : undefined;
-    const withCodexAttestation = (response) => {
-        if (!codexRequest)
-            return response;
-        const headers = new Headers(response.headers);
-        if (typeof attestedModel === "string")
-            headers.set("x-h2a-resolved-model", attestedModel);
-        if (attestedEffort)
-            headers.set("x-h2a-reasoning-effort", attestedEffort);
-        return new Response(response.body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers,
-        });
-    };
-    const messageId = `msg_${Date.now().toString(36)}`;
-    const estimatedInputTokens = Math.ceil(JSON.stringify(upstreamBody.messages).length / 4);
-    const doFetch = (token) => {
-        if (codexRequest) {
-            if (attestedEffort) {
-                console.info(`[llm-gateway] Codex request: model=${String(codexRequest.body.model ?? "")} reasoning.effort=${attestedEffort}`);
-            }
-            return fetch(codexRequest.url, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                    "content-type": "application/json",
-                    originator: "opencode",
-                    "User-Agent": "opencode/0.1.0",
-                    session_id: `codex_${Date.now().toString(36)}`,
-                },
-                body: JSON.stringify(codexRequest.body),
-                // @ts-expect-error Node 18+ supports duplex for streaming
-                duplex: "half",
-                signal: c.req.raw.signal,
-            });
-        }
-        return fetch(`${OPENAI_BASE}/v1/chat/completions`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify(upstreamReq),
-            // @ts-expect-error Node 18+ supports duplex for streaming
-            duplex: "half",
-            signal: c.req.raw.signal,
-        });
-    };
-    let upstream;
-    try {
-        upstream = await fetchUpstreamWithRetry(() => doFetch(session.token));
-    }
-    catch (err) {
-        if (abortError(err))
-            return new Response(null, { status: 499 });
-        return c.json(anthropicGatewayError(`Upstream fetch failed: ${upstreamFetchErrorMessage(err)}`), 502);
-    }
-    // 401 → attempt OAuth token refresh + retry once
-    if (upstream.status === 401 && session.accountId) {
-        const newToken = await refreshOAuthTokenForRetry(session.accountId);
-        if (newToken) {
-            await upstream.body?.cancel().catch(() => { });
-            try {
-                upstream = await fetchUpstreamWithRetry(() => doFetch(newToken));
-            }
-            catch (err) {
-                if (abortError(err))
-                    return new Response(null, { status: 499 });
-                return c.json(anthropicGatewayError(`Upstream fetch failed: ${upstreamFetchErrorMessage(err)}`), 502);
-            }
-        }
-        else {
-            await upstream.body?.cancel().catch(() => { });
-            return c.json(anthropicGatewayError("Upstream Codex OAuth returned 401 and token refresh failed; re-enroll the Codex account with `h2a llm-mesh enroll codex`."), 502);
-        }
-    }
-    if (!upstream.ok) {
-        const errBody = await upstream.text();
-        return new Response(errBody, {
-            status: upstream.status,
-            headers: {
-                "content-type": upstream.headers.get("content-type") ?? "application/json",
-            },
-        });
-    }
-    if (body.stream && isCodex && upstream.body) {
-        const stream = translateCodexStreamToAnthropic(upstream.body, originalModel, messageId, estimatedInputTokens);
-        return withCodexAttestation(new Response(stream, {
-            status: 200,
-            headers: {
-                "content-type": "text/event-stream; charset=utf-8",
-                "cache-control": "no-cache",
-                "x-accel-buffering": "no",
-            },
-        }));
-    }
-    // Codex OAuth Responses API streams even for requests where the Anthropic
-    // client expects a non-streaming JSON message. In that case collect the SSE
-    // upstream and return a normal Anthropic Messages JSON response.
-    if (isCodex && upstream.body) {
-        try {
-            return withCodexAttestation(c.json(await codexStreamToAnthropicResponse(upstream.body, originalModel, messageId, estimatedInputTokens)));
-        }
-        catch (err) {
-            return c.json(anthropicGatewayError(err instanceof Error ? err.message : String(err)), 502);
-        }
-    }
-    if (body.stream && upstream.body) {
-        const stream = translateOpenAIStreamToAnthropic(upstream.body, originalModel, messageId, estimatedInputTokens);
-        return new Response(stream, {
-            status: 200,
-            headers: {
-                "content-type": "text/event-stream; charset=utf-8",
-                "cache-control": "no-cache",
-                "x-accel-buffering": "no",
-            },
-        });
-    }
-    const openaiResp = (await upstream.json());
-    return c.json(toAnthropicResponse(openaiResp, originalModel));
-}
-//# sourceMappingURL=proxy-openai.js.map