@dbx-tools/appkit-model-gateway 0.9.36

package/lib/src/protocols/encode.js

@@ -0,0 +1,498 @@
+/**
+ * Streaming and buffered protocol encoders for AI SDK fallback results.
+ *
+ * @module
+ */
+/** Encode AI SDK events as the requested protocol while preserving backpressure. */
+export function encodeGatewayStream(protocol, model, source) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                const events = protocol === "openai-responses"
+                    ? responsesEvents(model, source)
+                    : protocol === "anthropic-messages"
+                        ? anthropicEvents(model, source)
+                        : chatEvents(model, source);
+                for await (const event of events)
+                    controller.enqueue(encoder.encode(event));
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
+/** Encode a completed AI SDK generation as one protocol-native JSON response. */
+export function encodeGatewayResponse(protocol, model, generation) {
+    if (protocol === "openai-responses")
+        return responsesObject(model, generation);
+    if (protocol === "anthropic-messages")
+        return anthropicObject(model, generation);
+    return chatObject(model, generation);
+}
+async function* responsesEvents(model, source) {
+    const responseId = `resp_${crypto.randomUUID().replaceAll("-", "")}`;
+    const createdAt = Math.floor(Date.now() / 1000);
+    const output = [];
+    const response = {
+        id: responseId,
+        object: "response",
+        created_at: createdAt,
+        model,
+        status: "in_progress",
+        background: false,
+        completed_at: null,
+        error: null,
+        incomplete_details: null,
+        instructions: null,
+        max_output_tokens: null,
+        output,
+        parallel_tool_calls: true,
+        previous_response_id: null,
+        reasoning: null,
+        store: false,
+        temperature: null,
+        text: { format: { type: "text" } },
+        tool_choice: "auto",
+        tools: [],
+        top_p: null,
+        truncation: "disabled",
+        usage: null,
+        metadata: {},
+    };
+    let sequenceNumber = 0;
+    const event = (name, payload) => sse(name, { ...payload, sequence_number: sequenceNumber++ });
+    yield event("response.created", { type: "response.created", response });
+    yield event("response.in_progress", { type: "response.in_progress", response });
+    let outputIndex = 0;
+    let messageId;
+    let textValue = "";
+    const toolIndexes = new Map();
+    let usage;
+    for await (const part of source) {
+        if (part.type === "text-start") {
+            messageId = `msg_${crypto.randomUUID().replaceAll("-", "")}`;
+            yield event("response.output_item.added", {
+                type: "response.output_item.added",
+                output_index: outputIndex,
+                item: {
+                    id: messageId,
+                    type: "message",
+                    role: "assistant",
+                    status: "in_progress",
+                    phase: "final_answer",
+                    content: [],
+                },
+            });
+            yield event("response.content_part.added", {
+                type: "response.content_part.added",
+                item_id: messageId,
+                output_index: outputIndex,
+                content_index: 0,
+                part: { type: "output_text", text: "", annotations: [], logprobs: [] },
+            });
+        }
+        else if (part.type === "text-delta") {
+            textValue += part.text;
+            yield event("response.output_text.delta", {
+                type: "response.output_text.delta",
+                item_id: messageId,
+                output_index: outputIndex,
+                content_index: 0,
+                delta: part.text,
+                logprobs: [],
+            });
+        }
+        else if (part.type === "text-end") {
+            yield event("response.output_text.done", {
+                type: "response.output_text.done",
+                item_id: messageId,
+                output_index: outputIndex,
+                content_index: 0,
+                text: textValue,
+                logprobs: [],
+            });
+            yield event("response.content_part.done", {
+                type: "response.content_part.done",
+                item_id: messageId,
+                output_index: outputIndex,
+                content_index: 0,
+                part: { type: "output_text", text: textValue, annotations: [], logprobs: [] },
+            });
+            const item = {
+                id: messageId,
+                type: "message",
+                role: "assistant",
+                status: "completed",
+                phase: "final_answer",
+                content: [{ type: "output_text", text: textValue, annotations: [], logprobs: [] }],
+            };
+            output.push(item);
+            yield event("response.output_item.done", {
+                type: "response.output_item.done",
+                output_index: outputIndex,
+                item,
+            });
+            outputIndex++;
+            textValue = "";
+        }
+        else if (part.type === "reasoning-delta") {
+            yield event("response.reasoning_summary_text.delta", {
+                type: "response.reasoning_summary_text.delta",
+                output_index: outputIndex,
+                delta: part.text,
+            });
+        }
+        else if (part.type === "tool-input-start") {
+            toolIndexes.set(part.id, outputIndex);
+            yield event("response.output_item.added", {
+                type: "response.output_item.added",
+                output_index: outputIndex,
+                item: {
+                    id: `fc_${part.id}`,
+                    type: "function_call",
+                    call_id: part.id,
+                    name: part.toolName,
+                    arguments: "",
+                    status: "in_progress",
+                },
+            });
+            outputIndex++;
+        }
+        else if (part.type === "tool-input-delta") {
+            yield event("response.function_call_arguments.delta", {
+                type: "response.function_call_arguments.delta",
+                item_id: `fc_${part.id}`,
+                output_index: toolIndexes.get(part.id) ?? outputIndex,
+                delta: part.delta,
+            });
+        }
+        else if (part.type === "tool-call") {
+            const index = toolIndexes.get(part.toolCallId) ?? outputIndex++;
+            const item = {
+                id: `fc_${part.toolCallId}`,
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input),
+                status: "completed",
+            };
+            yield event("response.function_call_arguments.done", {
+                type: "response.function_call_arguments.done",
+                item_id: `fc_${part.toolCallId}`,
+                output_index: index,
+                arguments: JSON.stringify(part.input),
+            });
+            yield event("response.output_item.done", {
+                type: "response.output_item.done",
+                output_index: index,
+                item,
+            });
+            output.push(item);
+        }
+        else if (part.type === "finish") {
+            usage = part.totalUsage;
+        }
+        else if (part.type === "error") {
+            yield event("error", protocolError(part.error));
+        }
+    }
+    yield event("response.completed", {
+        type: "response.completed",
+        response: {
+            ...response,
+            status: "completed",
+            completed_at: Math.floor(Date.now() / 1000),
+            usage: responsesUsage(usage),
+        },
+    });
+}
+async function* chatEvents(model, source) {
+    const id = `chatcmpl-${crypto.randomUUID().replaceAll("-", "")}`;
+    const created = Math.floor(Date.now() / 1000);
+    yield data({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }],
+    });
+    const toolIndexes = new Map();
+    let nextToolIndex = 0;
+    for await (const part of source) {
+        if (part.type === "text-delta") {
+            yield data({
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                choices: [{ index: 0, delta: { content: part.text }, finish_reason: null }],
+            });
+        }
+        else if (part.type === "tool-input-start") {
+            const index = nextToolIndex++;
+            toolIndexes.set(part.id, index);
+            yield data({
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            tool_calls: [
+                                {
+                                    index,
+                                    id: part.id,
+                                    type: "function",
+                                    function: { name: part.toolName, arguments: "" },
+                                },
+                            ],
+                        },
+                        finish_reason: null,
+                    },
+                ],
+            });
+        }
+        else if (part.type === "tool-input-delta") {
+            yield data({
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            tool_calls: [
+                                {
+                                    index: toolIndexes.get(part.id) ?? 0,
+                                    function: { arguments: part.delta },
+                                },
+                            ],
+                        },
+                        finish_reason: null,
+                    },
+                ],
+            });
+        }
+        else if (part.type === "finish") {
+            yield data({
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                choices: [{ index: 0, delta: {}, finish_reason: chatFinishReason(part.finishReason) }],
+                usage: chatUsage(part.totalUsage),
+            });
+        }
+        else if (part.type === "error") {
+            yield data(protocolError(part.error));
+        }
+    }
+    yield "data: [DONE]\n\n";
+}
+async function* anthropicEvents(model, source) {
+    const id = `msg_${crypto.randomUUID().replaceAll("-", "")}`;
+    yield sse("message_start", {
+        type: "message_start",
+        message: {
+            id,
+            type: "message",
+            role: "assistant",
+            model,
+            content: [],
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+        },
+    });
+    let contentIndex = 0;
+    const toolIndexes = new Map();
+    for await (const part of source) {
+        if (part.type === "text-start") {
+            yield sse("content_block_start", {
+                type: "content_block_start",
+                index: contentIndex,
+                content_block: { type: "text", text: "" },
+            });
+        }
+        else if (part.type === "text-delta") {
+            yield sse("content_block_delta", {
+                type: "content_block_delta",
+                index: contentIndex,
+                delta: { type: "text_delta", text: part.text },
+            });
+        }
+        else if (part.type === "text-end") {
+            yield sse("content_block_stop", { type: "content_block_stop", index: contentIndex++ });
+        }
+        else if (part.type === "tool-input-start") {
+            toolIndexes.set(part.id, contentIndex);
+            yield sse("content_block_start", {
+                type: "content_block_start",
+                index: contentIndex++,
+                content_block: { type: "tool_use", id: part.id, name: part.toolName, input: {} },
+            });
+        }
+        else if (part.type === "tool-input-delta") {
+            yield sse("content_block_delta", {
+                type: "content_block_delta",
+                index: toolIndexes.get(part.id) ?? 0,
+                delta: { type: "input_json_delta", partial_json: part.delta },
+            });
+        }
+        else if (part.type === "tool-input-end") {
+            yield sse("content_block_stop", {
+                type: "content_block_stop",
+                index: toolIndexes.get(part.id) ?? 0,
+            });
+        }
+        else if (part.type === "finish") {
+            yield sse("message_delta", {
+                type: "message_delta",
+                delta: { stop_reason: anthropicFinishReason(part.finishReason), stop_sequence: null },
+                usage: { output_tokens: part.totalUsage.outputTokens ?? 0 },
+            });
+        }
+        else if (part.type === "error") {
+            yield sse("error", protocolError(part.error));
+        }
+    }
+    yield sse("message_stop", { type: "message_stop" });
+}
+function responsesObject(model, generation) {
+    const output = [];
+    if (generation.text) {
+        output.push({
+            id: `msg_${crypto.randomUUID().replaceAll("-", "")}`,
+            type: "message",
+            role: "assistant",
+            status: "completed",
+            content: [{ type: "output_text", text: generation.text, annotations: [] }],
+        });
+    }
+    for (const call of generation.toolCalls) {
+        output.push({
+            id: `fc_${call.toolCallId}`,
+            type: "function_call",
+            call_id: call.toolCallId,
+            name: call.toolName,
+            arguments: JSON.stringify(call.input),
+            status: "completed",
+        });
+    }
+    return {
+        id: `resp_${crypto.randomUUID().replaceAll("-", "")}`,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status: "completed",
+        model,
+        output,
+        usage: responsesUsage(generation.usage),
+    };
+}
+function chatObject(model, generation) {
+    return {
+        id: `chatcmpl-${crypto.randomUUID().replaceAll("-", "")}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: "assistant",
+                    content: generation.text || null,
+                    ...(generation.toolCalls.length > 0
+                        ? {
+                            tool_calls: generation.toolCalls.map((call) => ({
+                                id: call.toolCallId,
+                                type: "function",
+                                function: { name: call.toolName, arguments: JSON.stringify(call.input) },
+                            })),
+                        }
+                        : {}),
+                },
+                finish_reason: chatFinishReason(generation.finishReason),
+            },
+        ],
+        usage: chatUsage(generation.usage),
+    };
+}
+function anthropicObject(model, generation) {
+    return {
+        id: `msg_${crypto.randomUUID().replaceAll("-", "")}`,
+        type: "message",
+        role: "assistant",
+        model,
+        content: [
+            ...(generation.text ? [{ type: "text", text: generation.text }] : []),
+            ...generation.toolCalls.map((call) => ({
+                type: "tool_use",
+                id: call.toolCallId,
+                name: call.toolName,
+                input: call.input,
+            })),
+        ],
+        stop_reason: anthropicFinishReason(generation.finishReason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: generation.usage.inputTokens ?? 0,
+            output_tokens: generation.usage.outputTokens ?? 0,
+        },
+    };
+}
+function responsesUsage(usage) {
+    const input = usage?.inputTokens ?? 0;
+    const output = usage?.outputTokens ?? 0;
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: input + output,
+        input_tokens_details: { cached_tokens: usage?.inputTokenDetails.cacheReadTokens ?? 0 },
+        output_tokens_details: {
+            reasoning_tokens: usage?.outputTokenDetails.reasoningTokens ?? 0,
+        },
+    };
+}
+function chatUsage(usage) {
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    return { prompt_tokens: input, completion_tokens: output, total_tokens: input + output };
+}
+function chatFinishReason(reason) {
+    if (reason === "tool-calls")
+        return "tool_calls";
+    if (reason === "length")
+        return "length";
+    if (reason === "content-filter")
+        return "content_filter";
+    return "stop";
+}
+function anthropicFinishReason(reason) {
+    if (reason === "tool-calls")
+        return "tool_use";
+    if (reason === "length")
+        return "max_tokens";
+    return "end_turn";
+}
+function protocolError(error) {
+    return {
+        type: "error",
+        error: {
+            type: "api_error",
+            message: error instanceof Error ? error.message : String(error),
+        },
+    };
+}
+function sse(event, payload) {
+    return `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`;
+}
+function data(payload) {
+    return `data: ${JSON.stringify(payload)}\n\n`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../../src/protocols/encode.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Streaming and buffered protocol encoders for AI SDK fallback results.\n *\n * @module\n */\n\nimport type { ClientProtocol } from \"@dbx-tools/shared-model-gateway\";\nimport type { FinishReason, LanguageModelUsage, TextStreamPart, ToolSet, TypedToolCall } from \"ai\";\n\n/** Completed AI SDK generation data used by non-streaming encoders. */\nexport interface CompletedGeneration {\n  readonly text: string;\n  readonly toolCalls: readonly TypedToolCall<ToolSet>[];\n  readonly usage: LanguageModelUsage;\n  readonly finishReason: FinishReason;\n}\n\n/** Encode AI SDK events as the requested protocol while preserving backpressure. */\nexport function encodeGatewayStream(\n  protocol: ClientProtocol,\n  model: string,\n  source: AsyncIterable<TextStreamPart<ToolSet>>,\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder();\n  return new ReadableStream<Uint8Array>({\n    async start(controller) {\n      try {\n        const events =\n          protocol === \"openai-responses\"\n            ? responsesEvents(model, source)\n            : protocol === \"anthropic-messages\"\n              ? anthropicEvents(model, source)\n              : chatEvents(model, source);\n        for await (const event of events) controller.enqueue(encoder.encode(event));\n        controller.close();\n      } catch (error) {\n        controller.error(error);\n      }\n    },\n  });\n}\n\n/** Encode a completed AI SDK generation as one protocol-native JSON response. */\nexport function encodeGatewayResponse(\n  protocol: ClientProtocol,\n  model: string,\n  generation: CompletedGeneration,\n): Record<string, unknown> {\n  if (protocol === \"openai-responses\") return responsesObject(model, generation);\n  if (protocol === \"anthropic-messages\") return anthropicObject(model, generation);\n  return chatObject(model, generation);\n}\n\nasync function* responsesEvents(\n  model: string,\n  source: AsyncIterable<TextStreamPart<ToolSet>>,\n): AsyncGenerator<string> {\n  const responseId = `resp_${crypto.randomUUID().replaceAll(\"-\", \"\")}`;\n  const createdAt = Math.floor(Date.now() / 1000);\n  const output: Record<string, unknown>[] = [];\n  const response = {\n    id: responseId,\n    object: \"response\",\n    created_at: createdAt,\n    model,\n    status: \"in_progress\",\n    background: false,\n    completed_at: null,\n    error: null,\n    incomplete_details: null,\n    instructions: null,\n    max_output_tokens: null,\n    output,\n    parallel_tool_calls: true,\n    previous_response_id: null,\n    reasoning: null,\n    store: false,\n    temperature: null,\n    text: { format: { type: \"text\" } },\n    tool_choice: \"auto\",\n    tools: [],\n    top_p: null,\n    truncation: \"disabled\",\n    usage: null,\n    metadata: {},\n  };\n  let sequenceNumber = 0;\n  const event = (name: string, payload: Record<string, unknown>) =>\n    sse(name, { ...payload, sequence_number: sequenceNumber++ });\n  yield event(\"response.created\", { type: \"response.created\", response });\n  yield event(\"response.in_progress\", { type: \"response.in_progress\", response });\n  let outputIndex = 0;\n  let messageId: string | undefined;\n  let textValue = \"\";\n  const toolIndexes = new Map<string, number>();\n  let usage: LanguageModelUsage | undefined;\n\n  for await (const part of source) {\n    if (part.type === \"text-start\") {\n      messageId = `msg_${crypto.randomUUID().replaceAll(\"-\", \"\")}`;\n      yield event(\"response.output_item.added\", {\n        type: \"response.output_item.added\",\n        output_index: outputIndex,\n        item: {\n          id: messageId,\n          type: \"message\",\n          role: \"assistant\",\n          status: \"in_progress\",\n          phase: \"final_answer\",\n          content: [],\n        },\n      });\n      yield event(\"response.content_part.added\", {\n        type: \"response.content_part.added\",\n        item_id: messageId,\n        output_index: outputIndex,\n        content_index: 0,\n        part: { type: \"output_text\", text: \"\", annotations: [], logprobs: [] },\n      });\n    } else if (part.type === \"text-delta\") {\n      textValue += part.text;\n      yield event(\"response.output_text.delta\", {\n        type: \"response.output_text.delta\",\n        item_id: messageId,\n        output_index: outputIndex,\n        content_index: 0,\n        delta: part.text,\n        logprobs: [],\n      });\n    } else if (part.type === \"text-end\") {\n      yield event(\"response.output_text.done\", {\n        type: \"response.output_text.done\",\n        item_id: messageId,\n        output_index: outputIndex,\n        content_index: 0,\n        text: textValue,\n        logprobs: [],\n      });\n      yield event(\"response.content_part.done\", {\n        type: \"response.content_part.done\",\n        item_id: messageId,\n        output_index: outputIndex,\n        content_index: 0,\n        part: { type: \"output_text\", text: textValue, annotations: [], logprobs: [] },\n      });\n      const item = {\n        id: messageId,\n        type: \"message\",\n        role: \"assistant\",\n        status: \"completed\",\n        phase: \"final_answer\",\n        content: [{ type: \"output_text\", text: textValue, annotations: [], logprobs: [] }],\n      };\n      output.push(item);\n      yield event(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: outputIndex,\n        item,\n      });\n      outputIndex++;\n      textValue = \"\";\n    } else if (part.type === \"reasoning-delta\") {\n      yield event(\"response.reasoning_summary_text.delta\", {\n        type: \"response.reasoning_summary_text.delta\",\n        output_index: outputIndex,\n        delta: part.text,\n      });\n    } else if (part.type === \"tool-input-start\") {\n      toolIndexes.set(part.id, outputIndex);\n      yield event(\"response.output_item.added\", {\n        type: \"response.output_item.added\",\n        output_index: outputIndex,\n        item: {\n          id: `fc_${part.id}`,\n          type: \"function_call\",\n          call_id: part.id,\n          name: part.toolName,\n          arguments: \"\",\n          status: \"in_progress\",\n        },\n      });\n      outputIndex++;\n    } else if (part.type === \"tool-input-delta\") {\n      yield event(\"response.function_call_arguments.delta\", {\n        type: \"response.function_call_arguments.delta\",\n        item_id: `fc_${part.id}`,\n        output_index: toolIndexes.get(part.id) ?? outputIndex,\n        delta: part.delta,\n      });\n    } else if (part.type === \"tool-call\") {\n      const index = toolIndexes.get(part.toolCallId) ?? outputIndex++;\n      const item = {\n        id: `fc_${part.toolCallId}`,\n        type: \"function_call\",\n        call_id: part.toolCallId,\n        name: part.toolName,\n        arguments: JSON.stringify(part.input),\n        status: \"completed\",\n      };\n      yield event(\"response.function_call_arguments.done\", {\n        type: \"response.function_call_arguments.done\",\n        item_id: `fc_${part.toolCallId}`,\n        output_index: index,\n        arguments: JSON.stringify(part.input),\n      });\n      yield event(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: index,\n        item,\n      });\n      output.push(item);\n    } else if (part.type === \"finish\") {\n      usage = part.totalUsage;\n    } else if (part.type === \"error\") {\n      yield event(\"error\", protocolError(part.error));\n    }\n  }\n  yield event(\"response.completed\", {\n    type: \"response.completed\",\n    response: {\n      ...response,\n      status: \"completed\",\n      completed_at: Math.floor(Date.now() / 1000),\n      usage: responsesUsage(usage),\n    },\n  });\n}\n\nasync function* chatEvents(\n  model: string,\n  source: AsyncIterable<TextStreamPart<ToolSet>>,\n): AsyncGenerator<string> {\n  const id = `chatcmpl-${crypto.randomUUID().replaceAll(\"-\", \"\")}`;\n  const created = Math.floor(Date.now() / 1000);\n  yield data({\n    id,\n    object: \"chat.completion.chunk\",\n    created,\n    model,\n    choices: [{ index: 0, delta: { role: \"assistant\", content: \"\" }, finish_reason: null }],\n  });\n  const toolIndexes = new Map<string, number>();\n  let nextToolIndex = 0;\n  for await (const part of source) {\n    if (part.type === \"text-delta\") {\n      yield data({\n        id,\n        object: \"chat.completion.chunk\",\n        created,\n        model,\n        choices: [{ index: 0, delta: { content: part.text }, finish_reason: null }],\n      });\n    } else if (part.type === \"tool-input-start\") {\n      const index = nextToolIndex++;\n      toolIndexes.set(part.id, index);\n      yield data({\n        id,\n        object: \"chat.completion.chunk\",\n        created,\n        model,\n        choices: [\n          {\n            index: 0,\n            delta: {\n              tool_calls: [\n                {\n                  index,\n                  id: part.id,\n                  type: \"function\",\n                  function: { name: part.toolName, arguments: \"\" },\n                },\n              ],\n            },\n            finish_reason: null,\n          },\n        ],\n      });\n    } else if (part.type === \"tool-input-delta\") {\n      yield data({\n        id,\n        object: \"chat.completion.chunk\",\n        created,\n        model,\n        choices: [\n          {\n            index: 0,\n            delta: {\n              tool_calls: [\n                {\n                  index: toolIndexes.get(part.id) ?? 0,\n                  function: { arguments: part.delta },\n                },\n              ],\n            },\n            finish_reason: null,\n          },\n        ],\n      });\n    } else if (part.type === \"finish\") {\n      yield data({\n        id,\n        object: \"chat.completion.chunk\",\n        created,\n        model,\n        choices: [{ index: 0, delta: {}, finish_reason: chatFinishReason(part.finishReason) }],\n        usage: chatUsage(part.totalUsage),\n      });\n    } else if (part.type === \"error\") {\n      yield data(protocolError(part.error));\n    }\n  }\n  yield \"data: [DONE]\\n\\n\";\n}\n\nasync function* anthropicEvents(\n  model: string,\n  source: AsyncIterable<TextStreamPart<ToolSet>>,\n): AsyncGenerator<string> {\n  const id = `msg_${crypto.randomUUID().replaceAll(\"-\", \"\")}`;\n  yield sse(\"message_start\", {\n    type: \"message_start\",\n    message: {\n      id,\n      type: \"message\",\n      role: \"assistant\",\n      model,\n      content: [],\n      stop_reason: null,\n      stop_sequence: null,\n      usage: { input_tokens: 0, output_tokens: 0 },\n    },\n  });\n  let contentIndex = 0;\n  const toolIndexes = new Map<string, number>();\n  for await (const part of source) {\n    if (part.type === \"text-start\") {\n      yield sse(\"content_block_start\", {\n        type: \"content_block_start\",\n        index: contentIndex,\n        content_block: { type: \"text\", text: \"\" },\n      });\n    } else if (part.type === \"text-delta\") {\n      yield sse(\"content_block_delta\", {\n        type: \"content_block_delta\",\n        index: contentIndex,\n        delta: { type: \"text_delta\", text: part.text },\n      });\n    } else if (part.type === \"text-end\") {\n      yield sse(\"content_block_stop\", { type: \"content_block_stop\", index: contentIndex++ });\n    } else if (part.type === \"tool-input-start\") {\n      toolIndexes.set(part.id, contentIndex);\n      yield sse(\"content_block_start\", {\n        type: \"content_block_start\",\n        index: contentIndex++,\n        content_block: { type: \"tool_use\", id: part.id, name: part.toolName, input: {} },\n      });\n    } else if (part.type === \"tool-input-delta\") {\n      yield sse(\"content_block_delta\", {\n        type: \"content_block_delta\",\n        index: toolIndexes.get(part.id) ?? 0,\n        delta: { type: \"input_json_delta\", partial_json: part.delta },\n      });\n    } else if (part.type === \"tool-input-end\") {\n      yield sse(\"content_block_stop\", {\n        type: \"content_block_stop\",\n        index: toolIndexes.get(part.id) ?? 0,\n      });\n    } else if (part.type === \"finish\") {\n      yield sse(\"message_delta\", {\n        type: \"message_delta\",\n        delta: { stop_reason: anthropicFinishReason(part.finishReason), stop_sequence: null },\n        usage: { output_tokens: part.totalUsage.outputTokens ?? 0 },\n      });\n    } else if (part.type === \"error\") {\n      yield sse(\"error\", protocolError(part.error));\n    }\n  }\n  yield sse(\"message_stop\", { type: \"message_stop\" });\n}\n\nfunction responsesObject(model: string, generation: CompletedGeneration): Record<string, unknown> {\n  const output: Record<string, unknown>[] = [];\n  if (generation.text) {\n    output.push({\n      id: `msg_${crypto.randomUUID().replaceAll(\"-\", \"\")}`,\n      type: \"message\",\n      role: \"assistant\",\n      status: \"completed\",\n      content: [{ type: \"output_text\", text: generation.text, annotations: [] }],\n    });\n  }\n  for (const call of generation.toolCalls) {\n    output.push({\n      id: `fc_${call.toolCallId}`,\n      type: \"function_call\",\n      call_id: call.toolCallId,\n      name: call.toolName,\n      arguments: JSON.stringify(call.input),\n      status: \"completed\",\n    });\n  }\n  return {\n    id: `resp_${crypto.randomUUID().replaceAll(\"-\", \"\")}`,\n    object: \"response\",\n    created_at: Math.floor(Date.now() / 1000),\n    status: \"completed\",\n    model,\n    output,\n    usage: responsesUsage(generation.usage),\n  };\n}\n\nfunction chatObject(model: string, generation: CompletedGeneration): Record<string, unknown> {\n  return {\n    id: `chatcmpl-${crypto.randomUUID().replaceAll(\"-\", \"\")}`,\n    object: \"chat.completion\",\n    created: Math.floor(Date.now() / 1000),\n    model,\n    choices: [\n      {\n        index: 0,\n        message: {\n          role: \"assistant\",\n          content: generation.text || null,\n          ...(generation.toolCalls.length > 0\n            ? {\n                tool_calls: generation.toolCalls.map((call) => ({\n                  id: call.toolCallId,\n                  type: \"function\",\n                  function: { name: call.toolName, arguments: JSON.stringify(call.input) },\n                })),\n              }\n            : {}),\n        },\n        finish_reason: chatFinishReason(generation.finishReason),\n      },\n    ],\n    usage: chatUsage(generation.usage),\n  };\n}\n\nfunction anthropicObject(model: string, generation: CompletedGeneration): Record<string, unknown> {\n  return {\n    id: `msg_${crypto.randomUUID().replaceAll(\"-\", \"\")}`,\n    type: \"message\",\n    role: \"assistant\",\n    model,\n    content: [\n      ...(generation.text ? [{ type: \"text\", text: generation.text }] : []),\n      ...generation.toolCalls.map((call) => ({\n        type: \"tool_use\",\n        id: call.toolCallId,\n        name: call.toolName,\n        input: call.input,\n      })),\n    ],\n    stop_reason: anthropicFinishReason(generation.finishReason),\n    stop_sequence: null,\n    usage: {\n      input_tokens: generation.usage.inputTokens ?? 0,\n      output_tokens: generation.usage.outputTokens ?? 0,\n    },\n  };\n}\n\nfunction responsesUsage(usage: LanguageModelUsage | undefined): Record<string, unknown> {\n  const input = usage?.inputTokens ?? 0;\n  const output = usage?.outputTokens ?? 0;\n  return {\n    input_tokens: input,\n    output_tokens: output,\n    total_tokens: input + output,\n    input_tokens_details: { cached_tokens: usage?.inputTokenDetails.cacheReadTokens ?? 0 },\n    output_tokens_details: {\n      reasoning_tokens: usage?.outputTokenDetails.reasoningTokens ?? 0,\n    },\n  };\n}\n\nfunction chatUsage(usage: LanguageModelUsage): Record<string, number> {\n  const input = usage.inputTokens ?? 0;\n  const output = usage.outputTokens ?? 0;\n  return { prompt_tokens: input, completion_tokens: output, total_tokens: input + output };\n}\n\nfunction chatFinishReason(reason: FinishReason): string {\n  if (reason === \"tool-calls\") return \"tool_calls\";\n  if (reason === \"length\") return \"length\";\n  if (reason === \"content-filter\") return \"content_filter\";\n  return \"stop\";\n}\n\nfunction anthropicFinishReason(reason: FinishReason): string {\n  if (reason === \"tool-calls\") return \"tool_use\";\n  if (reason === \"length\") return \"max_tokens\";\n  return \"end_turn\";\n}\n\nfunction protocolError(error: unknown): Record<string, unknown> {\n  return {\n    type: \"error\",\n    error: {\n      type: \"api_error\",\n      message: error instanceof Error ? error.message : String(error),\n    },\n  };\n}\n\nfunction sse(event: string, payload: unknown): string {\n  return `event: ${event}\\ndata: ${JSON.stringify(payload)}\\n\\n`;\n}\n\nfunction data(payload: unknown): string {\n  return `data: ${JSON.stringify(payload)}\\n\\n`;\n}\n"]}

package/lib/src/reasoning-adapt.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Reasoning-effort adaptation for gateway round trips.
+ *
+ * Proactively remaps client efforts onto the known ladder, then on a single
+ * unsupported-value 400 learns from the error and retries once with the
+ * updated ladder.
+ *
+ * @module
+ */
+/** Result of the first proactive adaptation pass. */
+export interface AdaptedInferenceBody {
+    readonly body: Readonly<Record<string, unknown>>;
+    readonly wireEffort?: string;
+    readonly changed: boolean;
+}
+/** Adapt a request body onto the current known ladder for `model`. */
+export declare function adaptInferenceReasoning(model: string, body: Readonly<Record<string, unknown>>): AdaptedInferenceBody;
+/**
+ * On an unsupported-reasoning 400, learn once and optionally produce a
+ * remapped retry body. Returns `undefined` when no retry should occur.
+ */
+export declare function learnAndAdaptReasoningRetry(input: {
+    readonly model: string;
+    readonly body: Readonly<Record<string, unknown>>;
+    readonly response: Response;
+    readonly previousWireEffort?: string;
+}): Promise<Readonly<Record<string, unknown>> | undefined>;