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

package/src/modules/ai_assistant/api/settings/__tests__/route.test.ts

@@ -0,0 +1,408 @@
+/**
+ * Tests for Phase 4a additions to /api/ai_assistant/settings:
+ *   - PUT /api/ai_assistant/settings — upsert + ACL gate
+ *   - DELETE /api/ai_assistant/settings — clear + ACL gate
+ *
+ * The GET handler is tested implicitly via integration; unit testing
+ * the existing GET would require mocking many opencode-provider helpers.
+ */
+
+const authMock = jest.fn()
+const loadAclMock = jest.fn()
+const createRequestContainerMock = jest.fn()
+const upsertDefaultMock = jest.fn()
+const clearDefaultMock = jest.fn()
+
+jest.mock('@open-mercato/shared/lib/auth/server', () => ({
+  getAuthFromRequest: (...args: unknown[]) => authMock(...args),
+}))
+
+jest.mock('@open-mercato/shared/lib/di/container', () => ({
+  createRequestContainer: (...args: unknown[]) => createRequestContainerMock(...args),
+}))
+
+jest.mock('../../../data/repositories/AiAgentRuntimeOverrideRepository', () => {
+  return {
+    AiAgentRuntimeOverrideRepository: jest.fn().mockImplementation(() => ({
+      upsertDefault: upsertDefaultMock,
+      clearDefault: clearDefaultMock,
+    })),
+    AiAgentRuntimeOverrideValidationError: class AiAgentRuntimeOverrideValidationError extends Error {
+      constructor(message: string) {
+        super(message)
+        this.name = 'AiAgentRuntimeOverrideValidationError'
+      }
+    },
+  }
+})
+
+const readBaseurlAllowlistMock = jest.fn()
+const isBaseurlAllowlistedMock = jest.fn()
+
+jest.mock('../../../lib/baseurl-allowlist', () => ({
+  readBaseurlAllowlist: (...args: unknown[]) => readBaseurlAllowlistMock(...args),
+  isBaseurlAllowlisted: (...args: unknown[]) => isBaseurlAllowlistedMock(...args),
+}))
+
+// The GET handler uses opencode-provider helpers — mock only what is needed
+// to prevent import errors; GET tests are not included here.
+jest.mock('@open-mercato/shared/lib/ai/opencode-provider', () => ({
+  OPEN_CODE_PROVIDER_IDS: [],
+  OPEN_CODE_PROVIDERS: {},
+  getOpenCodeProviderConfiguredEnvKey: () => null,
+  isOpenCodeProviderConfigured: () => false,
+  resolveOpenCodeModel: () => ({ modelWithProvider: 'gpt-4o-mini' }),
+  resolveOpenCodeProviderId: () => 'openai',
+}))
+
+jest.mock('@open-mercato/shared/lib/ai/llm-provider-registry', () => ({
+  llmProviderRegistry: {
+    get: jest.fn(),
+    list: jest.fn(() => []),
+  },
+}))
+
+jest.mock('../../../lib/agent-registry', () => ({
+  loadAgentRegistry: jest.fn().mockResolvedValue(undefined),
+  listAgents: jest.fn(() => []),
+}))
+
+jest.mock('../../../lib/model-factory', () => ({
+  createModelFactory: jest.fn(() => ({
+    resolveModel: jest.fn(() => ({
+      providerId: 'openai',
+      modelId: 'gpt-4o-mini',
+      baseURL: null,
+      source: 'provider_default',
+    })),
+  })),
+}))
+
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
+import { GET, PUT, DELETE } from '../route'
+
+function buildRequest(method: 'PUT' | 'DELETE', body: unknown): Request {
+  return new Request('http://localhost/api/ai_assistant/settings', {
+    method,
+    body: typeof body === 'string' ? body : JSON.stringify(body),
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+describe('PUT /api/ai_assistant/settings', () => {
+  let consoleErrorSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    authMock.mockResolvedValue({ sub: 'user-1', tenantId: 'tenant-1', orgId: 'org-1' })
+    loadAclMock.mockResolvedValue({ features: ['ai_assistant.settings.manage'], isSuperAdmin: false })
+    createRequestContainerMock.mockResolvedValue({
+      resolve: (name: string) => {
+        if (name === 'rbacService') return { loadAcl: loadAclMock }
+        if (name === 'em') return {}
+        return null
+      },
+    })
+    upsertDefaultMock.mockResolvedValue({
+      id: 'row-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: null,
+      providerId: 'openai',
+      modelId: 'gpt-5-mini',
+      baseUrl: null,
+      updatedAt: new Date('2026-05-08T00:00:00Z'),
+    })
+    readBaseurlAllowlistMock.mockReturnValue(['openrouter.ai'])
+    isBaseurlAllowlistedMock.mockReturnValue(true)
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    authMock.mockResolvedValueOnce(null)
+
+    const response = await PUT(buildRequest('PUT', { providerId: 'openai' }) as any)
+
+    expect(response.status).toBe(401)
+  })
+
+  it('returns 403 when caller lacks ai_assistant.settings.manage', async () => {
+    loadAclMock.mockResolvedValueOnce({ features: ['ai_assistant.view'], isSuperAdmin: false })
+
+    const response = await PUT(buildRequest('PUT', { providerId: 'openai' }) as any)
+
+    expect(response.status).toBe(403)
+    const json = await response.json()
+    expect(json.code).toBe('forbidden')
+  })
+
+  it('returns 400 with validation_error for invalid body', async () => {
+    const response = await PUT(buildRequest('PUT', 'not-json') as any)
+
+    expect(response.status).toBe(400)
+  })
+
+  it('upserts the override and returns the saved row on success', async () => {
+    const response = await PUT(
+      buildRequest('PUT', { providerId: 'openai', modelId: 'gpt-5-mini', agentId: null }) as any,
+    )
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.providerId).toBe('openai')
+    expect(json.modelId).toBe('gpt-5-mini')
+    expect(upsertDefaultMock).toHaveBeenCalledWith(
+      expect.objectContaining({ providerId: 'openai', modelId: 'gpt-5-mini' }),
+      expect.objectContaining({ tenantId: 'tenant-1', organizationId: 'org-1', userId: 'user-1' }),
+    )
+  })
+
+  it('saves per-agent chat override allowlist without requiring a model override', async () => {
+    upsertDefaultMock.mockResolvedValueOnce({
+      id: 'row-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: 'catalog.catalog_assistant',
+      providerId: null,
+      modelId: null,
+      baseUrl: null,
+      allowedOverrideProviders: ['openai'],
+      allowedOverrideModelsByProvider: { openai: ['gpt-5-mini'] },
+      updatedAt: new Date('2026-05-08T00:00:00Z'),
+    })
+
+    const response = await PUT(
+      buildRequest('PUT', {
+        agentId: 'catalog.catalog_assistant',
+        allowedOverrideProviders: ['openai'],
+        allowedOverrideModelsByProvider: { openai: ['gpt-5-mini'] },
+      }) as any,
+    )
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.allowedOverrideProviders).toEqual(['openai'])
+    expect(json.allowedOverrideModelsByProvider).toEqual({ openai: ['gpt-5-mini'] })
+    expect(upsertDefaultMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        agentId: 'catalog.catalog_assistant',
+        allowedOverrideProviders: ['openai'],
+        allowedOverrideModelsByProvider: { openai: ['gpt-5-mini'] },
+      }),
+      expect.objectContaining({ tenantId: 'tenant-1', organizationId: 'org-1', userId: 'user-1' }),
+    )
+  })
+
+  it('saves per-agent chat override allowlist with inherited providers and no provider override', async () => {
+    upsertDefaultMock.mockResolvedValueOnce({
+      id: 'row-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: 'catalog.catalog_assistant',
+      providerId: null,
+      modelId: null,
+      baseUrl: null,
+      allowedOverrideProviders: null,
+      allowedOverrideModelsByProvider: {},
+      updatedAt: new Date('2026-05-08T00:00:00Z'),
+    })
+
+    const response = await PUT(
+      buildRequest('PUT', {
+        agentId: 'catalog.catalog_assistant',
+        allowedOverrideProviders: null,
+        allowedOverrideModelsByProvider: {},
+      }) as any,
+    )
+
+    expect(response.status).toBe(200)
+    expect(upsertDefaultMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        agentId: 'catalog.catalog_assistant',
+        allowedOverrideProviders: null,
+        allowedOverrideModelsByProvider: {},
+      }),
+      expect.objectContaining({ tenantId: 'tenant-1', organizationId: 'org-1', userId: 'user-1' }),
+    )
+  })
+
+  it('requires agentId when saving per-agent chat override allowlist', async () => {
+    const response = await PUT(
+      buildRequest('PUT', { allowedOverrideProviders: ['openai'] }) as any,
+    )
+
+    expect(response.status).toBe(400)
+    const json = await response.json()
+    expect(json.code).toBe('agent_required')
+    expect(upsertDefaultMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 baseurl_not_allowlisted when baseURL fails allowlist check', async () => {
+    isBaseurlAllowlistedMock.mockReturnValue(false)
+
+    const response = await PUT(
+      buildRequest('PUT', { baseURL: 'https://evil.example.com/v1' }) as any,
+    )
+
+    expect(response.status).toBe(400)
+    const json = await response.json()
+    expect(json.code).toBe('baseurl_not_allowlisted')
+    expect(upsertDefaultMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 provider_unknown when upsert throws AiAgentRuntimeOverrideValidationError', async () => {
+    const { AiAgentRuntimeOverrideValidationError } = await import('../../../data/repositories/AiAgentRuntimeOverrideRepository')
+    upsertDefaultMock.mockRejectedValueOnce(
+      new AiAgentRuntimeOverrideValidationError('Unknown provider id "unknown"'),
+    )
+
+    const response = await PUT(buildRequest('PUT', { providerId: 'unknown' }) as any)
+
+    expect(response.status).toBe(400)
+    const json = await response.json()
+    expect(json.code).toBe('provider_unknown')
+  })
+
+  it('allows superAdmin even without the manage feature', async () => {
+    loadAclMock.mockResolvedValueOnce({ features: [], isSuperAdmin: true })
+
+    const response = await PUT(buildRequest('PUT', { providerId: 'openai' }) as any)
+
+    expect(response.status).toBe(200)
+  })
+})
+
+describe('GET /api/ai_assistant/settings', () => {
+  let consoleWarnSpy: jest.SpyInstance
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    originalEnv = { ...process.env }
+    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    authMock.mockResolvedValue({ sub: 'user-1', tenantId: null, orgId: null })
+    createRequestContainerMock.mockResolvedValue({ resolve: () => null })
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+    consoleWarnSpy.mockRestore()
+  })
+
+  it('does not run LM Studio slashy model ids through the legacy OpenCode model parser', async () => {
+    process.env.OM_AI_PROVIDER = 'lm_studio'
+    process.env.OM_AI_MODEL = 'qwen/qwen3.5-9b'
+    process.env.OM_AI_AVAILABLE_PROVIDERS = 'openai,lm_studio'
+    process.env.OM_AI_AVAILABLE_MODELS_LM_STUDIO = 'qwen/qwen3.5-9b'
+    process.env.LM_STUDIO_API_KEY = 'lm-studio'
+
+    const provider = {
+      id: 'lm-studio',
+      name: 'LM Studio (local)',
+      defaultModel: '',
+      defaultModels: [],
+      isConfigured: jest.fn(() => true),
+      resolveApiKey: jest.fn(() => 'lm-studio'),
+      getConfiguredEnvKey: jest.fn(() => 'LM_STUDIO_API_KEY'),
+      createModel: jest.fn(),
+      envKeys: ['LM_STUDIO_API_KEY'],
+    }
+    ;(llmProviderRegistry.list as jest.Mock).mockReturnValue([provider])
+    ;(llmProviderRegistry.get as jest.Mock).mockImplementation((id: string) =>
+      id === 'lm-studio' ? provider : null,
+    )
+
+    const response = await GET(new Request('http://localhost/api/ai_assistant/settings') as any)
+    const json = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(json.provider.id).toBe('lm-studio')
+    expect(json.provider.model).toBe('lm-studio/qwen/qwen3.5-9b')
+    expect(json.allowlistProviders[0].id).toBe('lm-studio')
+    expect(json.allowlistProviders[0].defaultModel).toBe('qwen/qwen3.5-9b')
+    expect(json.allowlistProviders[0].defaultModels).toEqual([
+      { id: 'qwen/qwen3.5-9b', name: 'qwen/qwen3.5-9b' },
+    ])
+  })
+})
+
+describe('DELETE /api/ai_assistant/settings', () => {
+  let consoleErrorSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    authMock.mockResolvedValue({ sub: 'user-1', tenantId: 'tenant-1', orgId: 'org-1' })
+    loadAclMock.mockResolvedValue({ features: ['ai_assistant.settings.manage'], isSuperAdmin: false })
+    createRequestContainerMock.mockResolvedValue({
+      resolve: (name: string) => {
+        if (name === 'rbacService') return { loadAcl: loadAclMock }
+        if (name === 'em') return {}
+        return null
+      },
+    })
+    clearDefaultMock.mockResolvedValue(true)
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    authMock.mockResolvedValueOnce(null)
+
+    const response = await DELETE(buildRequest('DELETE', {}) as any)
+
+    expect(response.status).toBe(401)
+  })
+
+  it('returns 403 when caller lacks ai_assistant.settings.manage', async () => {
+    loadAclMock.mockResolvedValueOnce({ features: ['ai_assistant.view'], isSuperAdmin: false })
+
+    const response = await DELETE(buildRequest('DELETE', {}) as any)
+
+    expect(response.status).toBe(403)
+    const json = await response.json()
+    expect(json.code).toBe('forbidden')
+  })
+
+  it('clears the tenant-wide override and returns { cleared: true }', async () => {
+    const response = await DELETE(buildRequest('DELETE', {}) as any)
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.cleared).toBe(true)
+    expect(clearDefaultMock).toHaveBeenCalledWith({
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: null,
+    })
+  })
+
+  it('clears an agent-specific override when agentId is given', async () => {
+    const response = await DELETE(buildRequest('DELETE', { agentId: 'customers.assistant' }) as any)
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.cleared).toBe(true)
+    expect(clearDefaultMock).toHaveBeenCalledWith({
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: 'customers.assistant',
+    })
+  })
+
+  it('returns { cleared: false } when no active row was found (idempotent)', async () => {
+    clearDefaultMock.mockResolvedValueOnce(false)
+
+    const response = await DELETE(buildRequest('DELETE', {}) as any)
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.cleared).toBe(false)
+  })
+})

