@meistrari/chat-nuxt 1.13.0 → 2.0.0

package/dist/runtime/server/api/workspace/usage.get.js

@@ -1,187 +0,0 @@
-import { defineEventHandler, getQuery } from "h3";
-import { and, eq, gte, lte, sql, desc } from "drizzle-orm";
-import { useDb, schema } from "#chat-runtime/server/db";
-import { requireUser } from "#chat-runtime/server/utils/auth";
-import { getWorkspaceBilling, transformCostForBilling } from "#chat-runtime/server/utils/billing";
-export default defineEventHandler(async (event) => {
-  const session = requireUser(event);
-  const db = useDb();
-  const query = getQuery(event);
-  const startDate = query.startDate ? new Date(query.startDate) : void 0;
-  const endDate = query.endDate ? new Date(query.endDate) : void 0;
-  const groupBy = query.groupBy;
-  const cursor = query.cursor;
-  const limit = Math.min(Number(query.limit) || 100, 250);
-  const conditions = [eq(schema.conversationUsage.workspaceId, session.workspace.id)];
-  if (startDate && !Number.isNaN(startDate.getTime())) {
-    conditions.push(gte(schema.conversationUsage.createdAt, startDate));
-  }
-  if (endDate && !Number.isNaN(endDate.getTime())) {
-    conditions.push(lte(schema.conversationUsage.createdAt, endDate));
-  }
-  if (cursor) {
-    const [cursorDate, cursorId] = cursor.split("_");
-    const parsedDate = new Date(cursorDate);
-    if (!Number.isNaN(parsedDate.getTime()) && cursorId) {
-      conditions.push(
-        sql`(${schema.conversationUsage.createdAt}, ${schema.conversationUsage.id}) < (${parsedDate}, ${cursorId})`
-      );
-    }
-  }
-  const [totals] = await db.select({
-    totalTokens: sql`COALESCE(SUM(${schema.conversationUsage.totalTokens}), 0)::int`,
-    promptTokens: sql`COALESCE(SUM(${schema.conversationUsage.promptTokens}), 0)::int`,
-    completionTokens: sql`COALESCE(SUM(${schema.conversationUsage.completionTokens}), 0)::int`,
-    totalCost: sql`COALESCE(SUM(${schema.conversationUsage.totalCost}::numeric), 0)::float`,
-    promptCost: sql`COALESCE(SUM(${schema.conversationUsage.promptCost}::numeric), 0)::float`,
-    completionCost: sql`COALESCE(SUM(${schema.conversationUsage.completionCost}::numeric), 0)::float`
-  }).from(schema.conversationUsage).where(and(...conditions));
-  const records = await db.select({
-    id: schema.conversationUsage.id,
-    conversationId: schema.conversationUsage.conversationId,
-    promptTokens: schema.conversationUsage.promptTokens,
-    completionTokens: schema.conversationUsage.completionTokens,
-    totalTokens: schema.conversationUsage.totalTokens,
-    promptCost: schema.conversationUsage.promptCost,
-    completionCost: schema.conversationUsage.completionCost,
-    totalCost: schema.conversationUsage.totalCost,
-    durationMs: schema.conversationUsage.durationMs,
-    turns: schema.conversationUsage.turns,
-    userId: schema.conversationUsage.userId,
-    userEmail: schema.conversationUsage.userEmail,
-    model: schema.conversationUsage.model,
-    createdAt: schema.conversationUsage.createdAt
-  }).from(schema.conversationUsage).where(and(...conditions)).orderBy(desc(schema.conversationUsage.createdAt)).limit(limit + 1);
-  const hasMore = records.length > limit;
-  const paginatedRecords = records.slice(0, limit);
-  const billing = await getWorkspaceBilling(event);
-  const formattedRecords = paginatedRecords.map((r) => {
-    const transformedCosts = transformCostForBilling({
-      promptCost: Number(r.promptCost),
-      completionCost: Number(r.completionCost),
-      totalCost: Number(r.totalCost),
-      promptTokens: r.promptTokens,
-      completionTokens: r.completionTokens
-    }, billing);
-    return {
-      ...r,
-      ...transformedCosts
-    };
-  });
-  const totalsCosts = transformCostForBilling({
-    promptCost: totals?.promptCost ?? 0,
-    completionCost: totals?.completionCost ?? 0,
-    totalCost: totals?.totalCost ?? 0,
-    promptTokens: totals?.promptTokens ?? 0,
-    completionTokens: totals?.completionTokens ?? 0
-  }, billing);
-  const response = {
-    usage: {
-      totalTokens: totals?.totalTokens ?? 0,
-      totalCost: totalsCosts.totalCost,
-      breakdown: {
-        promptTokens: totals?.promptTokens ?? 0,
-        completionTokens: totals?.completionTokens ?? 0,
-        promptCost: totalsCosts.promptCost,
-        completionCost: totalsCosts.completionCost
-      }
-    },
-    records: formattedRecords,
-    hasMore,
-    billing
-  };
-  if (hasMore && paginatedRecords.length > 0) {
-    const lastRecord = paginatedRecords[paginatedRecords.length - 1];
-    response.cursor = `${lastRecord?.createdAt.toISOString()}_${lastRecord?.id}`;
-  }
-  if (groupBy) {
-    let groupedQuery;
-    switch (groupBy) {
-      case "day":
-        groupedQuery = db.select({
-          key: sql`DATE_TRUNC('day', ${schema.conversationUsage.createdAt})::text`,
-          totalTokens: sql`COALESCE(SUM(${schema.conversationUsage.totalTokens}), 0)::int`,
-          promptTokens: sql`COALESCE(SUM(${schema.conversationUsage.promptTokens}), 0)::int`,
-          completionTokens: sql`COALESCE(SUM(${schema.conversationUsage.completionTokens}), 0)::int`,
-          totalCost: sql`COALESCE(SUM(${schema.conversationUsage.totalCost}::numeric), 0)::float`,
-          promptCost: sql`COALESCE(SUM(${schema.conversationUsage.promptCost}::numeric), 0)::float`,
-          completionCost: sql`COALESCE(SUM(${schema.conversationUsage.completionCost}::numeric), 0)::float`,
-          count: sql`COUNT(*)::int`
-        }).from(schema.conversationUsage).where(and(...conditions)).groupBy(sql`DATE_TRUNC('day', ${schema.conversationUsage.createdAt})`).orderBy(sql`DATE_TRUNC('day', ${schema.conversationUsage.createdAt}) DESC`);
-        break;
-      case "week":
-        groupedQuery = db.select({
-          key: sql`DATE_TRUNC('week', ${schema.conversationUsage.createdAt})::text`,
-          totalTokens: sql`COALESCE(SUM(${schema.conversationUsage.totalTokens}), 0)::int`,
-          promptTokens: sql`COALESCE(SUM(${schema.conversationUsage.promptTokens}), 0)::int`,
-          completionTokens: sql`COALESCE(SUM(${schema.conversationUsage.completionTokens}), 0)::int`,
-          totalCost: sql`COALESCE(SUM(${schema.conversationUsage.totalCost}::numeric), 0)::float`,
-          promptCost: sql`COALESCE(SUM(${schema.conversationUsage.promptCost}::numeric), 0)::float`,
-          completionCost: sql`COALESCE(SUM(${schema.conversationUsage.completionCost}::numeric), 0)::float`,
-          count: sql`COUNT(*)::int`
-        }).from(schema.conversationUsage).where(and(...conditions)).groupBy(sql`DATE_TRUNC('week', ${schema.conversationUsage.createdAt})`).orderBy(sql`DATE_TRUNC('week', ${schema.conversationUsage.createdAt}) DESC`);
-        break;
-      case "month":
-        groupedQuery = db.select({
-          key: sql`DATE_TRUNC('month', ${schema.conversationUsage.createdAt})::text`,
-          totalTokens: sql`COALESCE(SUM(${schema.conversationUsage.totalTokens}), 0)::int`,
-          promptTokens: sql`COALESCE(SUM(${schema.conversationUsage.promptTokens}), 0)::int`,
-          completionTokens: sql`COALESCE(SUM(${schema.conversationUsage.completionTokens}), 0)::int`,
-          totalCost: sql`COALESCE(SUM(${schema.conversationUsage.totalCost}::numeric), 0)::float`,
-          promptCost: sql`COALESCE(SUM(${schema.conversationUsage.promptCost}::numeric), 0)::float`,
-          completionCost: sql`COALESCE(SUM(${schema.conversationUsage.completionCost}::numeric), 0)::float`,
-          count: sql`COUNT(*)::int`
-        }).from(schema.conversationUsage).where(and(...conditions)).groupBy(sql`DATE_TRUNC('month', ${schema.conversationUsage.createdAt})`).orderBy(sql`DATE_TRUNC('month', ${schema.conversationUsage.createdAt}) DESC`);
-        break;
-      case "user":
-        groupedQuery = db.select({
-          key: schema.conversationUsage.userId,
-          label: schema.conversationUsage.userEmail,
-          totalTokens: sql`COALESCE(SUM(${schema.conversationUsage.totalTokens}), 0)::int`,
-          promptTokens: sql`COALESCE(SUM(${schema.conversationUsage.promptTokens}), 0)::int`,
-          completionTokens: sql`COALESCE(SUM(${schema.conversationUsage.completionTokens}), 0)::int`,
-          totalCost: sql`COALESCE(SUM(${schema.conversationUsage.totalCost}::numeric), 0)::float`,
-          promptCost: sql`COALESCE(SUM(${schema.conversationUsage.promptCost}::numeric), 0)::float`,
-          completionCost: sql`COALESCE(SUM(${schema.conversationUsage.completionCost}::numeric), 0)::float`,
-          count: sql`COUNT(*)::int`
-        }).from(schema.conversationUsage).where(and(...conditions)).groupBy(schema.conversationUsage.userId, schema.conversationUsage.userEmail).orderBy(sql`SUM(${schema.conversationUsage.totalCost}::numeric) DESC`);
-        break;
-      case "conversation":
-        groupedQuery = db.select({
-          key: schema.conversationUsage.conversationId,
-          totalTokens: sql`COALESCE(SUM(${schema.conversationUsage.totalTokens}), 0)::int`,
-          promptTokens: sql`COALESCE(SUM(${schema.conversationUsage.promptTokens}), 0)::int`,
-          completionTokens: sql`COALESCE(SUM(${schema.conversationUsage.completionTokens}), 0)::int`,
-          totalCost: sql`COALESCE(SUM(${schema.conversationUsage.totalCost}::numeric), 0)::float`,
-          promptCost: sql`COALESCE(SUM(${schema.conversationUsage.promptCost}::numeric), 0)::float`,
-          completionCost: sql`COALESCE(SUM(${schema.conversationUsage.completionCost}::numeric), 0)::float`,
-          count: sql`COUNT(*)::int`
-        }).from(schema.conversationUsage).where(and(...conditions)).groupBy(schema.conversationUsage.conversationId).orderBy(sql`SUM(${schema.conversationUsage.totalCost}::numeric) DESC`);
-        break;
-    }
-    if (groupedQuery) {
-      const groupedResults = await groupedQuery;
-      response.grouped = groupedResults.map((r) => {
-        const transformedCosts = transformCostForBilling({
-          promptCost: r.promptCost,
-          completionCost: r.completionCost,
-          totalCost: r.totalCost,
-          promptTokens: r.promptTokens,
-          completionTokens: r.completionTokens
-        }, billing);
-        return {
-          key: r.key,
-          label: "label" in r ? r.label ?? r.key : r.key,
-          totalTokens: r.totalTokens,
-          promptTokens: r.promptTokens,
-          completionTokens: r.completionTokens,
-          totalCost: transformedCosts.totalCost,
-          promptCost: transformedCosts.promptCost,
-          completionCost: transformedCosts.completionCost,
-          count: r.count
-        };
-      });
-    }
-  }
-  return response;
-});

