@meistrari/chat-nuxt 1.0.0

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

@@ -0,0 +1,186 @@
+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(session.workspace.id);
+  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

@@ -0,0 +1,6 @@
+import * as schema from './schema.js';
+export type { ContextFile, ExternalSkill } from './schema.js';
+export declare function useDb(): import("drizzle-orm/postgres-js").PostgresJsDatabase<Record<string, unknown>> & {
+    $client: import("postgres").Sql<{}>;
+};
+export { schema };

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

@@ -0,0 +1,19 @@
+import postgres from "postgres";
+import { drizzle } from "drizzle-orm/postgres-js";
+import * as schema from "./schema/index.js";
+import { logger } from "#chat-runtime/server/utils/logger";
+let dbInstance = null;
+export function useDb() {
+  if (dbInstance) {
+    return dbInstance;
+  }
+  const config = useRuntimeConfig();
+  if (!config.databaseUrl) {
+    throw new Error("DATABASE_URL is not configured");
+  }
+  const client = postgres(config.databaseUrl, { max: 10 });
+  dbInstance = drizzle(client, { schema });
+  logger.info("Database connection pool initialized");
+  return dbInstance;
+}
+export { schema };

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

@@ -0,0 +1,438 @@
+export type ConversationUsageMetadata = {
+    filesUsed?: {
+        name: string;
+        mimeType?: string;
+        source: 'user' | 'context';
+    }[];
+    toolsInvoked?: string[];
+    knowledgeSourcesUsed?: string[];
+    hasCanvasTools?: boolean;
+};
+export type ModelUsageEntry = {
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    cacheReadInputTokens?: number | null;
+    cacheCreationInputTokens?: number | null;
+    webSearchRequests?: number | null;
+    costUSD?: number | null;
+    contextWindow?: number | null;
+};
+export declare const conversationUsage: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "conversation_usage";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "conversation_usage";
+            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_usage";
+            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;
+        }, {}, {}>;
+        conversationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conversation_id";
+            tableName: "conversation_usage";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        promptTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "prompt_tokens";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completionTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completion_tokens";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totalTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "total_tokens";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        promptCost: import("drizzle-orm/pg-core").PgColumn<{
+            name: "prompt_cost";
+            tableName: "conversation_usage";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completionCost: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completion_cost";
+            tableName: "conversation_usage";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        totalCost: import("drizzle-orm/pg-core").PgColumn<{
+            name: "total_cost";
+            tableName: "conversation_usage";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        durationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_ms";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        turns: import("drizzle-orm/pg-core").PgColumn<{
+            name: "turns";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "conversation_usage";
+            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;
+        }, {}, {}>;
+        userEmail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_email";
+            tableName: "conversation_usage";
+            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;
+        }, {}, {}>;
+        model: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model";
+            tableName: "conversation_usage";
+            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;
+        }, {}, {}>;
+        sessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "session_id";
+            tableName: "conversation_usage";
+            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;
+        }, {}, {}>;
+        cacheReadInputTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cache_read_input_tokens";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cacheCreationInputTokens: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cache_creation_input_tokens";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        modelUsage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model_usage";
+            tableName: "conversation_usage";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, ModelUsageEntry>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, ModelUsageEntry>;
+        }>;
+        durationApiMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_api_ms";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        webSearchRequests: import("drizzle-orm/pg-core").PgColumn<{
+            name: "web_search_requests";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        webFetchRequests: import("drizzle-orm/pg-core").PgColumn<{
+            name: "web_fetch_requests";
+            tableName: "conversation_usage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "conversation_usage";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ConversationUsageMetadata;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ConversationUsageMetadata;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "conversation_usage";
+            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_usage";
+            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-usage.js

@@ -0,0 +1,34 @@
+import { pgTable, uuid, text, timestamp, index, jsonb, integer, numeric, unique } from "drizzle-orm/pg-core";
+import { conversations } from "./conversations.js";
+export const conversationUsage = pgTable("conversation_usage", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  workspaceId: text("workspace_id").notNull(),
+  conversationId: uuid("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+  promptTokens: integer("prompt_tokens").notNull(),
+  completionTokens: integer("completion_tokens").notNull(),
+  totalTokens: integer("total_tokens").notNull(),
+  promptCost: numeric("prompt_cost", { precision: 12, scale: 8 }).notNull(),
+  completionCost: numeric("completion_cost", { precision: 12, scale: 8 }).notNull(),
+  totalCost: numeric("total_cost", { precision: 12, scale: 8 }).notNull(),
+  durationMs: integer("duration_ms"),
+  turns: integer("turns"),
+  userId: text("user_id").notNull(),
+  userEmail: text("user_email"),
+  model: text("model"),
+  sessionId: text("session_id"),
+  cacheReadInputTokens: integer("cache_read_input_tokens"),
+  cacheCreationInputTokens: integer("cache_creation_input_tokens"),
+  modelUsage: jsonb("model_usage").$type(),
+  durationApiMs: integer("duration_api_ms"),
+  webSearchRequests: integer("web_search_requests"),
+  webFetchRequests: integer("web_fetch_requests"),
+  metadata: jsonb("metadata").$type(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => [
+  unique("conversation_usage_conversation_id_unique").on(table.conversationId),
+  index("idx_usage_workspace").on(table.workspaceId),
+  index("idx_usage_workspace_created").on(table.workspaceId, table.createdAt),
+  index("idx_usage_conversation").on(table.conversationId),
+  index("idx_usage_user").on(table.userId)
+]);