@axiom-lattice/pg-stores 5.1.2 → 5.2.0

package/dist/index.mjs

@@ -1769,6 +1769,43 @@ var createMcpServerConfigsTable = {
     await client.query("DROP TABLE IF EXISTS lattice_mcp_server_configs");
   }
 };
+var createPersonalMcpServerConfigsTable = {
+  version: 220,
+  name: "create_personal_mcp_server_configs_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_personal_mcp_server_configs (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        owner_assistant_id VARCHAR(255) NOT NULL,
+        key VARCHAR(255) NOT NULL,
+        name VARCHAR(255),
+        description TEXT,
+        config JSONB NOT NULL,
+        selected_tools JSONB NOT NULL DEFAULT '[]',
+        is_env_encrypted BOOLEAN NOT NULL DEFAULT FALSE,
+        status VARCHAR(50) NOT NULL DEFAULT 'disconnected',
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+        PRIMARY KEY (tenant_id, owner_assistant_id, id)
+      )
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_lattice_personal_mcp_assistant_key
+      ON lattice_personal_mcp_server_configs(tenant_id, owner_assistant_id, key)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_personal_mcp_assistant
+      ON lattice_personal_mcp_server_configs(tenant_id, owner_assistant_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_personal_mcp_assistant_key");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_personal_mcp_assistant");
+    await client.query("DROP TABLE IF EXISTS lattice_personal_mcp_server_configs");
+  }
+};
 
 // src/stores/PostgreSQLMcpServerConfigStore.ts
 import { encrypt as encrypt3, safeDecrypt as safeDecrypt3 } from "@axiom-lattice/core";
@@ -1792,6 +1829,7 @@ var PostgreSQLMcpServerConfigStore = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createMcpServerConfigsTable);
+    this.migrationManager.register(createPersonalMcpServerConfigsTable);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLMcpServerConfigStore:", error);
@@ -2019,6 +2057,231 @@ var PostgreSQLMcpServerConfigStore = class {
     );
     return result.rows.length > 0;
   }
