@open-mercato/ai-assistant 0.6.1-develop.3246.1.dbef9d7392 → 0.6.1-develop.3256.1.fe3dec2464

package/src/modules/ai_assistant/data/entities/AiAgentRuntimeOverride.ts

@@ -0,0 +1,7 @@
+// Canonical entity class lives in `../entities.ts` (single-file aggregate, same
+// pattern as `packages/core/src/modules/customers/data/entities.ts`). This
+// thin re-export exists so call sites that prefer the by-name import path
+// (`.../entities/AiAgentRuntimeOverride`) keep working.
+
+export { AiAgentRuntimeOverride } from '../entities'
+export type { AiAgentRuntimeOverride as default } from '../entities'

package/src/modules/ai_assistant/data/entities/AiTenantModelAllowlist.ts

@@ -0,0 +1,2 @@
+export { AiTenantModelAllowlist } from '../entities'
+export type { AiTenantModelAllowlist as default } from '../entities'

package/src/modules/ai_assistant/data/entities.ts

@@ -210,6 +210,101 @@ export class AiPendingAction {
   resolvedByUserId?: string | null
 }
 
+/**
+ * Per-tenant runtime override row that controls which provider, model, and
+ * base URL the AI runtime uses for a given agent (or all agents when
+ * `agent_id` is null).
+ *
+ * Resolution at query time: a non-null `agent_id` row takes precedence over
+ * a null `agent_id` (tenant-wide) row for the same `(tenant_id,
+ * organization_id)` scope. All value columns are nullable — an admin can
+ * override just the provider, just the model, or any subset. A null value
+ * means "inherit from the next source in the factory resolution chain."
+ *
+ * Soft-delete via `deleted_at` so the unique partial index and audit trail
+ * remain intact across upsert operations.
+ *
+ * Phase 4a of spec `2026-04-27-ai-agents-provider-model-baseurl-overrides`.
+ */
+@Entity({ tableName: 'ai_agent_runtime_overrides' })
+@Index({
+  name: 'ai_agent_runtime_overrides_tenant_org_agent_uq',
+  expression:
+    'create unique index "ai_agent_runtime_overrides_tenant_org_agent_uq" on "ai_agent_runtime_overrides" ("tenant_id", "organization_id", "agent_id") where "deleted_at" is null and "organization_id" is not null and "agent_id" is not null',
+})
+@Index({
+  name: 'ai_agent_runtime_overrides_tenant_agent_null_org_uq',
+  expression:
+    'create unique index "ai_agent_runtime_overrides_tenant_agent_null_org_uq" on "ai_agent_runtime_overrides" ("tenant_id", "agent_id") where "deleted_at" is null and "organization_id" is null and "agent_id" is not null',
+})
+@Index({
+  name: 'ai_agent_runtime_overrides_tenant_null_agent_null_org_uq',
+  expression:
+    'create unique index "ai_agent_runtime_overrides_tenant_null_agent_null_org_uq" on "ai_agent_runtime_overrides" ("tenant_id") where "deleted_at" is null and "organization_id" is null and "agent_id" is null',
+})
+@Index({
+  name: 'ai_agent_runtime_overrides_tenant_org_null_agent_uq',
+  expression:
+    'create unique index "ai_agent_runtime_overrides_tenant_org_null_agent_uq" on "ai_agent_runtime_overrides" ("tenant_id", "organization_id") where "deleted_at" is null and "organization_id" is not null and "agent_id" is null',
+})
+@Index({
+  name: 'ai_agent_runtime_overrides_tenant_idx',
+  properties: ['tenantId'],
+})
+export class AiAgentRuntimeOverride {
+  [OptionalProps]?:
+    | 'createdAt'
+    | 'updatedAt'
+    | 'organizationId'
+    | 'agentId'
+    | 'providerId'
+    | 'modelId'
+    | 'baseUrl'
+    | 'allowedOverrideProviders'
+    | 'allowedOverrideModelsByProvider'
+    | 'updatedByUserId'
+    | 'deletedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+
+  @Property({ name: 'agent_id', type: 'string', columnType: 'varchar(128)', nullable: true })
+  agentId?: string | null
+
+  @Property({ name: 'provider_id', type: 'string', columnType: 'varchar(64)', nullable: true })
+  providerId?: string | null
+
+  @Property({ name: 'model_id', type: 'string', columnType: 'varchar(256)', nullable: true })
+  modelId?: string | null
+
+  @Property({ name: 'base_url', type: 'string', columnType: 'varchar(2048)', nullable: true })
+  baseUrl?: string | null
+
+  @Property({ name: 'allowed_override_providers', type: 'jsonb', nullable: true })
+  allowedOverrideProviders?: string[] | null
+
+  @Property({ name: 'allowed_override_models_by_provider', type: 'jsonb', default: '{}' })
+  allowedOverrideModelsByProvider: Record<string, string[]> = {}
+
+  @Property({ name: 'updated_by_user_id', type: 'uuid', nullable: true })
+  updatedByUserId?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
 /**
  * Tenant-scoped override of an agent's declared `mutationPolicy` (Step 5.4).
  *
@@ -223,6 +318,75 @@ export class AiPendingAction {
  * < `confirm-required`. The route never allows an override to widen the
  * code-declared policy.
  */
+/**
+ * Tenant-scoped allowlist clipping which providers and models the runtime is
+ * permitted to use within the env-driven allowlist (Phase 1780-6 of spec
+ * `2026-04-27-ai-agents-provider-model-baseurl-overrides`).
+ *
+ * Effective constraint chain (outer → inner): `OM_AI_AVAILABLE_*` env vars →
+ * this tenant allowlist → per-tenant runtime overrides → per-request overrides.
+ * The tenant allowlist may NEVER widen the env allowlist; the runtime
+ * intersects the two and surfaces the intersection through the settings GET
+ * response so the UI never offers a value the runtime would refuse.
+ *
+ * `allowedProviders === null` means "inherit env" (no tenant-level restriction
+ * beyond what the env imposes). `allowedModelsByProvider` keys are provider
+ * ids; a missing key means "inherit env" for that provider; an empty array
+ * means "no models permitted for this provider" (effectively disabling it).
+ */
+@Entity({ tableName: 'ai_tenant_model_allowlists' })
+@Index({
+  name: 'ai_tenant_model_allowlists_tenant_org_uq',
+  expression:
+    'create unique index "ai_tenant_model_allowlists_tenant_org_uq" on "ai_tenant_model_allowlists" ("tenant_id", "organization_id") where "deleted_at" is null and "organization_id" is not null',
+})
+@Index({
+  name: 'ai_tenant_model_allowlists_tenant_null_org_uq',
+  expression:
+    'create unique index "ai_tenant_model_allowlists_tenant_null_org_uq" on "ai_tenant_model_allowlists" ("tenant_id") where "deleted_at" is null and "organization_id" is null',
+})
+@Index({
+  name: 'ai_tenant_model_allowlists_tenant_idx',
+  properties: ['tenantId'],
+})
+export class AiTenantModelAllowlist {
+  [OptionalProps]?:
+    | 'createdAt'
+    | 'updatedAt'
+    | 'organizationId'
+    | 'allowedProviders'
+    | 'allowedModelsByProvider'
+    | 'updatedByUserId'
+    | 'deletedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+
+  @Property({ name: 'allowed_providers', type: 'jsonb', nullable: true })
+  allowedProviders?: string[] | null
+
+  @Property({ name: 'allowed_models_by_provider', type: 'jsonb', default: '{}' })
+  allowedModelsByProvider: Record<string, string[]> = {}
+
+  @Property({ name: 'updated_by_user_id', type: 'uuid', nullable: true })
+  updatedByUserId?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
 @Entity({ tableName: 'ai_agent_mutation_policy_overrides' })
 @Index({
   name: 'ai_agent_mutation_policy_overrides_tenant_org_agent_uq',

package/src/modules/ai_assistant/data/repositories/AiAgentRuntimeOverrideRepository.ts

@@ -0,0 +1,227 @@
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
+import { canonicalProviderId } from '../../lib/model-allowlist'
+import { AiAgentRuntimeOverride } from '../entities'
+
+export interface AiAgentRuntimeOverrideContext {
+  tenantId: string
+  organizationId?: string | null
+  userId?: string | null
+}
+
+export interface AiAgentRuntimeOverrideInput {
+  /** null means tenant-wide default (no agent pinning). */
+  agentId?: string | null
+  providerId?: string | null
+  modelId?: string | null
+  baseURL?: string | null
+  allowedOverrideProviders?: string[] | null
+  allowedOverrideModelsByProvider?: Record<string, string[]>
+}
+
+/**
+ * Repository for per-tenant AI runtime overrides (Phase 4a of spec
+ * `2026-04-27-ai-agents-provider-model-baseurl-overrides`).
+ *
+ * All reads MUST filter by `tenant_id` first. The three public methods follow
+ * the same fail-safe pattern as sibling repositories: `getDefault` returns
+ * null on missing tenant context; `upsertDefault` validates provider id at
+ * write time; `clearDefault` soft-deletes via `deleted_at`.
+ *
+ * Resolution precedence returned by `getDefault`:
+ *   1. Agent-specific row (non-null `agent_id`) when `agentId` is provided.
+ *   2. Tenant-wide row (`agent_id IS NULL`) for the same `(tenant_id, org_id)`.
+ * Both rows are always scoped to the caller's `tenant_id` — cross-tenant
+ * reads are impossible because every query filters `WHERE tenant_id = ?`.
+ */
+export class AiAgentRuntimeOverrideRepository {
+  constructor(private readonly em: EntityManager) {}
+
+  /**
+   * Returns the most-specific active runtime override for the given context.
+   *
+   * When `agentId` is provided, an agent-specific row takes precedence over a
+   * tenant-wide null-agent row. Returns null when neither exists.
+   *
+   * Never returns a row with `deleted_at IS NOT NULL`.
+   */
+  async getDefault(ctx: {
+    tenantId: string
+    organizationId?: string | null
+    agentId?: string | null
+  }): Promise<AiAgentRuntimeOverride | null> {
+    if (!ctx?.tenantId) return null
+
+    const orgFilter = ctx.organizationId ?? null
+
+    // Try agent-specific first when caller provided an agentId.
+    if (ctx.agentId) {
+      const agentRow = await this.em.findOne(AiAgentRuntimeOverride, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        agentId: ctx.agentId,
+        deletedAt: null,
+      } satisfies FilterQuery<AiAgentRuntimeOverride>)
+      if (agentRow) return agentRow
+    }
+
+    // Fall back to tenant-wide row (agentId = null).
+    const tenantRow = await this.em.findOne(AiAgentRuntimeOverride, {
+      tenantId: ctx.tenantId,
+      organizationId: orgFilter,
+      agentId: null,
+      deletedAt: null,
+    } satisfies FilterQuery<AiAgentRuntimeOverride>)
+    return tenantRow ?? null
+  }
+
+  async getExact(ctx: {
+    tenantId: string
+    organizationId?: string | null
+    agentId?: string | null
+  }): Promise<AiAgentRuntimeOverride | null> {
+    if (!ctx?.tenantId) return null
+    const row = await this.em.findOne(AiAgentRuntimeOverride, {
+      tenantId: ctx.tenantId,
+      organizationId: ctx.organizationId ?? null,
+      agentId: ctx.agentId ?? null,
+      deletedAt: null,
+    } satisfies FilterQuery<AiAgentRuntimeOverride>)
+    return row ?? null
+  }
+
+  /**
+   * Inserts or updates the runtime override for the given context.
+   *
+   * Validates `providerId` against the registry at write time so an admin
+   * cannot save a typo (Phase 1.4 contract re-applied per spec §Data Models).
+   * An unknown provider id throws a typed error.
+   *
+   * The R6 base-URL allowlist check is intentionally NOT performed here —
+   * that enforcement lives at the HTTP layer (PUT settings route). The
+   * repository trusts that callers have already validated the value.
+   */
+  async upsertDefault(
+    input: AiAgentRuntimeOverrideInput,
+    ctx: AiAgentRuntimeOverrideContext,
+  ): Promise<AiAgentRuntimeOverride> {
+    if (!ctx?.tenantId) {
+      throw new Error('AiAgentRuntimeOverrideRepository.upsertDefault requires tenantId')
+    }
+
+    const normalizedProviderId = input.providerId
+      ? canonicalProviderId(input.providerId, llmProviderRegistry.list().map((p) => p.id))
+      : null
+    if (input.providerId) {
+      const knownProvider = normalizedProviderId ? llmProviderRegistry.get(normalizedProviderId) : null
+      if (!knownProvider) {
+        throw new AiAgentRuntimeOverrideValidationError(
+          `Unknown provider id "${input.providerId}". Registered provider ids: ${llmProviderRegistry.list().map((p) => p.id).join(', ')}.`,
+        )
+      }
+    }
+
+    const orgFilter = ctx.organizationId ?? null
+    const agentIdFilter = input.agentId ?? null
+    const hasProviderId = Object.prototype.hasOwnProperty.call(input, 'providerId')
+    const hasModelId = Object.prototype.hasOwnProperty.call(input, 'modelId')
+    const hasBaseURL = Object.prototype.hasOwnProperty.call(input, 'baseURL')
+    const hasAllowedOverrideProviders = Object.prototype.hasOwnProperty.call(input, 'allowedOverrideProviders')
+    const hasAllowedOverrideModels = Object.prototype.hasOwnProperty.call(input, 'allowedOverrideModelsByProvider')
+
+    return this.em.transactional(async (tx) => {
+      const existing = await tx.findOne(AiAgentRuntimeOverride, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        agentId: agentIdFilter,
+        deletedAt: null,
+      } satisfies FilterQuery<AiAgentRuntimeOverride>)
+
+      if (existing) {
+        if (hasProviderId) existing.providerId = normalizedProviderId
+        if (hasModelId) existing.modelId = input.modelId ?? null
+        if (hasBaseURL) existing.baseUrl = input.baseURL ?? null
+        if (hasAllowedOverrideProviders) {
+          existing.allowedOverrideProviders = input.allowedOverrideProviders ?? null
+        }
+        if (hasAllowedOverrideModels) {
+          existing.allowedOverrideModelsByProvider = input.allowedOverrideModelsByProvider ?? {}
+        }
+        existing.updatedByUserId = ctx.userId ?? null
+        existing.updatedAt = new Date()
+        await tx.persist(existing).flush()
+        return existing
+      }
+
+      const row = tx.create(AiAgentRuntimeOverride, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        agentId: agentIdFilter,
+        providerId: hasProviderId ? normalizedProviderId : null,
+        modelId: hasModelId ? (input.modelId ?? null) : null,
+        baseUrl: hasBaseURL ? (input.baseURL ?? null) : null,
+        allowedOverrideProviders: hasAllowedOverrideProviders
+          ? (input.allowedOverrideProviders ?? null)
+          : null,
+        allowedOverrideModelsByProvider: hasAllowedOverrideModels
+          ? (input.allowedOverrideModelsByProvider ?? {})
+          : {},
+        updatedByUserId: ctx.userId ?? null,
+      } as unknown as AiAgentRuntimeOverride)
+      await tx.persist(row).flush()
+      return row
+    })
+  }
+
+  /**
+   * Soft-deletes the active override matching the given context by setting
+   * `deleted_at = now()`. Returns true when a row was found and cleared,
+   * false when no active row existed.
+   */
+  async clearDefault(ctx: {
+    tenantId: string
+    organizationId?: string | null
+    agentId?: string | null
+  }): Promise<boolean> {
+    if (!ctx?.tenantId) return false
+
+    const orgFilter = ctx.organizationId ?? null
+    const agentIdFilter = ctx.agentId ?? null
+
+    return this.em.transactional(async (tx) => {
+      const existing = await tx.findOne(AiAgentRuntimeOverride, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        agentId: agentIdFilter,
+        deletedAt: null,
+      } satisfies FilterQuery<AiAgentRuntimeOverride>)
+      if (!existing) return false
+      if (
+        existing.allowedOverrideProviders != null ||
+        Object.keys(existing.allowedOverrideModelsByProvider ?? {}).length > 0
+      ) {
+        existing.providerId = null
+        existing.modelId = null
+        existing.baseUrl = null
+        existing.updatedAt = new Date()
+        await tx.persist(existing).flush()
+        return true
+      }
+      existing.deletedAt = new Date()
+      await tx.persist(existing).flush()
+      return true
+    })
+  }
+}
+
+/**
+ * Thrown by `upsertDefault` when an unknown provider id is submitted.
+ */
+export class AiAgentRuntimeOverrideValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'AiAgentRuntimeOverrideValidationError'
+  }
+}
+
+export default AiAgentRuntimeOverrideRepository

