@hebo-ai/gateway 0.6.2-rc0 → 0.6.2

package/src/endpoints/chat-completions/otel.test.ts

@@ -1,315 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { ChatCompletions, ChatCompletionsBody } from "./schema";
-
-import { getChatRequestAttributes, getChatResponseAttributes } from "./otel";
-
-describe("Chat Completions OTEL", () => {
-  test("should map request metadata into per-key attributes", () => {
-    const metadata = {
-      tenant: "acme",
-      "Org ID": "o-123",
-    };
-
-    const inputs: ChatCompletionsBody = {
-      model: "openai/gpt-oss-20b",
-      messages: [{ role: "user", content: "hi" }],
-      metadata,
-    };
-
-    const attrs = getChatRequestAttributes(inputs, "recommended");
-
-    expect(attrs["gen_ai.request.metadata"]).toBeUndefined();
-    expect(attrs["gen_ai.request.metadata.tenant"]).toBe("acme");
-    expect(attrs["gen_ai.request.metadata.Org ID"]).toBe("o-123");
-  });
-
-  test("should stringify each tool definition individually", () => {
-    const tool1 = {
-      type: "function" as const,
-      function: {
-        name: "get_weather",
-        parameters: {
-          type: "object",
-          properties: {
-            location: { type: "string" },
-          },
-          required: ["location"],
-        },
-      },
-    };
-
-    const tool2 = {
-      type: "function" as const,
-      function: {
-        name: "get_time",
-        parameters: {
-          type: "object",
-          properties: {
-            timezone: { type: "string" },
-          },
-        },
-      },
-    };
-
-    const inputs: ChatCompletionsBody = {
-      model: "openai/gpt-oss-20b",
-      messages: [{ role: "user", content: "hi" }],
-      tools: [tool1, tool2],
-    };
-
-    const attrs = getChatRequestAttributes(inputs, "full");
-
-    expect(attrs["gen_ai.tool.definitions"]).toEqual([
-      JSON.stringify(tool1),
-      JSON.stringify(tool2),
-    ]);
-  });
-
-  test("should map assistant text content part arrays in request attributes", () => {
-    const inputs: ChatCompletionsBody = {
-      model: "openai/gpt-oss-20b",
-      messages: [
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "hello " },
-            { type: "text", text: "world" },
-          ],
-        },
-      ],
-    };
-
-    const attrs = getChatRequestAttributes(inputs, "full");
-
-    expect(attrs["gen_ai.input.messages"]).toEqual([
-      JSON.stringify({
-        role: "assistant",
-        parts: [
-          { type: "text", content: "hello " },
-          { type: "text", content: "world" },
-        ],
-      }),
-    ]);
-  });
-
-  test("should map assistant reasoning string in request attributes", () => {
-    const inputs: ChatCompletionsBody = {
-      model: "openai/gpt-oss-20b",
-      messages: [
-        {
-          role: "assistant",
-          content: "final answer",
-          reasoning: "fallback reasoning",
-          reasoning_details: [
-            {
-              type: "reasoning.text",
-              index: 0,
-              text: "step-by-step",
-            },
-            {
-              type: "reasoning.encrypted",
-              index: 1,
-              data: "encrypted",
-            },
-          ],
-        },
-      ],
-    };
-
-    const attrs = getChatRequestAttributes(inputs, "full");
-
-    expect(attrs["gen_ai.input.messages"]).toEqual([
-      JSON.stringify({
-        role: "assistant",
-        parts: [
-          { type: "reasoning", content: "fallback reasoning" },
-          { type: "text", content: "final answer" },
-        ],
-      }),
-    ]);
-  });
-
-  test("should flatten tool content part arrays in request attributes", () => {
-    const inputs: ChatCompletionsBody = {
-      model: "openai/gpt-oss-20b",
-      messages: [
-        {
-          role: "tool",
-          tool_call_id: "call_1",
-          content: [
-            { type: "text", text: "line-1 " },
-            { type: "text", text: "line-2" },
-          ],
-        },
-      ],
-    };
-
-    const attrs = getChatRequestAttributes(inputs, "full");
-
-    expect(attrs["gen_ai.input.messages"]).toEqual([
-      JSON.stringify({
-        role: "tool",
-        parts: [{ type: "tool_call_response", id: "call_1", response: "line-1 line-2" }],
-      }),
-    ]);
-  });
-
-  test("should map user media content parts to schema-compatible uri/blob parts", () => {
-    const inputs: ChatCompletionsBody = {
-      model: "openai/gpt-oss-20b",
-      messages: [
-        {
-          role: "user",
-          content: [
-            { type: "image_url", image_url: { url: "https://example.com/cat.png" } },
-            { type: "image_url", image_url: { url: "data:image/png;base64,AAAA" } },
-            { type: "input_audio", input_audio: { data: "AAAA", format: "wav" } },
-            {
-              type: "file",
-              file: { data: "AAAA", media_type: "application/pdf", filename: "brochure.pdf" },
-            },
-          ],
-        },
-      ],
-    };
-
-    const attrs = getChatRequestAttributes(inputs, "full");
-
-    expect(attrs["gen_ai.input.messages"]).toEqual([
-      JSON.stringify({
-        role: "user",
-        parts: [
-          { type: "uri", modality: "image", uri: "https://example.com/cat.png" },
-          {
-            type: "blob",
-            modality: "image",
-            content: "[REDACTED_BINARY_DATA]",
-            mime_type: "image/png",
-          },
-          {
-            type: "blob",
-            modality: "audio",
-            content: "[REDACTED_BINARY_DATA]",
-            mime_type: "audio/wav",
-          },
-          {
-            type: "blob",
-            modality: "file",
-            content: "[REDACTED_BINARY_DATA]",
-            mime_type: "application/pdf",
-            file_name: "brochure.pdf",
-          },
-        ],
-      }),
-    ]);
-  });
-
-  test("should map assistant text content part arrays in response attributes", () => {
-    const completions: ChatCompletions = {
-      id: "chatcmpl_123",
-      object: "chat.completion",
-      created: 1700000000,
-      model: "openai/gpt-oss-20b",
-      choices: [
-        {
-          index: 0,
-          message: {
-            role: "assistant",
-            content: [
-              { type: "text", text: "hello " },
-              { type: "text", text: "world" },
-            ],
-          },
-          finish_reason: "stop",
-        },
-      ],
-      usage: null,
-    };
-
-    const attrs = getChatResponseAttributes(completions, "full");
-
-    expect(attrs["gen_ai.output.messages"]).toEqual([
-      JSON.stringify({
-        role: "assistant",
-        parts: [
-          { type: "text", content: "hello " },
-          { type: "text", content: "world" },
-        ],
-        finish_reason: "stop",
-      }),
-    ]);
-  });
-
-  test("should map assistant reasoning string to reasoning parts in response attributes", () => {
-    const completions: ChatCompletions = {
-      id: "chatcmpl_123",
-      object: "chat.completion",
-      created: 1700000000,
-      model: "openai/gpt-oss-20b",
-      choices: [
-        {
-          index: 0,
-          message: {
-            role: "assistant",
-            content: "final answer",
-            reasoning: "chain-of-thought",
-          },
-          finish_reason: "stop",
-        },
-      ],
-      usage: null,
-    };
-
-    const attrs = getChatResponseAttributes(completions, "full");
-
-    expect(attrs["gen_ai.output.messages"]).toEqual([
-      JSON.stringify({
-        role: "assistant",
-        parts: [
-          { type: "reasoning", content: "chain-of-thought" },
-          { type: "text", content: "final answer" },
-        ],
-        finish_reason: "stop",
-      }),
-    ]);
-  });
-
-  test("should map usage token attributes with cache_read_input/reasoning_output names", () => {
-    const completions: ChatCompletions = {
-      id: "chatcmpl_123",
-      object: "chat.completion",
-      created: 1700000000,
-      model: "openai/gpt-oss-20b",
-      choices: [
-        {
-          index: 0,
-          message: {
-            role: "assistant",
-            content: "done",
-          },
-          finish_reason: "stop",
-        },
-      ],
-      usage: {
-        prompt_tokens: 10,
-        completion_tokens: 20,
-        total_tokens: 30,
-        prompt_tokens_details: {
-          cached_tokens: 4,
-        },
-        completion_tokens_details: {
-          reasoning_tokens: 6,
-        },
-      },
-    };
-
-    const attrs = getChatResponseAttributes(completions, "recommended");
-
-    expect(attrs["gen_ai.usage.input_tokens"]).toBe(10);
-    expect(attrs["gen_ai.usage.output_tokens"]).toBe(20);
-    expect(attrs["gen_ai.usage.total_tokens"]).toBe(30);
-    expect(attrs["gen_ai.usage.cache_read.input_tokens"]).toBe(4);
-    expect(attrs["gen_ai.usage.reasoning.output_tokens"]).toBe(6);
-  });
-});

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