package/src/modules/ai_assistant/api/settings/allowlist/route.ts

@@ -0,0 +1,221 @@
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
+import { AiTenantModelAllowlistRepository } from '../../../data/repositories/AiTenantModelAllowlistRepository'
+import {
+  canonicalProviderId,
+  isModelAllowedForProvider,
+  isProviderAllowed,
+  modelAllowlistEnvVarName,
+} from '../../../lib/model-allowlist'
+
+const allowlistUpsertSchema = z.object({
+  allowedProviders: z.array(z.string().min(1).max(64)).nullable().optional(),
+  allowedModelsByProvider: z
+    .record(z.string().min(1).max(64), z.array(z.string().min(1).max(256)))
+    .optional(),
+})
+
+export type AllowlistUpsertBody = z.infer<typeof allowlistUpsertSchema>
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'AI Assistant',
+  summary: 'AI assistant tenant allowlist',
+  methods: {
+    PUT: {
+      summary: 'Upsert per-tenant AI provider/model allowlist',
+      description:
+        'Persists the per-tenant allowlist of providers and models. The runtime intersects this with the env allowlist (`OM_AI_AVAILABLE_*`) at resolution time. ' +
+        'Tenant values that fall outside the env allowlist are rejected with `provider_not_in_env_allowlist` / `model_not_in_env_allowlist` 400 codes. ' +
+        'Gated by `ai_assistant.settings.manage`.',
+      requestBody: {
+        contentType: 'application/json',
+        description:
+          'Allowlist payload. `allowedProviders: null` clears tenant provider restriction (inherit env). Missing key in `allowedModelsByProvider` inherits env for that provider.',
+        schema: allowlistUpsertSchema,
+      },
+      responses: [
+        { status: 200, description: 'Allowlist saved. Returns the saved snapshot.' },
+      ],
+      errors: [
+        { status: 400, description: 'Validation error or values outside env allowlist.' },
+        { status: 401, description: 'Unauthenticated.' },
+        { status: 403, description: 'Caller lacks ai_assistant.settings.manage.' },
+      ],
+    },
+    DELETE: {
+      summary: 'Clear per-tenant AI provider/model allowlist',
+      description:
+        'Soft-deletes the tenant allowlist row. Tenant overrides revert to env-only enforcement. Idempotent — returns `{ cleared: false }` when no active row existed.',
+      responses: [
+        { status: 200, description: 'Returns `{ cleared: boolean }`.' },
+      ],
+      errors: [
+        { status: 401, description: 'Unauthenticated.' },
+        { status: 403, description: 'Caller lacks ai_assistant.settings.manage.' },
+      ],
+    },
+  },
+}
+
+export const metadata = {
+  PUT: { requireAuth: true, requireFeatures: ['ai_assistant.settings.manage'] },
+  DELETE: { requireAuth: true, requireFeatures: ['ai_assistant.settings.manage'] },
+}
+
+export async function PUT(req: NextRequest) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  let parsedBody: unknown
+  try {
+    parsedBody = await req.json()
+  } catch {
+    return NextResponse.json(
+      { error: 'Request body must be valid JSON.', code: 'validation_error' },
+      { status: 400 },
+    )
+  }
+
+  const bodyResult = allowlistUpsertSchema.safeParse(parsedBody)
+  if (!bodyResult.success) {
+    return NextResponse.json(
+      { error: 'Invalid request body.', code: 'validation_error', issues: bodyResult.error.issues },
+      { status: 400 },
+    )
+  }
+
+  const env = process.env as Record<string, string | undefined>
+  const knownProviderIds = llmProviderRegistry.list().map((provider) => provider.id)
+  const canonicalize = (providerId: string) =>
+    canonicalProviderId(providerId, knownProviderIds) ?? providerId
+  const allowedProviders = bodyResult.data.allowedProviders === undefined
+    ? null
+    : bodyResult.data.allowedProviders?.map(canonicalize) ?? null
+  const allowedModelsByProvider = Object.fromEntries(
+    Object.entries(bodyResult.data.allowedModelsByProvider ?? {}).map(([providerId, models]) => [
+      canonicalize(providerId),
+      models,
+    ]),
+  )
+
+  // Reject tenant entries that escape the env allowlist. The runtime would
+  // intersect them away anyway; failing fast at write time keeps stored
+  // tenant snapshots honest and visible in admin audits.
+  if (Array.isArray(allowedProviders)) {
+    for (const providerId of allowedProviders) {
+      if (!isProviderAllowed(env, providerId)) {
+        return NextResponse.json(
+          {
+            error: `Provider "${providerId}" is not in OM_AI_AVAILABLE_PROVIDERS; tenant allowlist may not widen the env allowlist.`,
+            code: 'provider_not_in_env_allowlist',
+          },
+          { status: 400 },
+        )
+      }
+    }
+  }
+  for (const providerId of Object.keys(allowedModelsByProvider)) {
+    if (!isProviderAllowed(env, providerId)) {
+      return NextResponse.json(
+        {
+          error: `Provider "${providerId}" is not in OM_AI_AVAILABLE_PROVIDERS; cannot save tenant model allowlist for it.`,
+          code: 'provider_not_in_env_allowlist',
+        },
+        { status: 400 },
+      )
+    }
+    for (const modelId of allowedModelsByProvider[providerId] ?? []) {
+      if (!isModelAllowedForProvider(env, providerId, modelId)) {
+        return NextResponse.json(
+          {
+            error: `Model "${modelId}" is not in ${modelAllowlistEnvVarName(providerId)}; tenant allowlist may not widen the env allowlist.`,
+            code: 'model_not_in_env_allowlist',
+          },
+          { status: 400 },
+        )
+      }
+    }
+  }
+
+  try {
+    const container = await createRequestContainer()
+    const rbacService = container.resolve<RbacService>('rbacService')
+    const acl = await rbacService.loadAcl(auth.sub, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+    })
+    const canManage =
+      acl.isSuperAdmin || acl.features.includes('ai_assistant.settings.manage')
+    if (!canManage) {
+      return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
+    }
+
+    const em = container.resolve<EntityManager>('em')
+    const repo = new AiTenantModelAllowlistRepository(em)
+    const row = await repo.upsert(
+      { allowedProviders, allowedModelsByProvider },
+      {
+        tenantId: auth.tenantId ?? '',
+        organizationId: auth.orgId ?? null,
+        userId: auth.sub,
+      },
+    )
+    return NextResponse.json({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      allowedProviders: row.allowedProviders ?? null,
+      allowedModelsByProvider: row.allowedModelsByProvider ?? {},
+      updatedAt: row.updatedAt,
+    })
+  } catch (error) {
+    console.error('[AI Settings Allowlist] PUT error:', error)
+    return NextResponse.json(
+      { error: 'Failed to save tenant allowlist.' },
+      { status: 500 },
+    )
+  }
+}
+
+export async function DELETE(req: NextRequest) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const container = await createRequestContainer()
+    const rbacService = container.resolve<RbacService>('rbacService')
+    const acl = await rbacService.loadAcl(auth.sub, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+    })
+    const canManage =
+      acl.isSuperAdmin || acl.features.includes('ai_assistant.settings.manage')
+    if (!canManage) {
+      return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
+    }
+
+    const em = container.resolve<EntityManager>('em')
+    const repo = new AiTenantModelAllowlistRepository(em)
+    const cleared = await repo.clear({
+      tenantId: auth.tenantId ?? '',
+      organizationId: auth.orgId ?? null,
+    })
+    return NextResponse.json({ cleared })
+  } catch (error) {
+    console.error('[AI Settings Allowlist] DELETE error:', error)
+    return NextResponse.json(
+      { error: 'Failed to clear tenant allowlist.' },
+      { status: 500 },
+    )
+  }
+}