@hebo-ai/gateway 0.8.2 → 0.9.1

package/dist/endpoints/conversations/schema.js

@@ -1,159 +1,8 @@
 import * as z from "zod";
-/**
- * --- Metadata ---
- */
-// Note: The 16-key limit is not currently validated.
-export const MetadataSchema = z
-    .record(z.string().max(64), z.string().max(512))
-    .nullable()
-    .optional();
-export const ItemStatusSchema = z.enum(["in_progress", "completed", "incomplete"]);
-export const ImageDetailSchema = z.enum(["low", "high", "auto"]);
-/**
- * --- Messaging Content & Items ---
- */
-// Content Parts
-export const ResponseInputTextSchema = z.object({
-    type: z.literal("input_text"),
-    text: z.string(),
-});
-const ResponseInputImageURLSchema = z.object({
-    type: z.literal("input_image"),
-    image_url: z.string(),
-    file_id: z.string().optional(),
-    detail: ImageDetailSchema.optional(),
-});
-const ResponseInputImageIDSchema = z.object({
-    type: z.literal("input_image"),
-    file_id: z.string(),
-    image_url: z.string().optional(),
-    detail: ImageDetailSchema.optional(),
-});
-export const ResponseInputImageSchema = z.union([
-    ResponseInputImageURLSchema,
-    ResponseInputImageIDSchema,
-]);
-const ResponseInputFileDataSchema = z.object({
-    type: z.literal("input_file"),
-    file_data: z.string(),
-    file_id: z.string().optional(),
-    file_url: z.string().optional(),
-    filename: z.string().optional(),
-});
-const ResponseInputFileIDSchema = z.object({
-    type: z.literal("input_file"),
-    file_id: z.string(),
-    file_data: z.string().optional(),
-    file_url: z.string().optional(),
-    filename: z.string().optional(),
-});
-const ResponseInputFileURLSchema = z.object({
-    type: z.literal("input_file"),
-    file_url: z.string(),
-    file_data: z.string().optional(),
-    file_id: z.string().optional(),
-    filename: z.string().optional(),
-});
-export const ResponseInputFileSchema = z.union([
-    ResponseInputFileDataSchema,
-    ResponseInputFileIDSchema,
-    ResponseInputFileURLSchema,
-]);
-export const ResponseInputContentSchema = z.union([
-    ResponseInputTextSchema,
-    ResponseInputImageURLSchema,
-    ResponseInputImageIDSchema,
-    ResponseInputFileDataSchema,
-    ResponseInputFileIDSchema,
-    ResponseInputFileURLSchema,
-]);
-export const ResponseOutputTextSchema = z.object({
-    type: z.literal("output_text"),
-    text: z.string(),
-    annotations: z.array(z.unknown()).optional(),
-});
-// Message Items
-const MessageItemBaseSchema = z
-    .object({
-    type: z.literal("message"),
-    id: z.string().optional(),
-    status: ItemStatusSchema.optional(),
-})
-    .loose();
-const UserMessageSchema = MessageItemBaseSchema.extend({
-    role: z.literal("user"),
-    content: z.union([z.string(), z.array(ResponseInputContentSchema)]),
-});
-const AssistantMessageSchema = MessageItemBaseSchema.extend({
-    role: z.literal("assistant"),
-    content: z.union([z.string(), z.array(ResponseOutputTextSchema)]),
-});
-const SystemMessageSchema = MessageItemBaseSchema.extend({
-    role: z.literal("system"),
-    content: z.union([z.string(), z.array(ResponseInputContentSchema)]),
-});
-const DeveloperMessageSchema = MessageItemBaseSchema.extend({
-    role: z.literal("developer"),
-    content: z.union([z.string(), z.array(ResponseInputContentSchema)]),
-});
-export const MessageItemUnionSchema = z.discriminatedUnion("role", [
-    UserMessageSchema,
-    AssistantMessageSchema,
-    SystemMessageSchema,
-    DeveloperMessageSchema,
-]);
-/**
- * --- Function ---
- */
-export const ResponseFunctionToolCallSchema = z
-    .object({
-    type: z.literal("function_call"),
-    id: z.string().optional(),
-    call_id: z.string(),
-    name: z.string(),
-    arguments: z.string(),
-    status: ItemStatusSchema.optional(),
-})
-    .loose();
-export const FunctionCallOutputSchema = z
-    .object({
-    type: z.literal("function_call_output"),
-    id: z.string().optional(),
-    call_id: z.string(),
-    output: z.union([z.string(), z.array(ResponseInputContentSchema)]),
-    status: ItemStatusSchema.optional(),
-})
-    .loose();
-/**
- * --- Reasoning ---
- */
-export const ResponseSummaryTextSchema = z.object({
-    type: z.literal("summary_text"),
-    text: z.string(),
-});
-export const ResponseReasoningTextSchema = z.object({
-    type: z.literal("reasoning_text"),
-    text: z.string(),
-});
-export const ResponseReasoningItemSchema = z
-    .object({
-    type: z.literal("reasoning"),
-    id: z.string().optional(),
-    summary: z.array(ResponseSummaryTextSchema),
-    content: z.array(ResponseReasoningTextSchema).optional(),
-    encrypted_content: z.string().optional(),
-    status: ItemStatusSchema.optional(),
-})
-    .loose();
+import { ResponsesMetadataSchema, ResponsesInputItemSchema } from "../responses/schema";
 /**
  * --- Entities ---
  */
