@open-mercato/ai-assistant 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

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

@@ -1,122 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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/backend/config/ai-assistant/moderation-flags/AiModerationFlagsPageClient.tsx

@@ -1,186 +0,0 @@
-'use client'
-
-import * as React from 'react'
-import { useQuery } from '@tanstack/react-query'
-import type { ColumnDef } from '@tanstack/react-table'
-import { useT } from '@open-mercato/shared/lib/i18n/context'
-import { DataTable } from '@open-mercato/ui/backend/DataTable'
-import { Button } from '@open-mercato/ui/primitives/button'
-import { Input } from '@open-mercato/ui/primitives/input'
-import { Label } from '@open-mercato/ui/primitives/label'
-import { StatusBadge } from '@open-mercato/ui/primitives/status-badge'
-import { apiCallOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
-
-const PAGE_SIZE = 50
-
-type ModerationCategory = { flagged: boolean; score: number }
-
-type ModerationFlagRow = {
-  id: string
-  tenantId: string
-  organizationId: string | null
-  agentId: string
-  userId: string
-  providerId: string
-  modelId: string
-  categories: Record<string, ModerationCategory>
-  createdAt: string
-}
-
-type ModerationFlagsResponse = {
-  items: ModerationFlagRow[]
-  total: number
-  page: number
-  pageSize: number
-}
-
-async function fetchModerationFlags(params: {
-  page: number
-  from: string
-  to: string
-  agentId: string
-  userId: string
-}): Promise<ModerationFlagsResponse> {
-  const search = new URLSearchParams()
-  search.set('page', String(params.page))
-  search.set('pageSize', String(PAGE_SIZE))
-  if (params.from) search.set('from', params.from)
-  if (params.to) search.set('to', params.to)
-  if (params.agentId) search.set('agentId', params.agentId)
-  if (params.userId) search.set('userId', params.userId)
-  const { result, status } = await apiCallOrThrow<ModerationFlagsResponse>(
-    `/api/ai_assistant/moderation-flags?${search.toString()}`,
-    undefined,
-    { errorMessage: 'Failed to load moderation flags' },
-  )
-  if (!result) throw new Error(`Failed to load moderation flags (${status})`)
-  return result
-}
-
-function flaggedCategoryNames(categories: Record<string, ModerationCategory>): string[] {
-  return Object.entries(categories)
-    .filter(([, value]) => value.flagged)
-    .map(([name]) => name)
-}
-
-export function AiModerationFlagsPageClient() {
-  const t = useT()
-  const [page, setPage] = React.useState(1)
-  const [from, setFrom] = React.useState('')
-  const [to, setTo] = React.useState('')
-  const [agentId, setAgentId] = React.useState('')
-  const [userId, setUserId] = React.useState('')
-  const [applied, setApplied] = React.useState({ from: '', to: '', agentId: '', userId: '' })
-
-  const query = useQuery<ModerationFlagsResponse>({
-    queryKey: ['ai_assistant', 'moderation_flags', page, applied],
-    queryFn: () => fetchModerationFlags({ page, ...applied }),
-    retry: false,
-  })
-
-  const applyFilters = React.useCallback(() => {
-    setPage(1)
-    setApplied({ from, to, agentId, userId })
-  }, [from, to, agentId, userId])
-
-  const columns = React.useMemo<ColumnDef<ModerationFlagRow, unknown>[]>(
-    () => [
-      {
-        accessorKey: 'agentId',
-        header: t('ai_assistant.moderationFlags.columns.agent', 'Agent'),
-      },
-      {
-        accessorKey: 'userId',
-        header: t('ai_assistant.moderationFlags.columns.user', 'User'),
-        meta: { truncate: true, maxWidth: 220 },
-      },
-      {
-        accessorKey: 'categories',
-        header: t('ai_assistant.moderationFlags.columns.categories', 'Categories'),
-        cell: ({ row }) => {
-          const names = flaggedCategoryNames(row.original.categories)
-          if (names.length === 0) {
-            return <span className="text-muted-foreground">—</span>
-          }
-          return (
-            <div className="flex flex-wrap gap-1">
-              {names.map((name) => (
-                <StatusBadge key={name} variant="error" dot>
-                  {name}
-                </StatusBadge>
-              ))}
-            </div>
-          )
-        },
-      },
-      {
-        accessorKey: 'createdAt',
-        header: t('ai_assistant.moderationFlags.columns.createdAt', 'Flagged at'),
-        cell: ({ row }) => new Date(row.original.createdAt).toLocaleString(),
-      },
-    ],
-    [t],
-  )
-
-  const total = query.data?.total ?? 0
-
-  return (
-    <div className="flex flex-col gap-4">
-      <div>
-        <h2 className="text-base font-semibold">
-          {t('ai_assistant.moderationFlags.title', 'Moderation flags')}
-        </h2>
-        <p className="text-xs text-muted-foreground">
-          {t(
-            'ai_assistant.moderationFlags.subtitle',
-            'Inputs blocked by the content safety filter. Category flags and scores only — no prompt content is stored.',
-          )}
-        </p>
-      </div>
-
-      <div className="flex flex-wrap items-end gap-3">
-        <div className="flex flex-col gap-1">
-          <Label htmlFor="moderation-from">{t('ai_assistant.moderationFlags.filters.from', 'From')}</Label>
-          <Input id="moderation-from" type="date" value={from} onChange={(e) => setFrom(e.target.value)} />
-        </div>
-        <div className="flex flex-col gap-1">
-          <Label htmlFor="moderation-to">{t('ai_assistant.moderationFlags.filters.to', 'To')}</Label>
-          <Input id="moderation-to" type="date" value={to} onChange={(e) => setTo(e.target.value)} />
-        </div>
-        <div className="flex flex-col gap-1">
-          <Label htmlFor="moderation-agent">{t('ai_assistant.moderationFlags.columns.agent', 'Agent')}</Label>
-          <Input
-            id="moderation-agent"
-            value={agentId}
-            onChange={(e) => setAgentId(e.target.value)}
-            placeholder={t('ai_assistant.moderationFlags.filters.agentPlaceholder', 'module.agent')}
-          />
-        </div>
-        <div className="flex flex-col gap-1">
-          <Label htmlFor="moderation-user">{t('ai_assistant.moderationFlags.columns.user', 'User')}</Label>
-          <Input id="moderation-user" value={userId} onChange={(e) => setUserId(e.target.value)} />
-        </div>
-        <Button type="button" variant="outline" onClick={applyFilters}>
-          {t('ai_assistant.moderationFlags.filters.apply', 'Apply')}
-        </Button>
-      </div>
-
-      <DataTable<ModerationFlagRow>
-        columns={columns}
-        data={query.data?.items ?? []}
-        isLoading={query.isLoading}
-        error={query.error ? (query.error as Error).message : undefined}
-        emptyState={t('ai_assistant.moderationFlags.empty', 'No flagged messages.')}
-        pagination={{
-          page,
-          pageSize: PAGE_SIZE,
-          total,
-          totalPages: Math.max(1, Math.ceil(total / PAGE_SIZE)),
-          onPageChange: setPage,
-        }}
-      />
-    </div>
-  )
-}
-
-export default AiModerationFlagsPageClient

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/page.meta.ts

@@ -1,24 +0,0 @@
-import React from 'react'
-
-const moderationIcon = React.createElement(
-  'svg',
-  { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' },
-  React.createElement('path', { d: 'M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z' }),
-  React.createElement('path', { d: 'M12 8v4' }),
-  React.createElement('path', { d: 'M12 16h.01' }),
-)
-
-export const metadata = {
-  requireAuth: true,
-  requireFeatures: ['ai_assistant.settings.manage'],
-  pageTitle: 'Moderation flags',
-  pageTitleKey: 'ai_assistant.moderationFlags.navTitle',
-  pageGroup: 'Module Configs',
-  pageGroupKey: 'settings.sections.moduleConfigs',
-  pageOrder: 432,
-  icon: moderationIcon,
-  pageContext: 'settings' as const,
-  breadcrumb: [
-    { label: 'Moderation flags', labelKey: 'ai_assistant.moderationFlags.navTitle' },
-  ],
-} as const

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/page.tsx

@@ -1,12 +0,0 @@
-import { Page, PageBody } from '@open-mercato/ui/backend/Page'
-import { AiModerationFlagsPageClient } from './AiModerationFlagsPageClient'
-
-export default async function AiModerationFlagsPage() {
-  return (
-    <Page>
-      <PageBody>
-        <AiModerationFlagsPageClient />
-      </PageBody>
-    </Page>
-  )
-}

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

@@ -1,79 +0,0 @@
-import type { EntityManager } from '@mikro-orm/postgresql'
-import { AiModerationFlag } from '../entities'
-import type { ModerationCategoryResult } from '../../lib/moderation'
-
-export interface CreateModerationFlagInput {
-  tenantId: string
-  organizationId?: string | null
-  agentId: string
-  userId: string
-  providerId: string
-  modelId: string
-  categories: Record<string, ModerationCategoryResult>
-}
-
-export interface ListModerationFlagsFilter {
-  tenantId: string
-  organizationId?: string | null
-  agentId?: string
-  userId?: string
-  /** Inclusive lower bound on `created_at`. */
-  from?: Date
-  /** Inclusive upper bound on `created_at`. */
-  to?: Date
-  page: number
-  pageSize: number
-}
-
-export interface ModerationFlagListResult {
-  items: AiModerationFlag[]
-  total: number
-}
-
-/**
- * Repository for the append-only `ai_moderation_flags` audit table. Every read
- * is tenant-scoped — cross-tenant access is structurally impossible because
- * `tenantId` is always part of the filter.
- *
- * Spec `2026-06-04-ai-input-moderation-and-safety-identifiers`.
- */
-export class AiModerationFlagRepository {
-  constructor(private readonly em: EntityManager) {}
-
-  async create(input: CreateModerationFlagInput): Promise<AiModerationFlag> {
-    const flag = this.em.create(AiModerationFlag, {
-      tenantId: input.tenantId,
-      organizationId: input.organizationId ?? null,
-      agentId: input.agentId,
-      userId: input.userId,
-      providerId: input.providerId,
-      modelId: input.modelId,
-      categories: input.categories,
-    })
-    this.em.persist(flag)
-    await this.em.flush()
-    return flag
-  }
-
-  async list(filter: ListModerationFlagsFilter): Promise<ModerationFlagListResult> {
-    const where: Record<string, unknown> = { tenantId: filter.tenantId }
-    if (filter.organizationId !== undefined && filter.organizationId !== null) {
-      where.organizationId = filter.organizationId
-    }
-    if (filter.agentId) where.agentId = filter.agentId
-    if (filter.userId) where.userId = filter.userId
-    if (filter.from || filter.to) {
-      const createdAt: Record<string, Date> = {}
-      if (filter.from) createdAt.$gte = filter.from
-      if (filter.to) createdAt.$lte = filter.to
-      where.createdAt = createdAt
-    }
-
-    const [items, total] = await this.em.findAndCount(AiModerationFlag, where, {
-      orderBy: { createdAt: 'desc' },
-      limit: filter.pageSize,
-      offset: (filter.page - 1) * filter.pageSize,
-    })
-    return { items, total }
-  }
-}