@hebo-ai/gateway 0.9.2 → 0.9.4

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import { type GatewayConfig, type GatewayConfigParsed } from "./types";
+export declare const parseConfig: (config: GatewayConfig) => GatewayConfigParsed;

package/dist/config.js

@@ -0,0 +1,125 @@
+import { InMemoryStorage } from "./endpoints/conversations/storage/memory";
+import { isLogger, logger, setLoggerInstance } from "./logger";
+import { createDefaultLogger } from "./logger/default";
+import { installAiSdkWarningLogger } from "./telemetry/ai-sdk";
+import { DEFAULT_CHAT_TIMEOUT_MS, kParsed, } from "./types";
+import { DEFAULT_MAX_BODY_SIZE } from "./utils/body";
+export const parseConfig = (config) => {
+    // If it has been parsed before, just return.
+    if (kParsed in config)
+        return config;
+    const providers = config.providers ?? {};
+    const parsedProviders = {};
+    const models = config.models ?? {};
+    const storage = config.storage ?? new InMemoryStorage();
+    // Set the global logger instance.
+    if (config.logger === undefined) {
+        setLoggerInstance(createDefaultLogger({}));
+    }
+    else if (config.logger !== null) {
+        setLoggerInstance(isLogger(config.logger) ? config.logger : createDefaultLogger(config.logger));
+        logger.info(isLogger(config.logger)
+            ? `[logger] custom logger configured`
+            : `[logger] logger configured: level=${config.logger.level}`);
+    }
+    // Strip providers that are not configured.
+    for (const id in providers) {
+        const provider = providers[id];
+        if (provider === undefined) {
+            logger.warn(`[config] ${id} provider removed (undefined)`);
+            continue;
+        }
+        parsedProviders[id] = provider;
+    }
+    if (Object.keys(parsedProviders).length === 0) {
+        throw new Error("No providers configured (config.providers is empty)");
+    }
+    // Strip providers that are not configured from models.
+    const parsedModels = {};
+    const warnings = new Set();
+    for (const id in models) {
+        const model = models[id];
+        const kept = [];
+        for (const p of model.providers) {
+            if (p in parsedProviders)
+                kept.push(p);
+            else
+                warnings.add(p);
+        }
+        if (kept.length > 0)
+            parsedModels[id] = { ...model, providers: kept };
+    }
+    for (const warning of warnings) {
+        logger.warn(`[config] ${warning} provider removed (not configured)`);
+    }
+    if (Object.keys(parsedModels).length === 0) {
+        throw new Error("No models configured (config.models is empty)");
+    }
+    // Default for the telemetry settings.
+    const telemetryEnabled = config.telemetry?.enabled ?? false;
+    const telemetrySignals = telemetryEnabled
+        ? {
+            http: config.telemetry?.signals?.http ?? "recommended",
+            gen_ai: config.telemetry?.signals?.gen_ai ?? "full",
+            hebo: config.telemetry?.signals?.hebo ?? "off",
+        }
+        : {
+            http: "off",
+            gen_ai: "off",
+            hebo: "off",
+        };
+    installAiSdkWarningLogger(telemetrySignals.gen_ai);
+    // Default timeouts
+    let normal;
+    let flex;
+    const t = config.timeouts;
+    if (t === null) {
+        normal = flex = undefined;
+    }
+    else if (typeof t === "number") {
+        normal = t;
+        flex = t * 3;
+    }
+    else {
+        if (t?.normal === null)
+            normal = undefined;
+        else if (t?.normal === undefined)
+            normal = DEFAULT_CHAT_TIMEOUT_MS;
+        else
+            normal = t.normal;
+        if (t?.flex === null)
+            flex = undefined;
+        else if (t?.flex === undefined)
+            flex = normal === undefined ? undefined : normal * 3;
+        else
+            flex = t.flex;
+    }
+    const parsedTimeouts = { normal, flex };
+    // Body size limit
+    const rawMax = config.maxBodySize;
+    let maxBodySize;
+    if (typeof rawMax === "number" && Number.isFinite(rawMax) && rawMax >= 0) {
+        maxBodySize = rawMax;
+    }
+    else {
+        maxBodySize = DEFAULT_MAX_BODY_SIZE;
+        if (rawMax !== undefined) {
+            logger.warn(`[config] invalid maxBodySize (${rawMax}), using default ${DEFAULT_MAX_BODY_SIZE}`);
+        }
+    }
+    // Return parsed config.
+    return {
+        ...config,
+        timeouts: parsedTimeouts,
+        maxBodySize,
+        telemetry: {
+            ...config.telemetry,
+            enabled: telemetryEnabled,
+            signals: telemetrySignals,
+        },
+        providers: parsedProviders,
+        models: parsedModels,
+        storage,
+        [kParsed]: true,
+    };
+};

