@sentry/junior 0.96.0 → 0.97.0

package/dist/cli/upgrade.js

@@ -4,47 +4,50 @@ import {
   recordConversationActivity,
   recordConversationExecution,
   requestConversationWork
-} from "../chunk-GQ3GK22G.js";
+} from "../chunk-FBHZJFHI.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
   pluginCatalogConfigFromPluginSet,
   pluginRuntimeRegistrationsFromPluginSet
 } from "../chunk-SG5WAA7H.js";
-import {
-  coerceThreadConversationState
-} from "../chunk-RAIB6WSG.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
+  addAgentTurnUsage,
+  coerceThreadConversationState,
+  listAgentTurnSessionSummariesForConversations
+} from "../chunk-WJOSZOON.js";
+import "../chunk-GUAP3H7O.js";
+import {
   importConversationFromLegacy
-} from "../chunk-5C6XTTFI.js";
+} from "../chunk-3F4OPKGF.js";
+import "../chunk-PDO5BLNM.js";
 import {
   loadAppPluginSet
 } from "../chunk-Y2CM7HXH.js";
 import {
   createPluginLogger,
   createPluginState
-} from "../chunk-2NAZZPPS.js";
+} from "../chunk-EOWXRY5E.js";
 import {
   createJuniorSqlExecutor,
   createSqlConversationMessageStore,
   createSqlStore,
-  getDb,
-  migrateSchema
-} from "../chunk-RITD7E5L.js";
+  getDb
+} from "../chunk-35BNLDOJ.js";
 import {
   disconnectStateAdapter,
   getChatConfig,
   getConnectedStateContext
-} from "../chunk-YDVEH3SB.js";
-import "../chunk-GY34VGP5.js";
+} from "../chunk-EEZCY5WX.js";
+import "../chunk-LVA4I4H7.js";
 import {
   parseDestination,
   sameDestination
 } from "../chunk-B7PUBQQM.js";
 import {
   pluginCatalogRuntime
-} from "../chunk-L7CDEIVJ.js";
+} from "../chunk-LMJPRYHP.js";
 import "../chunk-I35CTGPO.js";
 import {
   isRecord,
@@ -52,28 +55,14 @@ import {
   toOptionalString
 } from "../chunk-OB42YVAE.js";
 import "../chunk-6GWA276C.js";
-import "../chunk-6APU57E6.js";
+import "../chunk-B3IT5END.js";
 import "../chunk-7FBGKXPE.js";
+import "../chunk-3V7OFJZC.js";
 import "../chunk-MLKGABMK.js";
 
 // src/cli/upgrade.ts
 import { createJiti } from "jiti";
 
-// src/chat/conversations/sql/backfill.ts
-async function backfillToSql(args) {
-  const limit = Math.max(0, args.limit ?? 500);
-  const conversations = await args.source.listByActivity({
-    limit
-  });
-  await args.target.migrate();
-  for (const conversation of conversations) {
-    await args.target.backfillConversation(conversation);
-  }
-  return {
-    copiedCount: conversations.length
-  };
-}
-
 // src/chat/conversations/state.ts
 function createStateConversationStore(state) {
   return {
@@ -81,8 +70,8 @@ function createStateConversationStore(state) {
     // Task-execution state has no destination records, so visibility is never
     // source-confirmed here and cross-context reads fail closed to private.
     getDestinationVisibility: async () => void 0,
-    // Subagent child conversations are a SQL-only concept; the advisor always
-    // links its child through the SQL store, never this legacy metadata path.
+    // Child conversations are a SQL-only concept and never use this legacy
+    // metadata path.
     ensureChildConversation: async () => void 0,
     recordActivity: (args) => recordConversationActivity({ ...args, state }),
     recordExecution: (args) => recordConversationExecution({ ...args, state }),
@@ -107,16 +96,58 @@ async function migrateConversationsToSql(context, options = {}) {
   }
   const limit = Math.max(1, options.batchSize ?? CONVERSATION_BACKFILL_LIMIT);
   try {
-    const result = await backfillToSql({
-      limit,
-      source,
-      target
-    });
+    const [stateConversations, sqlConversations] = await Promise.all([
+      source.listByActivity({ limit }),
+      target.listByActivity({ limit })
+    ]);
+    const byId = new Map(
+      sqlConversations.map((conversation) => [
+        conversation.conversationId,
+        conversation
+      ])
+    );
+    for (const conversation of stateConversations) {
+      const existing = byId.get(conversation.conversationId);
+      const existingExecutionAt = existing?.execution.updatedAtMs ?? existing?.updatedAtMs ?? 0;
+      const stateExecutionAt = conversation.execution.updatedAtMs ?? conversation.updatedAtMs;
+      if (!existing || stateExecutionAt >= existingExecutionAt) {
+        byId.set(conversation.conversationId, conversation);
+      }
+    }
+    const conversations = [...byId.values()].sort(
+      (left, right) => right.lastActivityAtMs - left.lastActivityAtMs || left.conversationId.localeCompare(right.conversationId)
+    ).slice(0, limit);
+    const summaries = await listAgentTurnSessionSummariesForConversations(
+      context.stateAdapter,
+      conversations.map((conversation) => conversation.conversationId)
+    );
+    for (const conversation of conversations) {
+      const conversationSummaries = summaries.get(conversation.conversationId) ?? [];
+      const executionSummary = conversation.execution.runId ? conversationSummaries.find(
+        (summary) => summary.sessionId === conversation.execution.runId
+      ) : void 0;
+      await target.backfillConversation(
+        conversation,
+        conversationSummaries.length > 0 ? {
+          durationMs: conversationSummaries.reduce(
+            (total, summary) => total + summary.cumulativeDurationMs,
+            0
+          ),
+          usage: addAgentTurnUsage(
+            ...conversationSummaries.map(
+              (summary) => summary.cumulativeUsage
+            )
+          ),
+          executionDurationMs: executionSummary?.cumulativeDurationMs ?? 0,
+          executionUsage: executionSummary?.cumulativeUsage
+        } : void 0
+      );
+    }
     return {
       existing: 0,
-      migrated: result.copiedCount,
+      migrated: conversations.length,
       missing: 0,
-      scanned: result.copiedCount
+      scanned: conversations.length
     };
   } finally {
     await closeTarget?.();
@@ -127,6 +158,107 @@ var sqlConversationMigration = {
   run: migrateConversationsToSql
 };
 
+// src/chat/conversations/sql/migrations.ts
+import { basename, dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { readMigrationFiles } from "drizzle-orm/migrator";
+var LEGACY_CORE_MIGRATION_IDS = [
+  "0001_conversation_core",
+  "0002_slack_destination_visibility_backfill",
+  "0003_user_identities",
+  "0004_actor_cutover",
+  "0005_conversation_transcripts"
+];
+var LEGACY_METRICS_MIGRATION_ID = "0006_conversation_metrics";
+var MIGRATIONS_TABLE = "__drizzle_junior_core";
+function migrationFolder() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = basename(moduleDir) === "dist" ? dirname(moduleDir) : basename(dirname(moduleDir)) === "dist" ? resolve(moduleDir, "../..") : resolve(moduleDir, "../../../..");
+  return join(packageRoot, "migrations");
+}
+async function adoptLegacyMigrationState(executor, migrationsFolder) {
+  const [tables] = await executor.query(`
+SELECT
+  to_regclass('drizzle.__drizzle_junior_core')::text AS "drizzleTable",
+  to_regclass('public.junior_schema_migrations')::text AS "legacyTable"
+`);
+  if (!tables?.legacyTable || tables.drizzleTable) {
+    return;
+  }
+  const migrations = readMigrationFiles({ migrationsFolder });
+  const [metrics] = await executor.query(`
+SELECT count(*) = 4 AS complete
+FROM information_schema.columns
+WHERE table_schema = 'public'
+  AND table_name = 'junior_conversations'
+  AND column_name IN (
+    'duration_ms',
+    'usage_json',
+    'execution_duration_ms',
+    'execution_usage_json'
+  )
+`);
+  const legacyRecords = await executor.query("SELECT id, checksum FROM junior_schema_migrations");
+  const expectedIds = metrics?.complete ? [...LEGACY_CORE_MIGRATION_IDS, LEGACY_METRICS_MIGRATION_ID] : [...LEGACY_CORE_MIGRATION_IDS];
+  const validIds = new Set(
+    legacyRecords.filter((record) => record.checksum.trim().length > 0).map((record) => record.id)
+  );
+  const missingIds = expectedIds.filter((id) => !validIds.has(id));
+  if (missingIds.length > 0) {
+    throw new Error(
+      `Cannot adopt partial legacy core migration state; missing: ${missingIds.join(", ")}`
+    );
+  }
+  const migration = metrics?.complete ? migrations.at(-1) : migrations[0];
+  if (!migration) {
+    throw new Error("No core Drizzle migrations were packaged");
+  }
+  await executor.transaction(async () => {
+    await executor.execute("CREATE SCHEMA IF NOT EXISTS drizzle");
+    await executor.execute(`
+CREATE TABLE IF NOT EXISTS drizzle.__drizzle_junior_core (
+  id SERIAL PRIMARY KEY,
+  hash TEXT NOT NULL,
+  created_at BIGINT
+)
+`);
+    await executor.execute(
+      `INSERT INTO drizzle.__drizzle_junior_core (hash, created_at)
+       VALUES ($1, $2)`,
+      [migration.hash, migration.folderMillis]
+    );
+  });
+}
+async function migrateSchema(executor) {
+  const migrationsFolder = migrationFolder();
+  await executor.withMigrationLock(MIGRATIONS_TABLE, async () => {
+    await adoptLegacyMigrationState(executor, migrationsFolder);
+    await executor.migrate({
+      migrationsFolder,
+      migrationsTable: MIGRATIONS_TABLE
+    });
+  });
+}
+
+// src/cli/upgrade/migrations/core-sql.ts
+async function migrateCoreSqlSchema(_context) {
+  const { sql } = getChatConfig();
+  const executor = createJuniorSqlExecutor({
+    connectionString: sql.databaseUrl,
+    driver: sql.driver
+  });
+  try {
+    await migrateSchema(executor);
+    return { existing: 0, migrated: 0, missing: 0, scanned: 0 };
+  } finally {
+    await executor.close();
+  }
+}
+var coreSqlSchemaMigration = {
+  name: "core-sql-schema",
+  run: migrateCoreSqlSchema
+};
+
 // src/cli/upgrade/migrations/conversations-history-sql.ts
 var HISTORY_BACKFILL_LIMIT = 1e4;
 async function migrateConversationHistoryToSql(context, options = {}) {
@@ -143,7 +275,6 @@ async function migrateConversationHistoryToSql(context, options = {}) {
   }
   const limit = Math.max(1, options.batchSize ?? HISTORY_BACKFILL_LIMIT);
   try {
-    await migrateSchema(executor);
     const messageStore = createSqlConversationMessageStore(executor);
     const conversations = await source.listByActivity({ limit });
     let migrated = 0;
@@ -313,122 +444,116 @@ var pluginStorageMigration = {
   run: runPluginStorageMigrations
 };
 
-// src/chat/plugins/db.ts
+// src/chat/plugins/migrations.ts
 import { createHash } from "crypto";
-import { readdirSync, readFileSync, statSync } from "fs";
-import path from "path";
-import { z } from "zod";
-var PLUGIN_SCHEMA_LOCK_NAME = "junior_plugin_schema";
-var MIGRATION_FILENAME_RE = /^[0-9]{4}_[a-z0-9_]+\.sql$/;
-var migrationRecordSchema = z.object({
-  id: z.string().min(1),
-  checksum: z.string().min(1)
-}).strict();
-function checksumSql(sql) {
-  return createHash("sha256").update(sql).digest("hex");
+import { readMigrationFiles as readMigrationFiles2 } from "drizzle-orm/migrator";
+function migrationTable(pluginName) {
+  const label = pluginName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32);
+  const hash = createHash("sha256").update(pluginName).digest("hex").slice(0, 8);
+  return `__drizzle_${label}_${hash}`;
 }
-function parseStoredMigrationRecord(value) {
-  return migrationRecordSchema.parse(value);
+async function appliedMigrationTime(executor, table) {
+  const [exists] = await executor.query(
+    `SELECT to_regclass($1)::text AS "tableName"`,
+    [`drizzle.${table}`]
+  );
+  if (!exists?.tableName) {
+    return void 0;
+  }
+  const [row] = await executor.query(
+    `SELECT created_at::text AS "createdAt"
+     FROM drizzle.${table}
+     ORDER BY created_at DESC
+     LIMIT 1`
+  );
+  return row?.createdAt === null || row?.createdAt === void 0 ? void 0 : Number(row.createdAt);
 }
-function assertMigrationFilename(filename) {
-  if (!filename || filename !== path.basename(filename) || !MIGRATION_FILENAME_RE.test(filename)) {
-    throw new Error(`Plugin migration filename "${filename}" is invalid`);
+async function legacyMigrationHashes(executor, pluginName) {
+  const [exists] = await executor.query(
+    `SELECT to_regclass('public.junior_schema_migrations')::text AS "tableName"`
+  );
+  if (!exists?.tableName) {
+    return /* @__PURE__ */ new Set();
   }
+  const rows = await executor.query(
+    `SELECT checksum
+     FROM junior_schema_migrations
+     WHERE id LIKE $1
+     ORDER BY id ASC`,
+    [`plugin:${pluginName}/%`]
+  );
+  return new Set(rows.map((row) => row.checksum));
 }
-function assertUniqueMigrationIds(migrations) {
-  const seen = /* @__PURE__ */ new Set();
+function adoptedMigration(migrations, legacyHashes) {
+  let adopted;
   for (const migration of migrations) {
-    if (seen.has(migration.id)) {
-      throw new Error(`Duplicate plugin migration id ${migration.id}`);
+    if (!legacyHashes.has(migration.hash)) {
+      break;
     }
-    seen.add(migration.id);
+    adopted = migration;
   }
+  if (!adopted && migrations.length === 1 && legacyHashes.size > 0) {
+    return migrations[0];
+  }
+  return adopted;
 }
-function migrationId(pluginName, filename) {
-  return `plugin:${pluginName}/${filename}`;
-}
-function createMigrationTableSql() {
-  return `
-CREATE TABLE IF NOT EXISTS junior_schema_migrations (
-  id TEXT PRIMARY KEY,
-  checksum TEXT NOT NULL,
-  applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
-)
-`;
-}
-async function listAppliedMigrations(executor) {
-  const rows = await executor.query(
-    "SELECT id, checksum FROM junior_schema_migrations ORDER BY id ASC"
+async function adoptLegacyMigrationState2(args) {
+  const legacyHashes = await legacyMigrationHashes(
+    args.executor,
+    args.pluginName
   );
-  const records = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const record = parseStoredMigrationRecord(row);
-    records.set(record.id, record);
+  const migration = adoptedMigration(args.migrations, legacyHashes);
+  if (!migration) {
+    return void 0;
   }
-  return records;
-}
-async function applyPluginMigration(executor, migration) {
-  await executor.transaction(async () => {
-    await executor.execute(migration.sql);
-    await executor.execute(
-      "INSERT INTO junior_schema_migrations (id, checksum) VALUES ($1, $2)",
-      [migration.id, migration.checksum]
+  await args.executor.transaction(async () => {
+    await args.executor.execute("CREATE SCHEMA IF NOT EXISTS drizzle");
+    await args.executor.execute(`
+CREATE TABLE IF NOT EXISTS drizzle.${args.table} (
+  id SERIAL PRIMARY KEY,
+  hash TEXT NOT NULL,
+  created_at BIGINT
+)
+`);
+    await args.executor.execute(
+      `INSERT INTO drizzle.${args.table} (hash, created_at) VALUES ($1, $2)`,
+      [migration.hash, migration.folderMillis]
     );
   });
+  return migration.folderMillis;
 }
-function readPluginMigrations(root) {
-  const migrationsDir = root.dir;
-  let stat;
-  try {
-    stat = statSync(migrationsDir);
-  } catch {
-    return [];
-  }
-  if (!stat.isDirectory()) {
-    throw new Error(
-      `Plugin "${root.pluginName}" migrations path is not a directory`
-    );
-  }
-  return readdirSync(migrationsDir).filter((filename) => filename.endsWith(".sql")).sort((left, right) => left.localeCompare(right)).map((filename) => {
-    assertMigrationFilename(filename);
-    const sql = readFileSync(path.join(migrationsDir, filename), "utf8");
-    if (!sql.trim()) {
-      throw new Error(
-        `Plugin "${root.pluginName}" migration "${filename}" is empty`
-      );
-    }
-    return {
-      checksum: checksumSql(sql),
-      filename,
-      id: migrationId(root.pluginName, filename),
-      pluginName: root.pluginName,
-      sql
-    };
-  });
+function appliedCount(migrations, createdAt) {
+  return createdAt === void 0 ? 0 : migrations.filter((migration) => migration.folderMillis <= createdAt).length;
 }
-async function migratePluginSchemas(executor, migrations) {
-  assertUniqueMigrationIds(migrations);
+async function migratePluginSchemas(executor, roots) {
   const result = {
     existing: 0,
     migrated: 0,
-    scanned: migrations.length
+    scanned: 0
   };
-  await executor.withLock(PLUGIN_SCHEMA_LOCK_NAME, async () => {
-    await executor.execute(createMigrationTableSql());
-    const applied = await listAppliedMigrations(executor);
-    for (const migration of migrations) {
-      const existing = applied.get(migration.id);
-      if (existing) {
-        if (existing.checksum !== migration.checksum) {
-          throw new Error(`Plugin migration ${migration.id} checksum changed`);
-        }
-        result.existing++;
-        continue;
-      }
-      await applyPluginMigration(executor, migration);
-      result.migrated++;
-    }
-  });
+  const orderedRoots = [...roots].sort(
+    (left, right) => left.pluginName.localeCompare(right.pluginName)
+  );
+  for (const root of orderedRoots) {
+    const migrations = readMigrationFiles2({ migrationsFolder: root.dir });
+    const table = migrationTable(root.pluginName);
+    await executor.withMigrationLock(table, async () => {
+      const currentTime = await appliedMigrationTime(executor, table) ?? await adoptLegacyMigrationState2({
+        executor,
+        migrations,
+        pluginName: root.pluginName,
+        table
+      });
+      const existing = appliedCount(migrations, currentTime);
+      await executor.migrate({
+        migrationsFolder: root.dir,
+        migrationsTable: table
+      });
+      result.scanned += migrations.length;
+      result.existing += existing;
+      result.migrated += migrations.length - existing;
+    });
+  }
   return result;
 }
 
@@ -442,8 +567,10 @@ async function migratePluginsToSql(context) {
     driver: sql.driver
   });
   try {
-    const migrations = pluginCatalogRuntime.getMigrationRoots().flatMap((root) => readPluginMigrations(root));
-    const result = await migratePluginSchemas(executor, migrations);
+    const result = await migratePluginSchemas(
+      executor,
+      pluginCatalogRuntime.getMigrationRoots()
+    );
     return {
       existing: result.existing,
       migrated: result.migrated,
@@ -999,6 +1126,7 @@ var DEFAULT_IO = {
 var localPluginLoader = createJiti(import.meta.url, { moduleCache: false });
 var MIGRATIONS = [
   redisConversationStateMigration,
+  coreSqlSchemaMigration,
   sqlConversationMigration,
   sqlConversationHistoryMigration,
   sqlPluginMigration,

package/dist/db/db.d.ts

@@ -7,6 +7,7 @@
  */
 import type { PgDatabase } from "drizzle-orm/pg-core";
 import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
+import type { MigrationConfig } from "drizzle-orm/migrator";
 import type { juniorSqlSchema } from "./schema";
 export type JuniorDatabase = PgDatabase<PgQueryResultHKT, typeof juniorSqlSchema>;
 export interface JuniorSqlDatabase {
@@ -16,7 +17,10 @@ export interface JuniorSqlDatabase {
 }
 export interface JuniorSqlMigrationExecutor extends JuniorSqlDatabase {
     execute(statement: string, params?: readonly unknown[]): Promise<void>;
+    migrate(config: MigrationConfig): Promise<void>;
     query<T = unknown>(statement: string, params?: readonly unknown[]): Promise<T[]>;
+    /** Serialize adoption and migration for one Drizzle journal. */
+    withMigrationLock<T>(migrationTable: string, callback: () => Promise<T>): Promise<T>;
 }
 export interface JuniorSqlExecutor extends JuniorSqlMigrationExecutor {
     close(): Promise<void>;

package/dist/db/schema/conversations.d.ts

@@ -447,6 +447,134 @@ export declare const juniorConversations: import("drizzle-orm/pg-core").PgTableW
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        durationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "duration_ms";
+            tableName: "junior_conversations";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        usage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "usage_json";
+            tableName: "junior_conversations";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                inputTokens?: number | undefined;
+                outputTokens?: number | undefined;
+                cachedInputTokens?: number | undefined;
+                cacheCreationTokens?: number | undefined;
+                reasoningTokens?: number | undefined;
+                totalTokens?: number | undefined;
+                cost?: {
+                    input?: number | undefined;
+                    output?: number | undefined;
+                    cacheRead?: number | undefined;
+                    cacheWrite?: number | undefined;
+                    total?: number | undefined;
+                } | undefined;
+            };
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                inputTokens?: number | undefined;
+                outputTokens?: number | undefined;
+                cachedInputTokens?: number | undefined;
+                cacheCreationTokens?: number | undefined;
+                reasoningTokens?: number | undefined;
+                totalTokens?: number | undefined;
+                cost?: {
+                    input?: number | undefined;
+                    output?: number | undefined;
+                    cacheRead?: number | undefined;
+                    cacheWrite?: number | undefined;
+                    total?: number | undefined;
+                } | undefined;
+            };
+        }>;
+        executionDurationMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "execution_duration_ms";
+            tableName: "junior_conversations";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        executionUsage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "execution_usage_json";
+            tableName: "junior_conversations";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                inputTokens?: number | undefined;
+                outputTokens?: number | undefined;
+                cachedInputTokens?: number | undefined;
+                cacheCreationTokens?: number | undefined;
+                reasoningTokens?: number | undefined;
+                totalTokens?: number | undefined;
+                cost?: {
+                    input?: number | undefined;
+                    output?: number | undefined;
+                    cacheRead?: number | undefined;
+                    cacheWrite?: number | undefined;
+                    total?: number | undefined;
+                } | undefined;
+            };
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                inputTokens?: number | undefined;
+                outputTokens?: number | undefined;
+                cachedInputTokens?: number | undefined;
+                cacheCreationTokens?: number | undefined;
+                reasoningTokens?: number | undefined;
+                totalTokens?: number | undefined;
+                cost?: {
+                    input?: number | undefined;
+                    output?: number | undefined;
+                    cacheRead?: number | undefined;
+                    cacheWrite?: number | undefined;
+                    total?: number | undefined;
+                } | undefined;
+            };
+        }>;
     };
     dialect: "pg";
 }>;