llm-relay 0.77.0 → 0.78.0

package/dist/backend.js

@@ -2,8 +2,9 @@ import { translateBetweenProviders, handleUniversalStreamRequest } from "llm-bri
 import { buildAuthHeaders } from "./authEnv.js";
 import { isRecord } from "./json-shape.js";
 import { DocumentError, transcodeDocuments } from "./documents.js";
-import { anthropicRequestToOpenAi, RequestMappingError } from "./openai-request.js";
-import { openaiResponsesRequestToAnthropic } from "./responses-request.js";
+import { anthropicRequestToOpenAi, RequestMappingError, ToolCallIds, ThoughtSignatures } from "./openai-request.js";
+import { openaiResponsesRequestToAnthropic, DEFAULT_RESPONSES_MAX_TOKENS } from "./responses-request.js";
+import { observedMaxOutput } from "./context-limits.js";
 import { DIALECT_REFUSED_DESTRUCTIVE_CODE, describeRefused, dialectRefusalSignal, recoverToolCalls } from "./tool-dialects.js";
 import { recoverDialectInStream } from "./dialect-stream.js";
 import { toolSchemaMap } from "./anthropic.js";
@@ -13,6 +14,8 @@ import { invalidEnvelopeReason } from "./backend/envelope-validator.js";
 import { captureReportedModel, preflightResponseStream } from "./backend/health-prober.js";
 import { inspectDialectInOpenAiChat, recoverDialectInOpenAiChatStream, } from "./openai-dialect.js";
 import { observeUsage } from "./usage-observer.js";
