@axiom-lattice/pg-stores 1.0.83 → 1.0.85

package/dist/index.js

@@ -34,7 +34,7 @@ __export(index_exports, {
   ChannelIdentityMappingStore: () => ChannelIdentityMappingStore,
   MenuStore: () => MenuStore,
   MigrationManager: () => MigrationManager,
-  Pool: () => import_pg23.Pool,
+  Pool: () => import_pg24.Pool,
   PostgreSQLA2AApiKeyStore: () => PostgreSQLA2AApiKeyStore,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore: () => PostgreSQLChannelInstallationStore,
@@ -95,10 +95,10 @@ __export(index_exports, {
   safeParse: () => safeParse
 });
 module.exports = __toCommonJS(index_exports);
-var import_pg23 = require("pg");
+var import_pg24 = require("pg");
 
-// src/stores/PostgreSQLThreadStore.ts
-var import_pg = require("pg");
+// src/createPgStoreConfig.ts
+var import_pg21 = require("pg");
 
 // src/migrations/migration.ts
 var MigrationManager = class {
@@ -107,39 +107,73 @@ 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(`
+        DELETE FROM lattice_schema_migrations a
+        USING lattice_schema_migrations b
+        WHERE a.name = b.name AND a.version < b.version
+      `);
+      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
@@ -153,10 +187,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");
@@ -165,12 +198,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");
@@ -186,34 +219,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");
@@ -225,22 +261,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
+var import_pg = require("pg");
+
 // src/migrations/thread_migrations.ts
 var createThreadsTable = {
   version: 1,
@@ -381,10 +420,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 import_pg.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createThreadsTable);
@@ -727,10 +774,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 import_pg2.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg2.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createAssistantsTable);
@@ -1007,11 +1062,20 @@ var import_core = require("@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 import_pg3.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg3.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createDatabaseConfigsTable);
@@ -1230,7 +1294,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
@@ -1321,11 +1387,20 @@ var import_core2 = require("@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 import_pg4.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg4.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMetricsConfigsTable);
@@ -1544,7 +1619,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
@@ -1654,11 +1731,20 @@ var import_core3 = require("@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 import_pg5.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg5.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMcpServerConfigsTable);
@@ -1893,7 +1979,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
@@ -1994,10 +2082,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 import_pg6.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg6.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createWorkspacesTable);
@@ -2237,10 +2333,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 import_pg7.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg7.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createProjectsTable);
@@ -2487,10 +2591,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 import_pg8.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg8.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createUsersTable);
@@ -2503,7 +2616,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;
@@ -2676,10 +2791,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 import_pg9.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg9.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createTenantsTable);
@@ -2929,10 +3052,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 import_pg10.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg10.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createUserTenantLinkTable);
@@ -2945,7 +3077,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;
@@ -3174,11 +3308,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 import_pg11.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg11.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createWorkflowTrackingTables);
@@ -3191,7 +3334,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;
@@ -3680,10 +3825,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 import_pg12.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg12.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     for (const m of evalMigrations) {
@@ -4546,10 +4699,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 import_pg13.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg13.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createThreadMessageQueueTable);
@@ -4788,8 +4949,17 @@ var createChannelBindingsTable = {
 var ChannelBindingStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new import_pg14.Pool({ connectionString: options.poolConfig }) : new import_pg14.Pool(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new import_pg14.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg14.Pool(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) {
@@ -4812,6 +4982,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(
@@ -5035,8 +5210,17 @@ var import_core4 = require("@axiom-lattice/core");
 var PostgreSQLChannelInstallationStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new import_pg15.Pool({ connectionString: options.poolConfig }) : new import_pg15.Pool(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new import_pg15.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg15.Pool(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);
@@ -5067,6 +5251,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(
@@ -5311,8 +5500,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 import_pg16.Pool({ connectionString: options.poolConfig }) : new import_pg16.Pool(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new import_pg16.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg16.Pool(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) {
@@ -5335,6 +5533,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();
   }
@@ -5598,10 +5801,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 import_pg17.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg17.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createScheduledTasksTable);
@@ -5617,7 +5829,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();
     }
   }
@@ -6111,10 +6323,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 import_pg18.Pool({ connectionString: options.poolConfig });
-    } else {
+    } else if (options.poolConfig) {
       this.pool = new import_pg18.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createTasksTable);
@@ -6378,8 +6598,17 @@ var addFileContentType = {
 var MenuStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new import_pg19.Pool({ connectionString: options.poolConfig }) : new import_pg19.Pool(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new import_pg19.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg19.Pool(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);
@@ -6403,6 +6632,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"];
@@ -6573,8 +6807,17 @@ var createSharedResourcesTable = {
 var PostgresSharedResourceStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new import_pg20.Pool({ connectionString: options.poolConfig }) : new import_pg20.Pool(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new import_pg20.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg20.Pool(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) {
@@ -6600,6 +6843,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(
@@ -6737,39 +6985,6 @@ var PostgresSharedResourceStore = class {
 
 // src/createPgStoreConfig.ts
 var import_langgraph_checkpoint_postgres = require("@langchain/langgraph-checkpoint-postgres");
-function createPgStoreConfig(connectionString) {
-  const opts = { poolConfig: connectionString, autoMigrate: true };
-  const checkpoint = import_langgraph_checkpoint_postgres.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
-var import_pg21 = require("pg");
 
 // src/migrations/skill_migrations.ts
 var createSkillsTable = {
@@ -6924,16 +7139,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 import_pg21.Pool({ 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 = import_langgraph_checkpoint_postgres.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
+var import_pg22 = require("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 import_pg21.Pool({ connectionString: options.poolConfig });
+      this.pool = new import_pg22.Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new import_pg22.Pool(options.poolConfig);
     } else {
-      this.pool = new import_pg21.Pool(options.poolConfig);
+      throw new Error("Either pool or poolConfig must be provided");
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createSkillsTable);
@@ -7231,68 +7587,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
-var import_pg22 = require("pg");
+var import_pg23 = require("pg");
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
+    this.ownsPool = true;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new import_pg22.Pool({ connectionString: options.poolConfig }) : new import_pg22.Pool(options.poolConfig);
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new import_pg23.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg23.Pool(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) {
@@ -7319,6 +7629,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(