@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/chat/__tests__/route.test.ts

@@ -24,6 +24,39 @@ jest.mock('../../../../lib/agent-runtime', () => ({
   runAiAgentText: (...args: unknown[]) => runAiAgentTextMock(...args),
 }))
 
+const getMock = jest.fn()
+const listMock = jest.fn()
+
+jest.mock('@open-mercato/shared/lib/ai/llm-provider-registry', () => ({
+  llmProviderRegistry: {
+    get: (...args: unknown[]) => getMock(...args),
+    list: (...args: unknown[]) => listMock(...args),
+  },
+}))
+
+const readBaseurlAllowlistMock = jest.fn()
+const isBaseurlAllowlistedMock = jest.fn()
+
+jest.mock('../../../../lib/baseurl-allowlist', () => ({
+  readBaseurlAllowlist: (...args: unknown[]) => readBaseurlAllowlistMock(...args),
+  isBaseurlAllowlisted: (...args: unknown[]) => isBaseurlAllowlistedMock(...args),
+}))
+
+const tenantAllowlistGetSnapshotMock = jest.fn()
+const agentRuntimeOverrideGetExactMock = jest.fn()
+
+jest.mock('../../../../data/repositories/AiTenantModelAllowlistRepository', () => ({
+  AiTenantModelAllowlistRepository: jest.fn().mockImplementation(() => ({
+    getSnapshot: (...args: unknown[]) => tenantAllowlistGetSnapshotMock(...args),
+  })),
+}))
+
+jest.mock('../../../../data/repositories/AiAgentRuntimeOverrideRepository', () => ({
+  AiAgentRuntimeOverrideRepository: jest.fn().mockImplementation(() => ({
+    getExact: (...args: unknown[]) => agentRuntimeOverrideGetExactMock(...args),
+  })),
+}))
+
 import { POST } from '../route'
 
 function makeAgent(
@@ -85,15 +118,23 @@ describe('POST /api/ai/chat', () => {
     createRequestContainerMock.mockResolvedValue({
       resolve: (name: string) => {
         if (name === 'rbacService') return { loadAcl: loadAclMock }
+        if (name === 'em') return {}
         return null
       },
     })
+    tenantAllowlistGetSnapshotMock.mockResolvedValue(null)
+    agentRuntimeOverrideGetExactMock.mockResolvedValue(null)
     runAiAgentTextMock.mockResolvedValue(
       new Response('data: {"type":"text","content":"ok"}\n\ndata: [DONE]\n\n', {
         status: 200,
         headers: { 'Content-Type': 'text/event-stream' },
       }),
     )
+    // Phase 4a defaults: provider registry returns a configured provider by default
+    getMock.mockReturnValue({ id: 'openai', isConfigured: () => true })
+    listMock.mockReturnValue([{ id: 'openai', isConfigured: () => true }])
+    readBaseurlAllowlistMock.mockReturnValue(['openrouter.ai'])
+    isBaseurlAllowlistedMock.mockReturnValue(true)
   })
 
   afterEach(() => {
@@ -279,4 +320,236 @@ describe('POST /api/ai/chat', () => {
     const json = await response.json()
     expect(json.code).toBe('tool_not_whitelisted')
   })
+
+  describe('Phase 4a — query-param override validation', () => {
+    function buildRequestWithOverrides(overrides: {
+      provider?: string
+      model?: string
+      baseUrl?: string
+    }): Request {
+      const url = new URL('http://localhost/api/ai/chat')
+      url.searchParams.set('agent', 'customers.assistant')
+      if (overrides.provider) url.searchParams.set('provider', overrides.provider)
+      if (overrides.model) url.searchParams.set('model', overrides.model)
+      if (overrides.baseUrl) url.searchParams.set('baseUrl', overrides.baseUrl)
+      return new Request(url, {
+        method: 'POST',
+        body: JSON.stringify({ messages: [{ role: 'user', content: 'hi' }] }),
+        headers: { 'content-type': 'application/json' },
+      })
+    }
+
+    it('returns 400 with code runtime_override_disabled when agent has allowRuntimeModelOverride: false', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers', allowRuntimeModelOverride: false }),
+      ])
+
+      const response = await POST(buildRequestWithOverrides({ provider: 'openai' }) as any)
+
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('runtime_override_disabled')
+    })
+
+    it('returns 400 with code provider_unknown when provider is not registered', async () => {
+      getMock.mockReturnValue(null)
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(buildRequestWithOverrides({ provider: 'unknown-provider' }) as any)
+
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('provider_unknown')
+    })
+
+    it('returns 400 with code provider_not_configured when provider is registered but not configured', async () => {
+      getMock.mockReturnValue({ id: 'openai', isConfigured: () => false })
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(buildRequestWithOverrides({ provider: 'openai' }) as any)
+
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('provider_not_configured')
+    })
+
+    it('returns 400 with code baseurl_not_allowlisted when baseUrl is not in the allowlist', async () => {
+      isBaseurlAllowlistedMock.mockReturnValue(false)
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(buildRequestWithOverrides({ 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')
+    })
+
+    it('accepts valid provider and model overrides and forwards requestOverride to runAiAgentText', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      await POST(buildRequestWithOverrides({ provider: 'openai', model: 'gpt-5-mini' }) as any)
+
+      expect(runAiAgentTextMock).toHaveBeenCalledTimes(1)
+      const callArg = runAiAgentTextMock.mock.calls[0][0] as {
+        requestOverride?: { providerId?: string | null; modelId?: string | null; baseURL?: string | null }
+      }
+      expect(callArg.requestOverride).toEqual({
+        providerId: 'openai',
+        modelId: 'gpt-5-mini',
+        baseURL: null,
+      })
+    })
+
+    it('does NOT set requestOverride when no override query params are present', async () => {
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      await POST(
+        buildRequest({ agent: 'customers.assistant', body: { messages: [{ role: 'user', content: 'hi' }] } }) as any,
+      )
+
+      const callArg = runAiAgentTextMock.mock.calls[0][0] as { requestOverride?: unknown }
+      expect(callArg.requestOverride).toBeUndefined()
+    })
+
+    it('accepts valid baseUrl that passes the allowlist check', async () => {
+      isBaseurlAllowlistedMock.mockReturnValue(true)
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(
+        buildRequestWithOverrides({ baseUrl: 'https://openrouter.ai/api/v1' }) as any,
+      )
+
+      expect(response.status).toBe(200)
+      const callArg = runAiAgentTextMock.mock.calls[0][0] as {
+        requestOverride?: { providerId?: string | null; modelId?: string | null; baseURL?: string | null }
+      }
+      expect(callArg.requestOverride?.baseURL).toBe('https://openrouter.ai/api/v1')
+    })
+  })
+
+  describe('Phase 1780-5 / 1780-6 — env + tenant allowlist rejections', () => {
+    function buildRequestWithOverrides(overrides: {
+      provider?: string
+      model?: string
+    }): Request {
+      const url = new URL('http://localhost/api/ai/chat')
+      url.searchParams.set('agent', 'customers.assistant')
+      if (overrides.provider) url.searchParams.set('provider', overrides.provider)
+      if (overrides.model) url.searchParams.set('model', overrides.model)
+      return new Request(url, {
+        method: 'POST',
+        body: JSON.stringify({ messages: [{ role: 'user', content: 'hi' }] }),
+        headers: { 'content-type': 'application/json' },
+      })
+    }
+
+    const savedEnv: Record<string, string | undefined> = {}
+    const ENV_KEYS = [
+      'OM_AI_AVAILABLE_PROVIDERS',
+      'OM_AI_AVAILABLE_MODELS_OPENAI',
+      'OM_AI_AVAILABLE_MODELS_ANTHROPIC',
+    ]
+
+    beforeEach(() => {
+      for (const key of ENV_KEYS) {
+        savedEnv[key] = process.env[key]
+        delete process.env[key]
+      }
+      getMock.mockImplementation((id: string) => {
+        if (id === 'openai') return { id: 'openai', isConfigured: () => true }
+        if (id === 'anthropic') return { id: 'anthropic', isConfigured: () => true }
+        return null
+      })
+      listMock.mockReturnValue([
+        { id: 'openai', isConfigured: () => true },
+        { id: 'anthropic', isConfigured: () => true },
+      ])
+    })
+
+    afterEach(() => {
+      for (const key of ENV_KEYS) {
+        if (savedEnv[key] === undefined) {
+          delete process.env[key]
+        } else {
+          process.env[key] = savedEnv[key]
+        }
+      }
+    })
+
+    it('returns 400 provider_not_allowlisted when OM_AI_AVAILABLE_PROVIDERS excludes the requested provider', async () => {
+      process.env.OM_AI_AVAILABLE_PROVIDERS = 'anthropic'
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(buildRequestWithOverrides({ provider: 'openai' }) as any)
+
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('provider_not_allowlisted')
+      expect(json.error).toContain('OM_AI_AVAILABLE_PROVIDERS')
+    })
+
+    it('returns 400 model_not_allowlisted when OM_AI_AVAILABLE_MODELS_OPENAI excludes the requested model', async () => {
+      process.env.OM_AI_AVAILABLE_MODELS_OPENAI = 'gpt-4o'
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(
+        buildRequestWithOverrides({ provider: 'openai', model: 'gpt-5-mini' }) as any,
+      )
+
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('model_not_allowlisted')
+      expect(json.error).toContain('OM_AI_AVAILABLE_MODELS_OPENAI')
+    })
+
+    it('returns 503 tenant_allowlist_unavailable when the tenant allowlist lookup throws (fail closed)', async () => {
+      tenantAllowlistGetSnapshotMock.mockRejectedValueOnce(new Error('db connection refused'))
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(buildRequestWithOverrides({ provider: 'openai' }) as any)
+
+      expect(response.status).toBe(503)
+      const json = await response.json()
+      expect(json.code).toBe('tenant_allowlist_unavailable')
+    })
+
+    it('returns 400 model_not_allowlisted with "env ∩ tenant" wording when the tenant snapshot narrows the env allowlist', async () => {
+      process.env.OM_AI_AVAILABLE_PROVIDERS = 'openai'
+      process.env.OM_AI_AVAILABLE_MODELS_OPENAI = 'gpt-4o,gpt-5-mini'
+      tenantAllowlistGetSnapshotMock.mockResolvedValue({
+        allowedProviders: ['openai'],
+        allowedModelsByProvider: { openai: ['gpt-4o'] },
+      })
+      seedAgentRegistryForTests([
+        makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      ])
+
+      const response = await POST(
+        buildRequestWithOverrides({ provider: 'openai', model: 'gpt-5-mini' }) as any,
+      )
+
+      expect(response.status).toBe(400)
+      const json = await response.json()
+      expect(json.code).toBe('model_not_allowlisted')
+      expect(json.error).toContain('env ∩ tenant')
+    })
+  })
 })

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

