@hebo-ai/gateway 0.9.2 → 0.9.4

package/dist/endpoints/conversations/schema.js

@@ -0,0 +1,74 @@
+import * as z from "zod";
+import { ResponsesMetadataSchema, ResponsesInputItemSchema } from "../responses/schema";
+/**
+ * --- Entities ---
+ */
+export const ConversationItemSchema = z
+    .object({
+    id: z.string(),
+    object: z.literal("conversation.item"),
+    created_at: z.number().int(),
+})
+    .loose()
+    .and(ResponsesInputItemSchema);
+export const ConversationSchema = z.object({
+    id: z.string(),
+    object: z.literal("conversation"),
+    created_at: z.number().int(),
+    metadata: ResponsesMetadataSchema,
+});
+export const ConversationDeletedSchema = z.object({
+    id: z.string(),
+    deleted: z.boolean(),
+    object: z.literal("conversation.deleted"),
+});
+/**
+ * --- API ---
+ */
+export const ConversationCreateParamsSchema = z.object({
+    items: z.array(ResponsesInputItemSchema).max(1000).optional(),
+    metadata: ResponsesMetadataSchema.optional(),
+});
+export const ConversationUpdateBodySchema = z.object({
+    metadata: ResponsesMetadataSchema,
+});
+export const ConversationItemsAddBodySchema = z.object({
+    items: z.array(ResponsesInputItemSchema).max(1000),
+});
+export const ConversationItemListSchema = z.object({
+    object: z.literal("list"),
+    data: z.array(ConversationItemSchema),
+    has_more: z.boolean(),
+    first_id: z.string().optional(),
+    last_id: z.string().optional(),
+});
+export const ConversationListSchema = z.object({
+    object: z.literal("list"),
+    data: z.array(ConversationSchema),
+    has_more: z.boolean(),
+    first_id: z.string().optional(),
+    last_id: z.string().optional(),
+});
+export const ConversationItemListParamsSchema = z.object({
+    after: z.string().optional(),
+    limit: z.coerce.number().int().min(0).max(1000).default(20),
+    order: z.enum(["asc", "desc"]).default("desc"),
+});
+export const ConversationListParamsSchema = z.preprocess((input) => {
+    if (typeof input !== "object" || input === null)
+        return input;
+    const metadata = {};
+    const rest = { ...input };
+    for (const [key, value] of Object.entries(input)) {
+        if (key.startsWith("metadata.")) {
+            metadata[key.slice(9)] = String(value);
+            delete rest[key];
+        }
+    }
+    if (Object.keys(metadata).length > 0) {
+        rest["metadata"] = metadata;
+    }
+    return rest;
+}, ConversationItemListParamsSchema.extend({
+    metadata: ResponsesMetadataSchema.optional(),
+}));

package/dist/endpoints/conversations/storage/dialects/greptime.d.ts

@@ -0,0 +1,10 @@
+import { type PgPool, type PostgresJsSql } from "./postgres";
+import { type BunSql, type DialectConfig, type QueryExecutor, type SqlDialect } from "./types";
+export declare const GrepTimeDialectConfig: DialectConfig;
+export declare class GrepTimeDialect implements SqlDialect {
+    readonly executor: QueryExecutor;
+    readonly config: DialectConfig;
+    constructor(options: {
+        client: PgPool | PostgresJsSql | BunSql;
+    });
+}

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