package/dist/runtime/server/db/index.d.ts

@@ -1,23 +0,0 @@
-import { drizzle as drizzlePostgres } from 'drizzle-orm/postgres-js';
-import type { PgliteDatabase } from 'drizzle-orm/pglite';
-import * as schema from './schema.js';
-export type { ContextFile, ExternalSkill } from './schema.js';
-type PostgresDb = ReturnType<typeof drizzlePostgres<typeof schema>>;
-type PgliteDb = PgliteDatabase<typeof schema>;
-type AnyDb = PostgresDb | PgliteDb;
-export declare function isPgliteUrl(url: string): boolean;
-/**
- * Eagerly initializes the database during Nitro startup. Idempotent. Both
- * Postgres and pglite paths now run migrations on boot, so the chat-nuxt
- * tables in the `chat` Postgres schema are guaranteed to exist before the
- * first request hits a route that calls useDb().
- */
-export declare function initDb(): Promise<AnyDb>;
-/**
- * Returns the initialized database instance. initDb() must have already run
- * via the boot plugin so migrations have been applied — bare useDb() now
- * throws if called before init, regardless of driver, instead of silently
- * skipping migrations on the Postgres path.
- */
-export declare function useDb(): AnyDb;
-export { schema };

package/dist/runtime/server/db/index.js