@@ -5,10 +5,26 @@ 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 { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
+import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
 import { loadAgentRegistry } from '../../../lib/agent-registry'
 import { checkAgentPolicy, type AgentPolicyDenyCode } from '../../../lib/agent-policy'
 import { runAiAgentText } from '../../../lib/agent-runtime'
 import { AgentPolicyError } from '../../../lib/agent-tools'
+import { readBaseurlAllowlist, isBaseurlAllowlisted } from '../../../lib/baseurl-allowlist'
+import {
+  canonicalProviderId,
+  hasAllowlistSnapshotRestrictions,
+  intersectEffectiveAllowlistWithSnapshot,
+  intersectAllowlists,
+  isModelAllowedForProviderInEffective,
+  isProviderAllowedInEffective,
+  modelAllowlistEnvVarName,
+  readAgentRuntimeOverrideAllowlist,
+  type TenantAllowlistSnapshot,
+} from '../../../lib/model-allowlist'
+import { AiTenantModelAllowlistRepository } from '../../../data/repositories/AiTenantModelAllowlistRepository'
+import { AiAgentRuntimeOverrideRepository } from '../../../data/repositories/AiAgentRuntimeOverrideRepository'
+import type { EntityManager } from '@mikro-orm/postgresql'
 
 const MAX_MESSAGES = 100
 
@@ -50,6 +66,29 @@ const agentQuerySchema = z.object({
   agent: z
     .string()
     .regex(agentIdPattern, 'agent must match "<module>.<agent>" (lowercase, digits, underscores only)'),
+  /**
+   * Per-request provider override. Must match a registered + configured
+   * provider id. Validated against `llmProviderRegistry` at dispatch time.
+   * Rejected when the agent has `allowRuntimeModelOverride: false`.
+   *
+   * Phase 4a of spec `2026-04-27-ai-agents-provider-model-baseurl-overrides`.
+   */
+  provider: z.string().optional(),
+  /**
+   * Per-request model id override. Free-form string. Logged (not rejected)
+   * when not in the provider's curated `defaultModels` catalog.
+   *
+   * Phase 4a of spec `2026-04-27-ai-agents-provider-model-baseurl-overrides`.
+   */
+  model: z.string().optional(),
+  /**
+   * Per-request base URL override. Must parse as a URL and match
+   * `AI_RUNTIME_BASEURL_ALLOWLIST` (comma-separated host patterns). When the
+   * env var is unset or empty, any non-empty value is rejected.
+   *
+   * Phase 4a of spec `2026-04-27-ai-agents-provider-model-baseurl-overrides`.
+   */
+  baseUrl: z.string().optional(),
 })
 
 export const openApi: OpenApiRouteDoc = {
@@ -63,7 +102,12 @@ export const openApi: OpenApiRouteDoc = {
         'Dispatches a chat turn to the focused AI agent identified by `?agent=<module>.<agent>`. ' +
         'Enforces agent-level `requiredFeatures`, tool whitelisting, read-only / mutationPolicy, ' +
         'execution-mode compatibility, and attachment media-type policy. The streaming response ' +
-        'body uses an AI SDK-compatible `text/event-stream` transport.',
+        'body uses an AI SDK-compatible `text/event-stream` transport. ' +
+        'Optional `?provider=`, `?model=`, and `?baseUrl=` query params let callers ' +
+        'override the resolved provider/model/base-URL for this turn (Phase 4a). ' +
+        'Provider must be registered and configured; baseUrl must match ' +
+        '`AI_RUNTIME_BASEURL_ALLOWLIST` when set. Both are suppressed when the ' +
+        'agent declares `allowRuntimeModelOverride: false`.',
       query: agentQuerySchema,
       requestBody: {
         contentType: 'application/json',
@@ -74,7 +118,15 @@ export const openApi: OpenApiRouteDoc = {
         { status: 200, description: 'Streaming text/event-stream response compatible with AI SDK chat transports.', mediaType: 'text/event-stream' },
       ],
       errors: [
-        { status: 400, description: 'Invalid query param, malformed payload, or message count above the cap.' },
+        {
+          status: 400,
+          description:
+            'Invalid query param, malformed payload, or message count above the cap. ' +
+            'Typed codes: `runtime_override_disabled` (agent has allowRuntimeModelOverride:false), ' +
+            '`provider_unknown` (provider id not registered), ' +
+            '`provider_not_configured` (provider registered but no API key in env), ' +
+            '`baseurl_not_allowlisted` (baseUrl not in AI_RUNTIME_BASEURL_ALLOWLIST).',
+        },
         { status: 401, description: 'Unauthenticated caller.' },
         { status: 403, description: 'Caller lacks agent-level or tool-level required features.' },
         { status: 404, description: 'Unknown agent id.' },
@@ -127,6 +179,9 @@ export async function POST(req: NextRequest): Promise<Response> {
   const requestUrl = new URL(req.url)
   const queryResult = agentQuerySchema.safeParse({
     agent: requestUrl.searchParams.get('agent') ?? undefined,
+    provider: requestUrl.searchParams.get('provider') ?? undefined,
+    model: requestUrl.searchParams.get('model') ?? undefined,
+    baseUrl: requestUrl.searchParams.get('baseUrl') ?? undefined,
   })
   if (!queryResult.success) {
     return jsonError(400, 'Invalid or missing "agent" query parameter.', 'validation_error', {
@@ -134,6 +189,9 @@ export async function POST(req: NextRequest): Promise<Response> {
     })
   }
   const agentId = queryResult.data.agent
+  const rawProvider = queryResult.data.provider
+  const rawModel = queryResult.data.model
+  const rawBaseUrl = queryResult.data.baseUrl
 
   let parsedBody: unknown
   try {
@@ -177,6 +235,156 @@ export async function POST(req: NextRequest): Promise<Response> {
       return jsonError(statusForDenyCode(decision.code), decision.message, decision.code)
     }
 
+    const agentDef = decision.agent
+
+    // --- Phase 4a: validate runtime override query params ---
+    const hasRuntimeOverride =
+      (rawProvider && rawProvider.trim().length > 0) ||
+      (rawModel && rawModel.trim().length > 0) ||
+      (rawBaseUrl && rawBaseUrl.trim().length > 0)
+
+    if (hasRuntimeOverride) {
+      if (agentDef.allowRuntimeModelOverride === false) {
+        return jsonError(
+          400,
+          `Agent "${agentId}" has runtime model override disabled (allowRuntimeModelOverride: false).`,
+          'runtime_override_disabled',
+        )
+      }
+    }
+
+    let tenantAllowlistSnapshot: TenantAllowlistSnapshot | null = null
+    let agentRuntimeOverrideAllowlist: TenantAllowlistSnapshot | 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 agentRuntimeOverrideRow = await runtimeOverrideRepo.getExact({
+          tenantId: auth.tenantId,
+          organizationId: auth.orgId ?? null,
+          agentId,
+        })
+        const tenantAgentAllowlist = agentRuntimeOverrideRow
+          ? {
+              allowedProviders: agentRuntimeOverrideRow.allowedOverrideProviders ?? null,
+              allowedModelsByProvider: agentRuntimeOverrideRow.allowedOverrideModelsByProvider ?? {},
+            }
+          : null
+        agentRuntimeOverrideAllowlist = hasAllowlistSnapshotRestrictions(tenantAgentAllowlist)
+          ? tenantAgentAllowlist
+          : null
+      } catch (snapshotError) {
+        // Fail closed: refuse to dispatch if we cannot confirm the tenant allowlist.
+        // Silently falling back to env-only would widen the effective allowlist when
+        // the DB is unavailable, which is the opposite of what an admin intends.
+        console.error(
+          '[AI Chat Agent] Tenant allowlist lookup failed; refusing to dispatch:',
+          snapshotError,
+        )
+        return jsonError(
+          503,
+          'Tenant allowlist is temporarily unavailable. Try again shortly.',
+          'tenant_allowlist_unavailable',
+        )
+      }
+    }
+    const knownProviderIds = llmProviderRegistry.list().map((p) => p.id)
+    const baseEffectiveAllowlist = intersectAllowlists(
+      process.env as Record<string, string | undefined>,
+      knownProviderIds,
+      tenantAllowlistSnapshot,
+    )
+    const envAgentAllowlist = readAgentRuntimeOverrideAllowlist(
+      process.env as Record<string, string | undefined>,
+      agentId,
+      knownProviderIds,
+    )
+    const effectiveAllowlist = intersectEffectiveAllowlistWithSnapshot(
+      intersectEffectiveAllowlistWithSnapshot(
+        baseEffectiveAllowlist,
+        knownProviderIds,
+        envAgentAllowlist,
+      ),
+      knownProviderIds,
+      agentRuntimeOverrideAllowlist,
+    )
+
+    const normalizedProvider = rawProvider && rawProvider.trim().length > 0
+      ? canonicalProviderId(rawProvider.trim(), llmProviderRegistry.list().map((p) => p.id))
+      : null
+
+    if (rawProvider && rawProvider.trim().length > 0) {
+      const providerEntry = normalizedProvider ? llmProviderRegistry.get(normalizedProvider) : null
+      if (!providerEntry) {
+        return jsonError(
+          400,
+          `Provider "${rawProvider}" is not registered. Registered provider ids: ${llmProviderRegistry.list().map((p) => p.id).join(', ')}.`,
+          'provider_unknown',
+        )
+      }
+      if (!providerEntry.isConfigured()) {
+        return jsonError(
+          400,
+          `Provider "${rawProvider}" is registered but not configured in this environment (missing API key).`,
+          'provider_not_configured',
+        )
+      }
+      if (!isProviderAllowedInEffective(effectiveAllowlist, normalizedProvider!)) {
+        const source = effectiveAllowlist.tenantOverridesActive
+          ? 'the effective allowlist (env ∩ tenant)'
+          : 'OM_AI_AVAILABLE_PROVIDERS'
+        return jsonError(
+          400,
+          `Provider "${rawProvider}" is not in ${source}.`,
+          'provider_not_allowlisted',
+        )
+      }
+      if (
+        rawModel
+        && rawModel.trim().length > 0
+        && !isModelAllowedForProviderInEffective(
+          effectiveAllowlist,
+          normalizedProvider!,
+          rawModel.trim(),
+        )
+      ) {
+        const source = effectiveAllowlist.tenantOverridesActive
+          ? `the effective allowlist (env ∩ tenant) for "${normalizedProvider}"`
+          : modelAllowlistEnvVarName(normalizedProvider!)
+        return jsonError(
+          400,
+          `Model "${rawModel}" is not in ${source}.`,
+          'model_not_allowlisted',
+        )
+      }
+    }
+
+    if (rawBaseUrl && rawBaseUrl.trim().length > 0) {
+      const allowlist = readBaseurlAllowlist()
+      if (!isBaseurlAllowlisted(rawBaseUrl.trim(), allowlist)) {
+        return jsonError(
+          400,
+          `baseUrl "${rawBaseUrl}" is not in the AI_RUNTIME_BASEURL_ALLOWLIST. Set that env var to a comma-separated list of allowed host patterns to enable per-request baseUrl overrides.`,
+          'baseurl_not_allowlisted',
+        )
+      }
+    }
+    // --- end Phase 4a validation ---
+
+    const requestOverride =
+      hasRuntimeOverride
+        ? {
+            providerId: normalizedProvider,
+            modelId: rawModel && rawModel.trim().length > 0 ? rawModel.trim() : null,
+            baseURL: rawBaseUrl && rawBaseUrl.trim().length > 0 ? rawBaseUrl.trim() : null,
+          }
+        : undefined
+
     return await runAiAgentText({
       agentId,
       messages: bodyResult.data.messages as unknown as UIMessage[],
@@ -192,6 +400,7 @@ export async function POST(req: NextRequest): Promise<Response> {
         isSuperAdmin: acl.isSuperAdmin,
       },
       container,
+      requestOverride,
     })
   } catch (error) {
     if (error instanceof AgentPolicyError) {

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

@@ -5,15 +5,13 @@ import { z } from 'zod'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { llmProviderRegistry } from '@open-mercato/shared/lib/ai/llm-provider-registry'
-import {
-  resolveAiProviderIdFromEnv,
-  resolveOpenCodeModel,
-} from '@open-mercato/shared/lib/ai/opencode-provider'
+import { resolveOpenCodeModel } from '@open-mercato/shared/lib/ai/opencode-provider'
 import {
   resolveChatConfig,
   isProviderConfigured,
   type ChatProviderId,
 } from '../../lib/chat-config'
+import { createModelFactory, AiModelFactoryError } from '../../lib/model-factory'
 
 export const openApi: OpenApiRouteDoc = {
   tag: 'AI Assistant',
@@ -103,29 +101,55 @@ export async function POST(req: NextRequest) {
     const container = await createRequestContainer()
     let config = await resolveChatConfig(container)
 
-    // Fallback to first configured provider from the LLM provider registry.
-    // Honors the operator-selected provider via OM_AI_PROVIDER (with the
-    // legacy OPENCODE_PROVIDER as the BC fallback) and only then walks the
-    // native adapters before any OpenAI-compatible presets so a deployment
-    // that just sets OPENAI_API_KEY still resolves to OpenAI by default.
+    // When no DB-stored config is present, delegate provider + model resolution
+    // to createModelFactory so OM_AI_PROVIDER / OM_AI_MODEL (Phase 0 of spec
+    // 2026-04-27-ai-agents-provider-model-baseurl-overrides) and all registered
+    // OpenAI-compatible presets are respected without duplicating the
+    // resolution chain here. Legacy OPENCODE_PROVIDER / OPENCODE_MODEL envs are
+    // still honored as BC fallbacks inside the factory.
     if (!config) {
-      const operatorPreferred = resolveAiProviderIdFromEnv(process.env)
-      const baseOrder: ChatProviderId[] = ['openai', 'anthropic', 'google']
-      const order = [
-        operatorPreferred,
-        ...baseOrder.filter((id) => id !== operatorPreferred),
-      ]
-      const picked = llmProviderRegistry.resolveFirstConfigured({ order })
-      if (!picked) {
-        return NextResponse.json(
-          {
-            error:
-              'No AI provider configured. Please set an API key for one of the registered providers (Anthropic, OpenAI, Google, DeepInfra, Groq, …).',
-          },
-          { status: 503 },
-        )
+      let factoryResolution
+      try {
+        factoryResolution = createModelFactory(container).resolveModel({
+          callerOverride: undefined,
+        })
+      } catch (error) {
+        if (error instanceof AiModelFactoryError && error.code === 'no_provider_configured') {
+          return NextResponse.json(
+            {
+              error:
+                'No AI provider configured. Please set an API key for one of the registered providers (Anthropic, OpenAI, Google, DeepInfra, Groq, …).',
+            },
+            { status: 503 },
+          )
+        }
+        throw error
       }
-      config = { providerId: picked.id, model: '', updatedAt: '' }
+
+      console.log('[AI Route] Using provider:', factoryResolution.providerId)
+
+      const modelWithProvider = `${factoryResolution.providerId}/${factoryResolution.modelId}`
+      console.log('[AI Route] Calling generateObject with', modelWithProvider)
+
+      const result = await generateObject({
+        model: factoryResolution.model as Parameters<typeof generateObject>[0]['model'],
+        schema: RouteResultSchema,
+        prompt: `You are a routing assistant. Given a user query, determine if they want to use a specific tool or have a general conversation.
+
+Available tools:
+${availableTools.map((t) => `- ${t.name}: ${t.description}`).join('\n')}
+
+User query: "${query}"
+
+Respond with:
+- intent: "tool" if user wants to perform an action with a specific tool, "general_chat" otherwise
+- toolName: the exact tool name if intent is "tool"
+- confidence: 0-1 how confident you are
+- reasoning: brief explanation`,
+      })
+
+      console.log('[AI Route] Result:', result.object)
+      return NextResponse.json(result.object)
     }
 
     console.log('[AI Route] Using provider:', config.providerId)