@axiom-lattice/pg-stores 3.1.20 → 3.2.0

package/dist/index.js

@@ -37,7 +37,7 @@ __export(index_exports, {
   MenuStore: () => MenuStore,
   MigrationManager: () => MigrationManager,
   PGVectorStoreProvider: () => PGVectorStoreProvider,
-  Pool: () => import_pg30.Pool,
+  Pool: () => import_pg31.Pool,
   PostgreSQLA2AApiKeyStore: () => PostgreSQLA2AApiKeyStore,
   PostgreSQLAgentWebAppStore: () => PostgreSQLAgentWebAppStore,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
@@ -49,6 +49,7 @@ __export(index_exports, {
   PostgreSQLEvalStore: () => PostgreSQLEvalStore,
   PostgreSQLMcpServerConfigStore: () => PostgreSQLMcpServerConfigStore,
   PostgreSQLMetricsServerConfigStore: () => PostgreSQLMetricsServerConfigStore,
+  PostgreSQLModelProviderStore: () => PostgreSQLModelProviderStore,
   PostgreSQLOpenAuditStore: () => PostgreSQLOpenAuditStore,
   PostgreSQLProjectBotMembershipStore: () => PostgreSQLProjectBotMembershipStore,
   PostgreSQLProjectMembershipStore: () => PostgreSQLProjectMembershipStore,
@@ -126,10 +127,10 @@ __export(index_exports, {
   safeParse: () => safeParse
 });
 module.exports = __toCommonJS(index_exports);
-var import_pg30 = require("pg");
+var import_pg31 = require("pg");
 
 // src/createPgStoreConfig.ts
-var import_pg27 = require("pg");
+var import_pg28 = require("pg");
 
 // src/migrations/migration.ts
 var MigrationManager = class {
@@ -10079,6 +10080,116 @@ var createUserPushSubscriptions = {
   }
 };
 
+// src/migrations/model_provider_migrations.ts
+var createModelProvidersTable = {
+  version: 181,
+  name: "create_model_providers_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_model_providers (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        display_name VARCHAR(255),
+        protocol VARCHAR(64) NOT NULL,
+        api_style VARCHAR(32) NOT NULL DEFAULT 'chat-completions',
+        llm_provider VARCHAR(64) NOT NULL,
+        base_url TEXT NOT NULL,
+        api_key_enc TEXT,
+        api_key_hint VARCHAR(16),
+        enabled BOOLEAN NOT NULL DEFAULT TRUE,
+        status VARCHAR(32) NOT NULL DEFAULT 'unknown',
+        last_error VARCHAR(255),
+        last_discovered_at TIMESTAMP,
+        created_by VARCHAR(255),
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+        PRIMARY KEY (tenant_id, id),
+        CONSTRAINT uk_lattice_model_providers_tenant_name UNIQUE (tenant_id, name)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_model_providers_tenant_id
+      ON lattice_model_providers(tenant_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_model_providers_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_model_providers");
+  }
+};
+var createModelProviderModelsTable = {
+  version: 182,
+  name: "create_model_provider_models_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_model_provider_models (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        provider_id VARCHAR(255) NOT NULL,
+        model_id VARCHAR(512) NOT NULL,
+        display_name VARCHAR(255),
+        owned_by VARCHAR(255),
+        upstream_created TIMESTAMP,
+        enabled BOOLEAN NOT NULL DEFAULT TRUE,
+        raw JSONB,
+        discovered_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+        PRIMARY KEY (tenant_id, provider_id, model_id)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_model_provider_models_tenant_id
+      ON lattice_model_provider_models(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_model_provider_models_tenant_model
+      ON lattice_model_provider_models(tenant_id, model_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_model_provider_models_tenant_provider
+      ON lattice_model_provider_models(tenant_id, provider_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_model_provider_models_tenant_provider");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_model_provider_models_tenant_model");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_model_provider_models_tenant_id");
+    await client.query("DROP TABLE IF EXISTS lattice_model_provider_models");
+  }
+};
+var addModelProviderApiStyle = {
+  version: 183,
+  name: "add_model_provider_api_style",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_model_providers
+      ADD COLUMN IF NOT EXISTS api_style VARCHAR(32) NOT NULL DEFAULT 'chat-completions'
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_model_providers DROP COLUMN IF EXISTS api_style
+    `);
+  }
+};
+var addModelProviderModelStale = {
+  version: 184,
+  name: "add_model_provider_model_stale",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_model_provider_models
+      ADD COLUMN IF NOT EXISTS stale BOOLEAN NOT NULL DEFAULT FALSE
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_model_provider_models DROP COLUMN IF EXISTS stale
+    `);
+  }
+};
+
 // src/stores/PostgreSQLCapabilityBundleStore.ts
 var import_crypto4 = require("crypto");
 var import_pg26 = require("pg");
@@ -11040,9 +11151,513 @@ var PostgreSQLUserPushSubscriptionStore = class {
   }
 };
 
+// src/stores/PostgreSQLModelProviderStore.ts
+var import_pg27 = require("pg");
+var import_core7 = require("@axiom-lattice/core");
+var PostgreSQLModelProviderStore = 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_pg27.Pool({ connectionString: options.poolConfig });
+    } else if (options.poolConfig) {
+      this.pool = new import_pg27.Pool(options.poolConfig);
+    } else {
+      throw new Error("Either pool or poolConfig must be provided");
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createModelProvidersTable);
+    this.migrationManager.register(createModelProviderModelsTable);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLModelProviderStore:", error);
+        throw error;
+      });
+    }
+  }
+  /**
+   * Initialize the store and run migrations
+   * Uses a promise-based lock to prevent concurrent initialization
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  /**
+   * Get all provider configurations for a tenant
+   */
+  async listProviders(tenantId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, name, display_name, protocol, api_style, llm_provider, base_url,
+             api_key_enc, api_key_hint, enabled, status, last_error,
+             last_discovered_at, created_by, created_at, updated_at
+      FROM lattice_model_providers
+      WHERE tenant_id = $1
+      ORDER BY created_at DESC
+    `,
+      [tenantId]
+    );
+    return result.rows.map((row) => this.mapRowToEntry(row));
+  }
+  /**
+   * Get a provider configuration by ID
+   */
+  async getProviderById(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, name, display_name, protocol, api_style, llm_provider, base_url,
+             api_key_enc, api_key_hint, enabled, status, last_error,
+             last_discovered_at, created_by, created_at, updated_at
+      FROM lattice_model_providers
+      WHERE tenant_id = $1 AND id = $2
+    `,
+      [tenantId, id]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapRowToEntry(result.rows[0]);
+  }
+  /**
+   * Get a provider configuration by business name
+   */
+  async getProviderByName(tenantId, name) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, name, display_name, protocol, api_style, llm_provider, base_url,
+             api_key_enc, api_key_hint, enabled, status, last_error,
+             last_discovered_at, created_by, created_at, updated_at
+      FROM lattice_model_providers
+      WHERE tenant_id = $1 AND name = $2
+    `,
+      [tenantId, name]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapRowToEntry(result.rows[0]);
+  }
+  /**
+   * Create a new provider configuration
+   */
+  async createProvider(tenantId, id, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ new Date();
+    const nowString = now.toISOString();
+    const apiKeyEnc = data.apiKey ? (0, import_core7.encrypt)(data.apiKey) : null;
+    const apiKeyHint = data.apiKey ? data.apiKey.slice(-4) : null;
+    await this.pool.query(
+      `
+      INSERT INTO lattice_model_providers (
+        id, tenant_id, name, display_name, protocol, api_style, llm_provider, base_url,
+        api_key_enc, api_key_hint, enabled, status, created_at, updated_at
+      )
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, 'unknown', $12::timestamp, $13::timestamp)
+      ON CONFLICT (tenant_id, id) DO UPDATE SET
+        name = EXCLUDED.name,
+        display_name = EXCLUDED.display_name,
+        protocol = EXCLUDED.protocol,
+        api_style = EXCLUDED.api_style,
+        llm_provider = EXCLUDED.llm_provider,
+        base_url = EXCLUDED.base_url,
+        api_key_enc = EXCLUDED.api_key_enc,
+        api_key_hint = EXCLUDED.api_key_hint,
+        enabled = EXCLUDED.enabled,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [
+        id,
+        tenantId,
+        data.name,
+        data.displayName || null,
+        data.protocol,
+        data.apiStyle || "chat-completions",
+        // Phase 1 pins the LLM provider: the UI does not offer a choice, and
+        // some initChatModel branches hardcode their own baseURL and would
+        // silently ignore the tenant's (see ADR-138 decision 7b).
+        "openai",
+        data.baseURL,
+        apiKeyEnc,
+        apiKeyHint,
+        data.enabled !== false,
+        nowString,
+        nowString
+      ]
+    );
+    const created = await this.getProviderById(tenantId, id);
+    if (!created) {
+      throw new Error("Failed to create model provider");
+    }
+    return created;
+  }
+  /**
+   * Update an existing provider configuration.
+   * An omitted or empty `apiKey` leaves the stored key untouched.
+   */
+  async updateProvider(tenantId, id, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getProviderById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+    const updateData = {};
+    if (updates.name !== void 0) {
+      updateData.name = updates.name;
+    }
+    if (updates.displayName !== void 0) {
+      updateData.display_name = updates.displayName || null;
+    }
+    if (updates.protocol !== void 0) {
+      updateData.protocol = updates.protocol;
+    }
+    if (updates.apiStyle !== void 0) {
+      updateData.api_style = updates.apiStyle;
+    }
+    if (updates.baseURL !== void 0) {
+      updateData.base_url = updates.baseURL;
+    }
+    if (updates.clearApiKey === true) {
+      updateData.api_key_enc = null;
+      updateData.api_key_hint = null;
+    } else if (updates.apiKey) {
+      updateData.api_key_enc = (0, import_core7.encrypt)(updates.apiKey);
+      updateData.api_key_hint = updates.apiKey.slice(-4);
+    }
+    if (updates.enabled !== void 0) {
+      updateData.enabled = updates.enabled;
+    }
+    if (Object.keys(updateData).length === 0) {
+      return existing;
+    }
+    updateData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    const fields = Object.keys(updateData);
+    const values = Object.values(updateData);
+    values.push(tenantId);
+    values.push(id);
+    const setClauses = fields.map(
+      (field, index) => field === "updated_at" ? `${field} = $${index + 1}::timestamp` : `${field} = $${index + 1}`
+    );
+    const whereTenantIndex = fields.length + 1;
+    const whereIdIndex = fields.length + 2;
+    const sql = `
+      UPDATE lattice_model_providers
+      SET ${setClauses.join(", ")}
+      WHERE tenant_id = $${whereTenantIndex} AND id = $${whereIdIndex}
+    `;
+    await this.pool.query(sql, values);
+    return await this.getProviderById(tenantId, id);
+  }
+  /**
+   * Delete a provider configuration and its model snapshot
+   */
+  async deleteProvider(tenantId, id) {
+    await this.ensureInitialized();
+    await this.deleteModelsByProvider(tenantId, id);
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_model_providers
+      WHERE tenant_id = $1 AND id = $2
+    `,
+      [tenantId, id]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Record the outcome of a discovery attempt
+   */
+  async markProviderStatus(tenantId, id, status, lastError, discoveredAt) {
+    await this.ensureInitialized();
+    await this.pool.query(
+      `
+      UPDATE lattice_model_providers
+      SET status = $3,
+          last_error = $4,
+          last_discovered_at = CASE
+            WHEN $5::timestamp IS NULL THEN last_discovered_at
+            ELSE $5::timestamp
+          END,
+          updated_at = $6::timestamp
+      WHERE tenant_id = $1 AND id = $2
+    `,
+      [
+        tenantId,
+        id,
+        status,
+        status === "ok" ? null : lastError || null,
+        discoveredAt ? discoveredAt.toISOString() : null,
+        (/* @__PURE__ */ new Date()).toISOString()
+      ]
+    );
+  }
+  /**
+   * List snapshot models for a tenant
+   */
+  async listModels(tenantId, providerId) {
+    await this.ensureInitialized();
+    const result = providerId ? await this.pool.query(
+      `
+          SELECT id, tenant_id, provider_id, model_id, display_name, owned_by,
+                 upstream_created, enabled, stale, discovered_at
+          FROM lattice_model_provider_models
+          WHERE tenant_id = $1 AND provider_id = $2
+          ORDER BY model_id ASC
+        `,
+      [tenantId, providerId]
+    ) : await this.pool.query(
+      `
+          SELECT id, tenant_id, provider_id, model_id, display_name, owned_by,
+                 upstream_created, enabled, discovered_at
+          FROM lattice_model_provider_models
+          WHERE tenant_id = $1
+          ORDER BY model_id ASC
+        `,
+      [tenantId]
+    );
+    return result.rows.map((row) => this.mapRowToModel(row));
+  }
+  /**
+   * Get a single snapshot model.
+   * Keyed by provider as well as model id, since two providers in the same
+   * tenant may expose the same upstream model id.
+   */
+  async getModel(tenantId, providerId, modelId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, provider_id, model_id, display_name, owned_by,
+             upstream_created, enabled, discovered_at
+      FROM lattice_model_provider_models
+      WHERE tenant_id = $1 AND provider_id = $2 AND model_id = $3
+    `,
+      [tenantId, providerId, modelId]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapRowToModel(result.rows[0]);
+  }
+  /**
+   * Replace a provider's model snapshot with the result of one discovery.
+   *
+   * Runs in a single transaction. Model ids are scoped per provider, so the
+   * same upstream id may appear under several providers in one tenant — each
+   * is an independent model.
+   *
+   * Models the upstream no longer offers are deleted; models that survive are
+   * upserted *without* touching `enabled`, so the tenant's enable/disable
+   * choice survives a re-discovery. New rows take the column default (enabled).
+   */
+  async replaceProviderModels(tenantId, providerId, models) {
+    await this.ensureInitialized();
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const current = await client.query(
+        `
+        SELECT model_id, enabled FROM lattice_model_provider_models
+        WHERE tenant_id = $1 AND provider_id = $2
+      `,
+        [tenantId, providerId]
+      );
+      const currentEnabled = new Map(
+        current.rows.map((row) => [row.model_id, row.enabled])
+      );
+      const deduped = /* @__PURE__ */ new Map();
+      for (const model of models) {
+        deduped.set(model.id, model);
+      }
+      const rows = [...deduped.values()];
+      const effectiveEnabled = rows.map(
+        (model) => model.enabled ?? currentEnabled.get(model.id) ?? true
+      );
+      await client.query(
+        `
+        DELETE FROM lattice_model_provider_models
+        WHERE tenant_id = $1
+          AND provider_id = $2
+          AND model_id <> ALL($3::text[])
+      `,
+        [tenantId, providerId, rows.map((model) => model.id)]
+      );
+      if (models.length > 0) {
+        await client.query(
+          `
+          INSERT INTO lattice_model_provider_models (
+            id, tenant_id, provider_id, model_id, display_name, owned_by,
+            upstream_created, raw, enabled, stale, discovered_at
+          )
+          SELECT * FROM unnest(
+            $1::text[], $2::text[], $3::text[], $4::text[], $5::text[],
+            $6::text[], $7::timestamp[], $8::jsonb[], $9::boolean[], $10::boolean[], $11::timestamp[]
+          ) AS t(
+            id, tenant_id, provider_id, model_id, display_name, owned_by,
+            upstream_created, raw, enabled, stale, discovered_at
+          )
+          ON CONFLICT (tenant_id, provider_id, model_id) DO UPDATE SET
+            display_name = EXCLUDED.display_name,
+            owned_by = EXCLUDED.owned_by,
+            upstream_created = EXCLUDED.upstream_created,
+            raw = EXCLUDED.raw,
+            enabled = EXCLUDED.enabled,
+            stale = EXCLUDED.stale,
+            discovered_at = EXCLUDED.discovered_at
+        `,
+          [
+            rows.map((model) => `${providerId}:${model.id}`),
+            rows.map(() => tenantId),
+            rows.map(() => providerId),
+            rows.map((model) => model.id),
+            rows.map((model) => model.displayName ?? null),
+            rows.map((model) => model.ownedBy ?? null),
+            rows.map(
+              (model) => model.createdAt ? new Date(model.createdAt).toISOString() : null
+            ),
+            rows.map(
+              (model) => model.raw === void 0 ? null : JSON.stringify(model.raw)
+            ),
+            effectiveEnabled,
+            rows.map((model) => model.stale ?? false),
+            rows.map(() => (/* @__PURE__ */ new Date()).toISOString())
+          ]
+        );
+      }
+      await client.query("COMMIT");
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+    return models.map((model) => model.id);
+  }
+  /**
+   * Enable or disable a single snapshot model
+   */
+  async setModelEnabled(tenantId, providerId, modelId, enabled) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      UPDATE lattice_model_provider_models
+      SET enabled = $4
+      WHERE tenant_id = $1 AND provider_id = $2 AND model_id = $3
+    `,
+      [tenantId, providerId, modelId, enabled]
+    );
+    if (result.rowCount === null || result.rowCount === 0) {
+      return null;
+    }
+    return await this.getModel(tenantId, providerId, modelId);
+  }
+  /**
+   * Delete every snapshot model belonging to a provider
+   */
+  async deleteModelsByProvider(tenantId, providerId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_model_provider_models
+      WHERE tenant_id = $1 AND provider_id = $2
+    `,
+      [tenantId, providerId]
+    );
+    return result.rowCount ?? 0;
+  }
+  /**
+   * Dispose resources and close the connection pool
+   */
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  /**
+   * Ensure store is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Map provider row to ModelProviderEntry
+   * Automatically decrypts the API key if present
+   */
+  mapRowToEntry(row) {
+    let apiKey;
+    if (row.api_key_enc) {
+      try {
+        apiKey = (0, import_core7.decrypt)(row.api_key_enc);
+      } catch (error) {
+        console.error("Failed to decrypt model provider API key:", error);
+        throw new Error("Failed to decrypt model provider API key");
+      }
+    }
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      name: row.name,
+      displayName: row.display_name || void 0,
+      protocol: row.protocol,
+      apiStyle: row.api_style,
+      llmProvider: row.llm_provider,
+      baseURL: row.base_url,
+      apiKey,
+      apiKeyHint: row.api_key_hint || void 0,
+      enabled: row.enabled,
+      status: row.status,
+      lastError: row.last_error || void 0,
+      lastDiscoveredAt: row.last_discovered_at || void 0,
+      createdBy: row.created_by || void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Map model row to ModelProviderModelEntry
+   */
+  mapRowToModel(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      providerId: row.provider_id,
+      modelId: row.model_id,
+      displayName: row.display_name || void 0,
+      ownedBy: row.owned_by || void 0,
+      upstreamCreatedAt: row.upstream_created || void 0,
+      enabled: row.enabled,
+      stale: row.stale,
+      discoveredAt: row.discovered_at
+    };
+  }
+};
+
 // src/createPgStoreConfig.ts
 async function createPgStoreConfig(connectionString) {
-  const pool = new import_pg27.Pool({ connectionString });
+  const pool = new import_pg28.Pool({ connectionString });
   const mm = new MigrationManager(pool);
   mm.register(createThreadsTable);
   mm.register(createScheduledTasksTable);
@@ -11110,6 +11725,10 @@ async function createPgStoreConfig(connectionString) {
   mm.register(createProjectRoomReadStates);
   mm.register(createUserPushSubscriptions);
   mm.register(addProjectRoomMessageRetentionIndex);
+  mm.register(createModelProvidersTable);
+  mm.register(createModelProviderModelsTable);
+  mm.register(addModelProviderApiStyle);
+  mm.register(addModelProviderModelStale);
   await mm.migrate();
   const checkpoint = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(connectionString);
   checkpoint.setup().catch((err) => {
@@ -11131,6 +11750,7 @@ async function createPgStoreConfig(connectionString) {
     connection: new PostgreSQLConnectionStore(pool),
     metrics: new PostgreSQLMetricsServerConfigStore(opts),
     mcp: new PostgreSQLMcpServerConfigStore(opts),
+    modelProvider: new PostgreSQLModelProviderStore(opts),
     assistant: new PostgreSQLAssistantStore(opts),
     workflowTracking: new PostgreSQLWorkflowTrackingStore(opts),
     threadMessageQueue: new ThreadMessageQueueStore(opts),
@@ -11156,7 +11776,7 @@ async function createPgStoreConfig(connectionString) {
 }
 
 // src/stores/PostgreSQLSkillStore.ts
-var import_pg28 = require("pg");
+var import_pg29 = require("pg");
 var PostgreSQLSkillStore = class {
   constructor(options) {
     this.initialized = false;
@@ -11169,9 +11789,9 @@ var PostgreSQLSkillStore = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new import_pg28.Pool({ connectionString: options.poolConfig });
+      this.pool = new import_pg29.Pool({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new import_pg28.Pool(options.poolConfig);
+      this.pool = new import_pg29.Pool(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -11472,7 +12092,7 @@ var PostgreSQLSkillStore = class {
 };
 
 // src/stores/ChannelIdentityMappingStore.ts
-var import_pg29 = require("pg");
+var import_pg30 = require("pg");
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
@@ -11484,7 +12104,7 @@ var ChannelIdentityMappingStore = class {
       this.initialized = true;
       return;
     }
-    this.pool = typeof options.poolConfig === "string" ? new import_pg29.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg29.Pool(options.poolConfig) : (() => {
+    this.pool = typeof options.poolConfig === "string" ? new import_pg30.Pool({ connectionString: options.poolConfig }) : options.poolConfig ? new import_pg30.Pool(options.poolConfig) : (() => {
       throw new Error("Either pool or poolConfig must be provided");
     })();
     this.migrationManager = new MigrationManager(this.pool);
@@ -11723,6 +12343,7 @@ function mapRowToChannelIdentityMapping(row) {
   PostgreSQLEvalStore,
   PostgreSQLMcpServerConfigStore,
   PostgreSQLMetricsServerConfigStore,
+  PostgreSQLModelProviderStore,
   PostgreSQLOpenAuditStore,
   PostgreSQLProjectBotMembershipStore,
   PostgreSQLProjectMembershipStore,