@hebo-ai/gateway 0.8.0-rc0 → 0.8.0-rc2

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,111 @@
+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";
+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 };
+    // Return parsed config.
+    return {
+        ...config,
+        timeouts: parsedTimeouts,
+        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,43 @@
+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, ChatCompletionsStream, ChatCompletionsContentPart, ChatCompletionsMessage, ChatCompletionsUserMessage, ChatCompletionsAssistantMessage, ChatCompletionsToolMessage, ChatCompletionsFinishReason, ChatCompletionsUsage, ChatCompletionsInputs, ChatCompletions, ChatCompletionsChunk, ChatCompletionsReasoningDetail } from "./schema";
+import type { SseErrorFrame, SseFrame } from "../../utils/stream";
+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(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;