+  /**
+   * Get all personal MCP server configurations owned by one assistant.
+   */
+  async getAllConfigsForAssistant(tenantId, ownerAssistantId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, owner_assistant_id, key, name, description, config, selected_tools, is_env_encrypted, status, created_at, updated_at
+      FROM lattice_personal_mcp_server_configs
+      WHERE tenant_id = $1 AND owner_assistant_id = $2
+      ORDER BY created_at DESC
+    `,
+      [tenantId, ownerAssistantId]
+    );
+    return result.rows.map((row) => this.mapPersonalRowToEntry(row));
+  }
+  /**
+   * Get every personal MCP server configuration across tenants.
+   *
+   * Operations/tests only; startup restoration must not call this.
+   */
+  async getAllPersonalConfigsWithoutTenant() {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, owner_assistant_id, key, name, description, config, selected_tools, is_env_encrypted, status, created_at, updated_at
+      FROM lattice_personal_mcp_server_configs
+      ORDER BY created_at DESC
+    `
+    );
+    return result.rows.map((row) => this.mapPersonalRowToEntry(row));
+  }
+  /**
+   * Get one personal MCP server configuration by id.
+   */
+  async getConfigByIdForAssistant(tenantId, ownerAssistantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, owner_assistant_id, key, name, description, config, selected_tools, is_env_encrypted, status, created_at, updated_at
+      FROM lattice_personal_mcp_server_configs
+      WHERE tenant_id = $1 AND owner_assistant_id = $2 AND id = $3
+    `,
+      [tenantId, ownerAssistantId, id]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapPersonalRowToEntry(result.rows[0]);
+  }
+  /**
+   * Get one personal MCP server configuration by business key.
+   */
+  async getConfigByKeyForAssistant(tenantId, ownerAssistantId, key) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, owner_assistant_id, key, name, description, config, selected_tools, is_env_encrypted, status, created_at, updated_at
+      FROM lattice_personal_mcp_server_configs
+      WHERE tenant_id = $1 AND owner_assistant_id = $2 AND key = $3
+    `,
+      [tenantId, ownerAssistantId, key]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapPersonalRowToEntry(result.rows[0]);
+  }
+  /**
+   * Create a personal MCP server configuration.
+   */
+  async createConfigForAssistant(tenantId, ownerAssistantId, id, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ new Date();
+    const nowString = now.toISOString();
+    const { config: configWithEncryptedEnv, isEnvEncrypted } = this.encryptEnvInConfig(data.config);
+    await this.pool.query(
+      `
+      INSERT INTO lattice_personal_mcp_server_configs (id, tenant_id, owner_assistant_id, key, name, description, config, selected_tools, is_env_encrypted, status, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::timestamp, $12::timestamp)
+      ON CONFLICT (tenant_id, owner_assistant_id, id) DO UPDATE SET
+        key = EXCLUDED.key,
+        name = EXCLUDED.name,
+        description = EXCLUDED.description,
+        config = EXCLUDED.config,
+        selected_tools = EXCLUDED.selected_tools,
+        is_env_encrypted = EXCLUDED.is_env_encrypted,
+        status = EXCLUDED.status,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [
+        id,
+        tenantId,
+        ownerAssistantId,
+        data.key,
+        data.name || null,
+        data.description || null,
+        JSON.stringify(configWithEncryptedEnv),
+        JSON.stringify(data.selectedTools || []),
+        isEnvEncrypted,
+        "disconnected",
+        nowString,
+        nowString
+      ]
+    );
+    return {
+      id,
+      tenantId,
+      ownerAssistantId,
+      key: data.key,
+      config: data.config,
+      selectedTools: data.selectedTools || [],
+      isEnvEncrypted,
+      status: "disconnected",
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Update a personal MCP server configuration.
+   */
+  async updateConfigForAssistant(tenantId, ownerAssistantId, id, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getConfigByIdForAssistant(
+      tenantId,
+      ownerAssistantId,
+      id
+    );
+    if (!existing) {
+      return null;
+    }
+    const updateData = {};
+    if (updates.key !== void 0) {
+      updateData.key = updates.key;
+    }
+    if (updates.name !== void 0) {
+      updateData.name = updates.name || null;
+    }
+    if (updates.description !== void 0) {
+      updateData.description = updates.description || null;
+    }
+    if (updates.config !== void 0) {
+      const { config: configWithEncryptedEnv, isEnvEncrypted } = this.encryptEnvInConfig(updates.config);
+      updateData.config = JSON.stringify(configWithEncryptedEnv);
+      updateData.is_env_encrypted = isEnvEncrypted;
+    }
+    if (updates.selectedTools !== void 0) {
+      updateData.selected_tools = JSON.stringify(updates.selectedTools);
+    }
+    if (updates.status !== void 0) {
+      updateData.status = updates.status;
+    }
+    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(ownerAssistantId);
+    values.push(id);
+    const setClauses = fields.map((field, index) => {
+      if (field === "updated_at") {
+        return `${field} = $${index + 1}::timestamp`;
+      }
+      return `${field} = $${index + 1}`;
+    });
+    const whereTenantIndex = fields.length + 1;
+    const whereOwnerIndex = fields.length + 2;
+    const whereIdIndex = fields.length + 3;
+    const sql = `
+      UPDATE lattice_personal_mcp_server_configs
+      SET ${setClauses.join(", ")}
+      WHERE tenant_id = $${whereTenantIndex}
+        AND owner_assistant_id = $${whereOwnerIndex}
+        AND id = $${whereIdIndex}
+    `;
+    await this.pool.query(sql, values);
+    return this.getConfigByIdForAssistant(tenantId, ownerAssistantId, id);
+  }
+  /**
+   * Delete one personal MCP server configuration by id.
+   */
+  async deleteConfigForAssistant(tenantId, ownerAssistantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_personal_mcp_server_configs
+      WHERE tenant_id = $1 AND owner_assistant_id = $2 AND id = $3
+    `,
+      [tenantId, ownerAssistantId, id]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Delete every personal MCP server configuration owned by one assistant.
+   */
+  async deleteConfigsForAssistant(tenantId, ownerAssistantId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_personal_mcp_server_configs
+      WHERE tenant_id = $1 AND owner_assistant_id = $2
+    `,
+      [tenantId, ownerAssistantId]
+    );
+    return result.rowCount ?? 0;
+  }
+  /**
+   * Check whether a personal MCP server configuration exists.
+   */
+  async hasConfigForAssistant(tenantId, ownerAssistantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT 1 FROM lattice_personal_mcp_server_configs
+      WHERE tenant_id = $1 AND owner_assistant_id = $2 AND id = $3
+      LIMIT 1
+    `,
+      [tenantId, ownerAssistantId, id]
+    );
+    return result.rows.length > 0;
+  }
   /**
    * Dispose resources and close the connection pool
    */
@@ -2069,6 +2332,15 @@ var PostgreSQLMcpServerConfigStore = class {
       updatedAt: row.updated_at
     };
   }