@@ -1,159 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-import { useRuntimeConfig } from "nitropack/runtime";
-import { sql } from "drizzle-orm";
-import postgres from "postgres";
-import { drizzle as drizzlePostgres } from "drizzle-orm/postgres-js";
-import { migrate as migratePostgres } from "drizzle-orm/postgres-js/migrator";
-import * as schema from "./schema/index.js";
-import { CHAT_SCHEMA_NAME } from "./schema/_schema.js";
-import { logger } from "../utils/logger.js";
-let dbInstance = null;
-let dbInitPromise = null;
-const LEGACY_MIGRATIONS_SCHEMA = "drizzle";
-const MIGRATIONS_TABLE = "__drizzle_migrations";
-const MIGRATIONS_LEDGER_LOCK_KEY = 581073927;
-export function isPgliteUrl(url) {
-  return url.startsWith("pglite:") || url.startsWith("file:");
-}
-function resolvePgliteDataDir(url) {
-  if (url.startsWith("pglite:")) {
-    return url.slice("pglite:".length);
-  }
-  if (url.startsWith("file://")) {
-    return url.slice("file://".length);
-  }
-  if (url.startsWith("file:")) {
-    return url.slice("file:".length);
-  }
-  return url;
-}
-const IGNORED_NOTICE_CODES = /* @__PURE__ */ new Set(["42P06", "42P07"]);
-function getRows(result) {
-  if (Array.isArray(result)) {
-    return result;
-  }
-  if (result && typeof result === "object" && "rows" in result && Array.isArray(result.rows)) {
-    return result.rows;
-  }
-  return [];
-}
-async function tableExists(db, schemaName, tableName) {
-  const result = await db.execute(sql`
-        select exists (
-            select 1
-            from information_schema.tables
-            where table_schema = ${schemaName}
-                and table_name = ${tableName}
-        ) as "exists"
-    `);
-  const [row] = getRows(result);
-  return row?.exists ?? false;
-}
-async function tableHasRows(db, schemaName, tableName) {
-  const result = await db.execute(sql`
-        select exists (
-            select 1
-            from ${sql.identifier(schemaName)}.${sql.identifier(tableName)}
-        ) as "exists"
-    `);
-  const [row] = getRows(result);
-  return row?.exists ?? false;
-}
-async function seedChatMigrationsLedger(db) {
-  await db.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(CHAT_SCHEMA_NAME)}`);
-  await db.execute(sql`
-        CREATE TABLE IF NOT EXISTS ${sql.identifier(CHAT_SCHEMA_NAME)}.${sql.identifier(MIGRATIONS_TABLE)} (
-            id SERIAL PRIMARY KEY,
-            hash text NOT NULL,
-            created_at bigint
-        )
-    `);
-  if (await tableHasRows(db, CHAT_SCHEMA_NAME, MIGRATIONS_TABLE)) {
-    return;
-  }
-  if (!await tableExists(db, LEGACY_MIGRATIONS_SCHEMA, MIGRATIONS_TABLE)) {
-    return;
-  }
-  await db.execute(sql`
-        INSERT INTO ${sql.identifier(CHAT_SCHEMA_NAME)}.${sql.identifier(MIGRATIONS_TABLE)} ("hash", "created_at")
-        SELECT "hash", "created_at"
-        FROM ${sql.identifier(LEGACY_MIGRATIONS_SCHEMA)}.${sql.identifier(MIGRATIONS_TABLE)}
-        ORDER BY "created_at"
-    `);
-}
-async function initPostgresAsync(databaseUrl, migrationsDir) {
-  const client = postgres(databaseUrl, {
-    max: 10,
-    onnotice: (notice) => {
-      if (notice.code && IGNORED_NOTICE_CODES.has(notice.code))
-        return;
-      logger.info({ notice }, "Postgres notice");
-    }
-  });
-  const db = drizzlePostgres(client, { schema });
-  if (migrationsDir) {
-    await db.transaction(async (tx) => {
-      await tx.execute(sql`SELECT pg_advisory_xact_lock(${MIGRATIONS_LEDGER_LOCK_KEY})`);
-      await seedChatMigrationsLedger(tx);
-    });
-    await migratePostgres(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
-    logger.info({ migrationsSchema: CHAT_SCHEMA_NAME }, "Postgres connection pool initialized and migrations applied");
-  } else {
-    logger.warn("Postgres connection pool initialized without migrations directory \u2014 schema may be out of date");
-  }
-  return db;
-}
-async function initPgliteAsync(databaseUrl, migrationsDir) {
-  const dataDir = resolvePgliteDataDir(databaseUrl);
-  await mkdir(dirname(dataDir), { recursive: true });
-  const [{ PGlite }, { drizzle }, { migrate }] = await Promise.all([
-    import("@electric-sql/pglite"),
-    import("drizzle-orm/pglite"),
-    import("drizzle-orm/pglite/migrator")
-  ]);
-  const client = new PGlite(dataDir);
-  const db = drizzle(client, { schema });
-  if (migrationsDir) {
-    await seedChatMigrationsLedger(db);
-    await migrate(db, { migrationsFolder: migrationsDir, migrationsSchema: CHAT_SCHEMA_NAME });
-    logger.info({ dataDir, migrationsSchema: CHAT_SCHEMA_NAME }, "pglite database initialized and migrated");
-  } else {
-    logger.warn({ dataDir }, "pglite database initialized without migrations directory \u2014 schema may be empty");
-  }
-  return db;
-}
-export async function initDb() {
-  if (dbInstance) {
-    return dbInstance;
-  }
-  if (dbInitPromise) {
-    return dbInitPromise;
-  }
-  dbInitPromise = (async () => {
-    const config = useRuntimeConfig();
-    const databaseUrl = config.databaseUrl;
-    const migrationsDir = config.chatNuxt?.migrationsDir ?? "";
-    if (!databaseUrl) {
-      throw new Error("DATABASE_URL is not configured and no pglite fallback path was set");
-    }
-    const db = isPgliteUrl(databaseUrl) ? await initPgliteAsync(databaseUrl, migrationsDir) : await initPostgresAsync(databaseUrl, migrationsDir);
-    dbInstance = db;
-    return db;
-  })();
-  try {
-    return await dbInitPromise;
-  } catch (error) {
-    dbInitPromise = null;
-    throw error;
-  }
-}
-export function useDb() {
-  if (dbInstance) {
-    return dbInstance;
-  }
-  throw new Error(
-    "chat-nuxt database is not initialized. The chat-nuxt boot plugin should have called initDb() before any request \u2014 check that the module registered server/plugins/init-db.ts."
-  );
-}
-export { schema };

package/dist/runtime/server/db/schema/_schema.d.ts

@@ -1,2 +0,0 @@
-export declare const CHAT_SCHEMA_NAME = "chat";
-export declare const chatSchema: import("drizzle-orm/pg-core").PgSchema<"chat">;

package/dist/runtime/server/db/schema/_schema.js

@@ -1,3 +0,0 @@
-import { pgSchema } from "drizzle-orm/pg-core";
-export const CHAT_SCHEMA_NAME = "chat";
-export const chatSchema = pgSchema(CHAT_SCHEMA_NAME);

package/dist/runtime/server/db/schema/conversation-groups.d.ts

@@ -1,143 +0,0 @@
-export declare const conversationGroups: import("drizzle-orm/pg-core").PgTableWithColumns<{
-    name: "conversation_groups";
-    schema: "chat";
-    columns: {
-        id: import("drizzle-orm/pg-core").PgColumn<{
-            name: "id";
-            tableName: "conversation_groups";
-            dataType: "string";
-            columnType: "PgUUID";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: true;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "workspace_id";
-            tableName: "conversation_groups";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        telaAgentId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "tela_agent_id";
-            tableName: "conversation_groups";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        conversationScope: import("drizzle-orm/pg-core").PgColumn<{
-            name: "conversation_scope";
-            tableName: "conversation_groups";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        name: import("drizzle-orm/pg-core").PgColumn<{
-            name: "name";
-            tableName: "conversation_groups";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        createdBy: import("drizzle-orm/pg-core").PgColumn<{
-            name: "created_by";
-            tableName: "conversation_groups";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: false;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        createdAt: import("drizzle-orm/pg-core").PgColumn<{
-            name: "created_at";
-            tableName: "conversation_groups";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
-            name: "updated_at";
-            tableName: "conversation_groups";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-    };
-    dialect: "pg";
-}>;

package/dist/runtime/server/db/schema/conversation-groups.js

@@ -1,20 +0,0 @@
-import { index, text, timestamp, uuid } from "drizzle-orm/pg-core";
-import { chatSchema } from "./_schema.js";
-export const conversationGroups = chatSchema.table("conversation_groups", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  workspaceId: text("workspace_id").notNull(),
-  telaAgentId: text("tela_agent_id"),
-  conversationScope: text("conversation_scope"),
-  name: text("name").notNull(),
-  createdBy: text("created_by"),
-  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
-}, (table) => [
-  index("idx_conversation_groups_workspace").on(table.workspaceId),
-  index("idx_conversation_groups_runtime_created_at").on(
-    table.workspaceId,
-    table.telaAgentId,
-    table.conversationScope,
-    table.createdAt
-  )
-]);