@@ -0,0 +1,87 @@
+import { PostgresDialect, PostgresDialectConfig, isBunSql, isPgPool, } from "./postgres";
+import {} from "./types";
+import { createParamsMapper, dateToBigInt, escapeSqlString, jsonStringify } from "./utils";
+const GrepTimeBase = {
+    types: {
+        varchar: "VARCHAR",
+        json: "JSON",
+        timestamp: "TIMESTAMP",
+        index: "TIME",
+    },
+};
+export const GrepTimeDialectConfig = Object.assign({}, PostgresDialectConfig, GrepTimeBase, {
+    /**
+     * GreptimeDB has a bug where it can return invalid JSON strings
+     * containing Rust-style Unicode escapes like \u{xxxx} instead of standard JSON escapes \uxxxx.
+     * https://github.com/GreptimeTeam/greptimedb/issues/7808
+     *
+     * To prevent the Postgres drivers (postgresjs, pg, bun:sql) from crashing when they attempt
+     * to auto-parse this invalid JSON, we cast the JSON column to a raw STRING on the wire.
+     *
+     * Our storage layer then manually normalizes these Rust escapes before calling JSON.parse().
+     * See: src/endpoints/conversations/storage/dialects/utils.ts -> normalizeJsonUnicodeEscapes
+     */
+    selectJson: (c) => `${c}::STRING`,
+    jsonExtract: (c, k) => `json_get_string(${c}, '${escapeSqlString(k)}')`,
+    upsertSuffix: undefined,
+    supportCreateIndexIfNotExists: true,
+    limitAsLiteral: true,
+    partitionClause: (cols) => {
+        const col = cols[0];
+        return (`PARTITION ON COLUMNS (${col}) (` +
+            `${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,
+});
+const pad = (n, l = 2) => n.toString().padStart(l, "0");
+function dateToGreptimeString(v) {
+    if (v instanceof Date) {
+        return `${v.getUTCFullYear()}-${pad(v.getUTCMonth() + 1)}-${pad(v.getUTCDate())} ${pad(v.getUTCHours())}:${pad(v.getUTCMinutes())}:${pad(v.getUTCSeconds())}.${pad(v.getUTCMilliseconds(), 3)}`;
+    }
+    return v;
+}
+// GreptimeDB is strictly typed over the Postgres wire protocol, and each driver
+// 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.
+//    - `Bun.SQL` is flexible, but we use BigInt for consistency with postgresjs.
+//
+// 2. JSON:
+//    - GreptimeDB rejects plain strings for JSON, expecting a bytea-compatible format.
+//    - `pg` and `Bun.SQL` require the JSON string to be wrapped in a Uint8Array (binary).
+//    - `postgresjs` works with plain JSON strings.
+const mapParams = createParamsMapper([dateToBigInt, (v) => jsonStringify(v)]);
+const mapParamsBun = createParamsMapper([dateToBigInt, (v) => jsonStringify(v, true)]);
+const mapParamsPg = createParamsMapper([dateToGreptimeString, (v) => jsonStringify(v, true)]);
+export class GrepTimeDialect {
+    executor;
+    config = GrepTimeDialectConfig;
+    constructor(options) {
+        const { client } = options;
+        const dialect = new PostgresDialect({
+            client,
+            config: this.config,
+            mapParams: isPgPool(client) ? mapParamsPg : isBunSql(client) ? mapParamsBun : mapParams,
+        });
+        this.executor = dialect.executor;
+    }
+}

package/dist/endpoints/conversations/storage/dialects/mysql.d.ts

@@ -0,0 +1,12 @@
+import type { Pool as Mysql2Pool } from "mysql2/promise";
+import type { BunSql, DialectConfig, QueryExecutor, SqlDialect } from "./types";
+export type { Mysql2Pool };
+export declare const MySQLDialectConfig: DialectConfig;
+export declare class MysqlDialect implements SqlDialect {
+    readonly executor: QueryExecutor;
+    readonly config: DialectConfig;
+    constructor(options: {
+        client: Mysql2Pool | BunSql;
+        config?: DialectConfig;
+    });
+}

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

@@ -0,0 +1,118 @@
+import { createParamsMapper, dateToNumber, escapeSqlString, jsonStringify } from "./utils";
+const mapParams = createParamsMapper([dateToNumber, jsonStringify]);
+export const MySQLDialectConfig = {
+    placeholder: (_i) => "?",
+    quote: (i) => `\`${i}\``,
+    selectJson: (c) => c,
+    jsonExtract: (c, k) => `JSON_EXTRACT(${c}, '$.${escapeSqlString(k)}')`,
+    upsertSuffix: (q, _pk, cols) => `ON DUPLICATE KEY UPDATE ${cols.map((c) => `${q(c)} = VALUES(${q(c)})`).join(", ")}`,
+    limitAsLiteral: true,
+    supportCreateIndexIfNotExists: false,
+    types: {
+        varchar: "VARCHAR",
+        json: "JSON",
+        timestamp: "BIGINT",
+        index: "B-TREE",
+    },
+};
+function isMysql2(client) {
+    const c = client;
+    return !!client && typeof c["execute"] === "function" && typeof c["getConnection"] === "function";
+}
+function isBunSql(client) {
+    const c = client;
+    return !!client && typeof c["unsafe"] === "function" && typeof c["transaction"] === "function";
+}
+function createMysql2Executor(pool) {
+    const executor = {
+        async all(sql, params) {
+            const [rows] = await pool.execute(sql, mapParams(params));
+            return rows;
+        },
+        async get(sql, params) {
+            const [rows] = await pool.execute(sql, mapParams(params));
+            return rows?.[0];
+        },
+        async run(sql, params) {
+            const [res] = await pool.execute(sql, mapParams(params));
+            const header = res;
+            return { changes: header.affectedRows ?? 0 };
+        },
+        async transaction(fn) {
+            const conn = await pool.getConnection();
+            await conn.beginTransaction();
+            const txExecutor = {
+                async all(sql, params) {
+                    const [rows] = await conn.execute(sql, mapParams(params));
+                    return rows;
+                },
+                async get(sql, params) {
+                    const [rows] = await conn.execute(sql, mapParams(params));
+                    return rows?.[0];
+                },
+                async run(sql, params) {
+                    const [res] = await conn.execute(sql, mapParams(params));
+                    const header = res;
+                    return { changes: header.affectedRows ?? 0 };
+                },
+                transaction(txCallback) {
+                    return txCallback(txExecutor);
+                },
+            };
+            try {
+                const result = await fn(txExecutor);
+                await conn.commit();
+                return result;
+            }
+            catch (err) {
+                await conn.rollback();
+                throw err;
+            }
+            finally {
+                conn.release();
+            }
+        },
+    };
+    return executor;
+}
+function createBunMysqlExecutor(sql) {
+    const executor = {
+        all(query, params) {
+            return sql.unsafe(query, mapParams(params));
+        },
+        async get(query, params) {
+            const rows = await sql.unsafe(query, mapParams(params));
+            return rows?.[0];
+        },
+        async run(query, params) {
+            const res = (await sql.unsafe(query, mapParams(params)));
+            const result = res;
+            return { changes: result.affectedRows ?? result.count ?? 0 };
+        },
+        transaction(fn) {
+            return sql.transaction((tx) => {
+                const txExecutor = createBunMysqlExecutor(tx);
+                txExecutor.transaction = (f) => f(txExecutor);
+                return fn(txExecutor);
+            });
+        },
+    };
+    return executor;
+}
+export class MysqlDialect {
+    executor;
+    config;
+    constructor(options) {
+        const { client, config = MySQLDialectConfig } = options;
+        this.config = config;
+        if (isMysql2(client)) {
+            this.executor = createMysql2Executor(client);
+        }
+        else if (isBunSql(client)) {
+            this.executor = createBunMysqlExecutor(client);
+        }
+        else {
+            throw new Error("Unsupported MySQL client");
+        }
+    }
+}

package/dist/endpoints/conversations/storage/dialects/postgres.d.ts

@@ -0,0 +1,16 @@
+import type { Pool as PgPool } from "pg";
+import type { Sql as PostgresJsSql } from "postgres";
+import { type BunSql, type DialectConfig, type QueryExecutor, type SqlDialect } from "./types";
+export type { PostgresJsSql, PgPool };
+export declare const PostgresDialectConfig: DialectConfig;
+export declare function isPgPool(client: unknown): client is PgPool;
+export declare function isBunSql(client: unknown): client is BunSql;
+export declare class PostgresDialect implements SqlDialect {
+    readonly executor: QueryExecutor;
+    readonly config: DialectConfig;
+    constructor(options: {
+        client: PgPool | PostgresJsSql | BunSql;
+        config?: DialectConfig;
+        mapParams?: (params?: unknown[]) => (string | number | bigint | boolean | null)[];
+    });
+}

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

@@ -0,0 +1,185 @@
+import { LRUCache } from "lru-cache";
+import {} from "./types";
+import { createParamsMapper, dateToNumber, escapeSqlString } from "./utils";
+const defaultMapParams = createParamsMapper([dateToNumber]);
+export const PostgresDialectConfig = {
+    placeholder: (i) => `$${i + 1}`,
+    quote: (i) => `"${i}"`,
+    selectJson: (c) => c,
+    jsonExtract: (c, k) => `${c}->>'${escapeSqlString(k)}'`,
+    upsertSuffix: (q, pk, cols) => `ON CONFLICT (${pk.map((c) => q(c)).join(", ")}) DO UPDATE SET ${cols
+        .map((c) => `${q(c)} = EXCLUDED.${q(c)}`)
+        .join(", ")}`,
+    supportCreateIndexIfNotExists: true,
+    types: {
+        varchar: "VARCHAR",
+        json: "JSONB",
+        timestamp: "BIGINT",
+        index: "BRIN",
+    },
+};
+const MAX_CACHE_SIZE = 100;
+export function isPgPool(client) {
+    const c = client;
+    return !!client && typeof c["query"] === "function" && typeof c["connect"] === "function";
+}
+function isPostgresJs(client) {
+    const c = client;
+    return (!!client &&
+        typeof c["unsafe"] === "function" &&
+        typeof c["begin"] === "function" &&
+        !("transaction" in c));
+}
+export function isBunSql(client) {
+    const c = client;
+    return !!client && typeof c["unsafe"] === "function" && typeof c["transaction"] === "function";
+}
+function createPgExecutor(pool, mapParams) {
+    const cache = new LRUCache({ max: MAX_CACHE_SIZE });
+    let count = 0;
+    const getQuery = (sql, values) => {
+        let name = cache.get(sql);
+        if (!name) {
+            name = `q_${count++}`;
+            cache.set(sql, name);
+        }
+        return { name, text: sql, values };
+    };
+    const executor = {
+        async all(sql, params) {
+            const p = mapParams(params);
+            const res = await pool.query(getQuery(sql, p?.length > 0 ? p : undefined));
+            return res.rows;
+        },
+        async get(sql, params) {
+            const p = mapParams(params);
+            const res = await pool.query(getQuery(sql, p?.length > 0 ? p : undefined));
+            return res.rows?.[0];
+        },
+        async run(sql, params) {
+            const p = mapParams(params);
+            const res = await pool.query(getQuery(sql, p?.length > 0 ? p : undefined));
+            return { changes: res.rowCount ?? 0 };
+        },
+        async transaction(fn) {
+            const client = await pool.connect();
+            await client.query("BEGIN");
+            const txExecutor = {
+                async all(sql, params) {
+                    const p = mapParams(params);
+                    const res = await client.query(getQuery(sql, p?.length > 0 ? p : undefined));
+                    return res.rows;
+                },
+                async get(sql, params) {
+                    const p = mapParams(params);
+                    const res = await client.query(getQuery(sql, p?.length > 0 ? p : undefined));
+                    return res.rows?.[0];
+                },
+                async run(sql, params) {
+                    const p = mapParams(params);
+                    const res = await client.query(getQuery(sql, p?.length > 0 ? p : undefined));
+                    return { changes: res.rowCount ?? 0 };
+                },
+                transaction(txCallback) {
+                    return txCallback(txExecutor);
+                },
+            };
+            try {
+                const result = await fn(txExecutor);
+                await client.query("COMMIT");
+                return result;
+            }
+            catch (err) {
+                await client.query("ROLLBACK");
+                throw err;
+            }
+            finally {
+                client.release();
+            }
+        },
+    };
+    return executor;
+}
+function createPostgresJsExecutor(sql, mapParams) {
+    const executor = {
+        async all(query, params) {
+            const p = mapParams(params);
+            return (await sql.unsafe(query, (p?.length > 0 ? p : undefined), { prepare: true }));
+        },
+        async get(query, params) {
+            const p = mapParams(params);
+            const rows = await sql.unsafe(query, (p?.length > 0 ? p : undefined), { prepare: true });
+            return rows?.[0];
+        },
+        async run(query, params) {
+            const p = mapParams(params);
+            const res = await sql.unsafe(query, (p?.length > 0 ? p : undefined), { prepare: true });
+            const result = res;
+            return { changes: result.count ?? 0 };
+        },
+        async transaction(fn) {
+            return (await sql.begin((tx) => {
+                const txExecutor = createPostgresJsExecutor(tx, mapParams);
+                txExecutor.transaction = (f) => f(txExecutor);
+                return fn(txExecutor);
+            }));
+        },
+    };
+    return executor;
+}
+function createBunPostgresExecutor(sql, mapParams) {
+    const executor = {
+        all(query, params) {
+            const p = mapParams(params);
+            return sql.unsafe(query, p?.length > 0 ? p : undefined);
+        },
+        async get(query, params) {
+            const p = mapParams(params);
+            const rows = await sql.unsafe(query, p?.length > 0 ? p : undefined);
+            return rows?.[0];
+        },
+        async run(query, params) {
+            const p = mapParams(params);
+            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"
+            if (changes === 0 && result.command?.startsWith("OK ")) {
+                const parsed = parseInt(result.command.slice(3), 10);
+                if (!isNaN(parsed))
+                    changes = parsed;
+            }
+            return { changes };
+        },
+        transaction(fn) {
+            return sql.transaction((tx) => {
+                const txExecutor = createBunPostgresExecutor(tx, mapParams);
+                txExecutor.transaction = (f) => f(txExecutor);
+                return fn(txExecutor);
+            });
+        },
+    };
+    return executor;
+}
+export class PostgresDialect {
+    executor;
+    config;
+    constructor(options) {
+        const { client, config = PostgresDialectConfig, mapParams = defaultMapParams } = options;
+        this.config = config;
+        if (isPgPool(client)) {
+            this.executor = createPgExecutor(client, mapParams);
+        }
+        else if (isBunSql(client)) {
+            this.executor = createBunPostgresExecutor(client, mapParams);
+        }
+        else if (isPostgresJs(client)) {
+            this.executor = createPostgresJsExecutor(client, mapParams);
+        }
+        else {
+            throw new Error("Unsupported Postgres client");
+        }
+    }
+}

package/dist/endpoints/conversations/storage/dialects/sqlite.d.ts

@@ -0,0 +1,11 @@
+import type { Client as LibsqlClient } from "@libsql/client";
+import type { Database as BetterSqlite3Database } from "better-sqlite3";
+import type { BunSql, DialectConfig, QueryExecutor, SqlDialect } from "./types";
+export declare const SQLiteDialectConfig: DialectConfig;
+export declare class SqliteDialect implements SqlDialect {
+    readonly executor: QueryExecutor;
+    readonly config: DialectConfig;
+    constructor(options: {
+        client: BetterSqlite3Database | LibsqlClient | BunSql;
+    });
+}