@axiom-lattice/pg-stores 1.0.83 → 1.0.84

package/dist/index.mjs

@@ -1,8 +1,8 @@
 // src/index.ts
-import { Pool as Pool23 } from "pg";
+import { Pool as Pool24 } from "pg";
 
-// src/stores/PostgreSQLThreadStore.ts
-import { Pool } from "pg";
+// src/createPgStoreConfig.ts
+import { Pool as Pool21 } from "pg";
 
 // src/migrations/migration.ts
 var MigrationManager = class {
@@ -11,39 +11,68 @@ var MigrationManager = class {
     this.pool = pool;
   }
   /**
-   * Register a migration
+   * Register a migration.
+   * Duplicate names are rejected immediately (name = identity).
+   * Duplicate versions are allowed (version = ordering only).
    */
   register(migration) {
+    const existing = this.migrations.find((m) => m.name === migration.name);
+    if (existing) {
+      throw new Error(
+        `Migration name conflict: "${migration.name}" v${migration.version} collides with existing registration at v${existing.version}`
+      );
+    }
     this.migrations.push(migration);
     this.migrations.sort((a, b) => a.version - b.version);
   }
   /**
-   * Initialize migrations table if it doesn't exist
+   * Ensure the tracking table exists with the correct schema.
+   * Handles migration from old schema (PK on version) to new schema (PK on name).
    */
   async ensureMigrationsTable(client) {
-    await client.query(`
-      CREATE TABLE IF NOT EXISTS lattice_schema_migrations (
-        version INTEGER PRIMARY KEY,
-        name VARCHAR(255) NOT NULL,
-        applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+    const tableExists = await client.query(`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables
+        WHERE table_name = 'lattice_schema_migrations'
       )
     `);
+    if (!tableExists.rows[0].exists) {
+      await client.query(`
+        CREATE TABLE lattice_schema_migrations (
+          name VARCHAR(255) PRIMARY KEY,
+          version INTEGER NOT NULL,
+          applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      return;
+    }
+    const pkCheck = await client.query(`
+      SELECT a.attname AS column_name, con.conname AS constraint_name
+      FROM pg_index i
+      JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+      JOIN pg_constraint con ON con.conindid = i.indexrelid
+      WHERE i.indrelid = 'lattice_schema_migrations'::regclass
+        AND i.indisprimary
+    `);
+    const pkColumn = pkCheck.rows[0]?.column_name;
+    const constraintName = pkCheck.rows[0]?.constraint_name;
+    if (pkColumn === "version" && constraintName) {
+      await client.query(
+        `ALTER TABLE lattice_schema_migrations DROP CONSTRAINT ${constraintName}`
+      );
+      await client.query(
+        `ALTER TABLE lattice_schema_migrations ADD PRIMARY KEY (name)`
+      );
+    }
   }
   /**
-   * Get applied migrations from database
+   * Get the set of already-applied migration names from the tracking table.
    */
-  async getAppliedMigrations(client) {
-    await client.query(`
-      CREATE TABLE IF NOT EXISTS lattice_schema_migrations (
-        version INTEGER PRIMARY KEY,
-        name VARCHAR(255) NOT NULL,
-        applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
+  async getAppliedNames(client) {
     const result = await client.query(
-      "SELECT version, name, applied_at FROM lattice_schema_migrations ORDER BY version"
+      "SELECT name, version, applied_at FROM lattice_schema_migrations ORDER BY version"
     );
-    return result.rows;
+    return new Set(result.rows.map((r) => r.name));
   }
   /**
    * Apply pending migrations
@@ -57,10 +86,9 @@ var MigrationManager = class {
       try {
         await client.query("BEGIN");
         await this.ensureMigrationsTable(client);
-        const appliedMigrations = await this.getAppliedMigrations(client);
-        const appliedVersions = new Set(appliedMigrations.map((m) => m.version));
+        const appliedNames = await this.getAppliedNames(client);
         const pendingMigrations = this.migrations.filter(
-          (m) => !appliedVersions.has(m.version)
+          (m) => !appliedNames.has(m.name)
         );
         if (pendingMigrations.length === 0) {
           console.log("No pending migrations");
@@ -69,12 +97,12 @@ var MigrationManager = class {
         }
         for (const migration of pendingMigrations) {
           console.log(
-            `Applying migration ${migration.version}: ${migration.name}`
+            `Applying migration v${migration.version}: ${migration.name}`
           );
           await migration.up(client);
           await client.query(
-            "INSERT INTO lattice_schema_migrations (version, name) VALUES ($1, $2) ON CONFLICT (version) DO NOTHING",
-            [migration.version, migration.name]
+            "INSERT INTO lattice_schema_migrations (name, version) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING",
+            [migration.name, migration.version]
           );
         }
         await client.query("COMMIT");
@@ -90,34 +118,37 @@ var MigrationManager = class {
     }
   }
   /**
-   * Rollback last migration
+   * Rollback the last-applied migration (highest version).
    */
   async rollback() {
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
-      const appliedMigrations = await this.getAppliedMigrations(client);
-      if (appliedMigrations.length === 0) {
+      await this.ensureMigrationsTable(client);
+      const result = await client.query(
+        "SELECT name, version FROM lattice_schema_migrations ORDER BY version DESC LIMIT 1"
+      );
+      if (result.rows.length === 0) {
         console.log("No migrations to rollback");
         await client.query("COMMIT");
         return;
       }
-      const lastMigration = appliedMigrations[appliedMigrations.length - 1];
+      const lastApplied = result.rows[0];
       const migration = this.migrations.find(
-        (m) => m.version === lastMigration.version
+        (m) => m.name === lastApplied.name
       );
       if (!migration || !migration.down) {
         throw new Error(
-          `Migration ${lastMigration.version} does not have a down migration`
+          `Migration "${lastApplied.name}" (v${lastApplied.version}) does not have a down migration`
         );
       }
       console.log(
-        `Rolling back migration ${lastMigration.version}: ${lastMigration.name}`
+        `Rolling back migration v${lastApplied.version}: ${lastApplied.name}`
       );
       await migration.down(client);
       await client.query(
-        "DELETE FROM lattice_schema_migrations WHERE version = $1",
-        [lastMigration.version]
+        "DELETE FROM lattice_schema_migrations WHERE name = $1",
+        [lastApplied.name]
       );
       await client.query("COMMIT");
       console.log("Rollback completed");
@@ -129,22 +160,25 @@ var MigrationManager = class {
     }
   }
   /**
-   * Get current migration version
+   * Get the highest applied migration version.
    */
   async getCurrentVersion() {
     const client = await this.pool.connect();
     try {
-      const appliedMigrations = await this.getAppliedMigrations(client);
-      if (appliedMigrations.length === 0) {
-        return 0;
-      }
-      return Math.max(...appliedMigrations.map((m) => m.version));
+      await this.ensureMigrationsTable(client);
+      const result = await client.query(
+        "SELECT COALESCE(MAX(version), 0) AS max FROM lattice_schema_migrations"
+      );
+      return result.rows[0]?.max ?? 0;
     } finally {
       client.release();
     }
   }
 };
 
+// src/stores/PostgreSQLThreadStore.ts
+import { Pool } from "pg";
+
 // src/migrations/thread_migrations.ts
 var createThreadsTable = {
   version: 1,
@@ -285,10 +319,18 @@ var PostgreSQLThreadStore = class {
     this.initialized = false;
     this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createThreadsTable);
@@ -631,10 +673,18 @@ var PostgreSQLAssistantStore = class {
     this.initialized = false;
     this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool2({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool2(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createAssistantsTable);
@@ -911,11 +961,20 @@ import { encrypt, decrypt } from "@axiom-lattice/core";
 var PostgreSQLDatabaseConfigStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool3({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool3(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createDatabaseConfigsTable);
@@ -1134,7 +1193,9 @@ var PostgreSQLDatabaseConfigStore = class {
    * Dispose resources and close the connection pool
    */
   async dispose() {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
   /**
    * Ensure store is initialized
@@ -1225,11 +1286,20 @@ import { encrypt as encrypt2, decrypt as decrypt2 } from "@axiom-lattice/core";
 var PostgreSQLMetricsServerConfigStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool4({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool4(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMetricsConfigsTable);
@@ -1448,7 +1518,9 @@ var PostgreSQLMetricsServerConfigStore = class {
    * Dispose resources and close the connection pool
    */
   async dispose() {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
   /**
    * Ensure store is initialized
@@ -1558,11 +1630,20 @@ import { encrypt as encrypt3, decrypt as decrypt3 } from "@axiom-lattice/core";
 var PostgreSQLMcpServerConfigStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool5({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool5(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMcpServerConfigsTable);
@@ -1797,7 +1878,9 @@ var PostgreSQLMcpServerConfigStore = class {
    * Dispose resources and close the connection pool
    */
   async dispose() {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
   /**
    * Ensure store is initialized
@@ -1898,10 +1981,18 @@ var PostgreSQLWorkspaceStore = class {
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool6({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool6(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createWorkspacesTable);
@@ -2141,10 +2232,18 @@ var PostgreSQLProjectStore = class {
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool7({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool7(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createProjectsTable);
@@ -2391,10 +2490,19 @@ var addUserStatusColumn = {
 var PostgreSQLUserStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool8({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool8(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createUsersTable);
@@ -2407,7 +2515,9 @@ var PostgreSQLUserStore = class {
     }
   }
   async dispose() {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
   async initialize() {
     if (this.initialized) return;
@@ -2580,10 +2690,18 @@ var PostgreSQLTenantStore = class {
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool9({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool9(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createTenantsTable);
@@ -2833,10 +2951,19 @@ var migrateRemoveTenantIdFromUsers = {
 var PostgreSQLUserTenantLinkStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool10({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool10(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createUserTenantLinkTable);
@@ -2849,7 +2976,9 @@ var PostgreSQLUserTenantLinkStore = class {
     }
   }
   async dispose() {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
   async initialize() {
     if (this.initialized) return;
@@ -3078,11 +3207,20 @@ var addStepThreadId = {
 var PostgreSQLWorkflowTrackingStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool11({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool11(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createWorkflowTrackingTables);
@@ -3095,7 +3233,9 @@ var PostgreSQLWorkflowTrackingStore = class {
     }
   }
   async dispose() {
-    await this.pool.end();
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
   }
   async initialize() {
     if (this.initialized) return;
@@ -3584,10 +3724,18 @@ var PostgreSQLEvalStore = class {
     this.initialized = false;
     this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool12({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool12(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     for (const m of evalMigrations) {
@@ -4450,10 +4598,18 @@ var ThreadMessageQueueStore = class {
     this.ownsPool = true;
     this.initialized = false;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool13({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool13(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createThreadMessageQueueTable);
@@ -4692,8 +4848,17 @@ var createChannelBindingsTable = {
 var ChannelBindingStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool14({ connectionString: options.poolConfig }) : new Pool14(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool14({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool14(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createChannelBindingsTable);
     if (options.autoMigrate !== false) {
@@ -4716,6 +4881,11 @@ var ChannelBindingStore = class {
     })();
     return this.initPromise;
   }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
   async resolve(params) {
     await this.ensureInitialized();
     const result = await this.pool.query(
@@ -4939,8 +5109,17 @@ import { decrypt as decrypt4, encrypt as encrypt4 } from "@axiom-lattice/core";
 var PostgreSQLChannelInstallationStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool15({ connectionString: options.poolConfig }) : new Pool15(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool15({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool15(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createChannelInstallationsTable);
     this.migrationManager.register(alterChannelInstallationsTable);
@@ -4971,6 +5150,11 @@ var PostgreSQLChannelInstallationStore = class {
     })();
     return this.initPromise;
   }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
   async getInstallationById(installationId) {
     await this.ensureInitialized();
     const result = await this.pool.query(
@@ -5215,8 +5399,17 @@ function mapRowToRecord(row) {
 var PostgreSQLA2AApiKeyStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool16({ connectionString: options.poolConfig }) : new Pool16(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool16({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool16(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createA2AApiKeysTable);
     if (options.autoMigrate !== false) {
@@ -5239,6 +5432,11 @@ var PostgreSQLA2AApiKeyStore = class {
     })();
     return this.initPromise;
   }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
   async ensureInitialized() {
     if (!this.initialized) await this.initialize();
   }
@@ -5504,10 +5702,19 @@ var addScheduleTenantId = {
 var PostgreSQLScheduleStorage = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool17({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool17(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createScheduledTasksTable);
@@ -5523,7 +5730,7 @@ var PostgreSQLScheduleStorage = class {
    * Dispose resources and close the connection pool
    */
   async dispose() {
-    if (this.pool) {
+    if (this.ownsPool && this.pool) {
       await this.pool.end();
     }
   }
@@ -6017,10 +6224,18 @@ var PostgreSQLTaskStore = class {
     this.initialized = false;
     this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
       this.pool = new Pool18({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new Pool18(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createTasksTable);
@@ -6284,8 +6499,17 @@ var addFileContentType = {
 var MenuStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool19({ connectionString: options.poolConfig }) : new Pool19(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool19({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool19(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMenuItemsTable);
     this.migrationManager.register(addFileContentType);
@@ -6309,6 +6533,11 @@ var MenuStore = class {
     })();
     return this.initPromise;
   }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
   async list(params) {
     await this.ensureInitialized();
     const conditions = ["tenant_id = $1"];
@@ -6479,8 +6708,17 @@ var createSharedResourcesTable = {
 var PostgresSharedResourceStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool20({ connectionString: options.poolConfig }) : new Pool20(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool20({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool20(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createSharedResourcesTable);
     if (options.autoMigrate !== false) {
@@ -6506,6 +6744,11 @@ var PostgresSharedResourceStore = class {
     })();
     return this.initPromise;
   }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
   async findByToken(token) {
     await this.ensureInitialized();
     const { rows } = await this.pool.query(
@@ -6643,39 +6886,6 @@ var PostgresSharedResourceStore = class {
 
 // src/createPgStoreConfig.ts
 import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
-function createPgStoreConfig(connectionString) {
-  const opts = { poolConfig: connectionString, autoMigrate: true };
-  const checkpoint = PostgresSaver.fromConnString(connectionString);
-  checkpoint.setup().catch((err) => {
-    console.error("[pg-stores] Failed to setup checkpoint table:", err.message || err);
-  });
-  return {
-    workspace: new PostgreSQLWorkspaceStore(opts),
-    project: new PostgreSQLProjectStore(opts),
-    eval: new PostgreSQLEvalStore(opts),
-    user: new PostgreSQLUserStore(opts),
-    tenant: new PostgreSQLTenantStore(opts),
-    userTenantLink: new PostgreSQLUserTenantLinkStore(opts),
-    channelBinding: new ChannelBindingStore(opts),
-    channelInstallation: new PostgreSQLChannelInstallationStore(opts),
-    thread: new PostgreSQLThreadStore(opts),
-    database: new PostgreSQLDatabaseConfigStore(opts),
-    metrics: new PostgreSQLMetricsServerConfigStore(opts),
-    mcp: new PostgreSQLMcpServerConfigStore(opts),
-    assistant: new PostgreSQLAssistantStore(opts),
-    workflowTracking: new PostgreSQLWorkflowTrackingStore(opts),
-    threadMessageQueue: new ThreadMessageQueueStore(opts),
-    task: new PostgreSQLTaskStore(opts),
-    a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
-    schedule: new PostgreSQLScheduleStorage(opts),
-    menu: new MenuStore(opts),
-    sharedResource: new PostgresSharedResourceStore(opts),
-    checkpoint
-  };
-}
-
-// src/stores/PostgreSQLSkillStore.ts
-import { Pool as Pool21 } from "pg";
 
 // src/migrations/skill_migrations.ts
 var createSkillsTable = {
@@ -6830,16 +7040,157 @@ var changeSkillPrimaryKey = {
   }
 };
 
+// src/migrations/channel_identity_mapping_migration.ts
+var createChannelIdentityMappingTables = {
+  version: 20,
+  name: "create_channel_identity_mapping_tables",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS channel_identity_mappings (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        channel VARCHAR(50) NOT NULL,
+        channel_app_id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        assistant_id VARCHAR(255) NOT NULL,
+        mapping_mode VARCHAR(20) NOT NULL CHECK (mapping_mode IN ('user', 'group', 'hybrid')),
+        external_subject_type VARCHAR(20) NOT NULL CHECK (external_subject_type IN ('user', 'chat')),
+        external_subject_key VARCHAR(512) NOT NULL,
+        lark_open_id VARCHAR(255),
+        lark_chat_id VARCHAR(255) NOT NULL,
+        lark_message_id VARCHAR(255),
+        thread_id VARCHAR(255) NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        last_activity_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE (channel, channel_app_id, tenant_id, assistant_id, external_subject_key)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_channel_identity_lookup
+      ON channel_identity_mappings(channel, channel_app_id, tenant_id, assistant_id, external_subject_key)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_channel_identity_thread
+      ON channel_identity_mappings(thread_id, tenant_id)
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS channel_inbound_message_receipts (
+        channel VARCHAR(50) NOT NULL,
+        channel_app_id VARCHAR(255) NOT NULL,
+        external_message_id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        status VARCHAR(20) NOT NULL DEFAULT 'processing' CHECK (status IN ('processing', 'completed', 'failed')),
+        thread_id VARCHAR(255),
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (channel, channel_app_id, external_message_id)
+      )
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP TABLE IF EXISTS channel_inbound_message_receipts");
+    await client.query("DROP INDEX IF EXISTS idx_channel_identity_thread");
+    await client.query("DROP INDEX IF EXISTS idx_channel_identity_lookup");
+    await client.query("DROP TABLE IF EXISTS channel_identity_mappings");
+  }
+};
+
+// src/createPgStoreConfig.ts
+async function createPgStoreConfig(connectionString) {
+  const pool = new Pool21({ connectionString });
+  const mm = new MigrationManager(pool);
+  mm.register(createThreadsTable);
+  mm.register(createScheduledTasksTable);
+  mm.register(createAssistantsTable);
+  mm.register(createSkillsTable);
+  mm.register(createWorkspacesTable);
+  mm.register(createProjectsTable);
+  mm.register(createUsersTable);
+  mm.register(createTenantsTable);
+  mm.register(addUserStatusColumn);
+  mm.register(createUserTenantLinkTable);
+  mm.register(migrateRemoveTenantIdFromUsers);
+  mm.register(createMetricsConfigsTable);
+  mm.register(createMcpServerConfigsTable);
+  mm.register(addAssistantTenantId);
+  mm.register(addSkillTenantId);
+  mm.register(changeSkillPrimaryKey);
+  mm.register(addScheduleTenantId);
+  mm.register(changeThreadPrimaryKey);
+  mm.register(createChannelIdentityMappingTables);
+  mm.register(createChannelInstallationsTable);
+  mm.register(addThreadTenantId);
+  mm.register(addProjectConfigColumn);
+  mm.register(createThreadMessageQueueTable);
+  mm.register(addPriorityAndCommandColumns);
+  mm.register(alterMessageQueueIdColumn);
+  mm.register(createWorkflowTrackingTables);
+  for (const m of evalMigrations) {
+    mm.register(m);
+  }
+  mm.register(alterChannelInstallationsTable);
+  mm.register(createChannelBindingsTable);
+  mm.register(createDatabaseConfigsTable);
+  mm.register(changeAssistantPrimaryKey);
+  mm.register(addStepThreadId);
+  mm.register(addCustomRunConfigColumn);
+  mm.register(createA2AApiKeysTable);
+  mm.register(addWorkspaceProjectToQueue);
+  mm.register(addAssistantOwnerUserId);
+  mm.register(createTasksTable);
+  mm.register(createMenuItemsTable);
+  mm.register(createSharedResourcesTable);
+  mm.register(addFileContentType);
+  await mm.migrate();
+  const checkpoint = PostgresSaver.fromConnString(connectionString);
+  checkpoint.setup().catch((err) => {
+    console.error("[pg-stores] Failed to setup checkpoint table:", err.message || err);
+  });
+  const opts = { pool };
+  return {
+    workspace: new PostgreSQLWorkspaceStore(opts),
+    project: new PostgreSQLProjectStore(opts),
+    eval: new PostgreSQLEvalStore(opts),
+    user: new PostgreSQLUserStore(opts),
+    tenant: new PostgreSQLTenantStore(opts),
+    userTenantLink: new PostgreSQLUserTenantLinkStore(opts),
+    channelBinding: new ChannelBindingStore(opts),
+    channelInstallation: new PostgreSQLChannelInstallationStore(opts),
+    thread: new PostgreSQLThreadStore(opts),
+    database: new PostgreSQLDatabaseConfigStore(opts),
+    metrics: new PostgreSQLMetricsServerConfigStore(opts),
+    mcp: new PostgreSQLMcpServerConfigStore(opts),
+    assistant: new PostgreSQLAssistantStore(opts),
+    workflowTracking: new PostgreSQLWorkflowTrackingStore(opts),
+    threadMessageQueue: new ThreadMessageQueueStore(opts),
+    task: new PostgreSQLTaskStore(opts),
+    a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
+    schedule: new PostgreSQLScheduleStorage(opts),
+    menu: new MenuStore(opts),
+    sharedResource: new PostgresSharedResourceStore(opts),
+    checkpoint
+  };
+}
+
 // src/stores/PostgreSQLSkillStore.ts
+import { Pool as Pool22 } from "pg";
 var PostgreSQLSkillStore = class {
   constructor(options) {
     this.initialized = false;
     this.ownsPool = true;
     this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool21({ connectionString: options.poolConfig });
+      this.pool = new Pool22({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new Pool22(options.poolConfig);
     } else {
-      this.pool = new Pool21(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createSkillsTable);
@@ -7137,68 +7488,22 @@ var PostgreSQLSkillStore = class {
   }
 };
 
-// src/migrations/channel_identity_mapping_migration.ts
-var createChannelIdentityMappingTables = {
-  version: 20,
-  name: "create_channel_identity_mapping_tables",
-  up: async (client) => {
-    await client.query(`
-      CREATE TABLE IF NOT EXISTS channel_identity_mappings (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        channel VARCHAR(50) NOT NULL,
-        channel_app_id VARCHAR(255) NOT NULL,
-        tenant_id VARCHAR(255) NOT NULL,
-        assistant_id VARCHAR(255) NOT NULL,
-        mapping_mode VARCHAR(20) NOT NULL CHECK (mapping_mode IN ('user', 'group', 'hybrid')),
-        external_subject_type VARCHAR(20) NOT NULL CHECK (external_subject_type IN ('user', 'chat')),
-        external_subject_key VARCHAR(512) NOT NULL,
-        lark_open_id VARCHAR(255),
-        lark_chat_id VARCHAR(255) NOT NULL,
-        lark_message_id VARCHAR(255),
-        thread_id VARCHAR(255) NOT NULL,
-        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        last_activity_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        UNIQUE (channel, channel_app_id, tenant_id, assistant_id, external_subject_key)
-      )
-    `);
-    await client.query(`
-      CREATE INDEX IF NOT EXISTS idx_channel_identity_lookup
-      ON channel_identity_mappings(channel, channel_app_id, tenant_id, assistant_id, external_subject_key)
-    `);
-    await client.query(`
-      CREATE INDEX IF NOT EXISTS idx_channel_identity_thread
-      ON channel_identity_mappings(thread_id, tenant_id)
-    `);
-    await client.query(`
-      CREATE TABLE IF NOT EXISTS channel_inbound_message_receipts (
-        channel VARCHAR(50) NOT NULL,
-        channel_app_id VARCHAR(255) NOT NULL,
-        external_message_id VARCHAR(255) NOT NULL,
-        tenant_id VARCHAR(255) NOT NULL,
-        status VARCHAR(20) NOT NULL DEFAULT 'processing' CHECK (status IN ('processing', 'completed', 'failed')),
-        thread_id VARCHAR(255),
-        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (channel, channel_app_id, external_message_id)
-      )
-    `);
-  },
-  down: async (client) => {
-    await client.query("DROP TABLE IF EXISTS channel_inbound_message_receipts");
-    await client.query("DROP INDEX IF EXISTS idx_channel_identity_thread");
-    await client.query("DROP INDEX IF EXISTS idx_channel_identity_lookup");
-    await client.query("DROP TABLE IF EXISTS channel_identity_mappings");
-  }
-};
-
 // src/stores/ChannelIdentityMappingStore.ts
-import { Pool as Pool22 } from "pg";
+import { Pool as Pool23 } from "pg";
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool22({ connectionString: options.poolConfig }) : new Pool22(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool23({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool23(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createChannelIdentityMappingTables);
     if (options.autoMigrate !== false) {
@@ -7225,6 +7530,11 @@ var ChannelIdentityMappingStore = class {
     })();
     return this.initPromise;
   }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
   async createMapping(input) {
     await this.ensureInitialized();
     const result = await this.pool.query(
@@ -7414,7 +7724,7 @@ export {
   ChannelIdentityMappingStore,
   MenuStore,
   MigrationManager,
-  Pool23 as Pool,
+  Pool24 as Pool,
   PostgreSQLA2AApiKeyStore,
   PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore,