@axiom-lattice/pg-stores 1.0.85 → 1.0.87

package/dist/index.js

@@ -34,10 +34,13 @@ __export(index_exports, {
   ChannelIdentityMappingStore: () => ChannelIdentityMappingStore,
   MenuStore: () => MenuStore,
   MigrationManager: () => MigrationManager,
-  Pool: () => import_pg24.Pool,
+  PGVectorStoreProvider: () => PGVectorStoreProvider,
+  Pool: () => import_pg26.Pool,
   PostgreSQLA2AApiKeyStore: () => PostgreSQLA2AApiKeyStore,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore: () => PostgreSQLChannelInstallationStore,
+  PostgreSQLCollectionStore: () => PostgreSQLCollectionStore,
+  PostgreSQLConnectionStore: () => PostgreSQLConnectionStore,
   PostgreSQLDatabaseConfigStore: () => PostgreSQLDatabaseConfigStore,
   PostgreSQLEvalStore: () => PostgreSQLEvalStore,
   PostgreSQLMcpServerConfigStore: () => PostgreSQLMcpServerConfigStore,
@@ -69,6 +72,7 @@ __export(index_exports, {
   createChannelBindingsTable: () => createChannelBindingsTable,
   createChannelIdentityMappingTables: () => createChannelIdentityMappingTables,
   createChannelInstallationsTable: () => createChannelInstallationsTable,
+  createCollectionsTable: () => createCollectionsTable,
   createDatabaseConfigsTable: () => createDatabaseConfigsTable,
   createEvalCasesTable: () => createEvalCasesTable,
   createEvalProjectsTable: () => createEvalProjectsTable,
@@ -78,6 +82,7 @@ __export(index_exports, {
   createMcpServerConfigsTable: () => createMcpServerConfigsTable,
   createMenuItemsTable: () => createMenuItemsTable,
   createMetricsConfigsTable: () => createMetricsConfigsTable,
+  createPGVectorStoreProvider: () => createPGVectorStoreProvider,
   createPgStoreConfig: () => createPgStoreConfig,
   createProjectsTable: () => createProjectsTable,
   createScheduledTasksTable: () => createScheduledTasksTable,
@@ -95,10 +100,10 @@ __export(index_exports, {
   safeParse: () => safeParse
 });
 module.exports = __toCommonJS(index_exports);
-var import_pg24 = require("pg");
+var import_pg26 = require("pg");
 
 // src/createPgStoreConfig.ts
-var import_pg21 = require("pg");
+var import_pg23 = require("pg");
 
 // src/migrations/migration.ts
 var MigrationManager = class {
@@ -1343,6 +1348,101 @@ var PostgreSQLDatabaseConfigStore = class {
   }
 };
 
+// src/stores/PostgreSQLConnectionStore.ts
+var import_uuid = require("uuid");
+var TABLE = "lattice_connection_configs";
+var PostgreSQLConnectionStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async listByType(tenantId, type) {
+    const result = await this.db.query(
+      `SELECT * FROM ${TABLE} WHERE tenant_id = $1 AND type = $2 ORDER BY created_at`,
+      [tenantId, type]
+    );
+    return result.rows.map((row) => this.mapRow(row));
+  }
+  async getByKey(tenantId, type, key) {
+    const result = await this.db.query(
+      `SELECT * FROM ${TABLE} WHERE tenant_id = $1 AND type = $2 AND key = $3`,
+      [tenantId, type, key]
+    );
+    if (result.rows.length === 0) return null;
+    return this.mapRow(result.rows[0]);
+  }
+  async create(entry) {
+    const id = (0, import_uuid.v4)();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.db.query(
+      `INSERT INTO ${TABLE} (id, tenant_id, type, key, name, description, config, status, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, 'active', $8::timestamp, $9::timestamp)`,
+      [
+        id,
+        entry.tenantId,
+        entry.type,
+        entry.key,
+        entry.name,
+        entry.description || null,
+        JSON.stringify(entry.config),
+        now,
+        now
+      ]
+    );
+    return { id, ...entry, createdAt: now, updatedAt: now };
+  }
+  async update(tenantId, type, key, updates) {
+    const existing = await this.getByKey(tenantId, type, key);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    let paramIndex = 1;
+    if (updates.name !== void 0) {
+      setClauses.push(`name = $${paramIndex++}`);
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push(`description = $${paramIndex++}`);
+      values.push(updates.description || null);
+    }
+    if (updates.config !== void 0) {
+      setClauses.push(`config = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.config));
+    }
+    if (setClauses.length === 0) return existing;
+    setClauses.push(`updated_at = $${paramIndex++}::timestamp`);
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(tenantId, type, key);
+    const whereTenant = paramIndex++;
+    const whereType = paramIndex++;
+    const whereKey = paramIndex;
+    await this.db.query(
+      `UPDATE ${TABLE} SET ${setClauses.join(", ")} WHERE tenant_id = $${whereTenant} AND type = $${whereType} AND key = $${whereKey}`,
+      values
+    );
+    return this.getByKey(tenantId, type, key);
+  }
+  async delete(tenantId, type, key) {
+    const result = await this.db.query(
+      `DELETE FROM ${TABLE} WHERE tenant_id = $1 AND type = $2 AND key = $3`,
+      [tenantId, type, key]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  mapRow(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      type: row.type,
+      key: row.key,
+      name: row.name,
+      description: row.description || void 0,
+      config: typeof row.config === "string" ? JSON.parse(row.config) : row.config,
+      createdAt: row.created_at instanceof Date ? row.created_at.toISOString() : String(row.created_at),
+      updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at)
+    };
+  }
+};
+
 // src/stores/PostgreSQLMetricsServerConfigStore.ts
 var import_pg4 = require("pg");
 
@@ -1871,7 +1971,7 @@ var PostgreSQLMcpServerConfigStore = class {
         data.name || null,
         data.description || null,
         JSON.stringify(configWithEncryptedEnv),
-        data.selectedTools || [],
+        JSON.stringify(data.selectedTools || []),
         isEnvEncrypted,
         "disconnected",
         nowString,
@@ -1917,7 +2017,7 @@ var PostgreSQLMcpServerConfigStore = class {
       updateData.is_env_encrypted = isEnvEncrypted;
     }
     if (updates.selectedTools !== void 0) {
-      updateData.selected_tools = updates.selectedTools;
+      updateData.selected_tools = JSON.stringify(updates.selectedTools);
     }
     if (updates.status !== void 0) {
       updateData.status = updates.status;
@@ -3819,7 +3919,7 @@ var evalMigrations = [
 ];
 
 // src/stores/PostgreSQLEvalStore.ts
-var import_uuid = require("uuid");
+var import_uuid2 = require("uuid");
 var PostgreSQLEvalStore = class {
   constructor(options) {
     this.initialized = false;
@@ -4015,7 +4115,7 @@ var PostgreSQLEvalStore = class {
   /** Create a new eval project */
   async createProject(tenantId, id, data) {
     await this.ensureInitialized();
-    const actualId = id || (0, import_uuid.v4)();
+    const actualId = id || (0, import_uuid2.v4)();
     const { rows } = await this.pool.query(
       `INSERT INTO lattice_eval_projects
         (id, tenant_id, name, description, version, judge_model_config, target_server_config, concurrency, report_config)
@@ -4128,7 +4228,7 @@ var PostgreSQLEvalStore = class {
   /** Create a new eval suite */
   async createSuite(tenantId, projectId, id, data) {
     await this.ensureInitialized();
-    const actualId = id || (0, import_uuid.v4)();
+    const actualId = id || (0, import_uuid2.v4)();
     const { rows } = await this.pool.query(
       `INSERT INTO lattice_eval_suites (id, tenant_id, project_id, name)
        VALUES ($1, $2, $3, $4)
@@ -4202,7 +4302,7 @@ var PostgreSQLEvalStore = class {
   /** Create a new test case */
   async createCase(tenantId, suiteId, id, data) {
     await this.ensureInitialized();
-    const actualId = id || (0, import_uuid.v4)();
+    const actualId = id || (0, import_uuid2.v4)();
     const { rows } = await this.pool.query(
       `INSERT INTO lattice_eval_cases
         (id, tenant_id, suite_id, input_message, input_files, steps, output_type, content_assertion, rubrics)
@@ -4324,7 +4424,7 @@ var PostgreSQLEvalStore = class {
   /** Create a new eval run */
   async createRun(tenantId, projectId, id, data) {
     await this.ensureInitialized();
-    const actualId = id || (0, import_uuid.v4)();
+    const actualId = id || (0, import_uuid2.v4)();
     const { rows } = await this.pool.query(
       `INSERT INTO lattice_eval_runs
         (id, project_id, tenant_id, status, concurrency, total_cases, passed_cases, failed_cases, avg_score, started_at)
@@ -4422,7 +4522,7 @@ var PostgreSQLEvalStore = class {
   /** Create a result for a case within a run */
   async createRunResult(tenantId, runId, id, data) {
     await this.ensureInitialized();
-    const actualId = id || (0, import_uuid.v4)();
+    const actualId = id || (0, import_uuid2.v4)();
     const { rows } = await this.pool.query(
       `INSERT INTO lattice_eval_run_results
         (id, run_id, suite_name, case_id, pass, score, summary, dimension_results, duration_ms, messages, logs, error)
@@ -6298,7 +6398,7 @@ var createTasksTable = {
 };
 
 // src/stores/PostgreSQLTaskStore.ts
-var import_uuid2 = require("uuid");
+var import_uuid3 = require("uuid");
 function mapRowToTask(row) {
   return {
     id: row.id,
@@ -6364,7 +6464,7 @@ var PostgreSQLTaskStore = class {
   }
   async create(params) {
     await this.ensureInitialized();
-    const id = (0, import_uuid2.v4)();
+    const id = (0, import_uuid3.v4)();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await this.pool.query(
       `INSERT INTO lattice_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, created_at, updated_at)
@@ -6983,9 +7083,218 @@ var PostgresSharedResourceStore = class {
   }
 };
 
+// src/stores/PostgreSQLCollectionStore.ts
+var import_pg21 = require("pg");
+var PostgreSQLCollectionStore = 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 });
+    } else if (options.poolConfig) {
+      this.pool = new import_pg21.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
+    }
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLCollectionStore:", error);
+      });
+    }
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      this.initialized = true;
+    })();
+    return this.initPromise;
+  }
+  ensureInit() {
+    if (!this.initialized) {
+      throw new Error("PostgreSQLCollectionStore not initialized");
+    }
+  }
+  async getAllCollections(tenantId) {
+    this.ensureInit();
+    const result = await this.pool.query(
+      `SELECT id, name, tenant_id, label, embedding_key, schema, created_at, updated_at
+       FROM lattice_collections WHERE tenant_id = $1 ORDER BY name`,
+      [tenantId]
+    );
+    return result.rows.map(this.rowToCollection);
+  }
+  async getCollectionByName(tenantId, name) {
+    this.ensureInit();
+    const result = await this.pool.query(
+      `SELECT id, name, tenant_id, label, embedding_key, schema, created_at, updated_at
+       FROM lattice_collections WHERE tenant_id = $1 AND name = $2`,
+      [tenantId, name]
+    );
+    return result.rows.length > 0 ? this.rowToCollection(result.rows[0]) : null;
+  }
+  async createCollection(tenantId, data) {
+    this.ensureInit();
+    const schema = JSON.stringify(data.schema || { fields: [] });
+    const result = await this.pool.query(
+      `INSERT INTO lattice_collections (name, tenant_id, label, embedding_key, schema)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (tenant_id, name) DO NOTHING
+       RETURNING id, name, tenant_id, label, embedding_key, schema, created_at, updated_at`,
+      [data.name, tenantId, data.label, data.embeddingKey, schema]
+    );
+    if (result.rows.length === 0) {
+      throw new Error(`Collection "${data.name}" already exists`);
+    }
+    return this.rowToCollection(result.rows[0]);
+  }
+  async updateCollection(tenantId, name, updates) {
+    this.ensureInit();
+    const setClauses = [];
+    const values = [];
+    let paramIndex = 1;
+    if (updates.label !== void 0) {
+      setClauses.push(`label = $${paramIndex++}`);
+      values.push(updates.label);
+    }
+    if (updates.embeddingKey !== void 0) {
+      setClauses.push(`embedding_key = $${paramIndex++}`);
+      values.push(updates.embeddingKey);
+    }
+    if (updates.schema !== void 0) {
+      setClauses.push(`schema = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.schema));
+    }
+    if (setClauses.length === 0) return this.getCollectionByName(tenantId, name);
+    setClauses.push(`updated_at = NOW()`);
+    values.push(tenantId, name);
+    const result = await this.pool.query(
+      `UPDATE lattice_collections SET ${setClauses.join(", ")}
+       WHERE tenant_id = $${paramIndex++} AND name = $${paramIndex}
+       RETURNING id, name, tenant_id, label, embedding_key, schema, created_at, updated_at`,
+      values
+    );
+    return result.rows.length > 0 ? this.rowToCollection(result.rows[0]) : null;
+  }
+  async deleteCollection(tenantId, name) {
+    this.ensureInit();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_collections WHERE tenant_id = $1 AND name = $2`,
+      [tenantId, name]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  rowToCollection(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      tenantId: row.tenant_id,
+      label: row.label,
+      embeddingKey: row.embedding_key,
+      schema: typeof row.schema === "string" ? JSON.parse(row.schema) : row.schema,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+};
+
 // src/createPgStoreConfig.ts
 var import_langgraph_checkpoint_postgres = require("@langchain/langgraph-checkpoint-postgres");
 
+// src/PGVectorStoreProvider.ts
+var import_pg22 = require("pg");
+var import_pgvector = require("@langchain/community/vectorstores/pgvector");
+var import_documents = require("@langchain/core/documents");
+var import_core6 = require("@axiom-lattice/core");
+function safeTableName(name) {
+  if (!/^[a-z][a-z0-9_-]*$/.test(name)) {
+    throw new Error(`Invalid table name: ${name}`);
+  }
+  return name;
+}
+var PGVectorStoreProvider = class {
+  constructor(pool, connectionString) {
+    this.pool = pool;
+    this.connectionString = connectionString;
+  }
+  async create(params) {
+    const { tableName, embeddingKey } = params;
+    let embeddings;
+    try {
+      embeddings = import_core6.embeddingsLatticeManager.getEmbeddingsClient(embeddingKey);
+    } catch {
+      try {
+        embeddings = import_core6.embeddingsLatticeManager.getEmbeddingsClient("default");
+      } catch {
+        throw new Error(
+          `No embedding model registered. Register one first:
+  import { registerEmbeddingsLattice } from "@axiom-lattice/core";
+  registerEmbeddingsLattice("default", new SomeEmbeddings(...));`
+        );
+      }
+    }
+    return import_pgvector.PGVectorStore.initialize(embeddings, {
+      postgresConnectionOptions: { connectionString: this.connectionString },
+      tableName: safeTableName(tableName),
+      columns: {
+        idColumnName: "id",
+        vectorColumnName: "vector",
+        contentColumnName: "content",
+        metadataColumnName: "metadata"
+      },
+      distanceStrategy: "cosine"
+    });
+  }
+  async getEntryCount(tableName) {
+    const name = safeTableName(tableName);
+    try {
+      const result = await this.pool.query(`SELECT COUNT(*) as count FROM "${name}"`);
+      return parseInt(result.rows[0]?.count || "0", 10);
+    } catch {
+      return 0;
+    }
+  }
+  async listEntries(tableName) {
+    const name = safeTableName(tableName);
+    try {
+      const result = await this.pool.query(
+        `SELECT content, metadata FROM "${name}" ORDER BY metadata->>'_created_at' DESC`
+      );
+      return result.rows.map((row) => new import_documents.Document({
+        pageContent: row.content || "",
+        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata || {}
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async dropTable(tableName) {
+    const name = safeTableName(tableName);
+    await this.pool.query(`DROP TABLE IF EXISTS "${name}"`);
+  }
+  async dispose(_name) {
+  }
+};
+function createPGVectorStoreProvider(connectionString) {
+  const pool = new import_pg22.Pool({ connectionString });
+  return {
+    provider: new PGVectorStoreProvider(pool, connectionString),
+    pool
+  };
+}
+
 // src/migrations/skill_migrations.ts
 var createSkillsTable = {
   version: 4,
@@ -7194,9 +7503,83 @@ var createChannelIdentityMappingTables = {
   }
 };
 
+// src/migrations/connection_config_migrations.ts
+var createConnectionConfigsTable = {
+  version: 160,
+  name: "create_connection_configs_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_connection_configs (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        type VARCHAR(255) NOT NULL,
+        key VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        config JSONB NOT NULL DEFAULT '{}',
+        status VARCHAR(32) NOT NULL DEFAULT 'active',
+        last_test_result JSONB,
+        metadata JSONB NOT NULL DEFAULT '{}',
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+        PRIMARY KEY (tenant_id, id),
+        CONSTRAINT uk_lattice_connection_configs_tenant_type_key UNIQUE (tenant_id, type, key)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_connection_configs_tenant_id
+      ON lattice_connection_configs(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_connection_configs_tenant_type
+      ON lattice_connection_configs(tenant_id, type)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_connection_configs_tenant_type");
+    await client.query("DROP INDEX IF EXISTS idx_connection_configs_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_connection_configs");
+  }
+};
+
+// src/migrations/collection_migrations.ts
+var createCollectionsTable = {
+  version: 137,
+  name: "create_collections_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_collections (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL DEFAULT 'default',
+        label VARCHAR(255) NOT NULL,
+        embedding_key VARCHAR(255) NOT NULL DEFAULT 'default',
+        schema JSONB DEFAULT '{"fields":[]}',
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(tenant_id, name)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_collections_tenant
+      ON lattice_collections(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_collections_name
+      ON lattice_collections(name)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_collections_name");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_collections_tenant");
+    await client.query("DROP TABLE IF EXISTS lattice_collections");
+  }
+};
+
 // src/createPgStoreConfig.ts
 async function createPgStoreConfig(connectionString) {
-  const pool = new import_pg21.Pool({ connectionString });
+  const pool = new import_pg23.Pool({ connectionString });
   const mm = new MigrationManager(pool);
   mm.register(createThreadsTable);
   mm.register(createScheduledTasksTable);
@@ -7240,6 +7623,8 @@ async function createPgStoreConfig(connectionString) {
   mm.register(createMenuItemsTable);
   mm.register(createSharedResourcesTable);
   mm.register(addFileContentType);
+  mm.register(createCollectionsTable);
+  mm.register(createConnectionConfigsTable);
   await mm.migrate();
   const checkpoint = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(connectionString);
   checkpoint.setup().catch((err) => {
@@ -7257,6 +7642,7 @@ async function createPgStoreConfig(connectionString) {
     channelInstallation: new PostgreSQLChannelInstallationStore(opts),
     thread: new PostgreSQLThreadStore(opts),
     database: new PostgreSQLDatabaseConfigStore(opts),
+    connection: new PostgreSQLConnectionStore(pool),
     metrics: new PostgreSQLMetricsServerConfigStore(opts),
     mcp: new PostgreSQLMcpServerConfigStore(opts),
     assistant: new PostgreSQLAssistantStore(opts),
@@ -7267,12 +7653,14 @@ async function createPgStoreConfig(connectionString) {
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),
     sharedResource: new PostgresSharedResourceStore(opts),
+    collection: new PostgreSQLCollectionStore(opts),
+    vectorStoreProvider: new PGVectorStoreProvider(pool, connectionString),
     checkpoint
   };
 }
 
 // src/stores/PostgreSQLSkillStore.ts
-var import_pg22 = require("pg");
+var import_pg24 = require("pg");
 var PostgreSQLSkillStore = class {
   constructor(options) {
     this.initialized = false;
@@ -7285,9 +7673,9 @@ var PostgreSQLSkillStore = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new import_pg22.Pool({ connectionString: options.poolConfig });
+      this.pool = new import_pg24.Pool({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new import_pg22.Pool(options.poolConfig);
+      this.pool = new import_pg24.Pool(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -7588,7 +7976,7 @@ var PostgreSQLSkillStore = class {
 };
 
 // src/stores/ChannelIdentityMappingStore.ts
-var import_pg23 = require("pg");
+var import_pg25 = require("pg");
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
@@ -7600,7 +7988,7 @@ var ChannelIdentityMappingStore = class {
       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) : (() => {
+    this.pool = typeof options.poolConfig === "string" ? new import_pg25.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg25.Pool(options.poolConfig) : (() => {
       throw new Error("Either pool or poolConfig must be provided");
     })();
     this.migrationManager = new MigrationManager(this.pool);
@@ -7824,10 +8212,13 @@ function mapRowToChannelIdentityMapping(row) {
   ChannelIdentityMappingStore,
   MenuStore,
   MigrationManager,
+  PGVectorStoreProvider,
   Pool,
   PostgreSQLA2AApiKeyStore,
   PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore,
+  PostgreSQLCollectionStore,
+  PostgreSQLConnectionStore,
   PostgreSQLDatabaseConfigStore,
   PostgreSQLEvalStore,
   PostgreSQLMcpServerConfigStore,
@@ -7859,6 +8250,7 @@ function mapRowToChannelIdentityMapping(row) {
   createChannelBindingsTable,
   createChannelIdentityMappingTables,
   createChannelInstallationsTable,
+  createCollectionsTable,
   createDatabaseConfigsTable,
   createEvalCasesTable,
   createEvalProjectsTable,
@@ -7868,6 +8260,7 @@ function mapRowToChannelIdentityMapping(row) {
   createMcpServerConfigsTable,
   createMenuItemsTable,
   createMetricsConfigsTable,
+  createPGVectorStoreProvider,
   createPgStoreConfig,
   createProjectsTable,
   createScheduledTasksTable,