-export const ResponseInputItemSchema = z.discriminatedUnion("type", [
-    MessageItemUnionSchema,
-    ResponseFunctionToolCallSchema,
-    FunctionCallOutputSchema,
-    ResponseReasoningItemSchema,
-]);
 export const ConversationItemSchema = z
     .object({
     id: z.string(),
@@ -161,12 +10,12 @@ export const ConversationItemSchema = z
     created_at: z.number().int(),
 })
     .loose()
-    .and(ResponseInputItemSchema);
+    .and(ResponsesInputItemSchema);
 export const ConversationSchema = z.object({
     id: z.string(),
     object: z.literal("conversation"),
     created_at: z.number().int(),
-    metadata: MetadataSchema,
+    metadata: ResponsesMetadataSchema,
 });
 export const ConversationDeletedSchema = z.object({
     id: z.string(),
@@ -177,14 +26,14 @@ export const ConversationDeletedSchema = z.object({
  * --- API ---
  */
 export const ConversationCreateParamsSchema = z.object({
-    items: z.array(ResponseInputItemSchema).max(1000).optional(),
-    metadata: MetadataSchema.optional(),
+    items: z.array(ResponsesInputItemSchema).max(1000).optional(),
+    metadata: ResponsesMetadataSchema.optional(),
 });
 export const ConversationUpdateBodySchema = z.object({
-    metadata: MetadataSchema,
+    metadata: ResponsesMetadataSchema,
 });
 export const ConversationItemsAddBodySchema = z.object({
-    items: z.array(ResponseInputItemSchema).max(1000),
+    items: z.array(ResponsesInputItemSchema).max(1000),
 });
 export const ConversationItemListSchema = z.object({
     object: z.literal("list"),
@@ -221,5 +70,5 @@ export const ConversationListParamsSchema = z.preprocess((input) => {
     }
     return rest;
 }, ConversationItemListParamsSchema.extend({
-    metadata: MetadataSchema.optional(),
+    metadata: ResponsesMetadataSchema.optional(),
 }));

package/dist/endpoints/conversations/storage/dialects/greptime.js

@@ -29,10 +29,22 @@ export const GrepTimeDialectConfig = Object.assign({}, PostgresDialectConfig, Gr
     partitionClause: (cols) => {
         const col = cols[0];
         return (`PARTITION ON COLUMNS (${col}) (` +
-            `${col} < '4', ` +
-            `${col} >= '4' AND ${col} < '8', ` +
-            `${col} >= '8' AND ${col} < 'c', ` +
-            `${col} >= 'c')`);
+            `${col} < '1', ` +
+            `${col} >= 'f', ` +
+            `${col} >= '1' AND ${col} < '2', ` +
+            `${col} >= '2' AND ${col} < '3', ` +
+            `${col} >= '3' AND ${col} < '4', ` +
+            `${col} >= '4' AND ${col} < '5', ` +
+            `${col} >= '5' AND ${col} < '6', ` +
+            `${col} >= '6' AND ${col} < '7', ` +
+            `${col} >= '7' AND ${col} < '8', ` +
+            `${col} >= '8' AND ${col} < '9', ` +
+            `${col} >= '9' AND ${col} < 'a', ` +
+            `${col} >= 'a' AND ${col} < 'b', ` +
+            `${col} >= 'b' AND ${col} < 'c', ` +
+            `${col} >= 'c' AND ${col} < 'd', ` +
+            `${col} >= 'd' AND ${col} < 'e', ` +
+            `${col} >= 'e' AND ${col} < 'f')`);
     },
     types: GrepTimeBase.types,
 });
@@ -47,8 +59,10 @@ function dateToGreptimeString(v) {
 // coerces JavaScript types differently. There is no unified parameter format:
 //
 // 1. Timestamps:
-//    - `pg` requires a strictly formatted string (YYYY-MM-DD HH:mm:ss.SSS). It fails on BigInt.
-//    - `postgresjs` requires a BigInt (milliseconds). It parses strings into ISO formats which GreptimeDB rejects.
+//    - `pg` requires a strictly formatted string (YYYY-MM-DD HH:mm:ss.SSS).
+//      It fails on BigInt.
+//    - `postgresjs` requires a BigInt (milliseconds). It parses strings into ISO
+//       formats which GreptimeDB rejects.
 //    - `Bun.SQL` is flexible, but we use BigInt for consistency with postgresjs.
 //
 // 2. JSON:

package/dist/endpoints/conversations/storage/dialects/mysql.js

@@ -55,7 +55,9 @@ function createMysql2Executor(pool) {
                     const header = res;
                     return { changes: Number(header.affectedRows ?? 0) };
                 },
-                transaction: (f) => f(txExecutor),
+                transaction(txCallback) {
+                    return txCallback(txExecutor);
+                },
             };
             try {
                 const result = await fn(txExecutor);

package/dist/endpoints/conversations/storage/dialects/postgres.js

@@ -80,7 +80,9 @@ function createPgExecutor(pool, mapParams) {
                     const res = await client.query(getQuery(sql, p?.length > 0 ? p : undefined));
                     return { changes: Number(res.rowCount ?? 0) };
                 },
-                transaction: (f) => f(txExecutor),
+                transaction(txCallback) {
+                    return txCallback(txExecutor);
+                },
             };
             try {
                 const result = await fn(txExecutor);
@@ -141,8 +143,9 @@ function createBunPostgresExecutor(sql, mapParams) {
             const res = (await sql.unsafe(query, p?.length > 0 ? p : undefined));
             const result = res;
             let changes = result.affectedRows ?? result.count ?? 0;
-            // When Bun.SQL is used with GreptimeDB, mutation responses over the Postgres wire protocol
-            // don't populate `count` or `affectedRows`, but they do provide a command string like "OK 1"
+            // When Bun.SQL is used with GreptimeDB, mutation responses over the Postgres wire
+            // protocol don't populate `count` or `affectedRows`, but they do provide a command
+            // string like "OK 1"
             if (changes === 0 && result.command?.startsWith("OK ")) {
                 const parsed = parseInt(result.command.slice(3), 10);
                 if (!isNaN(parsed))

package/dist/endpoints/conversations/storage/dialects/sqlite.js

@@ -114,7 +114,9 @@ function createLibsqlExecutor(client) {
                     const rs = await tx.execute({ sql, args: mapParams(params) ?? [] });
                     return { changes: Number(rs.rowsAffected) };
                 },
-                transaction: (f) => f(txExecutor),
+                transaction(txCallback) {
+                    return txCallback(txExecutor);
+                },
             };
             try {
                 const result = await fn(txExecutor);

package/dist/endpoints/conversations/storage/sql.js

@@ -93,7 +93,8 @@ export class SqlStorage {
         const metadata = params.metadata ?? null;
         const now = new Date();
         return this.executor.transaction(async (tx) => {
-            await tx.run(`INSERT INTO ${q("conversations")} (${q("id")}, ${q("metadata")}, ${q("created_at")}) VALUES (${p(0)}, ${p(1)}, ${p(2)})`, [id, metadata, now]);
+            await tx.run(`INSERT INTO ${q("conversations")} (${q("id")}, ${q("metadata")}, ${q("created_at")}) ` +
+                `VALUES (${p(0)}, ${p(1)}, ${p(2)})`, [id, metadata, now]);
             const conversation = {
                 id,
                 created_at: now.getTime(),
@@ -158,10 +159,13 @@ export class SqlStorage {
         const { placeholder: p, quote: q, upsertSuffix } = this.config;
         return this.executor.transaction(async (tx) => {
             // Unified approach: Fetch original created_at to verify existence and preserve it.
-            // 1. Existence check: Ensure the conversation exists before updating (returning undefined if missing).
-            //    This prevents clients from accidentally creating "zombie" conversations with custom IDs.
-            // 2. Consistency: Standard SQL (Postgres/MySQL/SQLite) preserves the original creation timestamp.
-            // 3. Deduplication: GreptimeDB requires the EXACT same Time Index (created_at) to deduplicate the row.
+            // 1. Existence check: Ensure the conversation exists before updating (returning
+            //    undefined if missing). This prevents clients from accidentally creating
+            //    "zombie" conversations with custom IDs.
+            // 2. Consistency: Standard SQL (Postgres/MySQL/SQLite) preserves the original
+            //    creation timestamp.
+            // 3. Deduplication: GreptimeDB requires the EXACT same Time Index (created_at)
+            //    to deduplicate the row.
             const conversation = await this.getConversationInternal(id, tx);
             if (!conversation)
                 return;
@@ -169,7 +173,8 @@ export class SqlStorage {
             const pk = ["id"];
             const updateCols = ["metadata"];
             const suffix = upsertSuffix?.(q, pk, updateCols) ?? "";
-            await tx.run(`INSERT INTO ${q("conversations")} (${q("id")}, ${q("metadata")}, ${q("created_at")}) VALUES (${p(0)}, ${p(1)}, ${p(2)}) ${suffix}`, [id, metadata ?? null, new Date(createdAt)]);
+            await tx.run(`INSERT INTO ${q("conversations")} (${q("id")}, ${q("metadata")}, ${q("created_at")}) ` +
+                `VALUES (${p(0)}, ${p(1)}, ${p(2)}) ${suffix}`, [id, metadata ?? null, new Date(createdAt)]);
             return {
                 id,
                 created_at: createdAt,

package/dist/endpoints/embeddings/handler.js

@@ -16,6 +16,7 @@ export const embeddings = (config) => {
     const handler = async (ctx, cfg) => {
         const start = performance.now();
         ctx.operation = "embeddings";
+        setSpanAttributes({ "gen_ai.operation.name": ctx.operation });
         addSpanEvent("hebo.handler.started");
         // Guard: enforce HTTP method early.
         if (!ctx.request || ctx.request.method !== "POST") {
@@ -66,7 +67,6 @@ export const embeddings = (config) => {
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
         const { model: _model, ...inputs } = ctx.body;
-        // oxlint-disable-next-line no-unsafe-argument
         const embedOptions = convertToEmbedCallOptions(inputs);
         logger.trace({ requestId: ctx.requestId, options: embedOptions }, "[embeddings] AI SDK options");
         addSpanEvent("hebo.options.prepared");

package/dist/endpoints/responses/converters.d.ts

@@ -0,0 +1,17 @@
+import type { GenerateTextResult, StreamTextResult, ToolSet, ModelMessage, LanguageModelUsage, TextStreamPart } from "ai";
+import { Output } from "ai";
+import type { ResponsesInputItem, ResponsesInputs, Responses, ResponsesUsage, ResponsesStream, ResponsesStreamEvent, ResponsesToolChoice, ResponsesTool } from "./schema";
+import type { SseErrorFrame } from "../../utils/stream";
+import { type TextCallOptions, type ToolChoiceOptions } from "../shared/converters";
+export declare function convertToTextCallOptions(params: ResponsesInputs): TextCallOptions;
+export declare function convertToModelMessages(input: string | ResponsesInputItem[], instructions?: string): ModelMessage[];
+export declare const convertToToolSet: (tools: ResponsesTool[] | undefined) => ToolSet | undefined;
+export declare const convertToToolChoiceOptions: (toolChoice: ResponsesToolChoice | undefined) => ToolChoiceOptions;
+export declare function toResponses(result: GenerateTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null): Responses;
+export declare function toResponsesResponse(result: GenerateTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null, responseInit?: ResponseInit): Response;
+export declare function toResponsesStream(result: StreamTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null): ResponsesStream;
+export declare function toResponsesStreamResponse(result: StreamTextResult<ToolSet, Output.Output>, model: string, metadata?: Record<string, string> | null, responseInit?: ResponseInit): Response;
+export declare function toResponsesUsage(usage: LanguageModelUsage): ResponsesUsage;
+export declare class ResponsesTransformStream extends TransformStream<TextStreamPart<ToolSet>, ResponsesStreamEvent | SseErrorFrame> {
+    constructor(model: string, metadata?: Record<string, string> | null);
+}