@hebo-ai/gateway 0.5.2 → 0.6.0-rc0

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

@@ -1,43 +0,0 @@
-import type { SharedV3ProviderOptions, SharedV3ProviderMetadata } from "@ai-sdk/provider";
-import type { GenerateTextResult, StreamTextResult, FinishReason, ToolChoice, ToolSet, ModelMessage, UserContent, LanguageModelUsage, TextStreamPart, ReasoningOutput, AssistantModelMessage, ToolModelMessage, UserModelMessage } from "ai";
-import { Output } from "ai";
-import type { ChatCompletionsToolCall, ChatCompletionsTool, ChatCompletionsToolChoice, ChatCompletionsContentPart, ChatCompletionsMessage, ChatCompletionsUserMessage, ChatCompletionsAssistantMessage, ChatCompletionsToolMessage, ChatCompletionsFinishReason, ChatCompletionsUsage, ChatCompletionsInputs, ChatCompletions, ChatCompletionsChunk, ChatCompletionsReasoningDetail } from "./schema";
-import { OpenAIError } from "../../errors/openai";
-export type TextCallOptions = {
-    messages: ModelMessage[];
-    tools?: ToolSet;
-    toolChoice?: ToolChoice<ToolSet>;
-    activeTools?: Array<keyof ToolSet>;
-    output?: Output.Output;
-    temperature?: number;
-    maxOutputTokens?: number;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
-    seed?: number;
-    stopSequences?: string[];
-    topP?: number;
-    providerOptions: SharedV3ProviderOptions;
-};
-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) => {
-    toolChoice?: ToolChoice<ToolSet>;
-    activeTools?: Array<keyof ToolSet>;
-};
-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<E extends boolean = false>(result: StreamTextResult<ToolSet, Output.Output>, model: string, wrapErrors?: E): ReadableStream<ChatCompletionsChunk | (E extends true ? OpenAIError : Error)>;
-export declare function toChatCompletionsStreamResponse(result: StreamTextResult<ToolSet, Output.Output>, model: string, responseInit?: ResponseInit): Response;
-export declare class ChatCompletionsStream<E extends boolean = false> extends TransformStream<TextStreamPart<ToolSet>, ChatCompletionsChunk | (E extends true ? OpenAIError : Error)> {
-    constructor(model: string, wrapErrors?: E);
-}
-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

