@open-mercato/ai-assistant 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

package/src/modules/ai_assistant/api/moderation-flags/__tests__/route.test.ts

@@ -0,0 +1,122 @@
+const authMock = jest.fn()
+const loadAclMock = jest.fn()
+const createRequestContainerMock = jest.fn()
+const listMock = 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/AiModerationFlagRepository', () => ({
+  AiModerationFlagRepository: jest.fn().mockImplementation(() => ({ list: listMock })),
+}))
+
+import { GET } from '../route'
+
+function buildRequest(params: Record<string, string> = {}) {
+  const url = new URL('http://localhost/api/ai_assistant/moderation-flags')
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
+  return new Request(url.toString(), { method: 'GET' })
+}
+
+function makeRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'flag-1',
+    tenantId: 'tenant-1',
+    organizationId: null,
+    agentId: 'catalog.assistant',
+    userId: 'user-9',
+    providerId: 'openai',
+    modelId: 'gpt-5-mini',
+    categories: { hate: { flagged: true, score: 0.97 } },
+    createdAt: new Date('2026-06-10T12:00:00Z'),
+    ...overrides,
+  }
+}
+
+describe('GET /api/ai_assistant/moderation-flags', () => {
+  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,
+            hasAllFeatures: (req: string[], have: string[]) => req.every((r) => have.includes(r)),
+          }
+        }
+        if (name === 'em') return {}
+        throw new Error(`Unknown token: ${name}`)
+      },
+    })
+    listMock.mockResolvedValue({ items: [], total: 0 })
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    authMock.mockResolvedValue(null)
+    const res = await GET(buildRequest() as never)
+    expect(res.status).toBe(401)
+  })
+
+  it('returns 403 when the caller lacks ai_assistant.settings.manage', async () => {
+    loadAclMock.mockResolvedValue({ features: ['ai_assistant.view'], isSuperAdmin: false })
+    const res = await GET(buildRequest() as never)
+    expect(res.status).toBe(403)
+    expect((await res.json()).code).toBe('forbidden')
+  })
+
+  it('rejects pageSize above the 100 cap with a validation error', async () => {
+    const res = await GET(buildRequest({ pageSize: '101' }) as never)
+    expect(res.status).toBe(400)
+    expect((await res.json()).code).toBe('validation_error')
+    expect(listMock).not.toHaveBeenCalled()
+  })
+
+  it('lists tenant-scoped rows and echoes pagination', async () => {
+    listMock.mockResolvedValue({ items: [makeRow()], total: 1 })
+    const res = await GET(buildRequest({ page: '2', pageSize: '25' }) as never)
+    expect(res.status).toBe(200)
+    const json = await res.json()
+    expect(json.total).toBe(1)
+    expect(json.page).toBe(2)
+    expect(json.pageSize).toBe(25)
+    expect(json.items[0]).toMatchObject({ id: 'flag-1', userId: 'user-9', categories: { hate: { flagged: true, score: 0.97 } } })
+    // Tenant-scoped only — the listing does NOT narrow by organization_id.
+    expect(listMock).toHaveBeenCalledWith(
+      expect.objectContaining({ tenantId: 'tenant-1', page: 2, pageSize: 25 }),
+    )
+    expect(listMock.mock.calls[0][0].organizationId).toBeUndefined()
+  })
+
+  it('passes agentId/userId/date filters through to the repository', async () => {
+    await GET(buildRequest({ agentId: 'catalog.assistant', userId: 'user-9', from: '2026-06-01', to: '2026-06-10' }) as never)
+    const call = listMock.mock.calls[0][0]
+    expect(call.agentId).toBe('catalog.assistant')
+    expect(call.userId).toBe('user-9')
+    expect(call.from).toBeInstanceOf(Date)
+    expect(call.to).toBeInstanceOf(Date)
+    // `to` is extended to end-of-day so same-day rows are included.
+    expect((call.to as Date).toISOString()).toBe('2026-06-10T23:59:59.999Z')
+  })
+
+  it('returns an empty page (no repo call) when the caller has no tenant scope', async () => {
+    authMock.mockResolvedValue({ sub: 'user-1', tenantId: null, orgId: null })
+    const res = await GET(buildRequest() as never)
+    expect(res.status).toBe(200)
+    expect((await res.json()).items).toEqual([])
+    expect(listMock).not.toHaveBeenCalled()
+  })
+})

package/src/modules/ai_assistant/api/moderation-flags/route.ts

