aegra-hono 0.20.0 → 0.21.0

package/dist/cli.js

@@ -51,7 +51,7 @@ var __callDispose = (stack, error, hasError) => {
 
 // src/config/settings.ts
 import { z } from "zod";
-var DEFAULT_VERSION = "0.20.0", booleanFromEnv, positiveIntFromEnv = (fallback) => z.coerce.number().int().positive().default(fallback), environmentShape, environmentVariableNames, environmentSchema, raw, settings;
+var DEFAULT_VERSION = "0.21.0", booleanFromEnv, positiveIntFromEnv = (fallback) => z.coerce.number().int().positive().default(fallback), environmentShape, environmentVariableNames, environmentSchema, raw, settings;
 var init_settings = __esm(() => {
   booleanFromEnv = z.stringbool().default(false);
   environmentShape = {
@@ -135,160 +135,6 @@ var init_settings = __esm(() => {
   };
 });
 
-// src/core/schema.ts
-var exports_schema = {};
-__export(exports_schema, {
-  threads: () => threads,
-  threadTtl: () => threadTtl,
-  storeItems: () => storeItems,
-  runs: () => runs,
-  migrations: () => migrations,
-  crons: () => crons,
-  assistants: () => assistants,
-  assistantVersions: () => assistantVersions
-});
-import { sql } from "drizzle-orm";
-import {
-  boolean,
-  doublePrecision,
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  primaryKey,
-  text,
-  timestamp,
-  unique,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-var timestamps, migrations, assistants, assistantVersions, threads, runs, crons, storeItems, threadTtl;
-var init_schema = __esm(() => {
-  timestamps = {
-    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updated_at: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-  };
-  migrations = pgTable("aegra_migrations", {
-    checksum: text("checksum"),
-    version: integer("version").primaryKey(),
-    applied_at: timestamp("applied_at", { withTimezone: true }).notNull().defaultNow()
-  });
-  assistants = pgTable("assistant", {
-    assistant_id: text("assistant_id").primaryKey().default(sql`gen_random_uuid()::text`),
-    name: text("name").notNull(),
-    description: text("description"),
-    graph_id: text("graph_id").notNull(),
-    config: jsonb("config").$type().notNull().default({}),
-    context: jsonb("context").$type().notNull().default({}),
-    user_id: text("user_id").notNull(),
-    version: integer("version").notNull().default(1),
-    metadata: jsonb("metadata").$type().notNull().default({}),
-    ...timestamps
-  }, (table) => [
-    index("idx_assistant_user").on(table.user_id),
-    unique("assistant_user_id_unique").on(table.user_id, table.assistant_id),
-    uniqueIndex("idx_assistant_user_graph_config").on(table.user_id, table.graph_id, sql`md5(${table.config}::text)`),
-    index("idx_assistant_metadata_gin").using("gin", sql`${table.metadata} jsonb_path_ops`)
-  ]);
-  assistantVersions = pgTable("assistant_versions", {
-    assistant_id: text("assistant_id").notNull().references(() => assistants.assistant_id, { onDelete: "cascade" }),
-    version: integer("version").notNull(),
-    graph_id: text("graph_id").notNull(),
-    config: jsonb("config").$type(),
-    context: jsonb("context").$type(),
-    metadata: jsonb("metadata").$type().notNull().default({}),
-    name: text("name"),
-    description: text("description"),
-    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-  }, (table) => [primaryKey({ columns: [table.assistant_id, table.version] })]);
-  threads = pgTable("thread", {
-    thread_id: text("thread_id").primaryKey(),
-    status: text("status").notNull().default("idle"),
-    metadata_json: jsonb("metadata_json").$type().notNull().default({}),
-    user_id: text("user_id").notNull(),
-    ...timestamps
-  }, (table) => [
-    index("idx_thread_user").on(table.user_id),
-    index("idx_thread_metadata_gin").using("gin", sql`${table.metadata_json} jsonb_path_ops`)
-  ]);
-  runs = pgTable("runs", {
-    run_id: text("run_id").primaryKey().default(sql`gen_random_uuid()::text`),
-    thread_id: text("thread_id").notNull().references(() => threads.thread_id, { onDelete: "cascade" }),
-    assistant_id: text("assistant_id").references(() => assistants.assistant_id, {
-      onDelete: "cascade"
-    }),
-    status: text("status").notNull().default("pending"),
-    input: jsonb("input").$type(),
-    config: jsonb("config").$type(),
-    context: jsonb("context").$type(),
-    output: jsonb("output").$type(),
-    error_message: text("error_message"),
-    user_id: text("user_id").notNull(),
-    execution_params: jsonb("execution_params").$type(),
-    claimed_by: text("claimed_by"),
-    lease_expires_at: timestamp("lease_expires_at", { withTimezone: true }),
-    ...timestamps
-  }, (table) => [
-    index("idx_runs_thread_id").on(table.thread_id),
-    index("idx_runs_status").on(table.status),
-    index("idx_runs_user").on(table.user_id),
-    index("idx_runs_assistant_id").on(table.assistant_id),
-    index("idx_runs_created_at").on(table.created_at),
-    index("idx_runs_lease_reaper").on(table.status, table.lease_expires_at).where(sql`${table.status} = 'running'`)
-  ]);
-  crons = pgTable("crons", {
-    cron_id: text("cron_id").primaryKey().default(sql`gen_random_uuid()::text`),
-    assistant_id: text("assistant_id").notNull().references(() => assistants.assistant_id, { onDelete: "cascade" }),
-    thread_id: text("thread_id").references(() => threads.thread_id, { onDelete: "cascade" }),
-    user_id: text("user_id").notNull(),
-    schedule: text("schedule").notNull(),
-    payload: jsonb("payload").$type().notNull().default({}),
-    metadata: jsonb("metadata").$type().notNull().default({}),
-    on_run_completed: text("on_run_completed"),
-    enabled: boolean("enabled").notNull().default(true),
-    end_time: timestamp("end_time", { withTimezone: true }),
-    next_run_date: timestamp("next_run_date", { withTimezone: true }),
-    claimed_until: timestamp("claimed_until", { withTimezone: true }),
-    ...timestamps
-  }, (table) => [
-    index("idx_cron_user").on(table.user_id),
-    index("idx_cron_assistant_id").on(table.assistant_id),
-    index("idx_cron_thread_id").on(table.thread_id),
-    index("idx_cron_next_run").on(table.enabled, table.next_run_date)
-  ]);
-  storeItems = pgTable("store_items", {
-    user_id: text("user_id").notNull(),
-    namespace: text("namespace").array().notNull(),
-    key: text("key").notNull(),
-    value: jsonb("value").$type().notNull(),
-    ...timestamps
-  }, (table) => [primaryKey({ columns: [table.namespace, table.key] })]);
-  threadTtl = pgTable("thread_ttl", {
-    thread_id: text("thread_id").primaryKey().references(() => threads.thread_id, { onDelete: "cascade" }),
-    strategy: text("strategy").notNull().default("delete"),
-    ttl_minutes: doublePrecision("ttl_minutes").notNull(),
-    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    expires_at: timestamp("expires_at", { withTimezone: true }).notNull()
-  }, (table) => [index("idx_thread_ttl_expires_at").on(table.expires_at)]);
-});
-
-// src/core/langgraph-database.ts
-import pg from "pg";
-import { drizzle } from "drizzle-orm/node-postgres";
-async function closeLangGraphDatabase() {
-  await langgraphPool.end();
-}
-var langgraphPool, storeDb;
-var init_langgraph_database = __esm(() => {
-  init_settings();
-  init_schema();
-  langgraphPool = new pg.Pool({
-    connectionString: settings.DATABASE_URL,
-    min: settings.LANGGRAPH_POOL_MIN_SIZE,
-    max: settings.LANGGRAPH_POOL_MAX_SIZE
-  });
-  storeDb = drizzle({ client: langgraphPool, schema: exports_schema });
-});
-
 // src/config/project.ts
 import { readFile } from "fs/promises";
 import { dirname, resolve } from "path";
@@ -343,6 +189,232 @@ var init_project = __esm(() => {
   });
 });
 
+// src/core/optional-dependencies.ts
+import { createRequire } from "module";
+function installHint(specifier, feature) {
+  return `${feature} is enabled but the optional '${specifier}' package is not installed. Install it with: bun add ${specifier}`;
+}
+function isMissingModule(error, specifier) {
+  const code = error?.code;
+  if (typeof code === "string" && code.includes("MODULE_NOT_FOUND"))
+    return true;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED")
+    return true;
+  return error instanceof Error && error.message.includes(`'${specifier}'`);
+}
+async function optionalImport(specifier, feature) {
+  try {
+    return await import(specifier);
+  } catch (error) {
+    if (isMissingModule(error, specifier))
+      throw new Error(installHint(specifier, feature), { cause: error });
+    throw error;
+  }
+}
+function optionalRequire(specifier, feature) {
+  try {
+    return require2(specifier);
+  } catch (error) {
+    if (isMissingModule(error, specifier))
+      throw new Error(installHint(specifier, feature), { cause: error });
+    throw error;
+  }
+}
+var require2;
+var init_optional_dependencies = __esm(() => {
+  require2 = createRequire(import.meta.url);
+});
+
+// src/core/langgraph-database.ts
+import { AsyncLocalStorage } from "async_hooks";
+import pg from "pg";
+import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";
+function encodeNamespace(namespace) {
+  return namespace.map((segment) => `${Buffer.from(segment, "utf8").toString("hex")}g`);
+}
+function decodeNamespace(namespace) {
+  return namespace.map((segment) => {
+    if (!/^(?:[0-9a-f]{2})*g$/.test(segment))
+      throw new Error("Invalid encoded Store namespace");
+    return Buffer.from(segment.slice(0, -1), "hex").toString("utf8");
+  });
+}
+async function withStoreTransaction(operation) {
+  const current = transactionClient.getStore();
+  if (current)
+    return operation(current);
+  const client = await langgraphPool.connect();
+  try {
+    await client.query("BEGIN");
+    const result = await transactionClient.run(client, () => operation(client));
+    await client.query("COMMIT");
+    return result;
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function createOfficialStore(index) {
+  const store = new PostgresStore({
+    connectionOptions: { connectionString: settings.DATABASE_URL },
+    schema: "aegra_store",
+    ensureTables: false,
+    ...index ? { index } : {}
+  });
+  const core = store.core;
+  if (!core?.pool || typeof core.withClient !== "function")
+    throw new Error("Unsupported PostgresStore internals; verify the pinned SDK compatibility bridge");
+  await core.pool.end();
+  core.pool = new Proxy(langgraphPool, {
+    get(target, property) {
+      if (property === "end")
+        return async () => {};
+      if (property === "connect")
+        return async () => {
+          const client = transactionClient.getStore();
+          if (!client)
+            return target.connect();
+          return new Proxy(client, {
+            get(connection, member) {
+              if (member === "release")
+                return () => {};
+              const value2 = Reflect.get(connection, member);
+              return typeof value2 === "function" ? value2.bind(connection) : value2;
+            }
+          });
+        };
+      const value = Reflect.get(target, property);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  core.withClient = withStoreTransaction;
+  return store;
+}
+async function createEmbedder(provider, model, dims) {
+  if (provider === "openai") {
+    const { OpenAIEmbeddings } = await optionalImport("@langchain/openai", "the 'openai' store embedding provider");
+    return new OpenAIEmbeddings({ model, dimensions: dims });
+  }
+  if (provider === "bedrock") {
+    const { BedrockEmbeddings } = await optionalImport("@langchain/aws", "the 'bedrock' store embedding provider");
+    return new BedrockEmbeddings({ model, dimensions: dims });
+  }
+  if (provider === "cohere") {
+    const { CohereEmbeddings } = await optionalImport("@langchain/cohere", "the 'cohere' store embedding provider");
+    return new CohereEmbeddings({ model });
+  }
+  throw new Error(`Unsupported embedding provider '${provider}'`);
+}
+async function storeIndex() {
+  const index = (await loadConfig()).store?.index;
+  if (!index)
+    return;
+  const separator = index.embed.indexOf(":");
+  if (separator < 1 || separator === index.embed.length - 1)
+    throw new Error("store.index.embed must use provider:model format");
+  const model = await createEmbedder(index.embed.slice(0, separator), index.embed.slice(separator + 1), index.dims);
+  function validate(vectors, count) {
+    if (vectors.length !== count || vectors.some((vector) => vector.length !== index.dims || vector.some((number) => !Number.isFinite(number))))
+      throw new Error(`Embedding model returned invalid vectors; expected ${count} vectors of ${index.dims} dimensions`);
+    return vectors;
+  }
+  return {
+    dims: index.dims,
+    fields: index.fields ?? ["$"],
+    embed: {
+      embedDocuments: async (texts) => validate(await model.embedDocuments(texts), texts.length),
+      embedQuery: async (text) => validate([await model.embedQuery(text)], 1)[0]
+    }
+  };
+}
+async function migrateLegacyStore(client, legacySchema = "public", dims) {
+  if (!/^[a-z_][a-z0-9_]*$/.test(legacySchema))
+    throw new Error("Invalid migration schema");
+  const source = `"${legacySchema}"`;
+  const applied = await client.query(`SELECT 1 FROM ${source}.aegra_migrations WHERE version = 10001`);
+  if (applied.rowCount)
+    return;
+  await client.query(`LOCK TABLE ${source}.store_items IN SHARE MODE`);
+  const vectorTable = await client.query("SELECT to_regclass($1) AS name", [
+    `${legacySchema}.store_embeddings`
+  ]);
+  if (vectorTable.rows[0]?.name) {
+    await client.query(`LOCK TABLE ${source}.store_embeddings IN SHARE MODE`);
+    const dimensions = await client.query(`SELECT DISTINCT vector_dims(embedding) AS dims FROM ${source}.store_embeddings`);
+    if (dimensions.rows.length > 1 || dims && dimensions.rows.some((row) => row.dims !== dims))
+      throw new Error("Legacy Store embedding dimensions do not match store.index.dims; migration aborted without changing data");
+    if (!dims && dimensions.rows[0]) {
+      const setupStore = await createOfficialStore({
+        dims: dimensions.rows[0].dims,
+        embed: async () => {
+          throw new Error("Migration-only embedder");
+        }
+      });
+      try {
+        await setupStore.setup();
+      } finally {
+        await setupStore.stop();
+      }
+    }
+  }
+  const encoded = `(SELECT string_agg(encode(convert_to(part, 'UTF8'), 'hex') || 'g', ':' ORDER BY ordinal)
+    FROM unnest(namespace) WITH ORDINALITY AS labels(part, ordinal))`;
+  const collision = await client.query(`SELECT 1 FROM ${source}.store_items old
+    JOIN aegra_store.store target ON target.namespace_path = ${encoded} AND target.key = old.key LIMIT 1`);
+  if (collision.rowCount)
+    throw new Error("Official Store already contains legacy keys; migration aborted to avoid overwriting data");
+  await client.query(`INSERT INTO aegra_store.store(namespace_path, key, value, created_at, updated_at)
+    SELECT ${encoded}, key, value, created_at, updated_at FROM ${source}.store_items`);
+  if (vectorTable.rows[0]?.name) {
+    const count = await client.query(`SELECT count(*)::int AS count FROM ${source}.store_embeddings`);
+    if (count.rows[0].count)
+      await client.query(`INSERT INTO aegra_store.store_vectors(namespace_path, key, field_path, text_content, embedding)
+      SELECT ${encoded}, key, field_path, '', embedding FROM ${source}.store_embeddings`);
+  }
+  await client.query(`INSERT INTO ${source}.aegra_migrations(version, checksum) VALUES (10001, 'official-store-hexg-v1')`);
+}
+function getOfficialStore() {
+  storePromise ??= (async () => {
+    const index = await storeIndex();
+    const store = await createOfficialStore(index);
+    const lock = new pg.Client({ connectionString: settings.DATABASE_URL });
+    await lock.connect();
+    try {
+      await lock.query("SELECT pg_advisory_lock(1095067474)");
+      await store.setup();
+      await withStoreTransaction((client) => migrateLegacyStore(client, "public", index?.dims));
+      return store;
+    } catch (error) {
+      await store.stop();
+      throw error;
+    } finally {
+      await lock.end();
+    }
+  })();
+  return storePromise;
+}
+async function closeLangGraphDatabase() {
+  try {
+    await (await storePromise)?.stop();
+  } finally {
+    await langgraphPool.end();
+  }
+}
+var langgraphPool, transactionClient, storePromise;
+var init_langgraph_database = __esm(() => {
+  init_settings();
+  init_project();
+  init_optional_dependencies();
+  langgraphPool = new pg.Pool({
+    connectionString: settings.DATABASE_URL,
+    min: settings.LANGGRAPH_POOL_MIN_SIZE,
+    max: settings.LANGGRAPH_POOL_MAX_SIZE
+  });
+  transactionClient = new AsyncLocalStorage;
+});
+
 // src/core/logger.ts
 function startup(info) {
   if (production) {
@@ -398,14 +470,14 @@ function jsonValue(value) {
     return value;
   return { name: value.name, message: value.message, stack: value.stack };
 }
-function timestamp2(date = new Date) {
+function timestamp(date = new Date) {
   const pad = (value, width = 2) => String(value).padStart(width, "0");
   const offset = -date.getTimezoneOffset();
   const sign = offset >= 0 ? "+" : "-";
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` + `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}` + `${sign}${pad(Math.floor(Math.abs(offset) / 60))}:${pad(Math.abs(offset) % 60)}`;
 }
 function write(level, message, fields = {}) {
-  const time = timestamp2();
+  const time = timestamp();
   let line;
   if (production) {
     line = JSON.stringify({
@@ -448,18 +520,147 @@ var init_logger = __esm(() => {
   };
 });
 
+// src/core/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  threads: () => threads,
+  threadTtl: () => threadTtl,
+  runs: () => runs,
+  migrations: () => migrations,
+  crons: () => crons,
+  assistants: () => assistants,
+  assistantVersions: () => assistantVersions
+});
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp as timestamp2,
+  unique,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+var timestamps, migrations, assistants, assistantVersions, threads, runs, crons, threadTtl;
+var init_schema = __esm(() => {
+  timestamps = {
+    created_at: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow()
+  };
+  migrations = pgTable("aegra_migrations", {
+    checksum: text("checksum"),
+    version: integer("version").primaryKey(),
+    applied_at: timestamp2("applied_at", { withTimezone: true }).notNull().defaultNow()
+  });
+  assistants = pgTable("assistant", {
+    assistant_id: text("assistant_id").primaryKey().default(sql`gen_random_uuid()::text`),
+    name: text("name").notNull(),
+    description: text("description"),
+    graph_id: text("graph_id").notNull(),
+    config: jsonb("config").$type().notNull().default({}),
+    context: jsonb("context").$type().notNull().default({}),
+    user_id: text("user_id").notNull(),
+    version: integer("version").notNull().default(1),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    ...timestamps
+  }, (table) => [
+    index("idx_assistant_user").on(table.user_id),
+    unique("assistant_user_id_unique").on(table.user_id, table.assistant_id),
+    uniqueIndex("idx_assistant_user_graph_config").on(table.user_id, table.graph_id, sql`md5(${table.config}::text)`),
+    index("idx_assistant_metadata_gin").using("gin", sql`${table.metadata} jsonb_path_ops`)
+  ]);
+  assistantVersions = pgTable("assistant_versions", {
+    assistant_id: text("assistant_id").notNull().references(() => assistants.assistant_id, { onDelete: "cascade" }),
+    version: integer("version").notNull(),
+    graph_id: text("graph_id").notNull(),
+    config: jsonb("config").$type(),
+    context: jsonb("context").$type(),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    name: text("name"),
+    description: text("description"),
+    created_at: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+  }, (table) => [primaryKey({ columns: [table.assistant_id, table.version] })]);
+  threads = pgTable("thread", {
+    thread_id: text("thread_id").primaryKey(),
+    status: text("status").notNull().default("idle"),
+    metadata_json: jsonb("metadata_json").$type().notNull().default({}),
+    user_id: text("user_id").notNull(),
+    ...timestamps
+  }, (table) => [
+    index("idx_thread_user").on(table.user_id),
+    index("idx_thread_metadata_gin").using("gin", sql`${table.metadata_json} jsonb_path_ops`)
+  ]);
+  runs = pgTable("runs", {
+    run_id: text("run_id").primaryKey().default(sql`gen_random_uuid()::text`),
+    thread_id: text("thread_id").notNull().references(() => threads.thread_id, { onDelete: "cascade" }),
+    assistant_id: text("assistant_id").references(() => assistants.assistant_id, {
+      onDelete: "cascade"
+    }),
+    status: text("status").notNull().default("pending"),
+    input: jsonb("input").$type(),
+    config: jsonb("config").$type(),
+    context: jsonb("context").$type(),
+    output: jsonb("output").$type(),
+    error_message: text("error_message"),
+    user_id: text("user_id").notNull(),
+    execution_params: jsonb("execution_params").$type(),
+    claimed_by: text("claimed_by"),
+    lease_expires_at: timestamp2("lease_expires_at", { withTimezone: true }),
+    ...timestamps
+  }, (table) => [
+    index("idx_runs_thread_id").on(table.thread_id),
+    index("idx_runs_status").on(table.status),
+    index("idx_runs_user").on(table.user_id),
+    index("idx_runs_assistant_id").on(table.assistant_id),
+    index("idx_runs_created_at").on(table.created_at),
+    index("idx_runs_lease_reaper").on(table.status, table.lease_expires_at).where(sql`${table.status} = 'running'`)
+  ]);
+  crons = pgTable("crons", {
+    cron_id: text("cron_id").primaryKey().default(sql`gen_random_uuid()::text`),
+    assistant_id: text("assistant_id").notNull().references(() => assistants.assistant_id, { onDelete: "cascade" }),
+    thread_id: text("thread_id").references(() => threads.thread_id, { onDelete: "cascade" }),
+    user_id: text("user_id").notNull(),
+    schedule: text("schedule").notNull(),
+    payload: jsonb("payload").$type().notNull().default({}),
+    metadata: jsonb("metadata").$type().notNull().default({}),
+    on_run_completed: text("on_run_completed"),
+    enabled: boolean("enabled").notNull().default(true),
+    end_time: timestamp2("end_time", { withTimezone: true }),
+    next_run_date: timestamp2("next_run_date", { withTimezone: true }),
+    claimed_until: timestamp2("claimed_until", { withTimezone: true }),
+    ...timestamps
+  }, (table) => [
+    index("idx_cron_user").on(table.user_id),
+    index("idx_cron_assistant_id").on(table.assistant_id),
+    index("idx_cron_thread_id").on(table.thread_id),
+    index("idx_cron_next_run").on(table.enabled, table.next_run_date)
+  ]);
+  threadTtl = pgTable("thread_ttl", {
+    thread_id: text("thread_id").primaryKey().references(() => threads.thread_id, { onDelete: "cascade" }),
+    strategy: text("strategy").notNull().default("delete"),
+    ttl_minutes: doublePrecision("ttl_minutes").notNull(),
+    created_at: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expires_at: timestamp2("expires_at", { withTimezone: true }).notNull()
+  }, (table) => [index("idx_thread_ttl_expires_at").on(table.expires_at)]);
+});
+
 // src/core/database.ts
 var exports_database = {};
 __export(exports_database, {
   pingDatabase: () => pingDatabase,
   migrate: () => migrate,
+  initializeStore: () => initializeStore,
   db: () => db,
   closeDatabase: () => closeDatabase,
   client: () => client
 });
 import { createHash } from "crypto";
 import postgres from "postgres";
-import { drizzle as drizzle2 } from "drizzle-orm/postgres-js";
+import { drizzle } from "drizzle-orm/postgres-js";
 async function migrate(connection = client) {
   await connection.begin(async (sql2) => {
     await sql2.unsafe(`SELECT pg_advisory_xact_lock(${MIGRATION_LOCK_ID})`);
@@ -485,6 +686,9 @@ async function migrate(connection = client) {
     }
   });
 }
+async function initializeStore() {
+  await getOfficialStore();
+}
 async function pingDatabase() {
   try {
     await client`SELECT 1`;
@@ -494,8 +698,11 @@ async function pingDatabase() {
   }
 }
 async function closeDatabase() {
-  await closeLangGraphDatabase();
-  await client.end({ timeout: 5 });
+  try {
+    await closeLangGraphDatabase();
+  } finally {
+    await client.end({ timeout: 5 });
+  }
 }
 var client, db, migrations2, MIGRATION_LOCK_ID = 1095067474;
 var init_database = __esm(() => {
@@ -519,7 +726,7 @@ var init_database = __esm(() => {
       });
     }
   });
-  db = drizzle2({ client, schema: exports_schema });
+  db = drizzle({ client, schema: exports_schema });
   migrations2 = [
     {
       version: 1,
@@ -1147,9 +1354,13 @@ async function main(argv = process.argv.slice(2)) {
   if (command === "db" && args[0] === "upgrade") {
     const { options } = parseOptions(args.slice(1));
     await serverEnvironment(options);
-    const { migrate: migrate2, closeDatabase: closeDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
-    await migrate2();
-    await closeDatabase2();
+    const { migrate: migrate2, initializeStore: initializeStore2, closeDatabase: closeDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+    try {
+      await migrate2();
+      await initializeStore2();
+    } finally {
+      await closeDatabase2();
+    }
     console.log("Database is up to date");
     return;
   }
@@ -1164,4 +1375,4 @@ export {
   main
 };
 
-//# debugId=F0608CC7271E48CC64756E2164756E21
+//# debugId=9AF67AE5F33A402164756E2164756E21