+import { createSseTransformStream, parseSseEvent, BufferedSseFrames } from "./sse-frames.js";
+import { syntheticMessageId } from "./emitSse.js";
 export class DialectUnparseableError extends Error {
     dialect;
     constructor(dialect) {
@@ -57,6 +60,7 @@ function oneShotFetch(fetchFn, signal, onEgress) {
 export const DEGRADED_HEADER = "x-llm-relay-degraded";
 export const QUOTA_DEMOTED_HEADER = "x-llm-relay-quota-demoted";
 export const LATENCY_DEMOTED_HEADER = "x-llm-relay-latency-demoted";
+export const PROBATION_HEADER = "x-llm-relay-probation";
 export const HEDGED_HEADER = "x-llm-relay-hedged";
 export const HARD_CAP_HEADER = "x-llm-relay-capped";
 export const PAID_HEADER = "x-llm-relay-paid";
@@ -165,6 +169,9 @@ async function fetchAnthropicBackend(attempt, args, invokeFetch) {
     return attachUpstreamMetadata(res, metadata);
 }
 async function fetchOpenAiBackend(attempt, args, invokeFetch) {
+    if (attempt.target.wire === "responses") {
+        return fetchOpenAiResponsesBackend(attempt, args, invokeFetch);
+    }
     const target = attempt.target;
     let reqJson = args.reqJson;
     try {
@@ -324,6 +331,747 @@ async function fetchOpenAiBackend(attempt, args, invokeFetch) {
         metadata.thoughtSignatureSentinels = sentinelsStamped;
     return attachUpstreamMetadata(response, metadata);
 }
+function describeResponsesType(t) {
+    return typeof t === "string" && t.length > 0 ? `"${t.slice(0, 40)}"` : "(missing type)";
+}
+function responsesSystemText(system) {
+    if (typeof system === "string")
+        return system;
+    if (!Array.isArray(system))
+        return "";
+    const parts = [];
+    for (const block of system) {
+        if (isRecord(block) && block.type === "text" && typeof block.text === "string")
+            parts.push(block.text);
+    }
+    return parts.join("\n\n");
+}
+function responsesInputImagePart(block) {
+    const source = isRecord(block.source) ? block.source : {};
+    if (source.type === "url" && typeof source.url === "string")
+        return { type: "input_image", image_url: source.url };
+    if (source.type === "base64" && typeof source.data === "string" && typeof source.media_type === "string") {
+        return { type: "input_image", image_url: `data:${source.media_type};base64,${source.data}` };
+    }
+    throw new RequestMappingError("image block needs a base64 or url source");
+}
+function responsesToolResultParts(content) {
+    if (content === undefined || content === null)
+        return { text: "", images: [] };
+    if (typeof content === "string")
+        return { text: content, images: [] };
+    if (!Array.isArray(content)) {
+        throw new RequestMappingError("tool_result content must be text or a list of blocks");
+    }
+    const texts = [];
+    const images = [];
+    for (const raw of content) {
+        if (!isRecord(raw))
+            throw new RequestMappingError("tool_result content block is not an object");
+        switch (raw.type) {
+            case "text":
+                texts.push(typeof raw.text === "string" ? raw.text : "");
+                break;
+            case "image":
+                images.push(responsesInputImagePart(raw));
+                break;
+            default:
+                throw new RequestMappingError(`tool_result carries an unsupported ${describeResponsesType(raw.type)} block; a Responses function_call_output carries text and images only`);
+        }
+    }
+    return { text: texts.join("\n"), images };
+}
+function responsesToolResultItem(block, ids) {
+    if (typeof block.tool_use_id !== "string" || block.tool_use_id.length === 0) {
+        throw new RequestMappingError("tool_result block without a tool_use_id");
+    }
+    const callId = ids === null ? block.tool_use_id : ids.map(block.tool_use_id);
+    const { text, images } = responsesToolResultParts(block.content);
+    return { item: { type: "function_call_output", call_id: callId, output: text }, images };
+}
+function responsesFunctionCallItem(block, ids, sigs) {
+    if (typeof block.id !== "string" || block.id.length === 0) {
+        throw new RequestMappingError("tool_use block without an id");
+    }
+    if (typeof block.name !== "string" || block.name.length === 0) {
+        throw new RequestMappingError("tool_use block without a name");
+    }
+    const input = block.input ?? {};
+    const item = {
+        type: "function_call",
+        call_id: ids === null ? block.id : ids.map(block.id),
+        name: block.name,
+        arguments: typeof input === "string" ? input : JSON.stringify(input),
+    };
+    return sigs === null ? item : sigs.stamp(item);
+}
+function responsesAssistantItems(turn, ids, sigs) {
+    const content = turn.content;
+    if (typeof content === "string") {
+        return content.length > 0 ? [{ role: "assistant", content: [{ type: "output_text", text: content }] }] : [];
+    }
+    const out = [];
+    for (const raw of Array.isArray(content) ? content : []) {
+        if (!isRecord(raw))
+            throw new RequestMappingError("assistant content block is not an object");
+        switch (raw.type) {
+            case "text": {
+                const text = typeof raw.text === "string" ? raw.text : "";
+                if (text.length > 0)
+                    out.push({ role: "assistant", content: [{ type: "output_text", text }] });
+                break;
+            }
+            case "tool_use":
+                out.push(responsesFunctionCallItem(raw, ids, sigs));
+                break;
+            case "thinking":
+            case "redacted_thinking":
+                break;
+            default:
+                throw new RequestMappingError(`unsupported assistant content block ${describeResponsesType(raw.type)}`);
+        }
+    }
+    return out;
+}
+function responsesUserItems(turn, ids) {
+    const content = turn.content;
+    if (typeof content === "string") {
+        return content.length > 0 ? [{ role: "user", content: [{ type: "input_text", text: content }] }] : [];
+    }
+    const toolResultItems = [];
+    const trailingImages = [];
+    const contentParts = [];
+    for (const raw of Array.isArray(content) ? content : []) {
+        if (!isRecord(raw))
+            throw new RequestMappingError("user content block is not an object");
+        switch (raw.type) {
+            case "text": {
+                const text = typeof raw.text === "string" ? raw.text : "";
+                if (text.length > 0)
+                    contentParts.push({ type: "input_text", text });
+                break;
+            }
+            case "image":
+                contentParts.push(responsesInputImagePart(raw));
+                break;
+            case "tool_result": {
+                const { item, images } = responsesToolResultItem(raw, ids);
+                toolResultItems.push(item);
+                trailingImages.push(...images);
+                break;
+            }
+            case "thinking":
+            case "redacted_thinking":
+                break;
+            default:
+                throw new RequestMappingError(`unsupported user content block ${describeResponsesType(raw.type)}`);
+        }
+    }
+    const out = [...toolResultItems];
+    if (trailingImages.length > 0)
+        out.push({ role: "user", content: trailingImages });
+    if (contentParts.length > 0)
+        out.push({ role: "user", content: contentParts });
+    return out;
+}
+function mapAnthropicToolsToResponses(tools) {
+    if (!Array.isArray(tools) || tools.length === 0)
+        return null;
+    const out = [];
+    for (const raw of tools) {
+        if (!isRecord(raw))
+            throw new RequestMappingError("tool declaration is not an object");
+        if (typeof raw.name !== "string" || raw.name.length === 0) {
+            throw new RequestMappingError("tool declaration without a name");
+        }
+        const fn = { type: "function", name: raw.name };
+        if (typeof raw.description === "string" && raw.description.length > 0)
+            fn.description = raw.description;
+        fn.parameters = isRecord(raw.input_schema) ? raw.input_schema : { type: "object", properties: {} };
+        out.push(fn);
+    }
+    return out;
+}
+function mapAnthropicToolChoiceToResponses(choice) {
+    if (!isRecord(choice))
+        return {};
+    let toolChoice;
+    switch (choice.type) {
+        case "auto":
+            toolChoice = "auto";
+            break;
+        case "any":
+            toolChoice = "required";
+            break;
+        case "none":
+            toolChoice = "none";
+            break;
+        case "tool":
+            toolChoice = typeof choice.name === "string" && choice.name.length > 0
+                ? { type: "function", name: choice.name }
+                : undefined;
+            break;
+        default:
+            toolChoice = undefined;
+    }
+    if (toolChoice === undefined)
+        return {};
+    const parallelToolCalls = choice.disable_parallel_tool_use === true && choice.type !== "none" ? false : undefined;
+    return parallelToolCalls === undefined ? { toolChoice } : { toolChoice, parallelToolCalls };
+}
+function responsesRequestOptions(body, opts, out) {
+    if (opts.model !== undefined)
+        out.model = opts.model;
+    const stream = opts.stream ?? (typeof body.stream === "boolean" ? body.stream : undefined);
+    if (stream !== undefined)
+        out.stream = stream;
+    const instructions = responsesSystemText(body.system);
+    if (instructions.length > 0)
+        out.instructions = instructions;
+    if (typeof body.max_tokens === "number")
+        out.max_output_tokens = body.max_tokens;
+    if (typeof body.temperature === "number")
+        out.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        out.top_p = body.top_p;
+    const tools = mapAnthropicToolsToResponses(body.tools);
+    if (!tools)
+        return;
+    out.tools = tools;
+    const { toolChoice, parallelToolCalls } = mapAnthropicToolChoiceToResponses(body.tool_choice);
+    if (toolChoice !== undefined)
+        out.tool_choice = toolChoice;
+    if (parallelToolCalls !== undefined)
+        out.parallel_tool_calls = parallelToolCalls;
+}
+export function anthropicRequestToOpenAiResponses(reqJson, opts = {}) {
+    const body = isRecord(reqJson) ? reqJson : {};
+    const input = [];
+    const ids = opts.toolCallIds === "strict9" ? new ToolCallIds() : null;
+    const sigs = opts.thoughtSignature === "sentinel" ? new ThoughtSignatures() : null;
+    for (const raw of Array.isArray(body.messages) ? body.messages : []) {
+        if (!isRecord(raw))
+            throw new RequestMappingError("message is not an object");
+        if (raw.role === "assistant")
+            input.push(...responsesAssistantItems(raw, ids, sigs));
+        else
+            input.push(...responsesUserItems(raw, ids));
+    }
+    if (ids !== null)
+        opts.onToolCallIdsRewritten?.(ids.count());
+    if (sigs !== null)
+        opts.onThoughtSignatureSentinels?.(sigs.count());
+    const out = { input };
+    responsesRequestOptions(body, opts, out);
+    return out;
+}
+function parseResponsesFunctionCallOutputItem(raw, ordinal) {
+    const id = typeof raw.call_id === "string" ? raw.call_id
+        : typeof raw.id === "string" ? raw.id : `tu_${ordinal}`;
+    const name = typeof raw.name === "string" ? raw.name : "";
+    const rawArgs = typeof raw.arguments === "string" ? raw.arguments : "";
+    let input;
+    try {
+        input = rawArgs.length > 0 ? JSON.parse(rawArgs) : {};
+    }
+    catch {
+        input = rawArgs;
+    }
+    return { id, name, input };
+}
+function parseResponsesMessageOutputItem(raw) {
+    const textParts = [];
+    if (!Array.isArray(raw.content))
+        return textParts;
+    for (const part of raw.content) {
+        if (!isRecord(part))
+            continue;
+        if (part.type === "output_text" && typeof part.text === "string" && part.text.length > 0) {
+            textParts.push(part.text);
+        }
+        else if (part.type === "refusal" && typeof part.refusal === "string" && part.refusal.length > 0) {
+            textParts.push(part.refusal);
+        }
+    }
+    return textParts;
+}
+function parseOpenAiResponsesOutput(j) {
+    const outputs = Array.isArray(j.output) ? j.output : [];
+    const textParts = [];
+    const functionCalls = [];
+    for (const raw of outputs) {
+        if (!isRecord(raw))
+            continue;
+        const type = typeof raw.type === "string" ? raw.type : "";
+        if (type === "function_call") {
+            functionCalls.push(parseResponsesFunctionCallOutputItem(raw, functionCalls.length));
+        }
+        else if (type === "message") {
+            textParts.push(...parseResponsesMessageOutputItem(raw));
+        }
+    }
+    return { text: textParts.join(""), functionCalls };
+}
+function mapResponsesStopReason(j, hasToolCalls) {
+    if (hasToolCalls)
+        return "tool_use";
+    const status = typeof j.status === "string" ? j.status : undefined;
+    const incompleteReason = isRecord(j.incomplete_details) && typeof j.incomplete_details.reason === "string"
+        ? j.incomplete_details.reason
+        : undefined;
+    if (status === "incomplete" && incompleteReason === "max_output_tokens")
+        return "max_tokens";
+    return "end_turn";
+}
+function measuredResponsesCacheTokens(v) {
+    return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : undefined;
+}
+function extractAnthropicUsageFromResponses(rawUsage) {
+    if (!isRecord(rawUsage))
+        return null;
+    if (typeof rawUsage.input_tokens !== "number" && typeof rawUsage.output_tokens !== "number")
+        return null;
+    const out = {};
+    if (typeof rawUsage.input_tokens === "number") {
+        const details = isRecord(rawUsage.input_tokens_details) ? rawUsage.input_tokens_details : undefined;
+        const cached = details ? measuredResponsesCacheTokens(details.cached_tokens) : undefined;
+        if (cached !== undefined && cached <= rawUsage.input_tokens) {
+            out.input_tokens = rawUsage.input_tokens - cached;
+            out.cache_read_input_tokens = cached;
+        }
+        else {
+            out.input_tokens = rawUsage.input_tokens;
+        }
+    }
+    if (typeof rawUsage.output_tokens === "number")
+        out.output_tokens = rawUsage.output_tokens;
+    return Object.keys(out).length > 0 ? out : null;
+}
+function applyResponsesUsage(accumulator, usage) {
+    if (!usage)
+        return;
+    if (typeof usage.input_tokens === "number")
+        accumulator.inputTokens = usage.input_tokens;
+    if (typeof usage.output_tokens === "number") {
+        accumulator.outputTokens = usage.output_tokens;
+        accumulator.completionTokens = usage.output_tokens;
+    }
+    if (typeof usage.cache_read_input_tokens === "number")
+        accumulator.cacheReadInputTokens = usage.cache_read_input_tokens;
+}
+function openAiResponsesToAnthropicMessage(j, model, schemas, isDestructive) {
+    const parsed = parseOpenAiResponsesOutput(j);
+    const content = [];
+    let functionCalls = parsed.functionCalls;
+    if (functionCalls.length === 0 && parsed.text.length > 0) {
+        const { recoveredCalls, textParts } = recoverOpenAiTextDialect(parsed.text, schemas, isDestructive);
+        content.push(...textParts);
+        if (recoveredCalls.length > 0) {
+            functionCalls = recoveredCalls.map((c, i) => ({ id: `tu_recovered_${i}`, name: c.name, input: c.input }));
+        }
+    }
+    else if (parsed.text.length > 0) {
+        content.push({ type: "text", text: parsed.text });
+    }
+    for (const fc of functionCalls) {
+        content.push({ type: "tool_use", id: fc.id, name: fc.name, input: fc.input });
+    }
+    return {
+        id: typeof j.id === "string" ? j.id : "msg_translated",
+        type: "message",
+        role: "assistant",
+        model: model || (typeof j.model === "string" ? j.model : ""),
+        content,
+        stop_reason: mapResponsesStopReason(j, functionCalls.length > 0),
+        stop_sequence: null,
+        ...(extractAnthropicUsageFromResponses(j.usage) ? { usage: extractAnthropicUsageFromResponses(j.usage) } : {}),
+    };
+}
+function anthropicSseEvent(type, data) {
+    return `event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`;
+}
+function anthropicSseError(message) {
+    return `event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: `llm-relay: ${message}` } })}\n\n`;
+}
+function newResponsesStreamState() {
+    return {
+        messageStarted: false,
+        messageStopped: false,
+        nextBlockIndex: 0,
+        textBlocks: new Map(),
+        toolBlocks: new Map(),
+        openBlocksByItem: new Map(),
+    };
+}
+function ensureResponsesMessageStarted(state, push, response) {
+    if (state.messageStarted)
+        return;
+    state.messageStarted = true;
+    push(anthropicSseEvent("message_start", {
+        message: {
+            id: typeof response?.id === "string" ? response.id : syntheticMessageId(),
+            type: "message",
+            role: "assistant",
+            model: typeof response?.model === "string" ? response.model : "",
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: {},
+        },
+    }));
+}
+function openResponsesTextBlock(state, push, outputIndex, contentIndex) {
+    const key = `${outputIndex}:${contentIndex}`;
+    const existing = state.textBlocks.get(key);
+    if (existing !== undefined)
+        return existing;
+    const index = state.nextBlockIndex++;
+    state.textBlocks.set(key, index);
+    const opened = state.openBlocksByItem.get(outputIndex) ?? [];
+    opened.push(index);
+    state.openBlocksByItem.set(outputIndex, opened);
+    push(anthropicSseEvent("content_block_start", { index, content_block: { type: "text", text: "" } }));
+    return index;
+}
+function openResponsesToolBlock(state, push, outputIndex, callId, name) {
+    const existing = state.toolBlocks.get(outputIndex);
+    if (existing !== undefined)
+        return existing;
+    const index = state.nextBlockIndex++;
+    state.toolBlocks.set(outputIndex, index);
+    state.openBlocksByItem.set(outputIndex, [index]);
+    push(anthropicSseEvent("content_block_start", {
+        index, content_block: { type: "tool_use", id: callId, name, input: {} },
+    }));
+    return index;
+}
+function closeResponsesItemBlocks(state, push, outputIndex) {
+    const opened = state.openBlocksByItem.get(outputIndex);
+    if (!opened)
+        return;
+    for (const index of opened)
+        push(anthropicSseEvent("content_block_stop", { index }));
+    state.openBlocksByItem.delete(outputIndex);
+}
+function synthesizeResponsesFunctionCallBlock(state, push, outputIndex, item) {
+    if (state.toolBlocks.has(outputIndex))
+        return;
+    const callId = typeof item.call_id === "string" ? item.call_id
+        : typeof item.id === "string" ? item.id : `tu_${outputIndex}`;
+    const index = openResponsesToolBlock(state, push, outputIndex, callId, typeof item.name === "string" ? item.name : "");
+    const args = typeof item.arguments === "string" ? item.arguments : "";
+    if (args.length > 0) {
+        push(anthropicSseEvent("content_block_delta", { index, delta: { type: "input_json_delta", partial_json: args } }));
+    }
+}
+function synthesizeResponsesMessageBlocks(state, push, outputIndex, item) {
+    if (!Array.isArray(item.content))
+        return;
+    item.content.forEach((part, contentIndex) => {
+        if (!isRecord(part) || (part.type !== "output_text" && part.type !== "refusal"))
+            return;
+        if (state.textBlocks.has(`${outputIndex}:${contentIndex}`))
+            return;
+        const text = typeof part.text === "string" ? part.text : typeof part.refusal === "string" ? part.refusal : "";
+        const index = openResponsesTextBlock(state, push, outputIndex, contentIndex);
+        if (text.length > 0) {
+            push(anthropicSseEvent("content_block_delta", { index, delta: { type: "text_delta", text } }));
+        }
+    });
+}
+function synthesizeMissingResponsesBlocks(state, push, response) {
+    if (!Array.isArray(response.output))
+        return;
+    response.output.forEach((raw, outputIndex) => {
+        if (!isRecord(raw))
+            return;
+        if (raw.type === "function_call")
+            synthesizeResponsesFunctionCallBlock(state, push, outputIndex, raw);
+        else if (raw.type === "message")
+            synthesizeResponsesMessageBlocks(state, push, outputIndex, raw);
+    });
+}
+function finishResponsesStream(state, push, response) {
+    if (state.messageStopped)
+        return;
+    state.messageStopped = true;
+    ensureResponsesMessageStarted(state, push, response);
+    if (response)
+        synthesizeMissingResponsesBlocks(state, push, response);
+    for (const outputIndex of [...state.openBlocksByItem.keys()])
+        closeResponsesItemBlocks(state, push, outputIndex);
+    const hasToolCalls = state.toolBlocks.size > 0;
+    const stopReason = response ? mapResponsesStopReason(response, hasToolCalls) : (hasToolCalls ? "tool_use" : "end_turn");
+    const usage = response ? extractAnthropicUsageFromResponses(response.usage) : null;
+    push(anthropicSseEvent("message_delta", {
+        delta: { stop_reason: stopReason, stop_sequence: null },
+        ...(usage ? { usage } : {}),
+    }));
+    push(anthropicSseEvent("message_stop", {}));
+}
+function handleResponsesOutputItemAdded(state, push, data) {
+    ensureResponsesMessageStarted(state, push, undefined);
+    const item = isRecord(data.item) ? data.item : undefined;
+    const outputIndex = typeof data.output_index === "number" ? data.output_index : -1;
+    if (item?.type === "function_call" && outputIndex >= 0) {
+        const callId = typeof item.call_id === "string" ? item.call_id
+            : typeof item.id === "string" ? item.id : `tu_${outputIndex}`;
+        openResponsesToolBlock(state, push, outputIndex, callId, typeof item.name === "string" ? item.name : "");
+    }
+}
+function handleResponsesContentPartAdded(state, push, data) {
+    const outputIndex = typeof data.output_index === "number" ? data.output_index : -1;
+    const contentIndex = typeof data.content_index === "number" ? data.content_index : 0;
+    const part = isRecord(data.part) ? data.part : undefined;
+    if (outputIndex >= 0 && (part?.type === "output_text" || part?.type === "refusal")) {
+        ensureResponsesMessageStarted(state, push, undefined);
+        openResponsesTextBlock(state, push, outputIndex, contentIndex);
+    }
+}
+function handleResponsesTextDelta(state, push, data) {
+    const outputIndex = typeof data.output_index === "number" ? data.output_index : -1;
+    const contentIndex = typeof data.content_index === "number" ? data.content_index : 0;
+    const delta = typeof data.delta === "string" ? data.delta : "";
+    const index = state.textBlocks.get(`${outputIndex}:${contentIndex}`);
+    if (index !== undefined && delta.length > 0) {
+        push(anthropicSseEvent("content_block_delta", { index, delta: { type: "text_delta", text: delta } }));
+    }
+}
+function handleResponsesToolArgumentsDelta(state, push, data) {
+    const outputIndex = typeof data.output_index === "number" ? data.output_index : -1;
+    const delta = typeof data.delta === "string" ? data.delta : "";
+    const index = state.toolBlocks.get(outputIndex);
+    if (index !== undefined && delta.length > 0) {
+        push(anthropicSseEvent("content_block_delta", { index, delta: { type: "input_json_delta", partial_json: delta } }));
+    }
+}
+function handleResponsesOutputItemDone(state, push, data) {
+    const outputIndex = typeof data.output_index === "number" ? data.output_index : -1;
+    if (outputIndex >= 0)
+        closeResponsesItemBlocks(state, push, outputIndex);
+}
+function handleResponsesFailure(state, push, type, data) {
+    const response = isRecord(data.response) ? data.response : undefined;
+    ensureResponsesMessageStarted(state, push, response);
+    const message = isRecord(response?.error) && typeof response.error.message === "string"
+        ? response.error.message
+        : typeof data.message === "string" ? data.message
+            : isRecord(data.error) && typeof data.error.message === "string" ? data.error.message
+                : `stream ended: ${type}`;
+    push(anthropicSseError(message));
+    state.messageStopped = true;
+}
+const RESPONSES_STREAM_HANDLERS = {
+    "response.created": (state, push, data) => ensureResponsesMessageStarted(state, push, isRecord(data.response) ? data.response : undefined),
+    "response.in_progress": (state, push, data) => ensureResponsesMessageStarted(state, push, isRecord(data.response) ? data.response : undefined),
+    "response.output_item.added": handleResponsesOutputItemAdded,
+    "response.content_part.added": handleResponsesContentPartAdded,
+    "response.output_text.delta": handleResponsesTextDelta,
+    "response.refusal.delta": handleResponsesTextDelta,
+    "response.function_call_arguments.delta": handleResponsesToolArgumentsDelta,
+    "response.output_item.done": handleResponsesOutputItemDone,
+    "response.completed": (state, push, data) => finishResponsesStream(state, push, isRecord(data.response) ? data.response : undefined),
+    "response.incomplete": (state, push, data) => finishResponsesStream(state, push, isRecord(data.response) ? data.response : undefined),
+    "response.failed": (state, push, data) => handleResponsesFailure(state, push, "response.failed", data),
+    "response.cancelled": (state, push, data) => handleResponsesFailure(state, push, "response.cancelled", data),
+    error: (state, push, data) => handleResponsesFailure(state, push, "error", data),
+    ping: (_state, push) => push(`event: ping\ndata: {"type":"ping"}\n\n`),
+};
+function processResponsesStreamEvent(state, push, type, data) {
+    RESPONSES_STREAM_HANDLERS[type]?.(state, push, data);
+}
+function translateResponsesStreamToAnthropic(upstream) {
+    return createSseTransformStream(upstream, ({ push, frames }) => {
+        const state = newResponsesStreamState();
+        return {
+            flushHeld: () => finishResponsesStream(state, push, undefined),
+            processFrames: () => {
+                for (const { frame } of frames) {
+                    const ev = parseSseEvent(frame);
+                    if (!ev || !ev.data)
+                        continue;
+                    const type = typeof ev.data.type === "string" ? ev.data.type : ev.type;
+                    processResponsesStreamEvent(state, push, type, ev.data);
+                }
+            },
+        };
+    });
+}
+async function postResponsesRequest(attempt, args, reqJson, invokeFetch) {
+    const target = attempt.target;
+    let responsesBody;
+    let toolCallIdsRewritten = 0;
+    let sentinelsStamped = 0;
+    try {
+        responsesBody = anthropicRequestToOpenAiResponses(reqJson, {
+            model: target.model,
+            stream: args.wantsStream,
+            ...(target.toolCallIds !== undefined ? { toolCallIds: target.toolCallIds } : {}),
+            onToolCallIdsRewritten: (n) => { toolCallIdsRewritten = n; },
+            ...(target.thoughtSignature !== undefined ? { thoughtSignature: target.thoughtSignature } : {}),
+            onThoughtSignatureSentinels: (n) => { sentinelsStamped = n; },
+        });
+    }
+    catch (e) {
+        if (e instanceof RequestMappingError) {
+            return { ok: false, response: anthropicError(400, `llm-relay: ${e.message}`, "local") };
+        }
+        return { ok: false, response: anthropicError(502, `request translation failed: ${e.message}`, "local") };
+    }
+    const res = await invokeFetch(target.base + "/responses", {
+        method: "POST",
+        headers: buildTargetHeaders(attempt),
+        body: JSON.stringify(responsesBody),
+        signal: args.signal,
+    });
+    if (!res.ok) {
+        let body;
+        try {
+            body = await res.text();
+        }
+        catch (cause) {
+            return { ok: false, response: attachPostHeaderBodyFailure(res, cause) };
+        }
+        const hint = res.status === 404
+            ? ` — model "${target.model}" is not served by provider "${target.provider}" (a model can be listed in /models and still 404 here)`
+            : "";
+        return {
+            ok: false,
+            response: anthropicError(res.status, `openai backend HTTP ${res.status}${hint}: ${body.slice(0, 300)}`, "upstream", {
+                ...retryAfterHeader(res.headers),
+            }),
+        };
+    }
+    return { ok: true, res, toolCallIdsRewritten, sentinelsStamped };
+}
+async function fetchResponsesStreamed(args, res, toolCallIdsRewritten, sentinelsStamped) {
+    if (!res.body) {
+        return anthropicError(502, "llm-relay: invalid OpenAI upstream envelope: empty stream", "upstream", {
+            ...retryAfterHeader(res.headers),
+        }, "invalid_upstream_envelope");
+    }
+    const preflight = await preflightResponseStream(res.body, "openai-responses");
+    if (!preflight.ok) {
+        return anthropicError(502, `llm-relay: invalid OpenAI upstream envelope: ${preflight.reason}`, "upstream", {
+            ...retryAfterHeader(res.headers),
+        }, "invalid_upstream_envelope");
+    }
+    try {
+        const anthStream = translateResponsesStreamToAnthropic(preflight.body);
+        const observedStream = args.usage
+            ? observeUsage(new Response(anthStream), "anthropic-messages", args.usage, { streamed: true }).body ?? anthStream
+            : anthStream;
+        const strippedStream = stripThinkTagsInStream(observedStream);
+        const schemas = toolSchemaMap(args.reqJson);
+        const refusalSignal = dialectRefusalSignal();
+        const recovered = schemas.size > 0
+            ? recoverDialectInStream(strippedStream, schemas, args.isDestructive, refusalSignal)
+            : strippedStream;
+        const metadata = preflight.metadata;
+        if (toolCallIdsRewritten > 0)
+            metadata.toolCallIdRewrites = toolCallIdsRewritten;
+        if (sentinelsStamped > 0)
+            metadata.thoughtSignatureSentinels = sentinelsStamped;
+        const body = rewriteToolUseIdsInStream(recovered, () => knownToolUseIds(args.reqJson), (count) => { metadata.toolUseIdRewrites = count; });
+        const streamResponse = attachUpstreamMetadata(new Response(body, {
+            status: res.status,
+            headers: {
+                "content-type": "text/event-stream",
+                ...(toolCallIdsRewritten > 0 ? { [TOOL_CALL_IDS_HEADER]: `${toolCallIdsRewritten} rewritten` } : {}),
+            },
+        }), metadata);
+        dialectRefusalSignals.set(streamResponse, refusalSignal);
+        return streamResponse;
+    }
+    catch (e) {
+        return anthropicError(502, `llm-relay: response translation failed: ${e.message}`, "local", {}, "relay_mapper_defect");
+    }
+}
+function mapResponsesJsonToAnthropicOrError(upstreamJson, target, args) {
+    try {
+        const schemas = toolSchemaMap(args.reqJson);
+        const message = openAiResponsesToAnthropicMessage(upstreamJson, target.model ?? "", schemas, args.isDestructive);
+        return { ok: true, message };
+    }
+    catch (e) {
+        if (e instanceof DialectUnparseableError) {
+            return { ok: false, response: anthropicError(502, `llm-relay: ${e.message}`, "upstream", {}, "tool_dialect_unparseable") };
+        }
+        if (e instanceof DialectDestructiveError) {
+            return {
+                ok: false,
+                response: anthropicError(502, `llm-relay: ${e.message}`, "local", { [TOOL_DIALECT_HEADER]: "refused-destructive" }, DIALECT_REFUSED_DESTRUCTIVE_CODE),
+            };
+        }
+        return { ok: false, response: anthropicError(502, `llm-relay: response translation failed: ${e.message}`, "local", {}, "relay_mapper_defect") };
+    }
+}
+async function fetchResponsesBuffered(args, target, res, toolCallIdsRewritten, sentinelsStamped) {
+    let upstreamJson;
+    try {
+        upstreamJson = await res.json();
+    }
+    catch (cause) {
+        if (!(cause instanceof SyntaxError))
+            return attachPostHeaderBodyFailure(res, cause);
+        return anthropicError(502, "llm-relay: invalid OpenAI upstream envelope: body is not valid JSON", "upstream", {
+            ...retryAfterHeader(res.headers),
+        }, "invalid_upstream_envelope");
+    }
+    const invalidReason = invalidEnvelopeReason(upstreamJson, "openai-responses", false);
+    if (invalidReason) {
+        return anthropicError(502, `llm-relay: invalid OpenAI upstream envelope: ${invalidReason}`, "upstream", {
+            ...retryAfterHeader(res.headers),
+        }, "invalid_upstream_envelope");
+    }
+    const mapped = mapResponsesJsonToAnthropicOrError(upstreamJson, target, args);
+    if (!mapped.ok)
+        return mapped.response;
+    let anthropicJson = mapped.message;
+    const mintedIds = mintUniqueToolUseIds(anthropicJson, args.reqJson);
+    if (mintedIds.message)
+        anthropicJson = mintedIds.message;
+    const recoveredDialect = recoveredDialectOf(anthropicJson);
+    if (args.usage) {
+        applyResponsesUsage(args.usage, extractAnthropicUsageFromResponses(upstreamJson.usage));
+    }
+    const response = new Response(JSON.stringify(anthropicJson), {
+        status: 200,
+        headers: {
+            "content-type": "application/json",
+            ...(recoveredDialect ? { [TOOL_DIALECT_HEADER]: recoveredDialect } : {}),
+            ...(mintedIds.rewritten > 0 ? { [TOOL_USE_IDS_HEADER]: `${mintedIds.rewritten} rewritten` } : {}),
+            ...(toolCallIdsRewritten > 0 ? { [TOOL_CALL_IDS_HEADER]: `${toolCallIdsRewritten} rewritten` } : {}),
+        },
+    });
+    const metadata = {};
+    captureReportedModel(metadata, upstreamJson, "openai-responses", false);
+    if (mintedIds.rewritten > 0)
+        metadata.toolUseIdRewrites = mintedIds.rewritten;
+    if (toolCallIdsRewritten > 0)
+        metadata.toolCallIdRewrites = toolCallIdsRewritten;
+    if (sentinelsStamped > 0)
+        metadata.thoughtSignatureSentinels = sentinelsStamped;
+    return attachUpstreamMetadata(response, metadata);
+}
+async function fetchOpenAiResponsesBackend(attempt, args, invokeFetch) {
+    let reqJson = args.reqJson;
+    try {
+        reqJson = await transcodeDocuments(reqJson);
+    }
+    catch (e) {
+        if (e instanceof DocumentError)
+            return anthropicError(400, `llm-relay: ${e.message}`, "local");
+        return anthropicError(502, `document conversion failed: ${e.message}`, "local");
+    }
+    const posted = await postResponsesRequest(attempt, args, reqJson, invokeFetch);
+    if (!posted.ok)
+        return posted.response;
+    if (args.wantsStream) {
+        return fetchResponsesStreamed(args, posted.res, posted.toolCallIdsRewritten, posted.sentinelsStamped);
+    }
+    return fetchResponsesBuffered(args, attempt.target, posted.res, posted.toolCallIdsRewritten, posted.sentinelsStamped);
+}
 export async function fetchBackend(attempt, args, fetchFn = fetch) {
     const invokeFetch = oneShotFetch(fetchFn, args.signal, args.onEgress);
     if (attempt.target.kind === "anthropic") {
@@ -572,12 +1320,14 @@ function formatOpenAiChatCompletion(body, text, toolCalls, model, usage) {
     return out;
 }
 function formatOpenAiResponses(body, text, toolCalls, model, usage) {
+    const capped = body.stop_reason === "max_tokens";
+    const itemStatus = capped ? "incomplete" : "completed";
     const output = [];
     if (text) {
         output.push({
             type: "message",
             id: `msg_${typeof body.id === "string" ? body.id : "relay"}`,
-            status: "completed",
+            status: itemStatus,
             role: "assistant",
             content: [{ type: "output_text", text, annotations: [] }],
         });
@@ -590,18 +1340,20 @@ function formatOpenAiResponses(body, text, toolCalls, model, usage) {
             call_id: call.id,
             name: fn.name,
             arguments: fn.arguments,
-            status: "completed",
+            status: itemStatus,
         });
     }
     const out = {
         id: typeof body.id === "string" ? body.id : "resp_relay",
         object: "response",
         created_at: Math.floor(Date.now() / 1000),
-        status: "completed",
+        status: capped ? "incomplete" : "completed",
         model,
         output,
         output_text: text,
     };
+    if (capped)
+        out.incomplete_details = { reason: "max_output_tokens" };
     if (usage)
         out.usage = withOpenAiTotal(usage);
     return out;
@@ -720,6 +1472,17 @@ function buildTargetHeaders(attempt) {
         ...buildAuthHeaders(credential.value, target.authHeader),
     };
 }
+function resolveAnthropicResponsesMaxTokens(target, catalogLimits) {
+    if (target.model) {
+        const learned = observedMaxOutput(target.provider, target.model);
+        if (typeof learned === "number" && learned > 0)
+            return learned;
+        const published = catalogLimits?.(target.provider, target.model)?.maxOutputTokens;
+        if (typeof published === "number" && published > 0)
+            return published;
+    }
+    return DEFAULT_RESPONSES_MAX_TOKENS;
+}
 async function fetchDirectOpenAiChat(attempt, args, invokeFetch) {
     const target = attempt.target;
     const base = (args.reqJson ?? {});
@@ -814,6 +1577,58 @@ async function fetchDirectOpenAiChat(attempt, args, invokeFetch) {
     }
     return attachUpstreamMetadata(res, metadata);
 }
+function tapAnthropicStopReason(source, onStopReason) {
+    const decoder = new TextDecoder();
+    const frames = new BufferedSseFrames();
+    let seen = false;
+    return source.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            controller.enqueue(chunk);
+            if (seen)
+                return;
+            frames.append(decoder.decode(chunk, { stream: true }));
+            for (const { frame } of frames) {
+                if (seen)
+                    break;
+                const ev = parseSseEvent(frame);
+                if (ev?.type !== "message_delta" || !isRecord(ev.data))
+                    continue;
+                const delta = ev.data.delta;
+                if (isRecord(delta) && typeof delta.stop_reason === "string") {
+                    seen = true;
+                    onStopReason(delta.stop_reason);
+                }
+            }
+        },
+    }));
+}
+function responsesSseEvent(type, data) {
+    return `event: ${type}\ndata: ${JSON.stringify({ ...data, type })}\n\n`;
+}
+function markResponsesIncompleteOnMaxTokens(source, stopReason) {
+    return createSseTransformStream(source, ({ push, frames }) => ({
+        processFrames: () => {
+            for (const { frame, raw } of frames) {
+                const ev = parseSseEvent(frame);
+                if (stopReason.value === "max_tokens" &&
+                    ev?.type === "response.completed" &&
+                    isRecord(ev.data) &&
+                    isRecord(ev.data.response)) {
+                    push(responsesSseEvent("response.incomplete", {
+                        ...ev.data,
+                        response: {
+                            ...ev.data.response,
+                            status: "incomplete",
+                            incomplete_details: { reason: "max_output_tokens" },
+                        },
+                    }));
+                    continue;
+                }
+                push(raw);
+            }
+        },
+    }));
+}
 async function fetchTranslatedOpenAiFront(attempt, args, fetchFn) {
     const target = attempt.target;
     const protocol = args.protocol ?? "chat";
@@ -826,6 +1641,9 @@ async function fetchTranslatedOpenAiFront(attempt, args, fetchFn) {
         if (target.model !== undefined)
             anthropicBody.model = target.model;
         anthropicBody.stream = args.wantsStream;
+        if (protocol === "responses" && target.kind === "anthropic" && typeof anthropicBody.max_tokens !== "number") {
+            anthropicBody.max_tokens = resolveAnthropicResponsesMaxTokens(target, args.catalogLimits);
+        }
     }
     catch (e) {
         if (e instanceof RequestMappingError)
@@ -881,7 +1699,13 @@ async function fetchTranslatedOpenAiFront(attempt, args, fetchFn) {
         }
         const targetProtocol = protocol === "responses" ? "openai-responses" : "openai";
         try {
-            const output = handleUniversalStreamRequest(preflight.body, "anthropic", targetProtocol);
+            const stopReason = { value: null };
+            const anthropicSource = protocol === "responses"
+                ? tapAnthropicStopReason(preflight.body, (r) => { stopReason.value = r; })
+                : preflight.body;
+            let output = handleUniversalStreamRequest(anthropicSource, "anthropic", targetProtocol);
+            if (protocol === "responses")
+                output = markResponsesIncompleteOnMaxTokens(output, stopReason);
             const rewritten = backendRes.headers.get(TOOL_CALL_IDS_HEADER);
             const response = new Response(output, {
                 status: backendRes.status,
@@ -935,7 +1759,7 @@ async function fetchTranslatedOpenAiFront(attempt, args, fetchFn) {
 }
 export async function fetchOpenAiFront(attempt, args, fetchFn = fetch) {
     const protocol = args.protocol ?? "chat";
-    if (attempt.target.kind === "openai" && protocol === "chat") {
+    if (attempt.target.kind === "openai" && protocol === "chat" && attempt.target.wire !== "responses") {
         const invokeFetch = oneShotFetch(fetchFn, args.signal, args.onEgress);
         return fetchDirectOpenAiChat(attempt, args, invokeFetch);
     }