@@ -0,0 +1,137 @@
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import type { EntityManager } from '@mikro-orm/postgresql'
+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 { AiModerationFlagRepository } from '../../data/repositories/AiModerationFlagRepository'
+import { hasRequiredFeatures } from '../../lib/auth'
+
+const logger = createLogger('ai_assistant')
+
+const REQUIRED_FEATURE = 'ai_assistant.settings.manage'
+const MAX_PAGE_SIZE = 100
+
+const querySchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(MAX_PAGE_SIZE).default(50),
+  agentId: z.string().min(1).max(256).optional(),
+  userId: z.string().min(1).max(256).optional(),
+  from: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'from must be a date in YYYY-MM-DD format').optional(),
+  to: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'to must be a date in YYYY-MM-DD format').optional(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'AI Assistant',
+  summary: 'Input moderation flags audit log',
+  methods: {
+    GET: {
+      operationId: 'aiAssistantModerationFlags',
+      summary: 'List input-moderation audit flags for the current tenant.',
+      description:
+        'Returns the append-only `ai_moderation_flags` audit rows (category flags + scores only — never ' +
+        'prompt content) for the caller\'s tenant. Always tenant-scoped; cross-tenant access is impossible. ' +
+        'Optionally filtered by `agentId`, `userId`, and a `from`/`to` date window. Paginated (`pageSize` ≤ 100). ' +
+        'Requires `ai_assistant.settings.manage`.',
+      query: querySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Paginated moderation-flag rows: `{ items, total, page, pageSize }`.',
+          mediaType: 'application/json',
+        },
+      ],
+      errors: [
+        { status: 400, description: 'Invalid query parameters.' },
+        { status: 401, description: 'Unauthenticated caller.' },
+        { status: 403, description: 'Caller lacks `ai_assistant.settings.manage`.' },
+        { status: 500, description: 'Internal failure.' },
+      ],
+    },
+  },
+}
+
+export const metadata = {
+  path: '/ai_assistant/moderation-flags',
+  GET: { requireAuth: true, requireFeatures: [REQUIRED_FEATURE] },
+}
+
+function jsonError(status: number, message: string, code: string, extra?: Record<string, unknown>): NextResponse {
+  return NextResponse.json({ error: message, code, ...(extra ?? {}) }, { status })
+}
+
+export async function GET(req: NextRequest): Promise<Response> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth) {
+    return jsonError(401, 'Unauthorized', 'unauthenticated')
+  }
+
+  const { searchParams } = new URL(req.url)
+  const queryResult = querySchema.safeParse({
+    page: searchParams.get('page') ?? undefined,
+    pageSize: searchParams.get('pageSize') ?? undefined,
+    agentId: searchParams.get('agentId') ?? undefined,
+    userId: searchParams.get('userId') ?? undefined,
+    from: searchParams.get('from') ?? undefined,
+    to: searchParams.get('to') ?? undefined,
+  })
+  if (!queryResult.success) {
+    return jsonError(400, 'Invalid query parameters.', 'validation_error', {
+      issues: queryResult.error.issues,
+    })
+  }
+
+  const { page, pageSize, agentId, userId, from, to } = queryResult.data
+
+  try {
+    const container = await createRequestContainer()
+    const rbacService = container.resolve<RbacService>('rbacService')
+    const acl = await rbacService.loadAcl(auth.sub, {
+      tenantId: auth.tenantId,
+      organizationId: auth.orgId,
+    })
+
+    if (!hasRequiredFeatures([REQUIRED_FEATURE], acl.features, acl.isSuperAdmin, rbacService)) {
+      return jsonError(403, `Caller lacks required feature "${REQUIRED_FEATURE}".`, 'forbidden')
+    }
+
+    if (!auth.tenantId) {
+      return NextResponse.json({ items: [], total: 0, page, pageSize })
+    }
+
+    const em = container.resolve<EntityManager>('em')
+    const repo = new AiModerationFlagRepository(em)
+    const { items, total } = await repo.list({
+      tenantId: auth.tenantId,
+      // Tenant-scoped abuse audit: do NOT narrow by organization_id. Tenant is
+      // the hard isolation boundary; portal-surface flags often carry no org,
+      // and a tenant admin reviewing abuse needs every flag in the tenant.
+      agentId,
+      userId,
+      // `to` is an inclusive day; extend to end-of-day so same-day rows match.
+      from: from ? new Date(`${from}T00:00:00.000Z`) : undefined,
+      to: to ? new Date(`${to}T23:59:59.999Z`) : undefined,
+      page,
+      pageSize,
+    })
+
+    const serialized = items.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId ?? null,
+      agentId: row.agentId,
+      userId: row.userId,
+      providerId: row.providerId,
+      modelId: row.modelId,
+      categories: row.categories,
+      createdAt: row.createdAt.toISOString(),
+    }))
+
+    return NextResponse.json({ items: serialized, total, page, pageSize })
+  } catch (error) {
+    logger.error('Moderation flags GET failed', { err: error })
+    return jsonError(500, 'Failed to fetch moderation flags.', 'internal_error')
+  }
+}

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

