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

package/src/modules/ai_assistant/api/ai/agents/[agentId]/models/__tests__/route.test.ts

@@ -0,0 +1,240 @@
+import type { AiAgentDefinition } from '../../../../../../lib/ai-agent-definition'
+import {
+  resetAgentRegistryForTests,
+  seedAgentRegistryForTests,
+} from '../../../../../../lib/agent-registry'
+
+const authMock = jest.fn()
+const loadAclMock = jest.fn()
+const createRequestContainerMock = jest.fn()
+const getSnapshotMock = jest.fn()
+const getDefaultMock = jest.fn()
+const getExactMock = jest.fn()
+const resolveModelMock = 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('@open-mercato/shared/lib/ai/llm-provider-registry', () => {
+  const providers = [
+    {
+      id: 'openai',
+      name: 'OpenAI',
+      defaultModel: 'gpt-4o',
+      defaultModels: [{ id: 'gpt-4o', name: 'GPT-4o' }],
+      isConfigured: jest.fn(() => true),
+    },
+    {
+      id: 'lm-studio',
+      name: 'LM Studio (local)',
+      defaultModel: 'qwen/qwen3.5-9b',
+      defaultModels: [{ id: 'qwen/qwen3.5-9b', name: 'qwen/qwen3.5-9b' }],
+      isConfigured: jest.fn(() => true),
+    },
+  ]
+  return {
+    llmProviderRegistry: {
+      list: jest.fn(() => providers),
+      get: jest.fn((id: string) => providers.find((provider) => provider.id === id) ?? null),
+    },
+  }
+})
+
+jest.mock('../../../../../../data/repositories/AiTenantModelAllowlistRepository', () => ({
+  AiTenantModelAllowlistRepository: jest.fn().mockImplementation(() => ({
+    getSnapshot: getSnapshotMock,
+  })),
+}))
+
+jest.mock('../../../../../../data/repositories/AiAgentRuntimeOverrideRepository', () => ({
+  AiAgentRuntimeOverrideRepository: jest.fn().mockImplementation(() => ({
+    getDefault: getDefaultMock,
+    getExact: getExactMock,
+  })),
+}))
+
+jest.mock('../../../../../../lib/model-factory', () => ({
+  createModelFactory: jest.fn(() => ({
+    resolveModel: resolveModelMock,
+  })),
+}))
+
+import { GET } from '../route'
+
+function makeAgent(
+  overrides: Partial<AiAgentDefinition> & Pick<AiAgentDefinition, 'id' | 'moduleId'>,
+): AiAgentDefinition {
+  return {
+    label: `${overrides.id} label`,
+    description: `${overrides.id} description`,
+    systemPrompt: 'You are a test agent.',
+    allowedTools: [],
+    requiredFeatures: ['ai_assistant.view'],
+    ...overrides,
+  }
+}
+
+function buildParams(agentId: string) {
+  return { params: Promise.resolve({ agentId }) }
+}
+
+describe('GET /api/ai_assistant/ai/agents/[agentId]/models', () => {
+  let consoleErrorSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    resetAgentRegistryForTests()
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    authMock.mockResolvedValue({
+      sub: 'user-1',
+      tenantId: 'tenant-1',
+      orgId: 'org-1',
+    })
+    loadAclMock.mockResolvedValue({
+      features: ['ai_assistant.view'],
+      isSuperAdmin: false,
+    })
+    createRequestContainerMock.mockResolvedValue({
+      resolve: (name: string) => {
+        if (name === 'rbacService') return { loadAcl: loadAclMock }
+        if (name === 'em') return {}
+        return null
+      },
+    })
+    getSnapshotMock.mockResolvedValue(null)
+    getDefaultMock.mockResolvedValue(null)
+    getExactMock.mockResolvedValue(null)
+    resolveModelMock.mockReturnValue({
+      providerId: 'openai',
+      modelId: 'gpt-4o',
+      source: 'provider_default',
+      model: {},
+    })
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+  })
+
+  it('uses the tenant runtime override when resolving the picker default', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({ id: 'catalog.assistant', moduleId: 'catalog' }),
+    ])
+    getDefaultMock.mockResolvedValueOnce({
+      providerId: 'lm-studio',
+      modelId: 'qwen/qwen3.5-9b',
+      baseUrl: null,
+    })
+    resolveModelMock.mockImplementation((input) => ({
+      providerId: input.tenantOverride?.providerId ?? 'openai',
+      modelId: input.tenantOverride?.modelId ?? 'gpt-4o',
+      source: input.tenantOverride ? 'tenant_override' : 'provider_default',
+      model: {},
+    }))
+
+    const response = await GET(
+      new Request('http://localhost/api/ai_assistant/ai/agents/catalog.assistant/models') as any,
+      buildParams('catalog.assistant'),
+    )
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.defaultProviderId).toBe('lm-studio')
+    expect(json.defaultModelId).toBe('qwen/qwen3.5-9b')
+    expect(resolveModelMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        tenantOverride: {
+          providerId: 'lm-studio',
+          modelId: 'qwen/qwen3.5-9b',
+          baseURL: null,
+        },
+      }),
+    )
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    authMock.mockResolvedValueOnce(null)
+    const response = await GET(
+      new Request('http://localhost/api/ai_assistant/ai/agents/catalog.assistant/models') as any,
+      buildParams('catalog.assistant'),
+    )
+    expect(response.status).toBe(401)
+    const json = await response.json()
+    expect(json.error).toBe('Unauthorized')
+  })
+
+  it('returns 404 when the agent id is unknown', async () => {
+    seedAgentRegistryForTests([])
+    const response = await GET(
+      new Request('http://localhost/api/ai_assistant/ai/agents/unknown.assistant/models') as any,
+      buildParams('unknown.assistant'),
+    )
+    expect(response.status).toBe(404)
+    const json = await response.json()
+    expect(json.code).toBe('agent_unknown')
+  })
+
+  it('returns 403 when the caller lacks the agent\'s required features', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.assistant',
+        moduleId: 'catalog',
+        requiredFeatures: ['catalog.assistant.use'],
+      }),
+    ])
+    loadAclMock.mockResolvedValueOnce({ features: ['ai_assistant.view'], isSuperAdmin: false })
+    const response = await GET(
+      new Request('http://localhost/api/ai_assistant/ai/agents/catalog.assistant/models') as any,
+      buildParams('catalog.assistant'),
+    )
+    expect(response.status).toBe(403)
+    const json = await response.json()
+    expect(json.code).toBe('agent_features_denied')
+  })
+
+  it('returns an empty providers array when allowRuntimeModelOverride is false', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.assistant',
+        moduleId: 'catalog',
+        allowRuntimeModelOverride: false,
+      }),
+    ])
+    const response = await GET(
+      new Request('http://localhost/api/ai_assistant/ai/agents/catalog.assistant/models') as any,
+      buildParams('catalog.assistant'),
+    )
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.allowRuntimeModelOverride).toBe(false)
+    expect(json.providers).toEqual([])
+  })
+
+  it('clips providers and models against the tenant allowlist intersection', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({ id: 'catalog.assistant', moduleId: 'catalog' }),
+    ])
+    getSnapshotMock.mockResolvedValueOnce({
+      allowedProviders: ['openai'],
+      allowedModelsByProvider: { openai: [] },
+    })
+    const response = await GET(
+      new Request('http://localhost/api/ai_assistant/ai/agents/catalog.assistant/models') as any,
+      buildParams('catalog.assistant'),
+    )
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.providers.map((p: { id: string }) => p.id)).toEqual(['openai'])
+    const openaiEntry = json.providers.find((p: { id: string }) => p.id === 'openai')
+    expect(openaiEntry?.models ?? []).toEqual([])
+  })
+})

