@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/endpoints/chat-completions/schema.ts

@@ -1,364 +0,0 @@
-import * as z from "zod";
-
-export const ChatCompletionsCacheControlSchema = z.object({
-  type: z.literal("ephemeral"),
-  ttl: z.string().optional(),
-});
-export type ChatCompletionsCacheControl = z.infer<typeof ChatCompletionsCacheControlSchema>;
-
-export const ChatCompletionsContentPartTextSchema = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-  // Extension origin: Anthropic/OpenRouter/Vercel
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-export type ChatCompletionsContentPartText = z.infer<typeof ChatCompletionsContentPartTextSchema>;
-
-export const ChatCompletionsContentPartImageSchema = z.object({
-  type: z.literal("image_url"),
-  image_url: z.object({
-    url: z.string(),
-    detail: z.enum(["low", "high", "auto"]).optional(),
-  }),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-
-export const ChatCompletionsContentPartFileSchema = z.object({
-  type: z.literal("file"),
-  file: z.object({
-    data: z.string(),
-    media_type: z.string(),
-    filename: z.string().optional(),
-  }),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-
-export const ChatCompletionsContentPartAudioSchema = z.object({
-  type: z.literal("input_audio"),
-  input_audio: z.object({
-    data: z.string(),
-    // only wav and mp3 are official by OpenAI, rest is taken from Gemini support:
-    // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
-    format: z.enum([
-      "x-aac",
-      "flac",
-      "mp3",
-      "m4a",
-      "mpeg",
-      "mpga",
-      "mp4",
-      "ogg",
-      "pcm",
-      "wav",
-      "webm",
-    ]),
-  }),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-
-export const ChatCompletionsContentPartSchema = z.discriminatedUnion("type", [
-  ChatCompletionsContentPartTextSchema,
-  ChatCompletionsContentPartImageSchema,
-  ChatCompletionsContentPartFileSchema,
-  ChatCompletionsContentPartAudioSchema,
-]);
-export type ChatCompletionsContentPart = z.infer<typeof ChatCompletionsContentPartSchema>;
-
-export const ChatCompletionsToolCallSchema = z.object({
-  type: z.literal("function"),
-  id: z.string(),
-  function: z.object({
-    arguments: z.string(),
-    name: z.string(),
-  }),
-  // Extension origin: Gemini
-  extra_content: z
-    .record(z.string(), z.record(z.string(), z.unknown()))
-    .optional()
-    .meta({ extension: true }),
-});
-export type ChatCompletionsToolCall = z.infer<typeof ChatCompletionsToolCallSchema>;
-
-export const ChatCompletionsSystemMessageSchema = z.object({
-  role: z.literal("system"),
-  content: z.string(),
-  name: z.string().optional(),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-export type ChatCompletionsSystemMessage = z.infer<typeof ChatCompletionsSystemMessageSchema>;
-
-export const ChatCompletionsUserMessageSchema = z.object({
-  role: z.literal("user"),
-  content: z.union([z.string(), z.array(ChatCompletionsContentPartSchema)]),
-  name: z.string().optional(),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-export type ChatCompletionsUserMessage = z.infer<typeof ChatCompletionsUserMessageSchema>;
-
-export const ChatCompletionsReasoningDetailSchema = z.object({
-  id: z.string().optional(),
-  index: z.int().nonnegative(),
-  type: z.string(),
-  text: z.string().optional(),
-  signature: z.string().optional(),
-  data: z.string().optional(),
-  summary: z.string().optional(),
-  format: z.string().optional(),
-});
-export type ChatCompletionsReasoningDetail = z.infer<typeof ChatCompletionsReasoningDetailSchema>;
-
-export const ChatCompletionsAssistantMessageSchema = z.object({
-  role: z.literal("assistant"),
-  content: z
-    .union([z.string(), z.null(), z.array(ChatCompletionsContentPartTextSchema)])
-    .optional(),
-  name: z.string().optional(),
-  // FUTURE: This should also support Custom Tool Calls
-  tool_calls: z.array(ChatCompletionsToolCallSchema).optional(),
-  // Extension origin: OpenRouter/Vercel
-  reasoning: z.string().optional().meta({ extension: true }),
-  // Extension origin: OpenRouter/Vercel
-  reasoning_details: z
-    .array(ChatCompletionsReasoningDetailSchema)
-    .optional()
-    .meta({ extension: true }),
-  // Extension origin: Gemini
-  extra_content: z
-    .record(z.string(), z.record(z.string(), z.unknown()))
-    .optional()
-    .meta({ extension: true }),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-});
-export type ChatCompletionsAssistantMessage = z.infer<typeof ChatCompletionsAssistantMessageSchema>;
-
-export const ChatCompletionsToolMessageSchema = z.object({
-  role: z.literal("tool"),
-  content: z.union([z.string(), z.array(ChatCompletionsContentPartTextSchema)]),
-  tool_call_id: z.string(),
-});
-export type ChatCompletionsToolMessage = z.infer<typeof ChatCompletionsToolMessageSchema>;
-
-export const ChatCompletionsMessageSchema = z.discriminatedUnion("role", [
-  ChatCompletionsSystemMessageSchema,
-  ChatCompletionsUserMessageSchema,
-  ChatCompletionsAssistantMessageSchema,
-  ChatCompletionsToolMessageSchema,
-]);
-export type ChatCompletionsMessage = z.infer<typeof ChatCompletionsMessageSchema>;
-
-export const ChatCompletionsToolSchema = z.object({
-  type: z.literal("function"),
-  function: z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    parameters: z.record(z.string(), z.unknown()),
-    strict: z.boolean().optional(),
-  }),
-  // FUTURE: cache_control support on tools
-});
-export type ChatCompletionsTool = z.infer<typeof ChatCompletionsToolSchema>;
-
-const ChatCompletionsNamedFunctionToolChoiceSchema = z.object({
-  type: z.literal("function"),
-  function: z.object({
-    name: z.string(),
-  }),
-});
-
-const ChatCompletionsAllowedFunctionToolChoiceSchema = z.object({
-  type: z.literal("allowed_tools"),
-  allowed_tools: z.object({
-    mode: z.enum(["auto", "required"]),
-    tools: z.array(ChatCompletionsNamedFunctionToolChoiceSchema).nonempty(),
-  }),
-});
-
-export const ChatCompletionsToolChoiceSchema = z.union([
-  z.enum(["none", "auto", "required", "validated"]),
-  z.discriminatedUnion("type", [
-    ChatCompletionsNamedFunctionToolChoiceSchema,
-    ChatCompletionsAllowedFunctionToolChoiceSchema,
-  ]),
-  // FUTURE: Missing CustomTool
-]);
-export type ChatCompletionsToolChoice = z.infer<typeof ChatCompletionsToolChoiceSchema>;
-
-export const ChatCompletionsReasoningEffortSchema = z.enum([
-  "none",
-  // Extension origin: Gemini
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  // Extension origin: Anthropic
-  "max",
-]);
-export type ChatCompletionsReasoningEffort = z.infer<typeof ChatCompletionsReasoningEffortSchema>;
-
-export const ChatCompletionsReasoningConfigSchema = z.object({
-  enabled: z.optional(z.boolean()),
-  effort: z.optional(ChatCompletionsReasoningEffortSchema),
-  max_tokens: z.optional(z.number()),
-  exclude: z.optional(z.boolean()),
-});
-export type ChatCompletionsReasoningConfig = z.infer<typeof ChatCompletionsReasoningConfigSchema>;
-
-export const ChatCompletionsResponseFormatJsonSchema = z.object({
-  // FUTURE: consider support for legacy json_object (if demand)
-  type: z.literal("json_schema"),
-  json_schema: z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    schema: z.record(z.string(), z.unknown()),
-    // FUTURE: consider support for non-strict mode (for providers that support it)
-    strict: z.boolean().optional(),
-  }),
-});
-export const ChatCompletionsResponseFormatTextSchema = z.object({
-  type: z.literal("text"),
-});
-export const ChatCompletionsResponseFormatSchema = z.discriminatedUnion("type", [
-  ChatCompletionsResponseFormatJsonSchema,
-  ChatCompletionsResponseFormatTextSchema,
-]);
-export type ChatCompletionsResponseFormat = z.infer<typeof ChatCompletionsResponseFormatSchema>;
-
-export const ChatCompletionsMetadataSchema = z.record(
-  z.string().min(1).max(64),
-  z.string().max(512),
-);
-export type ChatCompletionsMetadata = z.infer<typeof ChatCompletionsMetadataSchema>;
-
-const ChatCompletionsInputsSchema = z.object({
-  messages: z.array(ChatCompletionsMessageSchema),
-  tools: z.array(ChatCompletionsToolSchema).optional(),
-  tool_choice: ChatCompletionsToolChoiceSchema.optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  max_tokens: z.int().nonnegative().optional(),
-  max_completion_tokens: z.int().nonnegative().optional(),
-  frequency_penalty: z.number().min(-2.0).max(2.0).optional(),
-  presence_penalty: z.number().min(-2.0).max(2.0).optional(),
-  seed: z.int().optional(),
-  stop: z.union([z.string(), z.array(z.string())]).optional(),
-  top_p: z.number().min(0).max(1.0).optional(),
-  metadata: ChatCompletionsMetadataSchema.optional(),
-  response_format: ChatCompletionsResponseFormatSchema.optional(),
-  reasoning_effort: ChatCompletionsReasoningEffortSchema.optional(),
-  prompt_cache_key: z.string().optional(),
-  prompt_cache_retention: z.enum(["in_memory", "24h"]).optional(),
-  // Extension origin: Gemini explicit cache handle
-  // FUTURE: generalize extra_body handling
-  // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/migrate/openai/overview
-  extra_body: z
-    .object({
-      google: z
-        .object({
-          cached_content: z.string().optional().meta({ extension: true }),
-        })
-        .optional(),
-    })
-    .optional(),
-  // Extension origin: OpenRouter/Vercel/Anthropic
-  cache_control: ChatCompletionsCacheControlSchema.optional().meta({ extension: true }),
-  // Extension origin: OpenRouter
-  reasoning: ChatCompletionsReasoningConfigSchema.optional().meta({ extension: true }),
-});
-export type ChatCompletionsInputs = z.infer<typeof ChatCompletionsInputsSchema>;
-
-export const ChatCompletionsBodySchema = z.looseObject({
-  model: z.string(),
-  stream: z.boolean().optional(),
-  ...ChatCompletionsInputsSchema.shape,
-});
-export type ChatCompletionsBody = z.infer<typeof ChatCompletionsBodySchema>;
-
-export const ChatCompletionsFinishReasonSchema = z.enum([
-  "stop",
-  "length",
-  "content_filter",
-  "tool_calls",
-]);
-export type ChatCompletionsFinishReason = z.infer<typeof ChatCompletionsFinishReasonSchema>;
-
-export const ChatCompletionsChoiceSchema = z.object({
-  index: z.int().nonnegative(),
-  message: ChatCompletionsAssistantMessageSchema,
-  finish_reason: ChatCompletionsFinishReasonSchema,
-  // FUTURE: model this out
-  logprobs: z.unknown().optional(),
-});
-export type ChatCompletionsChoice = z.infer<typeof ChatCompletionsChoiceSchema>;
-
-export const ChatCompletionsUsageSchema = z.object({
-  prompt_tokens: z.int().nonnegative().optional(),
-  completion_tokens: z.int().nonnegative().optional(),
-  total_tokens: z.int().nonnegative().optional(),
-  completion_tokens_details: z
-    .object({
-      // FUTURE: add missing properties
-      reasoning_tokens: z.int().nonnegative().optional(),
-    })
-    .optional(),
-  prompt_tokens_details: z
-    .object({
-      // FUTURE: add missing properties
-      cached_tokens: z.int().nonnegative().optional(),
-      // Extension origin: OpenRouter
-      cache_write_tokens: z.int().nonnegative().optional().meta({ extension: true }),
-    })
-    .optional(),
-});
-export type ChatCompletionsUsage = z.infer<typeof ChatCompletionsUsageSchema>;
-
-export const ChatCompletionsSchema = z.object({
-  id: z.string(),
-  object: z.literal("chat.completion"),
-  created: z.int().nonnegative(),
-  model: z.string(),
-  choices: z.array(ChatCompletionsChoiceSchema),
-  usage: ChatCompletionsUsageSchema.nullable(),
-  // Extension origin: Vercel AI Gateway
-  provider_metadata: z.unknown().optional().meta({ extension: true }),
-});
-export type ChatCompletions = z.infer<typeof ChatCompletionsSchema>;
-
-export const ChatCompletionsToolCallDeltaSchema = ChatCompletionsToolCallSchema.partial().extend({
-  index: z.int().nonnegative(),
-});
-export type ChatCompletionsToolCallDelta = z.infer<typeof ChatCompletionsToolCallDeltaSchema>;
-
-export const ChatCompletionsAssistantMessageDeltaSchema =
-  ChatCompletionsAssistantMessageSchema.partial().extend({
-    tool_calls: z.array(ChatCompletionsToolCallDeltaSchema).optional(),
-  });
-export type ChatCompletionsAssistantMessageDelta = z.infer<
-  typeof ChatCompletionsAssistantMessageDeltaSchema
->;
-
-export const ChatCompletionsChoiceDeltaSchema = z.object({
-  index: z.int().nonnegative(),
-  delta: ChatCompletionsAssistantMessageDeltaSchema,
-  finish_reason: ChatCompletionsFinishReasonSchema.nullable(),
-  // FUTURE: model this out
-  logprobs: z.unknown().optional(),
-});
-export type ChatCompletionsChoiceDelta = z.infer<typeof ChatCompletionsChoiceDeltaSchema>;
-
-export const ChatCompletionsChunkSchema = z.object({
-  id: z.string(),
-  object: z.literal("chat.completion.chunk"),
-  created: z.int().nonnegative(),
-  model: z.string(),
-  choices: z.array(ChatCompletionsChoiceDeltaSchema),
-  usage: ChatCompletionsUsageSchema.nullable(),
-  // Extension origin: Vercel AI Gateway
-  provider_metadata: z.unknown().optional().meta({ extension: true }),
-});
-export type ChatCompletionsChunk = z.infer<typeof ChatCompletionsChunkSchema>;

package/src/endpoints/embeddings/converters.ts

@@ -1,51 +0,0 @@
-import type { JSONObject, SharedV3ProviderOptions } from "@ai-sdk/provider";
-import type { EmbedManyResult } from "ai";
-
-import type { EmbeddingsInputs, EmbeddingsData, EmbeddingsUsage, Embeddings } from "./schema";
-
-import { toResponse } from "../../utils/response";
-
-export type EmbedCallOptions = {
-  values: string[];
-  providerOptions: SharedV3ProviderOptions;
-};
-
-export function convertToEmbedCallOptions(params: EmbeddingsInputs): EmbedCallOptions {
-  const { input, ...rest } = params;
-
-  return {
-    values: Array.isArray(input) ? input : [input],
-    providerOptions: {
-      unknown: rest as JSONObject,
-    },
-  };
-}
-
-export function toEmbeddings(embedManyResult: EmbedManyResult, modelId: string): Embeddings {
-  const data: EmbeddingsData[] = embedManyResult.embeddings.map((embedding, index) => ({
-    object: "embedding",
-    embedding,
-    index,
-  }));
-
-  const usage: EmbeddingsUsage = {
-    prompt_tokens: embedManyResult.usage.tokens,
-    total_tokens: embedManyResult.usage.tokens,
-  };
-
-  return {
-    object: "list",
-    data,
-    model: modelId,
-    usage,
-    provider_metadata: embedManyResult.providerMetadata,
-  };
-}
-
-export function createEmbeddingsResponse(
-  embedManyResult: EmbedManyResult,
-  modelId: string,
-  responseInit?: ResponseInit,
-): Response {
-  return toResponse(toEmbeddings(embedManyResult, modelId), responseInit);
-}

package/src/endpoints/embeddings/handler.test.ts

@@ -1,133 +0,0 @@
-import { MockEmbeddingModelV3, MockProviderV3 } from "ai/test";
-import { describe, expect, test } from "bun:test";
-
-import { parseResponse, postJson } from "../../../test/helpers/http";
-import { embeddings } from "./handler";
-
-const baseUrl = "http://localhost/embeddings";
-
-const expectedEmbeddingResponse = (count: number) => ({
-  object: "list",
-  data: Array.from({ length: count }, (_, index) => ({
-    object: "embedding",
-    embedding: [0.1, 0.2, 0.3],
-    index,
-  })),
-  model: "text-embedding-3-small",
-  usage: {
-    prompt_tokens: count * 10,
-    total_tokens: count * 10,
-  },
-  provider_metadata: {
-    provider: {
-      key: "value",
-    },
-  },
-});
-
-describe("Embeddings Handler", () => {
-  const endpoint = embeddings({
-    providers: {
-      openai: new MockProviderV3({
-        embeddingModels: {
-          "text-embedding-3-small": new MockEmbeddingModelV3({
-            // oxlint-disable-next-line require-await
-            doEmbed: async (options) => ({
-              embeddings: options.values.map(() => [0.1, 0.2, 0.3]),
-              usage: { tokens: 10 },
-              providerMetadata: { provider: { key: "value" } },
-              warnings: [],
-            }),
-          }),
-        },
-      }),
-    },
-    models: {
-      "text-embedding-3-small": {
-        name: "OpenAI Embedding Model",
-        modalities: { input: ["text"], output: ["embedding"] },
-        providers: ["openai"],
-      },
-      "gpt-oss-20b": {
-        name: "GPT-OSS 20B",
-        modalities: { input: ["text"], output: ["text"] },
-        providers: ["openai"],
-      },
-    },
-  });
-
-  test("should return 422 if model does not support embeddings", async () => {
-    const request = postJson(baseUrl, {
-      model: "gpt-oss-20b",
-      input: "hello world",
-    });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toMatchObject({
-      error: {
-        code: "model_unsupported_operation",
-        message: "Model 'gpt-oss-20b' does not support 'embedding' output",
-        type: "invalid_request_error",
-      },
-    });
-  });
-
-  test("should generate embeddings for a single string", async () => {
-    const request = postJson(baseUrl, {
-      model: "text-embedding-3-small",
-      input: "hello world",
-    });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toEqual(expectedEmbeddingResponse(1));
-  });
-
-  test("should generate embeddings for an array of strings", async () => {
-    const request = postJson(baseUrl, {
-      model: "text-embedding-3-small",
-      input: ["hello", "world"],
-    });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toEqual(expectedEmbeddingResponse(2));
-  });
-
-  test("should return 422 if input is missing", async () => {
-    const request = postJson(baseUrl, {
-      model: "text-embedding-3-small",
-    });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toMatchObject({
-      error: {
-        code: "bad_request",
-        message: "✖ Invalid input\n  → at input",
-        type: "invalid_request_error",
-        param: "",
-      },
-    });
-  });
-
-  test("should return 'Method Not Allowed' for GET request", async () => {
-    const request = new Request(baseUrl, { method: "GET" });
-
-    const res = await endpoint.handler(request);
-    const data = await parseResponse(res);
-
-    expect(data).toMatchObject({
-      error: {
-        code: "method_not_allowed",
-        message: "Method Not Allowed",
-        type: "invalid_request_error",
-      },
-    });
-  });
-});

package/src/endpoints/embeddings/handler.ts

@@ -1,137 +0,0 @@
-import { embedMany, wrapEmbeddingModel } from "ai";
-import * as z from "zod/mini";
-
-import type {
-  AfterHookContext,
-  BeforeHookContext,
-  GatewayConfig,
-  Endpoint,
-  GatewayContext,
-  ResolveProviderHookContext,
-  ResolveModelHookContext,
-} from "../../types";
-
-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 { convertToEmbedCallOptions, toEmbeddings } from "./converters";
-import { getEmbeddingsRequestAttributes, getEmbeddingsResponseAttributes } from "./otel";
-import { EmbeddingsBodySchema, type EmbeddingsBody } from "./schema";
-
-export const embeddings = (config: GatewayConfig): Endpoint => {
-  const hooks = config.hooks;
-
-  const handler = async (ctx: GatewayContext) => {
-    const start = performance.now();
-    ctx.operation = "embeddings";
-    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 {
-      ctx.body = await ctx.request.json();
-    } catch {
-      throw new GatewayError("Invalid JSON", 400);
-    }
-    logger.trace({ requestId: ctx.requestId, result: ctx.body }, "[chat] EmbeddingsBody");
-    addSpanEvent("hebo.request.deserialized");
-
-    const parsed = EmbeddingsBodySchema.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 as BeforeHookContext)) as EmbeddingsBody) ?? ctx.body;
-      addSpanEvent("hebo.hooks.before.completed");
-    }
-
-    // Resolve model + provider (hooks may override defaults).
-    let inputs;
-    ({ model: ctx.modelId, ...inputs } = ctx.body);
-
-    ctx.resolvedModelId =
-      (await hooks?.resolveModelId?.(ctx as ResolveModelHookContext)) ?? ctx.modelId;
-    logger.debug(`[embeddings] resolved ${ctx.modelId} to ${ctx.resolvedModelId}`);
-    addSpanEvent("hebo.model.resolved");
-
-    const override = await hooks?.resolveProvider?.(ctx as ResolveProviderHookContext);
-    ctx.provider =
-      override ??
-      resolveProvider({
-        providers: ctx.providers,
-        models: ctx.models,
-        modelId: ctx.resolvedModelId,
-        operation: ctx.operation,
-      });
-
-    const embeddingModel = ctx.provider.embeddingModel(ctx.resolvedModelId);
-    ctx.resolvedProviderId = embeddingModel.provider;
-    logger.debug(`[embeddings] using ${embeddingModel.provider} for ${ctx.resolvedModelId}`);
-    addSpanEvent("hebo.provider.resolved");
-
-    const genAiSignalLevel = config.telemetry?.signals?.gen_ai;
-    const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
-    setSpanAttributes(genAiGeneralAttrs);
-
-    // Convert inputs to AI SDK call options.
-    const embedOptions = convertToEmbedCallOptions(inputs);
-    logger.trace(
-      { requestId: ctx.requestId, options: embedOptions },
-      "[embeddings] AI SDK options",
-    );
-    addSpanEvent("hebo.options.prepared");
-    setSpanAttributes(getEmbeddingsRequestAttributes(ctx.body, genAiSignalLevel));
-
-    // Build middleware chain (model -> forward params -> provider).
-    const embeddingModelWithMiddleware = wrapEmbeddingModel({
-      model: embeddingModel,
-      middleware: modelMiddlewareMatcher.forEmbedding(ctx.resolvedModelId, embeddingModel.provider),
-    });
-
-    // Execute request.
-    addSpanEvent("hebo.ai-sdk.started");
-    const result = await embedMany({
-      model: embeddingModelWithMiddleware,
-      headers: prepareForwardHeaders(ctx.request),
-      abortSignal: ctx.request.signal,
-      ...embedOptions,
-    });
-    logger.trace({ requestId: ctx.requestId, result }, "[embeddings] AI SDK result");
-    addSpanEvent("hebo.ai-sdk.completed");
-
-    // Transform result.
-    ctx.result = toEmbeddings(result, ctx.modelId);
-    logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] Embeddings");
-    addSpanEvent("hebo.result.transformed");
-    const genAiResponseAttrs = getEmbeddingsResponseAttributes(ctx.result, genAiSignalLevel);
-    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-    setSpanAttributes(genAiResponseAttrs);
-
-    if (hooks?.after) {
-      ctx.result = (await hooks.after(ctx as AfterHookContext)) ?? ctx.result;
-      addSpanEvent("hebo.hooks.after.completed");
-    }
-
-    recordTimePerOutputToken(start, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-    return ctx.result;
-  };
-
-  return { handler: winterCgHandler(handler, config) };
-};

package/src/endpoints/embeddings/index.ts

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