@@ -8,7 +8,7 @@
  */
 
 const authMock = jest.fn()
-const loadAclMock = jest.fn()
+const userHasAllFeaturesMock = jest.fn()
 const createRequestContainerMock = jest.fn()
 const upsertDefaultMock = jest.fn()
 const clearDefaultMock = jest.fn()
@@ -96,10 +96,10 @@ describe('PUT /api/ai_assistant/settings', () => {
     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 })
+    userHasAllFeaturesMock.mockResolvedValue(true)
     createRequestContainerMock.mockResolvedValue({
       resolve: (name: string) => {
-        if (name === 'rbacService') return { loadAcl: loadAclMock }
+        if (name === 'rbacService') return { userHasAllFeatures: userHasAllFeaturesMock }
         if (name === 'em') return {}
         return null
       },
@@ -131,7 +131,7 @@ describe('PUT /api/ai_assistant/settings', () => {
   })
 
   it('returns 403 when caller lacks ai_assistant.settings.manage', async () => {
-    loadAclMock.mockResolvedValueOnce({ features: ['ai_assistant.view'], isSuperAdmin: false })
+    userHasAllFeaturesMock.mockResolvedValueOnce(false)
 
     const response = await PUT(buildRequest('PUT', { providerId: 'openai' }) as any)
 
@@ -161,6 +161,56 @@ describe('PUT /api/ai_assistant/settings', () => {
     )
   })
 
+  it('forwards inputModeration to the override upsert and echoes it back', async () => {
+    upsertDefaultMock.mockResolvedValueOnce({
+      id: 'row-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: 'catalog.catalog_assistant',
+      providerId: null,
+      modelId: null,
+      baseUrl: null,
+      inputModeration: true,
+      updatedAt: new Date('2026-06-10T00:00:00Z'),
+    })
+
+    const response = await PUT(
+      buildRequest('PUT', { agentId: 'catalog.catalog_assistant', inputModeration: true }) as any,
+    )
+
+    expect(response.status).toBe(200)
+    const json = await response.json()
+    expect(json.inputModeration).toBe(true)
+    expect(upsertDefaultMock).toHaveBeenCalledWith(
+      expect.objectContaining({ agentId: 'catalog.catalog_assistant', inputModeration: true }),
+      expect.objectContaining({ tenantId: 'tenant-1' }),
+    )
+  })
+
+  it('passes inputModeration: null (inherit) through to the upsert', async () => {
+    upsertDefaultMock.mockResolvedValueOnce({
+      id: 'row-1',
+      tenantId: 'tenant-1',
+      organizationId: 'org-1',
+      agentId: 'catalog.catalog_assistant',
+      providerId: null,
+      modelId: null,
+      baseUrl: null,
+      inputModeration: null,
+      updatedAt: new Date('2026-06-10T00:00:00Z'),
+    })
+
+    const response = await PUT(
+      buildRequest('PUT', { agentId: 'catalog.catalog_assistant', inputModeration: null }) as any,
+    )
+
+    expect(response.status).toBe(200)
+    expect(upsertDefaultMock).toHaveBeenCalledWith(
+      expect.objectContaining({ inputModeration: null }),
+      expect.anything(),
+    )
+  })
+
   it('saves per-agent chat override allowlist without requiring a model override', async () => {
     upsertDefaultMock.mockResolvedValueOnce({
       id: 'row-1',
@@ -268,7 +318,7 @@ describe('PUT /api/ai_assistant/settings', () => {
   })
 
   it('allows superAdmin even without the manage feature', async () => {
-    loadAclMock.mockResolvedValueOnce({ features: [], isSuperAdmin: true })
+    userHasAllFeaturesMock.mockResolvedValueOnce(true)
 
     const response = await PUT(buildRequest('PUT', { providerId: 'openai' }) as any)
 
@@ -337,10 +387,10 @@ describe('DELETE /api/ai_assistant/settings', () => {
     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 })
+    userHasAllFeaturesMock.mockResolvedValue(true)
     createRequestContainerMock.mockResolvedValue({
       resolve: (name: string) => {
-        if (name === 'rbacService') return { loadAcl: loadAclMock }
+        if (name === 'rbacService') return { userHasAllFeatures: userHasAllFeaturesMock }
         if (name === 'em') return {}
         return null
       },
@@ -361,7 +411,7 @@ describe('DELETE /api/ai_assistant/settings', () => {
   })
 
   it('returns 403 when caller lacks ai_assistant.settings.manage', async () => {
-    loadAclMock.mockResolvedValueOnce({ features: ['ai_assistant.view'], isSuperAdmin: false })
+    userHasAllFeaturesMock.mockResolvedValueOnce(false)
 
     const response = await DELETE(buildRequest('DELETE', {}) as any)
 

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

@@ -151,12 +151,11 @@ export async function PUT(req: NextRequest) {
   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')
+    const canManage = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['ai_assistant.settings.manage'],
+      { tenantId: auth.tenantId, organizationId: auth.orgId },
+    )
     if (!canManage) {
       return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
     }
@@ -197,12 +196,11 @@ export async function DELETE(req: NextRequest) {
   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')
+    const canManage = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['ai_assistant.settings.manage'],
+      { tenantId: auth.tenantId, organizationId: auth.orgId },
+    )
     if (!canManage) {
       return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
     }

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

@@ -17,6 +17,7 @@ import {
   isOpenCodeProviderConfigured,
 } from '@open-mercato/shared/lib/ai/opencode-provider'
 import { AiAgentRuntimeOverrideRepository, AiAgentRuntimeOverrideValidationError } from '../../data/repositories/AiAgentRuntimeOverrideRepository'
+import { resolveModerationPolicy } from '../../lib/moderation-policy'
 import { AiTenantModelAllowlistRepository } from '../../data/repositories/AiTenantModelAllowlistRepository'
 import { isBaseurlAllowlisted, readBaseurlAllowlist } from '../../lib/baseurl-allowlist'
 import { loadAgentRegistry, listAgents } from '../../lib/agent-registry'
@@ -59,6 +60,9 @@ const runtimeOverrideUpsertSchema = z.object({
   allowedOverrideModelsByProvider: z
     .record(z.string().min(1).max(64), z.array(z.string().min(1).max(256)))
     .optional(),
+  // Input moderation override: true = on, false = off, null = inherit.
+  // Spec 2026-06-04-ai-input-moderation-and-safety-identifiers.
+  inputModeration: z.boolean().nullable().optional(),
 })
 
 const runtimeOverrideClearSchema = z.object({
@@ -248,6 +252,7 @@ export async function GET(req: NextRequest) {
         const em = container.resolve<EntityManager>('em')
         const repo = new AiAgentRuntimeOverrideRepository(em)
         const overrideRow = await repo.getDefault({ tenantId, organizationId, agentId: null })
+        const tenantWideInputModeration = overrideRow?.inputModeration ?? null
         if (overrideRow) {
           tenantOverride = {
             providerId: overrideRow.providerId ?? null,
@@ -363,6 +368,20 @@ export async function GET(req: NextRequest) {
             modelId: agentResolution.modelId,
             baseURL: agentResolution.baseURL ?? null,
             source: agentResolution.source,
+            moderation: {
+              // `untrustedInput` agents enforce moderation; the UI renders a
+              // non-editable "Enforced" badge for them.
+              enforced: agent.untrustedInput === true,
+              // Per-agent control value: null = inherit, true = on, false = off.
+              override: agentOverrideRow?.inputModeration ?? null,
+              // Resolved runtime policy (enforced | on | off) after precedence.
+              effective: resolveModerationPolicy({
+                untrustedInput: agent.untrustedInput,
+                perAgentOverride: agentOverrideRow?.inputModeration ?? null,
+                tenantWideOverride: tenantWideInputModeration,
+                env,
+              }),
+            },
           }
         })
         agentResolutions = await Promise.all(agentResolutionPromises)
@@ -691,11 +710,11 @@ export async function PUT(req: NextRequest) {
   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')
+    const canManage = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['ai_assistant.settings.manage'],
+      { tenantId: auth.tenantId, organizationId: auth.orgId },
+    )
     if (!canManage) {
       return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
     }
@@ -719,6 +738,9 @@ export async function PUT(req: NextRequest) {
       ...(allowedOverrideModelsByProvider !== undefined
         ? { allowedOverrideModelsByProvider }
         : {}),
+      ...(Object.prototype.hasOwnProperty.call(bodyResult.data, 'inputModeration')
+        ? { inputModeration: bodyResult.data.inputModeration ?? null }
+        : {}),
     }
     const row = await repo.upsertDefault(
       upsertInput,
@@ -734,6 +756,7 @@ export async function PUT(req: NextRequest) {
       baseURL: row.baseUrl,
       allowedOverrideProviders: row.allowedOverrideProviders ?? null,
       allowedOverrideModelsByProvider: row.allowedOverrideModelsByProvider ?? {},
+      inputModeration: row.inputModeration ?? null,
       updatedAt: row.updatedAt,
     })
   } catch (error) {
@@ -777,11 +800,11 @@ export async function DELETE(req: NextRequest) {
   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')
+    const canManage = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['ai_assistant.settings.manage'],
+      { tenantId: auth.tenantId, organizationId: auth.orgId },
+    )
     if (!canManage) {
       return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
     }