package/dist/endpoints/chat-completions/converters.d.ts

@@ -0,0 +1,26 @@
+import type { SharedV3ProviderMetadata } from "@ai-sdk/provider";
+import type { GenerateTextResult, StreamTextResult, FinishReason, ToolSet, ModelMessage, UserContent, LanguageModelUsage, TextStreamPart, ReasoningOutput, AssistantModelMessage, ToolModelMessage, UserModelMessage } from "ai";
+import { Output } from "ai";
+import type { SseErrorFrame, SseFrame } from "../../utils/stream";
+import { type TextCallOptions, type ToolChoiceOptions } from "../shared/converters";
+import type { ChatCompletionsToolCall, ChatCompletionsTool, ChatCompletionsToolChoice, ChatCompletionsStream, ChatCompletionsContentPart, ChatCompletionsMessage, ChatCompletionsUserMessage, ChatCompletionsAssistantMessage, ChatCompletionsToolMessage, ChatCompletionsFinishReason, ChatCompletionsUsage, ChatCompletionsInputs, ChatCompletions, ChatCompletionsChunk, ChatCompletionsReasoningDetail } from "./schema";
+export declare function convertToTextCallOptions(params: ChatCompletionsInputs): TextCallOptions;
+export declare function convertToModelMessages(messages: ChatCompletionsMessage[]): ModelMessage[];
+export declare function fromChatCompletionsUserMessage(message: ChatCompletionsUserMessage): UserModelMessage;
+export declare function fromChatCompletionsAssistantMessage(message: ChatCompletionsAssistantMessage): AssistantModelMessage;
+export declare function fromChatCompletionsToolResultMessage(message: ChatCompletionsAssistantMessage, toolById: Map<string, ChatCompletionsToolMessage>): ToolModelMessage | undefined;
+export declare function fromChatCompletionsContent(content: ChatCompletionsContentPart[]): UserContent;
+export declare const convertToToolSet: (tools: ChatCompletionsTool[] | undefined) => ToolSet | undefined;
+export declare const convertToToolChoiceOptions: (toolChoice: ChatCompletionsToolChoice | undefined) => ToolChoiceOptions;
+export declare function toChatCompletions(result: GenerateTextResult<ToolSet, Output.Output>, model: string): ChatCompletions;
+export declare function toChatCompletionsResponse(result: GenerateTextResult<ToolSet, Output.Output>, model: string, responseInit?: ResponseInit): Response;
+export declare function toChatCompletionsStream(result: StreamTextResult<ToolSet, Output.Output>, model: string): ChatCompletionsStream;
+export declare function toChatCompletionsStreamResponse(result: StreamTextResult<ToolSet, Output.Output>, model: string, responseInit?: ResponseInit): Response;
+export declare class ChatCompletionsTransformStream extends TransformStream<TextStreamPart<ToolSet>, SseFrame<ChatCompletionsChunk> | SseErrorFrame> {
+    constructor(model: string);
+}
+export declare const toChatCompletionsAssistantMessage: (result: GenerateTextResult<ToolSet, Output.Output>) => ChatCompletionsAssistantMessage;
+export declare function toReasoningDetail(reasoning: ReasoningOutput, id: string, index: number): ChatCompletionsReasoningDetail;
+export declare function toChatCompletionsUsage(usage: LanguageModelUsage): ChatCompletionsUsage;
+export declare function toChatCompletionsToolCall(id: string, name: string, args: unknown, providerMetadata?: SharedV3ProviderMetadata): ChatCompletionsToolCall;
+export declare const toChatCompletionsFinishReason: (finishReason: FinishReason) => ChatCompletionsFinishReason;

package/dist/endpoints/chat-completions/converters.js

