@hebo-ai/gateway 0.1.2 → 0.2.0

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

@@ -1,19 +1,29 @@
-import { jsonSchema, tool } from "ai";
+import { jsonSchema, JsonToSseTransformStream, tool } from "ai";
 import { OpenAIError } from "../../utils/errors";
+import { mergeResponseInit } from "../../utils/response";
 // --- Request Flow ---
-export function transformCompletionsInputs(params) {
-    const { messages, tools, tool_choice, temperature = 1, ...rest } = params;
+export function convertToTextCallOptions(params) {
+    const { messages, tools, tool_choice, temperature, max_tokens, max_completion_tokens, reasoning_effort, reasoning, frequency_penalty, presence_penalty, seed, stop, top_p, ...rest } = params;
     return {
-        messages: fromCompletionsMessages(messages),
-        tools: fromCompletionsTools(tools),
-        toolChoice: fromCompletionsToolChoice(tool_choice),
+        messages: convertToModelMessages(messages),
+        tools: convertToToolSet(tools),
+        toolChoice: convertToToolChoice(tool_choice),
         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: {
-            openAICompat: rest,
+            unknown: {
+                ...rest,
+                ...parseReasoningOptions(reasoning_effort, reasoning),
+            },
         },
     };
 }
-export function fromCompletionsMessages(messages) {
+export function convertToModelMessages(messages) {
     const modelMessages = [];
     const toolById = indexToolMessages(messages);
     for (const message of messages) {
@@ -24,11 +34,11 @@ export function fromCompletionsMessages(messages) {
             continue;
         }
         if (message.role === "user") {
-            modelMessages.push(fromCompletionsUserMessage(message));
+            modelMessages.push(fromChatCompletionsUserMessage(message));
             continue;
         }
-        modelMessages.push(fromCompletionsAssistantMessage(message));
-        const toolResult = fromCompletionsToolResultMessage(message, toolById);
+        modelMessages.push(fromChatCompletionsAssistantMessage(message));
+        const toolResult = fromChatCompletionsToolResultMessage(message, toolById);
         if (toolResult)
             modelMessages.push(toolResult);
     }
@@ -42,15 +52,15 @@ function indexToolMessages(messages) {
     }
     return map;
 }
-export function fromCompletionsUserMessage(message) {
+export function fromChatCompletionsUserMessage(message) {
     return {
         role: "user",
         content: Array.isArray(message.content)
-            ? fromCompletionsContent(message.content)
+            ? fromChatCompletionsContent(message.content)
             : message.content,
     };
 }
-export function fromCompletionsAssistantMessage(message) {
+export function fromChatCompletionsAssistantMessage(message) {
     const { tool_calls, role, content } = message;
     if (!tool_calls || tool_calls.length === 0) {
         return {
@@ -71,7 +81,7 @@ export function fromCompletionsAssistantMessage(message) {
         }),
     };
 }
-export function fromCompletionsToolResultMessage(message, toolById) {
+export function fromChatCompletionsToolResultMessage(message, toolById) {
     const toolCalls = message.tool_calls ?? [];
     if (toolCalls.length === 0)
         return undefined;
@@ -89,7 +99,7 @@ export function fromCompletionsToolResultMessage(message, toolById) {
     }
     return toolResultParts.length > 0 ? { role: "tool", content: toolResultParts } : undefined;
 }
-export function fromCompletionsContent(content) {
+export function fromChatCompletionsContent(content) {
     return content.map((part) => {
         if (part.type === "image_url") {
             const url = part.image_url.url;
@@ -126,7 +136,7 @@ export function fromCompletionsContent(content) {
             };
         }
         if (part.type === "file") {
-            const { data, media_type } = part.file;
+            let { data, media_type, filename } = part.file;
             return media_type.startsWith("image/")
                 ? {
                     type: "image",
@@ -136,13 +146,14 @@ export function fromCompletionsContent(content) {
                 : {
                     type: "file",
                     data: Buffer.from(data, "base64"),
+                    filename,
                     mediaType: media_type,
                 };
         }
         return part;
     });
 }
-export const fromCompletionsTools = (tools) => {
+export const convertToToolSet = (tools) => {
     if (!tools) {
         return;
     }
@@ -155,7 +166,7 @@ export const fromCompletionsTools = (tools) => {
     }
     return toolSet;
 };
-export const fromCompletionsToolChoice = (toolChoice) => {
+export const convertToToolChoice = (toolChoice) => {
     if (!toolChoice) {
         return undefined;
     }
@@ -175,9 +186,19 @@ function parseToolOutput(content) {
         return { type: "text", value: content };
     }
 }
+function parseReasoningOptions(reasoning_effort, reasoning) {
+    const reasoningOptions = {};
+    if (reasoning)
+        reasoningOptions["reasoning"] = reasoning;
+    if (reasoning_effort !== undefined) {
+        (reasoningOptions["reasoning"] ??= {})["effort"] = reasoning_effort;
+        reasoningOptions["reasoningEffort"] = reasoning_effort;
+    }
+    return reasoningOptions;
+}
 // --- Response Flow ---
-export function toCompletions(result, model) {
-    const finish_reason = toCompletionsFinishReason(result.finishReason);
+export function toChatCompletions(result, model) {
+    const finish_reason = toChatCompletionsFinishReason(result.finishReason);
     return {
         id: "chatcmpl-" + crypto.randomUUID(),
         object: "chat.completion",
@@ -186,49 +207,56 @@ export function toCompletions(result, model) {
         choices: [
             {
                 index: 0,
-                message: toCompletionsMessage(result),
+                message: toChatCompletionsAssistantMessage(result),
                 finish_reason,
             },
         ],
-        usage: result.usage && toCompletionsUsage(result.usage),
-        providerMetadata: result.providerMetadata,
+        usage: result.totalUsage ? toChatCompletionsUsage(result.totalUsage) : null,
+        provider_metadata: result.providerMetadata,
     };
 }
-export function createCompletionsResponse(result, model) {
-    return new Response(JSON.stringify(toCompletions(result, model)), {
-        headers: { "Content-Type": "application/json" },
-    });
+export function toChatCompletionsResponse(result, model, responseInit) {
+    return new Response(JSON.stringify(toChatCompletions(result, model)), mergeResponseInit({ "Content-Type": "application/json" }, responseInit));
 }
-export function toCompletionsStream(result, model) {
+export function toChatCompletionsStream(result, model) {
     return result.fullStream
-        .pipeThrough(new CompletionsStream(model))
-        .pipeThrough(new SSETransformStream())
+        .pipeThrough(new ChatCompletionsStream(model))
+        .pipeThrough(new JsonToSseTransformStream())
         .pipeThrough(new TextEncoderStream());
 }
-export function createCompletionsStreamResponse(result, model) {
-    return new Response(toCompletionsStream(result, model), {
-        headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-        },
-    });
+export function toChatCompletionsStreamResponse(result, model, responseInit) {
+    return new Response(toChatCompletionsStream(result, model), mergeResponseInit({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    }, responseInit));
 }
-export class CompletionsStream extends TransformStream {
+export class ChatCompletionsStream extends TransformStream {
     constructor(model) {
         const streamId = `chatcmpl-${crypto.randomUUID()}`;
         const creationTime = Math.floor(Date.now() / 1000);
         let toolCallIndexCounter = 0;
-        const createChunk = (delta, finish_reason, usage) => ({
+        let lastProviderMetadata;
+        const createChunk = (delta, finish_reason, usage, provider_metadata) => ({
             id: streamId,
             object: "chat.completion.chunk",
             created: creationTime,
             model,
-            choices: [{ index: 0, delta, finish_reason }],
-            ...(usage ? { usage } : {}),
+            choices: [
+                {
+                    index: 0,
+                    delta,
+                    finish_reason: finish_reason ?? null,
+                },
+            ],
+            ...(usage ? { usage } : { usage: null }),
+            ...(provider_metadata === undefined ? {} : { provider_metadata }),
         });
         super({
             transform(part, controller) {
+                if ("providerMetadata" in part && part.providerMetadata !== undefined) {
+                    lastProviderMetadata = part.providerMetadata;
+                }
                 switch (part.type) {
                     case "text-delta": {
                         controller.enqueue(createChunk({ role: "assistant", content: part.text }));
@@ -242,7 +270,7 @@ export class CompletionsStream extends TransformStream {
                         controller.enqueue(createChunk({
                             tool_calls: [
                                 {
-                                    ...toCompletionsToolCall(part.toolCallId, part.toolName, part.input),
+                                    ...toChatCompletionsToolCall(part.toolCallId, part.toolName, part.input),
                                     index: toolCallIndexCounter++,
                                 },
                             ],
@@ -250,7 +278,7 @@ export class CompletionsStream extends TransformStream {
                         break;
                     }
                     case "finish": {
-                        controller.enqueue(createChunk({}, toCompletionsFinishReason(part.finishReason), toCompletionsUsage(part.totalUsage)));
+                        controller.enqueue(createChunk({}, toChatCompletionsFinishReason(part.finishReason), toChatCompletionsUsage(part.totalUsage), lastProviderMetadata));
                         break;
                     }
                     case "error": {
@@ -265,25 +293,13 @@ export class CompletionsStream extends TransformStream {
         });
     }
 }
-export class SSETransformStream extends TransformStream {
-    constructor() {
-        super({
-            transform(chunk, controller) {
-                controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);
-            },
-            flush(controller) {
-                controller.enqueue("data: [DONE]\n\n");
-            },
-        });
-    }
-}
-export const toCompletionsMessage = (result) => {
+export const toChatCompletionsAssistantMessage = (result) => {
     const message = {
         role: "assistant",
         content: null,
     };
     if (result.toolCalls && result.toolCalls.length > 0) {
-        message.tool_calls = result.toolCalls.map((toolCall) => toCompletionsToolCall(toolCall.toolCallId, toolCall.toolName, toolCall.input));
+        message.tool_calls = result.toolCalls.map((toolCall) => toChatCompletionsToolCall(toolCall.toolCallId, toolCall.toolName, toolCall.input));
     }
     for (const part of result.content) {
         if (part.type === "text") {
@@ -296,22 +312,32 @@ export const toCompletionsMessage = (result) => {
     }
     return message;
 };
-export function toCompletionsUsage(usage) {
-    if (!usage)
-        return undefined;
+export function toChatCompletionsUsage(usage) {
     return {
-        prompt_tokens: usage.inputTokens ?? 0,
-        completion_tokens: usage.outputTokens ?? 0,
-        total_tokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
-        completion_tokens_details: {
-            reasoning_tokens: usage.outputTokenDetails.reasoningTokens ?? 0,
-        },
-        prompt_tokens_details: {
-            cached_tokens: usage.inputTokenDetails.cacheReadTokens ?? 0,
-        },
+        ...(usage.inputTokens !== undefined && {
+            prompt_tokens: usage.inputTokens,
+        }),
+        ...(usage.outputTokens !== undefined && {
+            completion_tokens: usage.outputTokens,
+        }),
+        ...((usage.totalTokens !== undefined ||
+            usage.inputTokens !== undefined ||
+            usage.outputTokens !== undefined) && {
+            total_tokens: usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0),
+        }),
+        ...(usage.outputTokenDetails?.reasoningTokens !== undefined && {
+            completion_tokens_details: {
+                reasoning_tokens: usage.outputTokenDetails.reasoningTokens,
+            },
+        }),
+        ...(usage.inputTokenDetails?.cacheReadTokens !== undefined && {
+            prompt_tokens_details: {
+                cached_tokens: usage.inputTokenDetails.cacheReadTokens,
+            },
+        }),
     };
 }
-export function toCompletionsToolCall(id, name, args) {
+export function toChatCompletionsToolCall(id, name, args) {
     return {
         id,
         type: "function",
@@ -321,7 +347,7 @@ export function toCompletionsToolCall(id, name, args) {
         },
     };
 }
-export const toCompletionsFinishReason = (finishReason) => {
+export const toChatCompletionsFinishReason = (finishReason) => {
     if (finishReason === "error" || finishReason === "other") {
         return "stop";
     }

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

@@ -1,82 +1,88 @@
-import { generateText, streamText } from "ai";
+import { generateText, streamText, wrapLanguageModel } from "ai";
 import * as z from "zod/mini";
-import { parseConfig } from "../../config";
+import { withLifecycle } from "../../lifecycle";
+import { modelMiddlewareMatcher } from "../../middleware/matcher";
 import { resolveProvider } from "../../providers/registry";
 import { createErrorResponse } from "../../utils/errors";
-import { withHooks } from "../../utils/hooks";
-import { transformCompletionsInputs, createCompletionsResponse, createCompletionsStreamResponse, } from "./converters";
-import { CompletionsBodySchema } from "./schema";
+import { convertToTextCallOptions, toChatCompletionsResponse, toChatCompletionsStreamResponse, } from "./converters";
+import { ChatCompletionsBodySchema } from "./schema";
 export const chatCompletions = (config) => {
-    const { providers, models, hooks } = parseConfig(config);
-    const handler = async (req) => {
-        if (req.method !== "POST") {
+    const hooks = config.hooks;
+    const handler = async (ctx) => {
+        if (!ctx.request || ctx.request.method !== "POST") {
             return createErrorResponse("METHOD_NOT_ALLOWED", "Method Not Allowed", 405);
         }
         let body;
         try {
-            body = await req.json();
+            body = await ctx.request.json();
         }
         catch {
             return createErrorResponse("BAD_REQUEST", "Invalid JSON", 400);
         }
-        const parsed = CompletionsBodySchema.safeParse(body);
+        const parsed = ChatCompletionsBodySchema.safeParse(body);
         if (!parsed.success) {
             return createErrorResponse("UNPROCESSABLE_ENTITY", "Validation error", 422, z.prettifyError(parsed.error));
         }
-        const { model: modelId, stream, ...inputs } = parsed.data;
-        let resolvedModelId;
+        ctx.body = parsed.data;
+        let stream, inputs;
+        ({ model: ctx.modelId, stream, ...inputs } = parsed.data);
         try {
-            resolvedModelId = (await hooks?.resolveModelId?.({ modelId })) ?? modelId;
+            ctx.resolvedModelId = (await hooks?.resolveModelId?.(ctx)) ?? ctx.modelId;
         }
         catch (error) {
             return createErrorResponse("BAD_REQUEST", error, 400);
         }
-        let textOptions;
+        ctx.operation = "text";
         try {
-            textOptions = transformCompletionsInputs(inputs);
+            const override = await hooks?.resolveProvider?.(ctx);
+            ctx.provider =
+                override ??
+                    resolveProvider({
+                        providers: ctx.providers,
+                        models: ctx.models,
+                        modelId: ctx.resolvedModelId,
+                        operation: ctx.operation,
+                    });
         }
         catch (error) {
             return createErrorResponse("BAD_REQUEST", error, 400);
         }
-        let provider;
+        const languageModel = ctx.provider.languageModel(ctx.resolvedModelId);
+        let textOptions;
         try {
-            const args = {
-                providers,
-                models,
-                modelId: resolvedModelId,
-                operation: "text",
-            };
-            const override = await hooks?.resolveProvider?.(args);
-            provider = override ?? resolveProvider(args);
+            textOptions = convertToTextCallOptions(inputs);
         }
         catch (error) {
             return createErrorResponse("BAD_REQUEST", error, 400);
         }
-        const languageModel = provider.languageModel(resolvedModelId);
+        const languageModelWithMiddleware = wrapLanguageModel({
+            model: languageModel,
+            middleware: modelMiddlewareMatcher.for(ctx.resolvedModelId, languageModel.provider),
+        });
         if (stream) {
             let result;
             try {
                 result = streamText({
-                    model: languageModel,
+                    model: languageModelWithMiddleware,
                     ...textOptions,
                 });
             }
             catch (error) {
                 return createErrorResponse("INTERNAL_SERVER_ERROR", error, 500);
             }
-            return createCompletionsStreamResponse(result, modelId);
+            return toChatCompletionsStreamResponse(result, ctx.modelId);
         }
         let result;
         try {
             result = await generateText({
-                model: languageModel,
+                model: languageModelWithMiddleware,
                 ...textOptions,
             });
         }
         catch (error) {
             return createErrorResponse("INTERNAL_SERVER_ERROR", error, 500);
         }
-        return createCompletionsResponse(result, modelId);
+        return toChatCompletionsResponse(result, ctx.modelId);
     };
-    return { handler: withHooks(hooks, handler) };
+    return { handler: withLifecycle(handler, config) };
 };