+  /**
+   * Map a personal table row, tagging the owning assistant.
+   */
+  mapPersonalRowToEntry(row) {
+    return {
+      ...this.mapRowToEntry(row),
+      ownerAssistantId: row.owner_assistant_id
+    };
+  }
   /**
    * Encrypt env values in config before storing
    */
@@ -3262,6 +3534,9 @@ var PostgreSQLTenantStore = class {
 
 // src/stores/PostgreSQLUserTenantLinkStore.ts
 import { Pool as Pool10 } from "pg";
+import {
+  assertNotPlatformTenant
+} from "@axiom-lattice/protocols";
 
 // src/migrations/user_tenant_link_migrations.ts
 var createUserTenantLinkTable = {
@@ -3420,6 +3695,7 @@ var PostgreSQLUserTenantLinkStore = class {
     return this.mapRowToLink(result.rows[0]);
   }
   async createLink(data) {
+    assertNotPlatformTenant(data.tenantId);
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
     const role = data.role || "member";
@@ -11015,6 +11291,49 @@ var addOidcProviderAllowedHosts = {
   }
 };
 
+// src/migrations/platform_audit_migration.ts
+var createPlatformAuditTable = {
+  version: 219,
+  name: "create_platform_audit_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_platform_audit (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        initiator_user_id VARCHAR(255),
+        initiator_role VARCHAR(16),
+        initiator JSONB NOT NULL,
+        source VARCHAR(32) NOT NULL,
+        executor JSONB NOT NULL,
+        tenant_id VARCHAR(255),
+        action VARCHAR(16) NOT NULL,
+        status VARCHAR(16) NOT NULL,
+        summary JSONB NOT NULL,
+        before JSONB,
+        after JSONB,
+        error_code VARCHAR(64),
+        duration_ms INTEGER NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_platform_audit_created
+        ON lattice_platform_audit(created_at DESC, id DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_platform_audit_initiator
+        ON lattice_platform_audit(initiator_user_id, created_at DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_platform_audit_tenant
+        ON lattice_platform_audit(tenant_id, created_at DESC)
+        WHERE tenant_id IS NOT NULL
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP TABLE IF EXISTS lattice_platform_audit");
+  }
+};
+
 // src/migrations/collection_migrations.ts
 var createCollectionsTable = {
   version: 137,
@@ -14739,6 +15058,146 @@ var PostgreSQLPlatformSettingsStore = class {
   }
 };
 
+// src/stores/PostgreSQLPlatformAuditStore.ts
+var TABLE8 = "lattice_platform_audit";
+function parseJson(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+function normalizeBoundary(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  const parsed = new Date(trimmed);
+  if (Number.isNaN(parsed.getTime())) return void 0;
+  return parsed.toISOString();
+}
+function normalizePagination(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.trunc(value));
+}
+function mapRow16(row) {
+  return {
+    id: row.id,
+    initiator: parseJson(row.initiator),
+    source: row.source,
+    executor: parseJson(row.executor),
+    ...row.tenant_id !== null ? { tenantId: row.tenant_id } : {},
+    action: row.action,
+    status: row.status,
+    summary: parseJson(row.summary),
+    ...row.before !== null ? { before: parseJson(row.before) } : {},
+    ...row.after !== null ? { after: parseJson(row.after) } : {},
+    ...row.error_code !== null ? { errorCode: row.error_code } : {},
+    durationMs: Number(row.duration_ms),
+    createdAt: row.created_at
+  };
+}
+var PostgreSQLPlatformAuditStore = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get pool() {
+    return this.options.pool;
+  }
+  /** Appends a record, assigning a fresh id and creation timestamp. */
+  async append(record) {
+    const initiator = record.initiator;
+    const initiatorUserId = initiator.type === "human" ? initiator.userId : null;
+    const initiatorRole = initiator.type === "human" ? initiator.role : null;
+    const durationMs = Number.isFinite(record.durationMs) ? Math.max(0, Math.round(record.durationMs)) : 0;
+    const result = await this.pool.query(
+      `INSERT INTO ${TABLE8}
+         (initiator_user_id, initiator_role, initiator, source, executor,
+          tenant_id, action, status, summary, before, after, error_code,
+          duration_ms)
+       VALUES ($1,$2,$3::jsonb,$4,$5::jsonb,$6,$7,$8,$9::jsonb,$10::jsonb,
+               $11::jsonb,$12,$13)
+       RETURNING *`,
+      [
+        initiatorUserId,
+        initiatorRole,
+        JSON.stringify(initiator),
+        record.source,
+        JSON.stringify(record.executor),
+        record.tenantId ?? null,
+        record.action,
+        record.status,
+        JSON.stringify(record.summary),
+        record.before === void 0 ? null : JSON.stringify(record.before),
+        record.after === void 0 ? null : JSON.stringify(record.after),
+        record.errorCode ?? null,
+        durationMs
+      ]
+    );
+    const row = result.rows[0];
+    if (!row) throw new Error("Platform audit record was not persisted");
+    return mapRow16(row);
+  }
+  /** Returns a record by id, or null when it does not exist. */
+  async get(id) {
+    const result = await this.pool.query(
+      `SELECT * FROM ${TABLE8} WHERE id = $1`,
+      [id]
+    );
+    return result.rows[0] ? mapRow16(result.rows[0]) : null;
+  }
+  /**
+   * Returns matching records newest-first.
+   *
+   * `initiatorUserId` only matches human initiators. `from` is inclusive and
+   * `to` is exclusive after both are normalized to instants; invalid or empty
+   * boundaries are ignored. Records are ordered by `createdAt` descending,
+   * then by `id` descending. Results are paginated with a default limit of 100;
+   * non-finite `offset`/`limit` fall back to defaults, finite values are
+   * truncated to integers, and negatives are clamped to 0.
+   */
+  async query(params) {
+    const clauses = [];
+    const values = [];
+    if (params.initiatorUserId !== void 0) {
+      values.push(params.initiatorUserId);
+      clauses.push(`initiator_user_id = $${values.length}`);
+    }
+    if (params.source !== void 0) {
+      values.push(params.source);
+      clauses.push(`source = $${values.length}`);
+    }
+    if (params.tenantId !== void 0) {
+      values.push(params.tenantId);
+      clauses.push(`tenant_id = $${values.length}`);
+    }
+    if (params.action !== void 0) {
+      values.push(params.action);
+      clauses.push(`action = $${values.length}`);
+    }
+    if (params.status !== void 0) {
+      values.push(params.status);
+      clauses.push(`status = $${values.length}`);
+    }
+    const from = normalizeBoundary(params.from);
+    if (from !== void 0) {
+      values.push(from);
+      clauses.push(`created_at >= $${values.length}`);
+    }
+    const to = normalizeBoundary(params.to);
+    if (to !== void 0) {
+      values.push(to);
+      clauses.push(`created_at < $${values.length}`);
+    }
+    const limit = normalizePagination(params.limit, 100);
+    const offset = normalizePagination(params.offset, 0);
+    values.push(limit, offset);
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    const { rows } = await this.pool.query(
+      `SELECT * FROM ${TABLE8}${where}
+       ORDER BY created_at DESC, id DESC
+       LIMIT $${values.length - 1} OFFSET $${values.length}`,
+      values
+    );
+    return rows.map(mapRow16);
+  }
+};
+
 // src/stores/PostgreSQLChannelReplyJobStore.ts
 import { Pool as Pool31 } from "pg";
 import {
@@ -14764,7 +15223,7 @@ function toStatus(value) {
   }
   throw new Error(`Invalid channel reply job status: ${value}`);
 }
-function mapRow16(row) {
+function mapRow17(row) {
   return {
     runId: row.run_id,
     tenantId: row.tenant_id,
@@ -14864,7 +15323,7 @@ var PostgreSQLChannelReplyJobStore = class {
         input.availableAt
       ]
     );
-    return mapRow16(result.rows[0]);
+    return mapRow17(result.rows[0]);
   }
   /** Reads one job within a tenant scope. */
   async get(tenantId, runId) {
@@ -14874,7 +15333,7 @@ var PostgreSQLChannelReplyJobStore = class {
         WHERE tenant_id = $1 AND run_id = $2`,
       [tenantId, runId]
     );
-    return result.rowCount === 0 ? null : mapRow16(result.rows[0]);
+    return result.rowCount === 0 ? null : mapRow17(result.rows[0]);
   }
   /** Lists claimable pending jobs that are due at `now`, oldest first. */
   async listPending(now, limit) {
@@ -14888,7 +15347,7 @@ var PostgreSQLChannelReplyJobStore = class {
         LIMIT $2`,
       [now, normalizeChannelReplyJobListLimit(limit)]
     );
-    return result.rows.map(mapRow16);
+    return result.rows.map(mapRow17);
   }
   /**
    * Atomically leases a claimable job.
@@ -14912,7 +15371,7 @@ var PostgreSQLChannelReplyJobStore = class {
         RETURNING ${COLUMNS2}`,
       [tenantId, runId, owner, leaseMs]
     );
-    return result.rowCount === 0 ? null : mapRow16(result.rows[0]);
+    return result.rowCount === 0 ? null : mapRow17(result.rows[0]);
   }
   /**
    * Marks a job delivered when `owner` still holds the lease.
@@ -14938,7 +15397,7 @@ var PostgreSQLChannelReplyJobStore = class {
         RETURNING ${COLUMNS2}`,
       [tenantId, runId, owner, outputMessageId]
     );
-    return result.rowCount === 0 ? null : mapRow16(result.rows[0]);
+    return result.rowCount === 0 ? null : mapRow17(result.rows[0]);
   }
   /**
    * Returns a job to pending with an incremented attempt count.
@@ -14965,7 +15424,7 @@ var PostgreSQLChannelReplyJobStore = class {
         RETURNING ${COLUMNS2}`,
       [tenantId, runId, owner, error, availableAt]
     );
-    return result.rowCount === 0 ? null : mapRow16(result.rows[0]);
+    return result.rowCount === 0 ? null : mapRow17(result.rows[0]);
   }
   /**
    * Marks a job terminally failed when `owner` still holds the lease.
@@ -14990,7 +15449,7 @@ var PostgreSQLChannelReplyJobStore = class {
         RETURNING ${COLUMNS2}`,
       [tenantId, runId, owner, error]
     );
-    return result.rowCount === 0 ? null : mapRow16(result.rows[0]);
+    return result.rowCount === 0 ? null : mapRow17(result.rows[0]);
   }
   /** Deletes one job. Returns whether a row was removed. */
   async delete(tenantId, runId) {
@@ -15472,7 +15931,7 @@ import {
   storeExpiresAt,
   storePaginationValue
 } from "@axiom-lattice/protocols";
-function mapRow17(row) {
+function mapRow18(row) {
   return {
     namespace: row.namespace,
     key: row.key,
@@ -15504,7 +15963,7 @@ var PostgreSQLStore = class {
        RETURNING tenant_id, namespace, key, value, created_at, updated_at, expires_at`,
       [tenantId, input.namespace, input.key, JSON.stringify(input.value), now, expiresAt]
     );
-    return mapRow17(result.rows[0]);
+    return mapRow18(result.rows[0]);
   }
   async get(tenantId, namespace, key) {
     assertStoreIdentity(namespace, key);
@@ -15515,7 +15974,7 @@ var PostgreSQLStore = class {
          AND (expires_at IS NULL OR expires_at > $4)`,
       [tenantId, namespace, key, /* @__PURE__ */ new Date()]
     );
-    return result.rows[0] ? mapRow17(result.rows[0]) : null;
+    return result.rows[0] ? mapRow18(result.rows[0]) : null;
   }
   async delete(tenantId, namespace, key) {
     assertStoreIdentity(namespace, key);
@@ -15559,7 +16018,7 @@ var PostgreSQLStore = class {
        LIMIT $${limitParam} OFFSET $${offsetParam}`,
       params
     );
-    return result.rows.map(mapRow17);
+    return result.rows.map(mapRow18);
   }
   async listNamespaces(tenantId, prefix = [], limit = 100) {
     assertStoreNamespacePrefix(prefix);
@@ -15740,6 +16199,8 @@ async function createPgStoreConfig(connectionString) {
   mm.register(addOidcIdentityClaimInviteFields);
   mm.register(createPlatformSettingsTable);
   mm.register(addOidcProviderAllowedHosts);
+  mm.register(createPlatformAuditTable);
+  mm.register(createPersonalMcpServerConfigsTable);
   await mm.migrate();
   const checkpoint = PostgresSaver.fromConnString(connectionString);
   try {
@@ -15763,6 +16224,7 @@ async function createPgStoreConfig(connectionString) {
     oidcIdentityClaim: new PostgreSQLOidcIdentityClaimStore(opts),
     inviteLink: new PostgreSQLInviteLinkStore(opts),
     platformSettings: new PostgreSQLPlatformSettingsStore(opts),
+    platformAudit: new PostgreSQLPlatformAuditStore(opts),
     channelBinding: new ChannelBindingStore(opts),
     channelInstallation: new PostgreSQLChannelInstallationStore(opts),
     thread: new PostgreSQLThreadStore(opts),
@@ -16383,6 +16845,7 @@ export {
   PostgreSQLOidcIdentityClaimStore,
   PostgreSQLOidcProviderConfigStore,
   PostgreSQLOpenAuditStore,
+  PostgreSQLPlatformAuditStore,
   PostgreSQLPlatformInvitationStore,
   PostgreSQLPlatformMemberStore,
   PostgreSQLPlatformSettingsStore,
@@ -16454,7 +16917,9 @@ export {
   createOidcIdentityClaimsTable,
   createOidcProviderConfigsTable,
   createPGVectorStoreProvider,
+  createPersonalMcpServerConfigsTable,
   createPgStoreConfig,
+  createPlatformAuditTable,
   createPlatformInvitationsTable,
   createPlatformMembersTable,
   createPlatformSettingsTable,