package/src/modules/ai_assistant/api/ai/agents/[agentId]/models/route.ts

@@ -0,0 +1,251 @@
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
+import { getAgent, loadAgentRegistry } from '../../../../../lib/agent-registry'
+import { hasRequiredFeatures } from '../../../../../lib/auth'
+import { createModelFactory } from '../../../../../lib/model-factory'
+import {
+  hasAllowlistSnapshotRestrictions,
+  intersectEffectiveAllowlistWithSnapshot,
+  intersectAllowlists,
+  isModelAllowedForProviderInEffective,
+  isProviderAllowedInEffective,
+  readAgentRuntimeOverrideAllowlist,
+  type TenantAllowlistSnapshot,
+} from '../../../../../lib/model-allowlist'
+import { AiTenantModelAllowlistRepository } from '../../../../../data/repositories/AiTenantModelAllowlistRepository'
+import { AiAgentRuntimeOverrideRepository } from '../../../../../data/repositories/AiAgentRuntimeOverrideRepository'
+
+function modelsForPicker(
+  provider: ReturnType<typeof llmProviderRegistry.list>[number],
+  allowedModelIds: string[] | undefined,
+): ReadonlyArray<{ id: string; name: string; contextWindow?: number | null; tags?: readonly string[] }> {
+  if (provider.defaultModels.length > 0) return provider.defaultModels
+  return (allowedModelIds ?? []).map((id) => ({ id, name: id }))
+}
+
+const agentIdPattern = /^[a-z0-9_]+\.[a-z0-9_]+$/
+
+const agentIdParamSchema = z.object({
+  agentId: z
+    .string()
+    .regex(agentIdPattern, 'agentId must match "<module>.<agent>" (lowercase, digits, underscores only)'),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'AI Assistant',
+  summary: 'Available models for an AI agent',
+  methods: {
+    GET: {
+      operationId: 'aiAssistantGetAgentModels',
+      summary: 'Get the providers and curated models available for the chat-UI picker for this agent',
+      description:
+        'Returns all configured providers with their curated model catalogs, filtered to providers ' +
+        'that have an API key configured in the current environment. When the agent declares ' +
+        '`allowRuntimeModelOverride: false`, the response reflects that constraint so the ' +
+        'UI picker can hide itself. Includes the agent\'s resolved default provider/model so ' +
+        'the picker can render a "(default)" badge next to the right entry. ' +
+        'RBAC: requires the same features as the agent itself (typically `ai_assistant.view`).',
+      responses: [
+        {
+          status: 200,
+          description:
+            'Providers and curated models available for the agent picker. ' +
+            'Empty `providers` array when `allowRuntimeModelOverride` is false.',
+        },
+      ],
+      errors: [
+        { status: 401, description: 'Unauthenticated.' },
+        { status: 403, description: 'Caller lacks the agent\'s required features.' },
+        { status: 404, description: 'Unknown agent id.' },
+      ],
+    },
+  },
+}
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['ai_assistant.view'] },
+}
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ agentId: string }> },
+): Promise<Response> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const rawParams = await params
+  const paramResult = agentIdParamSchema.safeParse(rawParams)
+  if (!paramResult.success) {
+    return NextResponse.json(
+      { error: 'Invalid agentId path parameter.', code: 'validation_error', issues: paramResult.error.issues },
+      { status: 400 },
+    )
+  }
+  const agentId = paramResult.data.agentId
+
+  try {
+    await loadAgentRegistry()
+
+    const container = await createRequestContainer()
+    const rbacService = container.resolve<RbacService>('rbacService')
+    const acl = await rbacService.loadAcl(auth.sub, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+    })
+
+    const agent = getAgent(agentId)
+    if (!agent) {
+      return NextResponse.json({ error: `Agent "${agentId}" not found.`, code: 'agent_unknown' }, { status: 404 })
+    }
+
+    const agentFeatures = agent.requiredFeatures ?? []
+    if (agentFeatures.length > 0) {
+      const permitted = hasRequiredFeatures(agentFeatures, acl.features, acl.isSuperAdmin)
+      if (!permitted) {
+        return NextResponse.json(
+          {
+            error: `Access to agent "${agentId}" requires features: ${agentFeatures.join(', ')}.`,
+            code: 'agent_features_denied',
+          },
+          { status: 403 },
+        )
+      }
+    }
+
+    const allowRuntimeModelOverride = agent.allowRuntimeModelOverride !== false
+
+    // Load the per-tenant allowlist snapshot so the picker reflects both env
+    // and admin-edited tenant constraints (Phase 1780-6).
+    let tenantAllowlistSnapshot: TenantAllowlistSnapshot | null = null
+    let agentRuntimeOverrideAllowlist: TenantAllowlistSnapshot | null = null
+    let tenantRuntimeOverride: {
+      providerId: string | null
+      modelId: string | null
+      baseURL: string | null
+    } | null = null
+    if (auth.tenantId) {
+      try {
+        const em = container.resolve<EntityManager>('em')
+        const allowlistRepo = new AiTenantModelAllowlistRepository(em)
+        tenantAllowlistSnapshot = await allowlistRepo.getSnapshot({
+          tenantId: auth.tenantId,
+          organizationId: auth.orgId ?? null,
+        })
+        const runtimeOverrideRepo = new AiAgentRuntimeOverrideRepository(em)
+        const runtimeOverrideDefaultRow = await runtimeOverrideRepo.getDefault({
+          tenantId: auth.tenantId,
+          organizationId: auth.orgId ?? null,
+          agentId,
+        })
+        tenantRuntimeOverride = runtimeOverrideDefaultRow
+          ? {
+              providerId: runtimeOverrideDefaultRow.providerId ?? null,
+              modelId: runtimeOverrideDefaultRow.modelId ?? null,
+              baseURL: runtimeOverrideDefaultRow.baseUrl ?? null,
+            }
+          : null
+        const runtimeOverrideRow = await runtimeOverrideRepo.getExact({
+          tenantId: auth.tenantId,
+          organizationId: auth.orgId ?? null,
+          agentId,
+        })
+        const tenantAgentAllowlist = runtimeOverrideRow
+          ? {
+              allowedProviders: runtimeOverrideRow.allowedOverrideProviders ?? null,
+              allowedModelsByProvider: runtimeOverrideRow.allowedOverrideModelsByProvider ?? {},
+            }
+          : null
+        agentRuntimeOverrideAllowlist = hasAllowlistSnapshotRestrictions(tenantAgentAllowlist)
+          ? tenantAgentAllowlist
+          : null
+      } catch (snapshotError) {
+        // Picker still renders against env-only so the UI does not break, but log at
+        // error level so an outage is operationally visible. The chat dispatcher
+        // refuses to dispatch when this lookup fails, so writes stay safe.
+        console.error('[AI Agents Models] Failed to load tenant allowlist:', snapshotError)
+      }
+    }
+
+    // Resolve the agent's current default provider/model for the "(default)" badge
+    const factory = createModelFactory(container)
+    const defaultResolution = factory.resolveModel({
+      moduleId: agent.moduleId,
+      agentDefaultModel: agent.defaultModel,
+      agentDefaultProvider: agent.defaultProvider,
+      agentDefaultBaseUrl: agent.defaultBaseUrl,
+      allowRuntimeModelOverride,
+      tenantOverride: tenantRuntimeOverride ?? undefined,
+      tenantAllowlist: tenantAllowlistSnapshot,
+    })
+    const defaultProviderId = defaultResolution.providerId
+    const defaultModelId = defaultResolution.modelId
+
+    // Build provider list — only configured providers, with curated model
+    // catalogs, clipped to the EFFECTIVE allowlist (env ∩ tenant) so the
+    // chat-UI picker can never offer a value the runtime would refuse.
+    const env = process.env as Record<string, string | undefined>
+    const knownProviderIds = llmProviderRegistry.list().map((p) => p.id)
+    const baseEffectiveAllowlist = intersectAllowlists(
+      env,
+      knownProviderIds,
+      tenantAllowlistSnapshot,
+    )
+    const envAgentAllowlist = readAgentRuntimeOverrideAllowlist(env, agentId, knownProviderIds)
+    const effectiveAllowlist = intersectEffectiveAllowlistWithSnapshot(
+      intersectEffectiveAllowlistWithSnapshot(
+        baseEffectiveAllowlist,
+        knownProviderIds,
+        envAgentAllowlist,
+      ),
+      knownProviderIds,
+      agentRuntimeOverrideAllowlist,
+    )
+    const providers = allowRuntimeModelOverride
+      ? llmProviderRegistry.list()
+          .filter((provider) => provider.isConfigured())
+          .filter((provider) => isProviderAllowedInEffective(effectiveAllowlist, provider.id))
+          .map((provider) => {
+            const allowedModelIds = effectiveAllowlist.modelsByProvider[provider.id]
+            const filteredModels = modelsForPicker(provider, allowedModelIds).filter((model) =>
+              isModelAllowedForProviderInEffective(effectiveAllowlist, provider.id, model.id),
+            )
+            return {
+              id: provider.id,
+              name: provider.name,
+              isDefault: provider.id === defaultProviderId,
+              models: filteredModels.map((model) => ({
+                id: model.id,
+                name: model.name,
+                contextWindow: model.contextWindow,
+                tags: model.tags,
+                isDefault: provider.id === defaultProviderId && model.id === defaultModelId,
+              })),
+            }
+          })
+      : []
+
+    return NextResponse.json({
+      agentId,
+      allowRuntimeModelOverride,
+      defaultProviderId,
+      defaultModelId,
+      defaultProviderName: llmProviderRegistry.get(defaultProviderId)?.name ?? defaultProviderId,
+      defaultModelName:
+        llmProviderRegistry
+          .get(defaultProviderId)
+          ?.defaultModels.find((model) => model.id === defaultModelId)?.name ?? defaultModelId,
+      providers,
+    })
+  } catch (error) {
+    console.error('[AI Agents Models] GET error:', error)
+    return NextResponse.json({ error: 'Failed to resolve agent models.' }, { status: 500 })
+  }
+}

package/src/modules/ai_assistant/api/ai/agents/route.ts

@@ -83,6 +83,10 @@ export async function GET(req: NextRequest) {
         description: agent.description,
         systemPrompt: agent.systemPrompt,
         executionMode: agent.executionMode ?? 'chat',
+        defaultProvider: agent.defaultProvider ?? null,
+        defaultModel: agent.defaultModel ?? null,
+        defaultBaseUrl: agent.defaultBaseUrl ?? null,
+        allowRuntimeModelOverride: agent.allowRuntimeModelOverride !== false,
         mutationPolicy: agent.mutationPolicy ?? 'read-only',
         readOnly: Boolean(agent.readOnly),
         maxSteps: agent.maxSteps ?? null,