package/src/modules/ai_assistant/data/repositories/AiTenantModelAllowlistRepository.ts

@@ -0,0 +1,132 @@
+import type { EntityManager, FilterQuery } from '@mikro-orm/postgresql'
+import { AiTenantModelAllowlist } from '../entities'
+
+export interface AiTenantModelAllowlistContext {
+  tenantId: string
+  organizationId?: string | null
+  userId?: string | null
+}
+
+export interface AiTenantModelAllowlistInput {
+  /**
+   * Tenant-permitted provider ids. `null` means "inherit env" (no tenant
+   * restriction beyond what `OM_AI_AVAILABLE_PROVIDERS` imposes). An empty
+   * array means "no providers permitted" — the runtime will fall through to
+   * env-default behaviour but the settings UI will surface zero options.
+   */
+  allowedProviders?: string[] | null
+  /**
+   * Per-provider allowed model lists. A missing key means "inherit env" for
+   * that provider; an empty array means "no models permitted for this
+   * provider" (effectively disabling it for tenant-side picks).
+   */
+  allowedModelsByProvider?: Record<string, string[]>
+}
+
+export interface AiTenantModelAllowlistSnapshot {
+  allowedProviders: string[] | null
+  allowedModelsByProvider: Record<string, string[]>
+}
+
+/**
+ * Repository for the per-tenant provider/model allowlist (Phase 1780-6 of spec
+ * `2026-04-27-ai-agents-provider-model-baseurl-overrides`).
+ *
+ * Reads always filter by `tenant_id`. The tenant allowlist clips runtime
+ * choices within the env-driven outer constraint — the route layer is
+ * responsible for rejecting writes that escape `OM_AI_AVAILABLE_*`. This
+ * repository does not consult the env directly; it stores whatever the route
+ * has already validated.
+ */
+export class AiTenantModelAllowlistRepository {
+  constructor(private readonly em: EntityManager) {}
+
+  async getForTenant(ctx: {
+    tenantId: string
+    organizationId?: string | null
+  }): Promise<AiTenantModelAllowlist | null> {
+    if (!ctx?.tenantId) return null
+    const orgFilter = ctx.organizationId ?? null
+    const row = await this.em.findOne(AiTenantModelAllowlist, {
+      tenantId: ctx.tenantId,
+      organizationId: orgFilter,
+      deletedAt: null,
+    } satisfies FilterQuery<AiTenantModelAllowlist>)
+    return row ?? null
+  }
+
+  async getSnapshot(ctx: {
+    tenantId: string
+    organizationId?: string | null
+  }): Promise<AiTenantModelAllowlistSnapshot | null> {
+    const row = await this.getForTenant(ctx)
+    if (!row) return null
+    return {
+      allowedProviders: row.allowedProviders ?? null,
+      allowedModelsByProvider: row.allowedModelsByProvider ?? {},
+    }
+  }
+
+  async upsert(
+    input: AiTenantModelAllowlistInput,
+    ctx: AiTenantModelAllowlistContext,
+  ): Promise<AiTenantModelAllowlist> {
+    if (!ctx?.tenantId) {
+      throw new Error('AiTenantModelAllowlistRepository.upsert requires tenantId')
+    }
+
+    const orgFilter = ctx.organizationId ?? null
+    const providers = input.allowedProviders === undefined
+      ? null
+      : input.allowedProviders
+    const models = input.allowedModelsByProvider ?? {}
+
+    return this.em.transactional(async (tx) => {
+      const existing = await tx.findOne(AiTenantModelAllowlist, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        deletedAt: null,
+      } satisfies FilterQuery<AiTenantModelAllowlist>)
+
+      if (existing) {
+        existing.allowedProviders = providers
+        existing.allowedModelsByProvider = models
+        existing.updatedByUserId = ctx.userId ?? null
+        existing.updatedAt = new Date()
+        await tx.persist(existing).flush()
+        return existing
+      }
+
+      const row = tx.create(AiTenantModelAllowlist, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        allowedProviders: providers,
+        allowedModelsByProvider: models,
+        updatedByUserId: ctx.userId ?? null,
+      } as unknown as AiTenantModelAllowlist)
+      await tx.persist(row).flush()
+      return row
+    })
+  }
+
+  async clear(ctx: {
+    tenantId: string
+    organizationId?: string | null
+  }): Promise<boolean> {
+    if (!ctx?.tenantId) return false
+    const orgFilter = ctx.organizationId ?? null
+    return this.em.transactional(async (tx) => {
+      const existing = await tx.findOne(AiTenantModelAllowlist, {
+        tenantId: ctx.tenantId,
+        organizationId: orgFilter,
+        deletedAt: null,
+      } satisfies FilterQuery<AiTenantModelAllowlist>)
+      if (!existing) return false
+      existing.deletedAt = new Date()
+      await tx.persist(existing).flush()
+      return true
+    })
+  }
+}
+
+export default AiTenantModelAllowlistRepository