@@ -1,551 +0,0 @@
-import { Output, jsonSchema, tool } from "ai";
-import { z } from "zod";
-import { GatewayError } from "../../errors/gateway";
-import { OpenAIError, toOpenAIError } from "../../errors/openai";
-import { toResponse } from "../../utils/response";
-// --- Request Flow ---
-export function convertToTextCallOptions(params) {
-    const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, response_format, reasoning_effort, reasoning, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
-    Object.assign(rest, parseReasoningOptions(reasoning_effort, reasoning));
-    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;
-    }
-    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") {
-            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) {
-    return {
-        role: "user",
-        content: Array.isArray(message.content)
-            ? fromChatCompletionsContent(message.content)
-            : message.content,
-    };
-}
-export function fromChatCompletionsAssistantMessage(message) {
-    const { tool_calls, role, content, extra_content, reasoning_details } = 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") {
-                parts.push({
-                    type: "text",
-                    text: part.text,
-                });
-            }
-        }
-    }
-    if (tool_calls?.length) {
-        for (const tc of tool_calls) {
-            // eslint-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;
-    }
-    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);
-            case "file":
-                return fromFilePart(part.file.data, part.file.media_type, part.file.filename);
-            case "input_audio":
-                return fromFilePart(part.input_audio.data, `audio/${part.input_audio.format}`);
-            default:
-                return part;
-        }
-    });
-}
-function fromImageUrlPart(url) {
-    if (url.startsWith("data:")) {
-        const { mimeType, base64Data } = parseDataUrl(url);
-        return fromFilePart(base64Data, mimeType);
-    }
-    return {
-        type: "image",
-        image: new URL(url),
-    };
-}
-function fromFilePart(base64Data, mediaType, filename) {
-    if (mediaType.startsWith("image/")) {
-        return {
-            type: "image",
-            image: z.util.base64ToUint8Array(base64Data),
-            mediaType,
-        };
-    }
-    return {
-        type: "file",
-        data: z.util.base64ToUint8Array(base64Data),
-        filename,
-        mediaType,
-    };
-}
-export const convertToToolSet = (tools) => {
-    if (!tools) {
-        return;
-    }
-    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);
-}
-function parseJsonOrText(content) {
-    try {
-        return { type: "json", value: JSON.parse(content) };
-    }
-    catch {
-        return { type: "text", value: content };
-    }
-}
-function parseDataUrl(url) {
-    const commaIndex = url.indexOf(",");
-    if (commaIndex <= "data:".length || commaIndex === url.length - 1) {
-        throw new GatewayError("Invalid data URL: missing metadata or data", 400);
-    }
-    const metadata = url.slice("data:".length, commaIndex);
-    const base64Data = url.slice(commaIndex + 1);
-    const semicolonIndex = metadata.indexOf(";");
-    const mimeType = (semicolonIndex === -1 ? metadata : metadata.slice(0, semicolonIndex)).trim();
-    if (!mimeType) {
-        throw new GatewayError("Invalid data URL: missing MIME type", 400);
-    }
-    return { mimeType, base64Data };
-}
-function parseReasoningOptions(reasoning_effort, reasoning) {
-    const effort = reasoning?.effort ?? reasoning_effort;
-    const max_tokens = reasoning?.max_tokens;
-    if (reasoning?.enabled === false || effort === "none") {
-        return { reasoning: { enabled: false }, reasoning_effort: "none" };
-    }
-    if (!reasoning && effort === undefined)
-        return {};
-    const out = { reasoning: {} };
-    if (effort) {
-        out.reasoning.enabled = true;
-        out.reasoning.effort = effort;
-        out.reasoning_effort = effort;
-    }
-    if (max_tokens) {
-        out.reasoning.enabled = true;
-        out.reasoning.max_tokens = max_tokens;
-    }
-    if (out.reasoning.enabled) {
-        out.reasoning.exclude = reasoning?.exclude;
-    }
-    return out;
-}
-// --- 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,
-    };
-}
-export function toChatCompletionsResponse(result, model, responseInit) {
-    return toResponse(toChatCompletions(result, model), responseInit);
-}
-export function toChatCompletionsStream(result, model, wrapErrors) {
-    return result.fullStream.pipeThrough(new ChatCompletionsStream(model, wrapErrors));
-}
-export function toChatCompletionsStreamResponse(result, model, responseInit) {
-    return toResponse(toChatCompletionsStream(result, model, true), responseInit);
-}
-export class ChatCompletionsStream extends TransformStream {
-    constructor(model, wrapErrors) {
-        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 {
-                id: streamId,
-                object: "chat.completion.chunk",
-                created: creationTime,
-                model,
-                choices: [
-                    {
-                        index: 0,
-                        delta,
-                        finish_reason: finish_reason ?? null,
-                    },
-                ],
-                usage: usage ?? null,
-            };
-        };
-        super({
-            transform(part, controller) {
-                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_content: 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": {
-                        let err;
-                        if (wrapErrors) {
-                            err = toOpenAIError(part.error);
-                        }
-                        else if (part.error instanceof Error) {
-                            err = part.error;
-                        }
-                        else {
-                            err = new Error(String(part.error));
-                        }
-                        controller.enqueue(err);
-                    }
-                }
-            },
-        });
-    }
-}
-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_content = result.reasoningText;
-        if (reasoningDetails.length === 0) {
-            reasoningDetails.push(toReasoningDetail({ type: "reasoning", text: result.reasoningText }, `reasoning-${crypto.randomUUID()}`, 0));
-        }
-    }
-    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 providerMetadata = reasoning.providerMetadata ?? {};
-    let redactedData;
-    let signature;
-    for (const metadata of Object.values(providerMetadata)) {
-        if (metadata && typeof metadata === "object") {
-            if ("redactedData" in metadata && typeof metadata["redactedData"] === "string") {
-                redactedData = metadata["redactedData"];
-            }
-            if ("signature" in metadata && typeof metadata["signature"] === "string") {
-                signature = metadata["signature"];
-            }
-        }
-    }
-    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;
-    if (cached !== undefined)
-        out.prompt_tokens_details = { cached_tokens: cached };
-    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;
-}
-function normalizeToolName(name) {
-    // some models hallucinate invalid characters
-    // normalize to valid characters [^A-Za-z0-9_-.] (non regex for perf)
-    // https://modelcontextprotocol.io/specification/draft/server/tools#tool-names
-    let out = "";
-    for (let i = 0; i < name.length; i++) {
-        if (out.length === 128)
-            break;
-        // eslint-disable-next-line unicorn/prefer-code-point
-        const c = name.charCodeAt(i);
-        if ((c >= 48 && c <= 57) ||
-            (c >= 65 && c <= 90) ||
-            (c >= 97 && c <= 122) ||
-            c === 95 ||
-            c === 45 ||
-            c === 46) {
-            out += name[i];
-        }
-        else {
-            out += "_";
-        }
-    }
-    return out;
-}
-function stripEmptyKeys(obj) {
-    if (!obj || typeof obj !== "object" || Array.isArray(obj))
-        return obj;
-    // some models hallucinate empty parameters
-    delete obj[""];
-    return obj;
-}
-export const toChatCompletionsFinishReason = (finishReason) => {
-    if (finishReason === "error" || finishReason === "other") {
-        return "stop";
-    }
-    return finishReason.replaceAll("-", "_");
-};

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

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