@@ -0,0 +1,525 @@
+import { Output, jsonSchema, tool } from "ai";
+import { GatewayError } from "../../errors/gateway";
+import { toResponse } from "../../utils/response";
+import { parseJsonOrText, parseReasoningOptions, parsePromptCachingOptions, resolveResponseServiceTier, normalizeToolName, stripEmptyKeys, parseBase64, parseImageInput, extractReasoningMetadata, } from "../shared/converters";
+// --- Request Flow ---
+export function convertToTextCallOptions(params) {
+    const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, response_format, reasoning_effort, reasoning, prompt_cache_key, prompt_cache_retention, extra_body, cache_control, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
+    Object.assign(rest, parseReasoningOptions(reasoning_effort, reasoning));
+    Object.assign(rest, parsePromptCachingOptions(prompt_cache_key, prompt_cache_retention, cache_control));
+    if (extra_body) {
+        for (const v of Object.values(extra_body)) {
+            Object.assign(rest, v);
+        }
+    }
+    const { toolChoice, activeTools } = convertToToolChoiceOptions(tool_choice);
+    return {
+        messages: convertToModelMessages(messages),
+        tools: convertToToolSet(tools),
+        toolChoice,
+        activeTools,
+        output: convertToOutput(response_format),
+        temperature,
+        maxOutputTokens: max_completion_tokens ?? max_tokens,
+        frequencyPenalty: frequency_penalty,
+        presencePenalty: presence_penalty,
+        seed,
+        stopSequences: stop ? (Array.isArray(stop) ? stop : [stop]) : undefined,
+        topP: top_p,
+        providerOptions: {
+            unknown: rest,
+        },
+    };
+}
+function convertToOutput(responseFormat) {
+    if (!responseFormat || responseFormat.type === "text") {
+        return undefined;
+    }
+    const { name, description, schema } = responseFormat.json_schema;
+    return Output.object({
+        name,
+        description,
+        schema: jsonSchema(schema),
+    });
+}
+export function convertToModelMessages(messages) {
+    const modelMessages = [];
+    const toolById = indexToolMessages(messages);
+    for (const message of messages) {
+        if (message.role === "tool")
+            continue;
+        if (message.role === "system") {
+            if (message.cache_control) {
+                message.providerOptions = {
+                    unknown: { cache_control: message.cache_control },
+                };
+            }
+            modelMessages.push(message);
+            continue;
+        }
+        if (message.role === "user") {
+            modelMessages.push(fromChatCompletionsUserMessage(message));
+            continue;
+        }
+        modelMessages.push(fromChatCompletionsAssistantMessage(message));
+        const toolResult = fromChatCompletionsToolResultMessage(message, toolById);
+        if (toolResult)
+            modelMessages.push(toolResult);
+    }
+    return modelMessages;
+}
+function indexToolMessages(messages) {
+    const map = new Map();
+    for (const m of messages) {
+        if (m.role === "tool")
+            map.set(m.tool_call_id, m);
+    }
+    return map;
+}
+export function fromChatCompletionsUserMessage(message) {
+    const out = {
+        role: "user",
+        content: Array.isArray(message.content)
+            ? fromChatCompletionsContent(message.content)
+            : message.content,
+    };
+    if (message.cache_control) {
+        out.providerOptions = {
+            unknown: { cache_control: message.cache_control },
+        };
+    }
+    return out;
+}
+export function fromChatCompletionsAssistantMessage(message) {
+    const { tool_calls, role, content, extra_content, reasoning_details, cache_control } = message;
+    const parts = [];
+    if (reasoning_details?.length) {
+        for (const detail of reasoning_details) {
+            if (detail.text && detail.type === "reasoning.text") {
+                parts.push({
+                    type: "reasoning",
+                    text: detail.text,
+                    providerOptions: detail.signature
+                        ? {
+                            unknown: {
+                                signature: detail.signature,
+                            },
+                        }
+                        : undefined,
+                });
+            }
+            else if (detail.type === "reasoning.encrypted" && detail.data) {
+                parts.push({
+                    type: "reasoning",
+                    text: "",
+                    providerOptions: {
+                        unknown: {
+                            redactedData: detail.data,
+                        },
+                    },
+                });
+            }
+        }
+    }
+    if (content !== undefined && content !== null) {
+        const inputContent = typeof content === "string"
+            ? [{ type: "text", text: content }]
+            : content;
+        for (const part of inputContent) {
+            if (part.type === "text") {
+                const textPart = {
+                    type: "text",
+                    text: part.text,
+                };
+                if (part.cache_control) {
+                    textPart.providerOptions = {
+                        unknown: { cache_control: part.cache_control },
+                    };
+                }
+                parts.push(textPart);
+            }
+        }
+    }
+    if (tool_calls?.length) {
+        for (const tc of tool_calls) {
+            // oxlint-disable-next-line no-shadow
+            const { id, function: fn, extra_content } = tc;
+            const out = {
+                type: "tool-call",
+                toolCallId: id,
+                toolName: fn.name,
+                input: parseJsonOrText(fn.arguments).value,
+            };
+            if (extra_content) {
+                out.providerOptions = extra_content;
+            }
+            parts.push(out);
+        }
+    }
+    const out = {
+        role,
+        content: parts.length > 0 ? parts : (content ?? ""),
+    };
+    if (extra_content) {
+        out.providerOptions = extra_content;
+    }
+    if (cache_control) {
+        (out.providerOptions ??= {})["unknown"] = { cache_control };
+    }
+    return out;
+}
+export function fromChatCompletionsToolResultMessage(message, toolById) {
+    const toolCalls = message.tool_calls ?? [];
+    if (toolCalls.length === 0)
+        return undefined;
+    const toolResultParts = [];
+    for (const tc of toolCalls) {
+        const toolMsg = toolById.get(tc.id);
+        if (!toolMsg)
+            continue;
+        toolResultParts.push({
+            type: "tool-result",
+            toolCallId: tc.id,
+            toolName: tc.function.name,
+            output: parseToolResult(toolMsg.content),
+        });
+    }
+    return toolResultParts.length > 0 ? { role: "tool", content: toolResultParts } : undefined;
+}
+export function fromChatCompletionsContent(content) {
+    return content.map((part) => {
+        switch (part.type) {
+            case "image_url":
+                return fromImageUrlPart(part.image_url.url, part.cache_control);
+            case "file":
+                return fromFilePart(part.file.data, part.file.media_type, part.file.filename, part.cache_control);
+            case "input_audio":
+                return fromFilePart(part.input_audio.data, `audio/${part.input_audio.format}`, undefined, part.cache_control);
+            case "text": {
+                const out = {
+                    type: "text",
+                    text: part.text,
+                };
+                if (part.cache_control) {
+                    out.providerOptions = {
+                        unknown: { cache_control: part.cache_control },
+                    };
+                }
+                return out;
+            }
+            default:
+                throw new GatewayError(`Unsupported content part type: ${part.type}`, 400);
+        }
+    });
+}
+function fromImageUrlPart(url, cacheControl) {
+    const { image, mediaType } = parseImageInput(url);
+    if (image instanceof URL) {
+        const out = {
+            type: "image",
+            image,
+        };
+        if (cacheControl) {
+            out.providerOptions = {
+                unknown: { cache_control: cacheControl },
+            };
+        }
+        return out;
+    }
+    return fromFilePart(image, mediaType ?? "image/jpeg", undefined, cacheControl);
+}
+function fromFilePart(base64Data, mediaType, filename, cacheControl) {
+    const data = parseBase64(base64Data);
+    if (mediaType.startsWith("image/")) {
+        const out = {
+            type: "image",
+            image: data,
+            mediaType,
+        };
+        if (cacheControl) {
+            out.providerOptions = {
+                unknown: { cache_control: cacheControl },
+            };
+        }
+        return out;
+    }
+    const out = {
+        type: "file",
+        data: data,
+        filename,
+        mediaType,
+    };
+    if (cacheControl) {
+        out.providerOptions = {
+            unknown: { cache_control: cacheControl },
+        };
+    }
+    return out;
+}
+export const convertToToolSet = (tools) => {
+    if (!tools) {
+        return undefined;
+    }
+    const toolSet = {};
+    for (const t of tools) {
+        toolSet[t.function.name] = tool({
+            description: t.function.description,
+            inputSchema: jsonSchema(t.function.parameters),
+            strict: t.function.strict,
+        });
+    }
+    return toolSet;
+};
+export const convertToToolChoiceOptions = (toolChoice) => {
+    if (!toolChoice) {
+        return {};
+    }
+    if (toolChoice === "none" || toolChoice === "auto" || toolChoice === "required") {
+        return { toolChoice };
+    }
+    // FUTURE: this is right now google specific, which is not supported by AI SDK, until then,
+    // we temporarily map it to auto for now
+    // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/migrate/openai/overview
+    if (toolChoice === "validated") {
+        return { toolChoice: "auto" };
+    }
+    if (toolChoice.type === "allowed_tools") {
+        return {
+            toolChoice: toolChoice.allowed_tools.mode,
+            activeTools: toolChoice.allowed_tools.tools.map((toolRef) => toolRef.function.name),
+        };
+    }
+    return {
+        toolChoice: {
+            type: "tool",
+            toolName: toolChoice.function.name,
+        },
+    };
+};
+function parseToolResult(content) {
+    if (Array.isArray(content)) {
+        return {
+            type: "content",
+            value: content.map((part) => ({
+                type: "text",
+                text: part.text,
+            })),
+        };
+    }
+    return parseJsonOrText(content);
+}
+// --- Response Flow ---
+export function toChatCompletions(result, model) {
+    return {
+        id: "chatcmpl-" + crypto.randomUUID(),
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [
+            {
+                index: 0,
+                message: toChatCompletionsAssistantMessage(result),
+                finish_reason: toChatCompletionsFinishReason(result.finishReason),
+            },
+        ],
+        usage: result.totalUsage ? toChatCompletionsUsage(result.totalUsage) : null,
+        provider_metadata: result.providerMetadata,
+        service_tier: resolveResponseServiceTier(result.providerMetadata),
+    };
+}
+export function toChatCompletionsResponse(result, model, responseInit) {
+    return toResponse(toChatCompletions(result, model), responseInit);
+}
+export function toChatCompletionsStream(result, model) {
+    return result.fullStream.pipeThrough(new ChatCompletionsTransformStream(model));
+}
+export function toChatCompletionsStreamResponse(result, model, responseInit) {
+    return toResponse(toChatCompletionsStream(result, model), responseInit);
+}
+export class ChatCompletionsTransformStream extends TransformStream {
+    constructor(model) {
+        const streamId = `chatcmpl-${crypto.randomUUID()}`;
+        const creationTime = Math.floor(Date.now() / 1000);
+        let toolCallIndexCounter = 0;
+        const reasoningIdToIndex = new Map();
+        let finishProviderMetadata;
+        const createChunk = (delta, provider_metadata, finish_reason, usage) => {
+            if (provider_metadata) {
+                delta.extra_content = provider_metadata;
+            }
+            return {
+                data: {
+                    id: streamId,
+                    object: "chat.completion.chunk",
+                    created: creationTime,
+                    model,
+                    choices: [
+                        {
+                            index: 0,
+                            delta,
+                            finish_reason: finish_reason ?? null,
+                        },
+                    ],
+                    usage: usage ?? null,
+                    service_tier: resolveResponseServiceTier(provider_metadata),
+                },
+            };
+        };
+        super({
+            transform(part, controller) {
+                // Omit lifecycle (start/end) and intermediate events; /chat/completions
+                // is a stateless stream of deltas. Tool calls are emitted once fully-formed.
+                // oxlint-disable-next-line switch-exhaustiveness-check
+                switch (part.type) {
+                    case "text-delta": {
+                        controller.enqueue(createChunk({ role: "assistant", content: part.text }, part.providerMetadata));
+                        break;
+                    }
+                    case "reasoning-delta": {
+                        let index = reasoningIdToIndex.get(part.id);
+                        if (index === undefined) {
+                            index = reasoningIdToIndex.size;
+                            reasoningIdToIndex.set(part.id, index);
+                        }
+                        controller.enqueue(createChunk({
+                            reasoning: part.text,
+                            reasoning_details: [
+                                toReasoningDetail({
+                                    type: "reasoning",
+                                    text: part.text,
+                                    providerMetadata: part.providerMetadata,
+                                }, part.id, index),
+                            ],
+                        }, part.providerMetadata));
+                        break;
+                    }
+                    case "tool-call": {
+                        const toolCall = toChatCompletionsToolCall(part.toolCallId, part.toolName, part.input, part.providerMetadata);
+                        toolCall.index = toolCallIndexCounter++;
+                        controller.enqueue(createChunk({
+                            tool_calls: [toolCall],
+                        }));
+                        break;
+                    }
+                    case "finish-step": {
+                        finishProviderMetadata = part.providerMetadata;
+                        break;
+                    }
+                    case "finish": {
+                        controller.enqueue(createChunk({}, finishProviderMetadata, toChatCompletionsFinishReason(part.finishReason), toChatCompletionsUsage(part.totalUsage)));
+                        break;
+                    }
+                    case "error": {
+                        controller.enqueue({
+                            data: part.error instanceof Error ? part.error : new Error(String(part.error)),
+                        });
+                    }
+                }
+            },
+        });
+    }
+}
+export const toChatCompletionsAssistantMessage = (result) => {
+    const message = {
+        role: "assistant",
+        content: null,
+    };
+    if (result.toolCalls && result.toolCalls.length > 0) {
+        message.tool_calls = result.toolCalls.map((toolCall) => toChatCompletionsToolCall(toolCall.toolCallId, toolCall.toolName, toolCall.input, toolCall.providerMetadata));
+    }
+    const reasoningDetails = [];
+    for (const part of result.content) {
+        if (part.type === "text") {
+            if (message.content === null) {
+                message.content = part.text;
+            }
+            else {
+                message.content += part.text;
+            }
+            if (part.providerMetadata) {
+                message.extra_content = part.providerMetadata;
+            }
+        }
+        else if (part.type === "reasoning") {
+            reasoningDetails.push(toReasoningDetail(part, `reasoning-${crypto.randomUUID()}`, reasoningDetails.length));
+        }
+    }
+    if (result.reasoningText) {
+        message.reasoning = result.reasoningText;
+    }
+    if (reasoningDetails.length > 0) {
+        message.reasoning_details = reasoningDetails;
+    }
+    if (!message.content && !message.tool_calls) {
+        // some models return just reasoning without tool calls or content
+        message.content = "";
+    }
+    return message;
+};
+export function toReasoningDetail(reasoning, id, index) {
+    const { redactedData, signature } = extractReasoningMetadata(reasoning.providerMetadata);
+    if (redactedData) {
+        return {
+            id,
+            index,
+            type: "reasoning.encrypted",
+            data: redactedData,
+            format: "unknown",
+        };
+    }
+    return {
+        id,
+        index,
+        type: "reasoning.text",
+        text: reasoning.text,
+        signature,
+        format: "unknown",
+    };
+}
+export function toChatCompletionsUsage(usage) {
+    const out = {};
+    const prompt = usage.inputTokens;
+    if (prompt !== undefined)
+        out.prompt_tokens = prompt;
+    const completion = usage.outputTokens;
+    if (completion !== undefined)
+        out.completion_tokens = completion;
+    if (prompt !== undefined || completion !== undefined || usage.totalTokens !== undefined) {
+        out.total_tokens = usage.totalTokens ?? (prompt ?? 0) + (completion ?? 0);
+    }
+    const reasoning = usage.outputTokenDetails?.reasoningTokens;
+    if (reasoning !== undefined)
+        out.completion_tokens_details = { reasoning_tokens: reasoning };
+    const cached = usage.inputTokenDetails?.cacheReadTokens;
+    const cacheWrite = usage.inputTokenDetails?.cacheWriteTokens;
+    if (cached !== undefined || cacheWrite !== undefined) {
+        out.prompt_tokens_details = {};
+        if (cached !== undefined) {
+            out.prompt_tokens_details.cached_tokens = cached;
+        }
+        if (cacheWrite !== undefined) {
+            out.prompt_tokens_details.cache_write_tokens = cacheWrite;
+        }
+    }
+    return out;
+}
+export function toChatCompletionsToolCall(id, name, args, providerMetadata) {
+    const out = {
+        id,
+        type: "function",
+        function: {
+            name: normalizeToolName(name),
+            arguments: typeof args === "string" ? args : JSON.stringify(stripEmptyKeys(args)),
+        },
+    };
+    if (providerMetadata) {
+        out.extra_content = providerMetadata;
+    }
+    return out;
+}
+export const toChatCompletionsFinishReason = (finishReason) => {
+    if (finishReason === "error" || finishReason === "other") {
+        return "stop";
+    }
+    return finishReason.replaceAll("-", "_");
+};

package/dist/endpoints/chat-completions/handler.d.ts

@@ -0,0 +1,2 @@
+import type { GatewayConfig, Endpoint } from "../../types";
+export declare const chatCompletions: (config: GatewayConfig) => Endpoint;