@hebo-ai/gateway 0.9.1 → 0.9.2

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

@@ -1,524 +0,0 @@
-import { Output, jsonSchema, tool } from "ai";
-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;
-    }
-    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 Error(`Unhandled content part type: ${part.type}`);
-        }
-    });
-}
-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;
-    }
-    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

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

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

@@ -1,149 +0,0 @@
-import { generateText, Output, streamText, wrapLanguageModel, } from "ai";
-import * as z from "zod/mini";
-import { GatewayError } from "../../errors/gateway";
-import { winterCgHandler } from "../../lifecycle";
-import { logger } from "../../logger";
-import { modelMiddlewareMatcher } from "../../middleware/matcher";
-import { resolveProvider } from "../../providers/registry";
-import { getGenAiGeneralAttributes, recordTimePerOutputToken, recordTokenUsage, } from "../../telemetry/gen-ai";
-import { addSpanEvent, setSpanAttributes } from "../../telemetry/span";
-import { prepareForwardHeaders } from "../../utils/request";
-import { convertToTextCallOptions, toChatCompletions, toChatCompletionsStream } from "./converters";
-import { getChatRequestAttributes, getChatResponseAttributes } from "./otel";
-import { ChatCompletionsBodySchema, } from "./schema";
-export const chatCompletions = (config) => {
-    const hooks = config.hooks;
-    const handler = async (ctx, cfg) => {
-        const start = performance.now();
-        ctx.operation = "chat";
-        setSpanAttributes({ "gen_ai.operation.name": ctx.operation });
-        addSpanEvent("hebo.handler.started");
-        // Guard: enforce HTTP method early.
-        if (!ctx.request || ctx.request.method !== "POST") {
-            throw new GatewayError("Method Not Allowed", 405);
-        }
-        // Parse + validate input.
-        try {
-            // oxlint-disable-next-line no-unsafe-assignment
-            ctx.body = await ctx.request.json();
-        }
-        catch {
-            throw new GatewayError("Invalid JSON", 400);
-        }
-        logger.trace({ requestId: ctx.requestId, body: ctx.body }, "[chat] ChatCompletionsBody");
-        addSpanEvent("hebo.request.deserialized");
-        const parsed = ChatCompletionsBodySchema.safeParse(ctx.body);
-        if (!parsed.success) {
-            // FUTURE: consider adding body shape to metadata
-            throw new GatewayError(z.prettifyError(parsed.error), 400, undefined, parsed.error);
-        }
-        ctx.body = parsed.data;
-        addSpanEvent("hebo.request.parsed");
-        if (hooks?.before) {
-            ctx.body =
-                (await hooks.before(ctx)) ?? ctx.body;
-            addSpanEvent("hebo.hooks.before.completed");
-        }
-        // Resolve model + provider (hooks may override defaults).
-        ctx.modelId = ctx.body.model;
-        ctx.resolvedModelId =
-            (await hooks?.resolveModelId?.(ctx)) ?? ctx.modelId;
-        logger.debug(`[chat] resolved ${ctx.modelId} to ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.model.resolved");
-        const override = await hooks?.resolveProvider?.(ctx);
-        ctx.provider =
-            override ??
-                resolveProvider({
-                    providers: ctx.providers,
-                    models: ctx.models,
-                    modelId: ctx.resolvedModelId,
-                    operation: ctx.operation,
-                });
-        const languageModel = ctx.provider.languageModel(ctx.resolvedModelId);
-        ctx.resolvedProviderId = languageModel.provider;
-        logger.debug(`[chat] using ${languageModel.provider} for ${ctx.resolvedModelId}`);
-        addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = cfg.telemetry?.signals?.gen_ai;
-        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
-        setSpanAttributes(genAiGeneralAttrs);
-        // Convert inputs to AI SDK call options.
-        const { model: _model, stream, ...inputs } = ctx.body;
-        const textOptions = convertToTextCallOptions(inputs);
-        logger.trace({
-            requestId: ctx.requestId,
-            options: textOptions,
-        }, "[chat] AI SDK options");
-        addSpanEvent("hebo.options.prepared");
-        setSpanAttributes(getChatRequestAttributes(ctx.body, genAiSignalLevel));
-        // Build middleware chain (model -> forward params -> provider).
-        const languageModelWithMiddleware = wrapLanguageModel({
-            model: languageModel,
-            middleware: modelMiddlewareMatcher.for(ctx.resolvedModelId, languageModel.provider),
-        });
-        // Execute request (streaming vs. non-streaming).
-        if (stream) {
-            addSpanEvent("hebo.ai-sdk.started");
-            const result = streamText({
-                model: languageModelWithMiddleware,
-                headers: prepareForwardHeaders(ctx.request),
-                abortSignal: ctx.request.signal,
-                timeout: {
-                    totalMs: ctx.body.service_tier === "flex" ? cfg.timeouts.flex : cfg.timeouts.normal,
-                },
-                onAbort: () => {
-                    throw new DOMException("The operation was aborted.", "AbortError");
-                },
-                onError: () => { },
-                onFinish: (res) => {
-                    addSpanEvent("hebo.ai-sdk.completed");
-                    const streamResult = toChatCompletions(res, ctx.resolvedModelId);
-                    logger.trace({ requestId: ctx.requestId, result: streamResult }, "[chat] ChatCompletions");
-                    addSpanEvent("hebo.result.transformed");
-                    const genAiResponseAttrs = getChatResponseAttributes(streamResult, genAiSignalLevel);
-                    setSpanAttributes(genAiResponseAttrs);
-                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-                    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-                },
-                experimental_include: {
-                    requestBody: false,
-                },
-                includeRawChunks: false,
-                ...textOptions,
-            });
-            ctx.result = toChatCompletionsStream(result, ctx.resolvedModelId);
-            if (hooks?.after) {
-                ctx.result = (await hooks.after(ctx)) ?? ctx.result;
-                addSpanEvent("hebo.hooks.after.completed");
-            }
-            return ctx.result;
-        }
-        addSpanEvent("hebo.ai-sdk.started");
-        const result = await generateText({
-            model: languageModelWithMiddleware,
-            headers: prepareForwardHeaders(ctx.request),
-            abortSignal: ctx.request.signal,
-            timeout: ctx.body.service_tier === "flex" ? cfg.timeouts.flex : cfg.timeouts.normal,
-            experimental_include: {
-                requestBody: false,
-                responseBody: false,
-            },
-            ...textOptions,
-        });
-        logger.trace({ requestId: ctx.requestId, result }, "[chat] AI SDK result");
-        addSpanEvent("hebo.ai-sdk.completed");
-        // Transform result.
-        ctx.result = toChatCompletions(result, ctx.resolvedModelId);
-        logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] ChatCompletions");
-        addSpanEvent("hebo.result.transformed");
-        const genAiResponseAttrs = getChatResponseAttributes(ctx.result, genAiSignalLevel);
-        setSpanAttributes(genAiResponseAttrs);
-        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-        if (hooks?.after) {
-            ctx.result = (await hooks.after(ctx)) ?? ctx.result;
-            addSpanEvent("hebo.hooks.after.completed");
-        }
-        recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-        return ctx.result;
-    };
-    return { handler: winterCgHandler(handler, config) };
-};

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

@@ -1,4 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";
-export * from "./otel";

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

@@ -1,4 +0,0 @@
-export * from "./converters";
-export * from "./handler";
-export * from "./schema";
-export * from "./otel";

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

@@ -1,5 +0,0 @@
-import type { Attributes } from "@opentelemetry/api";
-import type { ChatCompletions, ChatCompletionsBody } from "./schema";
-import { type TelemetrySignalLevel } from "../../types";
-export declare const getChatRequestAttributes: (body: ChatCompletionsBody, signalLevel?: TelemetrySignalLevel) => Attributes;
-export declare const getChatResponseAttributes: (completions: ChatCompletions, signalLevel?: TelemetrySignalLevel) => Attributes;