@@ -1,214 +0,0 @@
-import type { Attributes } from "@opentelemetry/api";
-
-import type {
-  ChatCompletionsAssistantMessage,
-  ChatCompletions,
-  ChatCompletionsBody,
-  ChatCompletionsContentPart,
-  ChatCompletionsContentPartText,
-  ChatCompletionsMessage,
-} from "./schema";
-
-import { type TelemetrySignalLevel } from "../../types";
-import { parseDataUrl } from "../../utils/url";
-
-const toTextParts = (content: string | ChatCompletionsContentPart[] | null | undefined) => {
-  if (typeof content === "string") {
-    return [{ type: "text", content }];
-  }
-
-  const result = [];
-  if (Array.isArray(content)) {
-    for (const part of content) {
-      if (part.type === "text") {
-        result.push({ type: "text", content: part.text });
-      }
-    }
-  }
-  return result;
-};
-
-const toBlobPart = (modality: string, mimeType?: string) => {
-  const part: Record<string, unknown> = {
-    type: "blob",
-    modality,
-    content: "[REDACTED_BINARY_DATA]",
-  };
-  if (mimeType) part["mime_type"] = mimeType;
-  return part;
-};
-
-const toToolResponsePart = (id: string, content: string | ChatCompletionsContentPartText[]) => ({
-  type: "tool_call_response" as const,
-  id,
-  response: typeof content === "string" ? content : content.map((p) => p.text).join(""),
-});
-
-const toAssistantParts = (message: ChatCompletionsAssistantMessage) => {
-  const parts: Record<string, unknown>[] = [];
-
-  if (typeof message.reasoning === "string") {
-    parts.push({ type: "reasoning", content: message.reasoning });
-  }
-
-  for (const part of toTextParts(message.content)) {
-    parts.push(part);
-  }
-
-  if (Array.isArray(message.tool_calls)) {
-    for (const call of message.tool_calls) {
-      parts.push({
-        type: "tool_call",
-        id: call.id,
-        name: call.function.name,
-        arguments: call.function.arguments,
-      });
-    }
-  }
-
-  return parts;
-};
-
-const toUserParts = (content: string | ChatCompletionsContentPart[]) => {
-  if (typeof content === "string") return [{ type: "text", content }];
-
-  const parts: Record<string, unknown>[] = [];
-
-  for (const part of content) {
-    switch (part.type) {
-      case "text":
-        parts.push({ type: "text", content: part.text });
-        break;
-      case "image_url": {
-        const url = part.image_url.url;
-        if (url.slice(0, 5).toLowerCase() === "data:") {
-          const { mimeType } = parseDataUrl(url);
-          parts.push(toBlobPart("image", mimeType || undefined));
-        } else {
-          parts.push({ type: "uri", modality: "image", uri: url });
-        }
-        break;
-      }
-      case "input_audio":
-        parts.push(toBlobPart("audio", `audio/${part.input_audio.format}`));
-        break;
-      case "file": {
-        const filePart = toBlobPart("file", part.file.media_type);
-        if (part.file.filename) filePart["file_name"] = part.file.filename;
-        parts.push(filePart);
-        break;
-      }
-    }
-  }
-
-  return parts;
-};
-
-const toMessageParts = (message: ChatCompletionsMessage) => {
-  switch (message.role) {
-    case "assistant":
-      return toAssistantParts(message);
-    case "tool":
-      return [toToolResponsePart(message.tool_call_id, message.content)];
-    case "user":
-      return toUserParts(message.content);
-    // FUTURE: remove once Langfuse supports gen_ai.system_instructions
-    // https://github.com/langfuse/langfuse/issues/11607
-    case "system":
-      return toTextParts(message.content);
-    default:
-      return [];
-  }
-};
-
-export const getChatRequestAttributes = (
-  inputs: ChatCompletionsBody,
-  signalLevel?: TelemetrySignalLevel,
-): Attributes => {
-  if (!signalLevel || signalLevel === "off") return {};
-
-  const attrs: Attributes = {};
-
-  if (inputs.seed !== undefined) {
-    Object.assign(attrs, { "gen_ai.request.seed": inputs.seed });
-  }
-
-  if (signalLevel !== "required") {
-    Object.assign(attrs, {
-      // FUTURE: add reasoning info
-      "gen_ai.request.stream": inputs.stream,
-      "gen_ai.request.frequency_penalty": inputs.frequency_penalty,
-      "gen_ai.request.max_tokens": inputs.max_completion_tokens,
-      "gen_ai.request.presence_penalty": inputs.presence_penalty,
-      "gen_ai.request.stop_sequences": inputs.stop
-        ? Array.isArray(inputs.stop)
-          ? inputs.stop
-          : [inputs.stop]
-        : undefined,
-      "gen_ai.request.temperature": inputs.temperature,
-      "gen_ai.request.top_p": inputs.top_p,
-    });
-
-    if (inputs.metadata) {
-      for (const key in inputs.metadata) {
-        attrs[`gen_ai.request.metadata.${key}`] = inputs.metadata[key];
-      }
-    }
-  }
-
-  if (signalLevel === "full") {
-    Object.assign(attrs, {
-      // FUTURE: move system instructions from messages to here
-      // blocker: https://github.com/langfuse/langfuse/issues/11607
-      // "gen_ai.system_instructions": inputs.messages
-      //   .filter((m) => m.role === "system")
-      //   .map((m) => JSON.stringify(toTextPart(m.content))),
-      "gen_ai.input.messages": inputs.messages
-        //.filter((m) => m.role !== "system")
-        .map((m) => JSON.stringify({ role: m.role, parts: toMessageParts(m) })),
-      "gen_ai.tool.definitions": inputs.tools?.map((toolDefinition) =>
-        JSON.stringify(toolDefinition),
-      ),
-    });
-  }
-
-  return attrs;
-};
-
-export const getChatResponseAttributes = (
-  completions: ChatCompletions,
-  signalLevel?: TelemetrySignalLevel,
-): Attributes => {
-  if (!signalLevel || signalLevel === "off") return {};
-
-  const attrs: Attributes = {
-    "gen_ai.response.id": completions.id,
-  };
-
-  if (signalLevel !== "required") {
-    Object.assign(attrs, {
-      "gen_ai.response.finish_reasons": completions.choices?.map((c) => c.finish_reason),
-      "gen_ai.usage.total_tokens": completions.usage?.total_tokens,
-      "gen_ai.usage.input_tokens": completions.usage?.prompt_tokens,
-      "gen_ai.usage.cache_read.input_tokens":
-        completions.usage?.prompt_tokens_details?.cached_tokens,
-      "gen_ai.usage.output_tokens": completions.usage?.completion_tokens,
-      "gen_ai.usage.reasoning.output_tokens":
-        completions.usage?.completion_tokens_details?.reasoning_tokens,
-    });
-  }
-
-  if (signalLevel === "full") {
-    Object.assign(attrs, {
-      "gen_ai.output.messages": completions.choices?.map((c) =>
-        JSON.stringify({
-          role: c.message.role,
-          parts: toMessageParts(c.message),
-          finish_reason: c.finish_reason,
-        }),
-      ),
-    });
-  }
-
-  return attrs;
-};