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

package/src/modules/ai_assistant/i18n/pl.json

@@ -36,21 +36,44 @@
   "ai_assistant.agents.meta.readOnlyYes": "Tak",
   "ai_assistant.agents.meta.unlimited": "Bez limitu",
   "ai_assistant.agents.model_override.allowlistCustom": "niestandardowe",
+  "ai_assistant.agents.model_override.allowlistEmpty": "Brak skonfigurowanych dostawców dostępnych do nadpisań w czacie.",
+  "ai_assistant.agents.model_override.allowlistHelp": "Ogranicz, które nadpisania dostawcy i modelu użytkownicy mogą wybrać w stopce czatu dla tego agenta.",
   "ai_assistant.agents.model_override.allowlistInherited": "dziedziczone",
   "ai_assistant.agents.model_override.allowlistReset": "Dziedzicz",
   "ai_assistant.agents.model_override.allowlistSave": "Zapisz wybór",
+  "ai_assistant.agents.model_override.allowlistSaved": "Zapisano dozwolone opcje nadpisań w czacie.",
+  "ai_assistant.agents.model_override.allowlistTitle": "Dozwolone opcje nadpisań w czacie",
   "ai_assistant.agents.model_override.anyProvider": "pierwszy skonfigurowany",
   "ai_assistant.agents.model_override.clear": "Wyczyść nadpisanie",
+  "ai_assistant.agents.model_override.cleared": "Nadpisanie modelu zostało wyczyszczone; agent korzysta ze standardowego łańcucha rozwiązywania.",
   "ai_assistant.agents.model_override.codeDefault": "Domyślne z kodu",
   "ai_assistant.agents.model_override.defaultBadge": "domyślne",
+  "ai_assistant.agents.model_override.envAlsoNarrows": "dodatkowo zawęża tę listę na podstawie zmiennych środowiskowych.",
+  "ai_assistant.agents.model_override.loadErrorTitle": "Nie udało się wczytać katalogu dostawców",
+  "ai_assistant.agents.model_override.loading": "Wczytywanie katalogu dostawców…",
   "ai_assistant.agents.model_override.model": "Model",
   "ai_assistant.agents.model_override.noOverride": "Brak nadpisania dla agenta",
   "ai_assistant.agents.model_override.provider": "Dostawca",
   "ai_assistant.agents.model_override.providerDefault": "domyślne dostawcy",
   "ai_assistant.agents.model_override.save": "Zapisz nadpisanie",
   "ai_assistant.agents.model_override.saved": "Nadpisanie modelu zapisane.",
+  "ai_assistant.agents.model_override.selectModel": "Wybierz model",
+  "ai_assistant.agents.model_override.selectProvider": "Wybierz dostawcę",
+  "ai_assistant.agents.model_override.subtitle": "Nadpisz domyślnego dostawcę i model dla tego najemcy i agenta.",
   "ai_assistant.agents.model_override.tenantOverride": "Nadpisanie tenant",
   "ai_assistant.agents.model_override.title": "Dostawca i model",
+  "ai_assistant.agents.moderation.controlLabel": "Moderacja",
+  "ai_assistant.agents.moderation.effectiveEnforced": "Wymuszona",
+  "ai_assistant.agents.moderation.effectiveOff": "Wyłączona",
+  "ai_assistant.agents.moderation.effectiveOn": "Włączona",
+  "ai_assistant.agents.moderation.enforcedBadge": "Wymuszona",
+  "ai_assistant.agents.moderation.enforcedHint": "Ten agent przyjmuje niezaufane dane wejściowe, więc moderacja jest zawsze włączona i nie można jej tutaj wyłączyć.",
+  "ai_assistant.agents.moderation.inheritLabel": "Dziedzicz",
+  "ai_assistant.agents.moderation.offLabel": "Wyłączona",
+  "ai_assistant.agents.moderation.onLabel": "Włączona",
+  "ai_assistant.agents.moderation.saved": "Zapisano ustawienie moderacji danych wejściowych.",
+  "ai_assistant.agents.moderation.subtitle": "Filtruj dane wejściowe użytkownika pod kątem niebezpiecznych treści przed uruchomieniem modelu. Działa tylko, gdy wybrany dostawca obsługuje moderację.",
+  "ai_assistant.agents.moderation.title": "Moderacja danych wejściowych",
   "ai_assistant.agents.mutation_policy.clear": "Wyczyść nadpisanie",
   "ai_assistant.agents.mutation_policy.clearedMessage": "Nadpisanie polityki mutacji usunięte; agent korzysta z polityki zadeklarowanej w kodzie.",
   "ai_assistant.agents.mutation_policy.codeDeclared": "Zadeklarowane w kodzie",
@@ -275,7 +298,9 @@
   "ai_assistant.chat.toolRunning": "w toku…",
   "ai_assistant.chat.transcriptLabel": "Transkrypcja czatu",
   "ai_assistant.chat.uiPartPending": "Oczekująca część UI:",
+  "ai_assistant.chat.uploadingHint": "Trwa przesyłanie załączników… Wysyłanie jest zablokowane do zakończenia.",
   "ai_assistant.chat.userRoleLabel": "Ty",
+  "ai_assistant.chat.welcomeDescription": "Zapytaj mnie o cokolwiek z Twoich danych. Oto kilka rzeczy, które potrafię:",
   "ai_assistant.chat.welcomeTitle": "W czym mogę pomóc?",
   "ai_assistant.chat.zoomImage": "Otwórz podgląd {name}",
   "ai_assistant.dock.bottom": "Dokuj na dole",
@@ -284,13 +309,17 @@
   "ai_assistant.dock.left": "Dokuj po lewej",
   "ai_assistant.dock.minimize": "Minimalizuj",
   "ai_assistant.dock.right": "Dokuj po prawej",
+  "ai_assistant.errors.moderationBlocked": "Twoja wiadomość została zablokowana przez filtr bezpieczeństwa treści. Przeformułuj ją i spróbuj ponownie.",
+  "ai_assistant.errors.moderationUnavailable": "Sprawdzanie bezpieczeństwa treści jest chwilowo niedostępne. Spróbuj ponownie za chwilę.",
   "ai_assistant.launcher.composerPlaceholder": "Zapytaj o cokolwiek…",
+  "ai_assistant.launcher.dialogDescription": "Wybierz asystenta. Nawiguj klawiszami ↑/↓, Enter uruchamia, Esc zamyka.",
   "ai_assistant.launcher.dialogTitle": "Asystenci AI",
   "ai_assistant.launcher.dock.subtitle": "Asystent AI",
   "ai_assistant.launcher.empty": "Żaden asystent nie pasuje do wyszukiwania.",
   "ai_assistant.launcher.hint.close": "Zamknij",
   "ai_assistant.launcher.hint.launch": "Uruchom",
   "ai_assistant.launcher.hint.navigate": "Nawigacja",
+  "ai_assistant.launcher.none": "Dla Twojego konta nie są dostępni żadni asystenci.",
   "ai_assistant.launcher.searchPlaceholder": "Szukaj asystentów...",
   "ai_assistant.launcher.setup.body": "Asystenci AI są zainstalowani, ale nie skonfigurowano klucza dostawcy. Ustaw OM_AI_PROVIDER oraz pasujący klucz API w pliku .env, a następnie uruchom aplikację ponownie.",
   "ai_assistant.launcher.setup.docs": "Dokumentacja asystenta AI",
@@ -299,6 +328,7 @@
   "ai_assistant.launcher.sheet.dock": "Przypnij z boku",
   "ai_assistant.launcher.triggerAriaLabel": "Otwórz asystenta AI",
   "ai_assistant.launcher.triggerLabel": "AI",
+  "ai_assistant.launcher.welcome.fallback": "W czym mogę pomóc?",
   "ai_assistant.launcher.welcome.suggestion1": "W czym możesz mi pomóc?",
   "ai_assistant.launcher.welcome.suggestion2": "Pokaż, do jakich danych masz dostęp",
   "ai_assistant.launcher.welcome.suggestion3": "Zaproponuj, co mogę wypróbować",
@@ -326,6 +356,18 @@
   "ai_assistant.modelPicker.triggerAriaLabel": "Wybierz model AI",
   "ai_assistant.modelPicker.useDefault": "Użyj domyślnego agenta",
   "ai_assistant.modelPicker.useDefaultWithModel": "Użyj domyślnego agenta: {{model}}",
+  "ai_assistant.moderationFlags.columns.agent": "Agent",
+  "ai_assistant.moderationFlags.columns.categories": "Kategorie",
+  "ai_assistant.moderationFlags.columns.createdAt": "Oznaczono",
+  "ai_assistant.moderationFlags.columns.user": "Użytkownik",
+  "ai_assistant.moderationFlags.empty": "Brak oznaczonych wiadomości.",
+  "ai_assistant.moderationFlags.filters.agentPlaceholder": "moduł.agent",
+  "ai_assistant.moderationFlags.filters.apply": "Zastosuj",
+  "ai_assistant.moderationFlags.filters.from": "Od",
+  "ai_assistant.moderationFlags.filters.to": "Do",
+  "ai_assistant.moderationFlags.navTitle": "Flagi moderacji",
+  "ai_assistant.moderationFlags.subtitle": "Dane wejściowe zablokowane przez filtr bezpieczeństwa treści. Tylko flagi kategorii i wyniki — treść promptu nie jest przechowywana.",
+  "ai_assistant.moderationFlags.title": "Flagi moderacji",
   "ai_assistant.notifications.conversation_shared.body": "Udostępniono Ci konwersację z asystentem AI.",
   "ai_assistant.notifications.conversation_shared.title": "Udostępniono Ci konwersację",
   "ai_assistant.notifications.conversation_shared.view_button": "Otwórz konwersację",

package/src/modules/ai_assistant/lib/__tests__/auth.test.ts

@@ -137,7 +137,7 @@ describe('hasRequiredFeatures', () => {
     ).toBe(true)
   })
 
-  it('delegates to rbacService when provided', () => {
+  it('uses the shared policy even when a legacy rbacService argument is provided', () => {
     const rbacService = {
       hasAllFeatures: jest.fn().mockReturnValue(true),
     }
@@ -148,9 +148,6 @@ describe('hasRequiredFeatures', () => {
       rbacService as any
     )
     expect(result).toBe(true)
-    expect(rbacService.hasAllFeatures).toHaveBeenCalledWith(
-      ['customers.view'],
-      ['customers.view']
-    )
+    expect(rbacService.hasAllFeatures).not.toHaveBeenCalled()
   })
 })

package/src/modules/ai_assistant/lib/__tests__/input-moderation-gate.test.ts

@@ -0,0 +1,121 @@
+import { extractLatestUserText, runInputModerationGate } from '../agent-runtime'
+import {
+  AiModerationBlockedError,
+  AiModerationUnavailableError,
+  type ModerationResult,
+  type ModerationService,
+} from '../moderation'
+
+function serviceReturning(result: ModerationResult): ModerationService {
+  return { checkInput: jest.fn(async () => result) }
+}
+function serviceThrowing(error: unknown): ModerationService {
+  return { checkInput: jest.fn(async () => { throw error }) }
+}
+
+const CLEAN: ModerationResult = { flagged: false, categories: { hate: { flagged: false, score: 0.01 } } }
+const FLAGGED: ModerationResult = { flagged: true, categories: { hate: { flagged: true, score: 0.98 } } }
+
+const base = {
+  supportsInputModeration: true,
+  userText: 'hello there',
+  resolveApiKey: () => 'sk-test' as string | null,
+  env: {} as Record<string, string | undefined>,
+}
+
+describe('extractLatestUserText', () => {
+  it('returns the text parts of the most recent user message', () => {
+    const messages = [
+      { role: 'user', parts: [{ type: 'text', text: 'first' }] },
+      { role: 'assistant', parts: [{ type: 'text', text: 'reply' }] },
+      { role: 'user', parts: [{ type: 'text', text: 'second' }, { type: 'text', text: 'line' }] },
+    ] as never
+    expect(extractLatestUserText(messages)).toBe('second\nline')
+  })
+
+  it('falls back to string content and returns empty when no user message', () => {
+    expect(extractLatestUserText([{ role: 'user', content: 'plain' }] as never)).toBe('plain')
+    expect(extractLatestUserText([{ role: 'assistant', parts: [{ type: 'text', text: 'x' }] }] as never)).toBe('')
+  })
+})
+
+describe('runInputModerationGate', () => {
+  it('skips entirely when policy resolves to off (no untrusted, no override, no env)', async () => {
+    const service = serviceReturning(FLAGGED)
+    await expect(runInputModerationGate({ ...base, service })).resolves.toBeUndefined()
+    expect(service.checkInput).not.toHaveBeenCalled()
+  })
+
+  it('skips when the provider does not support moderation, even on an enforced surface', async () => {
+    const service = serviceReturning(FLAGGED)
+    await expect(
+      runInputModerationGate({ ...base, untrustedInput: true, supportsInputModeration: false, service }),
+    ).resolves.toBeUndefined()
+    expect(service.checkInput).not.toHaveBeenCalled()
+  })
+
+  it('skips when the user text is empty', async () => {
+    const service = serviceReturning(FLAGGED)
+    await expect(
+      runInputModerationGate({ ...base, untrustedInput: true, userText: '   ', service }),
+    ).resolves.toBeUndefined()
+    expect(service.checkInput).not.toHaveBeenCalled()
+  })
+
+  it('passes clean input through on an enabled surface', async () => {
+    const service = serviceReturning(CLEAN)
+    await expect(
+      runInputModerationGate({ ...base, perAgentOverride: true, service }),
+    ).resolves.toBeUndefined()
+    expect(service.checkInput).toHaveBeenCalledTimes(1)
+  })
+
+  it('throws AiModerationBlockedError (with categories) on flagged input', async () => {
+    const service = serviceReturning(FLAGGED)
+    const error = await runInputModerationGate({ ...base, untrustedInput: true, service }).catch((e) => e)
+    expect(error).toBeInstanceOf(AiModerationBlockedError)
+    expect((error as AiModerationBlockedError).categories.hate.flagged).toBe(true)
+  })
+
+  it('runs the onFlagged side effect before throwing, and the throw still applies if it fails', async () => {
+    const service = serviceReturning(FLAGGED)
+    const onFlagged = jest.fn(async () => { throw new Error('db down') })
+    const error = await runInputModerationGate({ ...base, untrustedInput: true, service, onFlagged }).catch((e) => e)
+    expect(onFlagged).toHaveBeenCalledWith(FLAGGED.categories)
+    expect(error).toBeInstanceOf(AiModerationBlockedError)
+  })
+
+  it('fails CLOSED on an enforced surface when the endpoint is unavailable', async () => {
+    const service = serviceThrowing(new AiModerationUnavailableError('endpoint down'))
+    await expect(
+      runInputModerationGate({ ...base, untrustedInput: true, service }),
+    ).rejects.toBeInstanceOf(AiModerationUnavailableError)
+  })
+
+  it('fails OPEN on an opt-in (on) surface when the endpoint is unavailable', async () => {
+    const service = serviceThrowing(new AiModerationUnavailableError('endpoint down'))
+    await expect(
+      runInputModerationGate({ ...base, perAgentOverride: true, service }),
+    ).resolves.toBeUndefined()
+  })
+
+  it('fails CLOSED on enforced when the service is missing from the container', async () => {
+    await expect(
+      runInputModerationGate({ ...base, untrustedInput: true, service: null }),
+    ).rejects.toBeInstanceOf(AiModerationUnavailableError)
+  })
+
+  it('fails OPEN on opt-in when the API key is missing', async () => {
+    const service = serviceReturning(CLEAN)
+    await expect(
+      runInputModerationGate({ ...base, perAgentOverride: true, resolveApiKey: () => null, service }),
+    ).resolves.toBeUndefined()
+    expect(service.checkInput).not.toHaveBeenCalled()
+  })
+
+  it('does not resolve the API key on the common skip path (policy off)', async () => {
+    const resolveApiKey = jest.fn(() => 'sk-test' as string | null)
+    await expect(runInputModerationGate({ ...base, resolveApiKey, service: serviceReturning(CLEAN) })).resolves.toBeUndefined()
+    expect(resolveApiKey).not.toHaveBeenCalled()
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/llm-adapters-anthropic.test.ts

@@ -87,4 +87,17 @@ describe('AnthropicAdapter', () => {
     })
     expect(model).toBeDefined()
   })
+
+  it('maps an end-user identifier into the Anthropic metadata.userId providerOptions fragment', () => {
+    // Key MUST be the AI SDK provider-option name `userId` (camelCase); the SDK
+    // translates it to the `metadata.user_id` request-body field and strips
+    // unknown providerOptions keys, so a snake_case key would be dropped.
+    expect(adapter.mapEndUserIdentifier?.('hashed-id')).toEqual({
+      anthropic: { metadata: { userId: 'hashed-id' } },
+    })
+  })
+
+  it('does not advertise input moderation support (Anthropic has no moderation endpoint)', () => {
+    expect(adapter.supportsInputModeration).toBeFalsy()
+  })
 })

package/src/modules/ai_assistant/lib/__tests__/llm-adapters-openai.test.ts

@@ -330,3 +330,44 @@ describe('LM Studio preset', () => {
     expect(model).toBeDefined()
   })
 })
+
+describe('OpenAIAdapter — safety identifier + moderation capability', () => {
+  it('maps an end-user identifier into the OpenAI safetyIdentifier providerOptions fragment', () => {
+    // Key MUST be the AI SDK provider-option name `safetyIdentifier` (camelCase);
+    // the SDK translates it to the `safety_identifier` request-body field and
+    // strips unknown providerOptions keys, so a snake_case key would be dropped.
+    const openaiPreset = OPENAI_COMPATIBLE_PRESETS.find((preset) => preset.id === 'openai')!
+    const provider = createOpenAICompatibleProvider(openaiPreset)
+    expect(provider.mapEndUserIdentifier?.('hashed-id')).toEqual({
+      openai: { safetyIdentifier: 'hashed-id' },
+    })
+  })
+
+  it('does not map a safety identifier for OpenAI-compatible backends (OpenAI-only param)', () => {
+    // `safety_identifier` is an OpenAI-specific body field; compatible/self-hosted
+    // backends (Groq, DeepInfra, Azure, Ollama, …) may reject the unknown param,
+    // so they must not advertise the mapping.
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    expect(provider.mapEndUserIdentifier).toBeUndefined()
+    for (const preset of OPENAI_COMPATIBLE_PRESETS) {
+      const built = createOpenAICompatibleProvider(preset)
+      if (preset.id === 'openai') {
+        expect(built.mapEndUserIdentifier).toBeDefined()
+      } else {
+        expect(built.mapEndUserIdentifier).toBeUndefined()
+      }
+    }
+  })
+
+  it('marks the native OpenAI preset as supporting input moderation', () => {
+    const openaiPreset = OPENAI_COMPATIBLE_PRESETS.find((preset) => preset.id === 'openai')
+    expect(openaiPreset).toBeDefined()
+    const provider = createOpenAICompatibleProvider(openaiPreset!)
+    expect(provider.supportsInputModeration).toBe(true)
+  })
+
+  it('leaves OpenAI-compatible backends without moderation support', () => {
+    const provider = createOpenAICompatibleProvider(DEEPINFRA_PRESET)
+    expect(provider.supportsInputModeration).toBe(false)
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/model-factory.test.ts

@@ -1216,6 +1216,66 @@ describe('Phase 4a — tenantOverride, requestOverride, allowRuntimeOverride (re
   })
 })
 
+describe('createModelFactory — end-user safety identifier + moderation capability', () => {
+  // The shared makeProvider helper lists fields explicitly and does not carry
+  // the optional mapEndUserIdentifier / supportsInputModeration members, so we
+  // build providers inline here.
+  type IdentifierProvider = FakeProvider & {
+    mapEndUserIdentifier?: (identifier: string) => Record<string, unknown>
+    supportsInputModeration?: boolean
+  }
+  function makeIdentifierProvider(overrides: Partial<IdentifierProvider> = {}): IdentifierProvider {
+    return {
+      id: 'test-provider',
+      defaultModel: 'provider-default-model',
+      resolveApiKey: () => 'test-api-key',
+      createModel: (options) => ({ kind: 'fake-model', ...options }),
+      isConfigured: () => true,
+      ...overrides,
+    }
+  }
+
+  it('emits the provider-mapped providerOptions fragment when an identifier is supplied', () => {
+    const mapEndUserIdentifier = jest.fn((id: string) => ({ openai: { safetyIdentifier: id } }))
+    const provider = makeIdentifierProvider({ mapEndUserIdentifier, supportsInputModeration: true })
+    const factory = createModelFactory(fakeContainer, makeFactoryDeps(provider))
+    const resolution = factory.resolveModel({ endUserIdentifier: 'hashed-user' })
+    expect(mapEndUserIdentifier).toHaveBeenCalledWith('hashed-user')
+    expect(resolution.providerOptions).toEqual({ openai: { safetyIdentifier: 'hashed-user' } })
+    expect(resolution.supportsInputModeration).toBe(true)
+  })
+
+  it('forwards the identifier to the adapter createModel options', () => {
+    const createModel = jest.fn((options: { modelId: string; apiKey: string }) => ({ ...options }))
+    const provider = makeIdentifierProvider({
+      createModel,
+      mapEndUserIdentifier: (id: string) => ({ openai: { safetyIdentifier: id } }),
+    })
+    const factory = createModelFactory(fakeContainer, makeFactoryDeps(provider))
+    factory.resolveModel({ endUserIdentifier: 'hashed-user' })
+    expect(createModel).toHaveBeenCalledWith(
+      expect.objectContaining({ endUserIdentifier: 'hashed-user' }),
+    )
+  })
+
+  it('omits providerOptions when no identifier is supplied', () => {
+    const mapEndUserIdentifier = jest.fn((id: string) => ({ openai: { safety_identifier: id } }))
+    const provider = makeIdentifierProvider({ mapEndUserIdentifier })
+    const factory = createModelFactory(fakeContainer, makeFactoryDeps(provider))
+    const resolution = factory.resolveModel({})
+    expect(mapEndUserIdentifier).not.toHaveBeenCalled()
+    expect(resolution.providerOptions).toBeUndefined()
+  })
+
+  it('omits providerOptions when the provider has no mapping, and reports moderation unsupported', () => {
+    const provider = makeIdentifierProvider()
+    const factory = createModelFactory(fakeContainer, makeFactoryDeps(provider))
+    const resolution = factory.resolveModel({ endUserIdentifier: 'hashed-user' })
+    expect(resolution.providerOptions).toBeUndefined()
+    expect(resolution.supportsInputModeration).toBe(false)
+  })
+})
+
 describe('createModelFactory — vendor-prefix gateways', () => {
   function gatewayProviders(
     overrides: { openrouterConfigured?: boolean } = {},

package/src/modules/ai_assistant/lib/__tests__/moderation-flag-recorder.test.ts

@@ -0,0 +1,76 @@
+import type { AwilixContainer } from 'awilix'
+
+const createMock = jest.fn()
+const emitMock = jest.fn()
+
+jest.mock('../../events', () => ({
+  emitAiAssistantEvent: (...args: unknown[]) => emitMock(...args),
+}))
+jest.mock('../../data/repositories/AiModerationFlagRepository', () => ({
+  AiModerationFlagRepository: jest.fn().mockImplementation(() => ({ create: createMock })),
+}))
+
+import { recordModerationFlag } from '../moderation-flag-recorder'
+
+function fakeContainer(): AwilixContainer {
+  return {
+    resolve: () => ({ fork: () => ({}) }),
+  } as unknown as AwilixContainer
+}
+
+const baseInput = {
+  tenantId: 'tenant-1',
+  organizationId: 'org-1',
+  agentId: 'customers.account_assistant',
+  userId: 'user-1',
+  providerId: 'openai',
+  modelId: 'gpt-5-mini',
+  categories: {
+    hate: { flagged: true, score: 0.97 },
+    violence: { flagged: false, score: 0.01 },
+  },
+}
+
+describe('recordModerationFlag', () => {
+  beforeEach(() => {
+    createMock.mockReset()
+    emitMock.mockReset()
+    createMock.mockResolvedValue({ id: 'flag-1' })
+    emitMock.mockResolvedValue(undefined)
+  })
+
+  it('persists the audit row and emits the event with only flagged categories', async () => {
+    await recordModerationFlag(baseInput, fakeContainer())
+    expect(createMock).toHaveBeenCalledWith(
+      expect.objectContaining({ tenantId: 'tenant-1', agentId: 'customers.account_assistant', providerId: 'openai' }),
+    )
+    expect(emitMock).toHaveBeenCalledWith(
+      'ai_assistant.moderation_flag.created',
+      expect.objectContaining({ id: 'flag-1', tenantId: 'tenant-1', categories: ['hate'] }),
+    )
+  })
+
+  it('skips entirely when tenantId is null (cannot tenant-scope the audit row)', async () => {
+    await recordModerationFlag({ ...baseInput, tenantId: null }, fakeContainer())
+    expect(createMock).not.toHaveBeenCalled()
+    expect(emitMock).not.toHaveBeenCalled()
+  })
+
+  it('skips when no container is available', async () => {
+    await recordModerationFlag(baseInput, undefined)
+    expect(createMock).not.toHaveBeenCalled()
+    expect(emitMock).not.toHaveBeenCalled()
+  })
+
+  it('swallows a persistence failure (never throws) and does not emit', async () => {
+    createMock.mockRejectedValue(new Error('db down'))
+    await expect(recordModerationFlag(baseInput, fakeContainer())).resolves.toBeUndefined()
+    expect(emitMock).not.toHaveBeenCalled()
+  })
+
+  it('swallows an emit failure after a successful persist (never throws)', async () => {
+    emitMock.mockRejectedValue(new Error('bus down'))
+    await expect(recordModerationFlag(baseInput, fakeContainer())).resolves.toBeUndefined()
+    expect(createMock).toHaveBeenCalledTimes(1)
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/moderation-policy.test.ts

@@ -0,0 +1,86 @@
+import {
+  isModerationActive,
+  resolveModerationPolicy,
+  shouldFailClosed,
+} from '../moderation-policy'
+
+describe('resolveModerationPolicy — 5-step precedence', () => {
+  it('1. untrustedInput wins over everything → enforced', () => {
+    expect(
+      resolveModerationPolicy({
+        untrustedInput: true,
+        perAgentOverride: false,
+        tenantWideOverride: false,
+        env: { OM_AI_INPUT_MODERATION: 'false' },
+      }),
+    ).toBe('enforced')
+  })
+
+  it('2. per-agent override wins over tenant-wide + env', () => {
+    expect(
+      resolveModerationPolicy({
+        perAgentOverride: true,
+        tenantWideOverride: false,
+        env: { OM_AI_INPUT_MODERATION: 'false' },
+      }),
+    ).toBe('on')
+    expect(
+      resolveModerationPolicy({
+        perAgentOverride: false,
+        tenantWideOverride: true,
+        env: { OM_AI_INPUT_MODERATION: 'true' },
+      }),
+    ).toBe('off')
+  })
+
+  it('3. tenant-wide override wins over env when per-agent is inherit', () => {
+    expect(
+      resolveModerationPolicy({
+        perAgentOverride: null,
+        tenantWideOverride: true,
+        env: { OM_AI_INPUT_MODERATION: 'false' },
+      }),
+    ).toBe('on')
+    expect(
+      resolveModerationPolicy({
+        perAgentOverride: undefined,
+        tenantWideOverride: false,
+        env: { OM_AI_INPUT_MODERATION: 'true' },
+      }),
+    ).toBe('off')
+  })
+
+  it('4. env default applies when both overrides inherit', () => {
+    expect(
+      resolveModerationPolicy({ perAgentOverride: null, tenantWideOverride: null, env: { OM_AI_INPUT_MODERATION: 'true' } }),
+    ).toBe('on')
+    expect(
+      resolveModerationPolicy({ env: { OM_AI_INPUT_MODERATION: '1' } }),
+    ).toBe('on')
+  })
+
+  it('5. defaults to off when nothing is set', () => {
+    expect(resolveModerationPolicy({ env: {} })).toBe('off')
+    expect(resolveModerationPolicy({ perAgentOverride: null, tenantWideOverride: null, env: {} })).toBe('off')
+  })
+
+  it('treats untrustedInput=false the same as unset (falls through)', () => {
+    expect(
+      resolveModerationPolicy({ untrustedInput: false, tenantWideOverride: true, env: {} }),
+    ).toBe('on')
+  })
+})
+
+describe('moderation policy helpers', () => {
+  it('isModerationActive is true for enforced and on, false for off', () => {
+    expect(isModerationActive('enforced')).toBe(true)
+    expect(isModerationActive('on')).toBe(true)
+    expect(isModerationActive('off')).toBe(false)
+  })
+
+  it('shouldFailClosed is true only for enforced (opt-in on fails open)', () => {
+    expect(shouldFailClosed('enforced')).toBe(true)
+    expect(shouldFailClosed('on')).toBe(false)
+    expect(shouldFailClosed('off')).toBe(false)
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/moderation.test.ts

@@ -0,0 +1,114 @@
+import {
+  AiModerationUnavailableError,
+  createModerationService,
+  DEFAULT_MODERATION_MODEL,
+} from '../moderation'
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  } as unknown as Response
+}
+
+function moderationBody(flagged: boolean): unknown {
+  return {
+    results: [
+      {
+        flagged,
+        categories: { hate: flagged, violence: false },
+        category_scores: { hate: flagged ? 0.97 : 0.01, violence: 0.002 },
+      },
+    ],
+  }
+}
+
+describe('createModerationService.checkInput', () => {
+  const service = createModerationService()
+  let fetchSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    fetchSpy = jest.spyOn(globalThis, 'fetch')
+  })
+  afterEach(() => {
+    fetchSpy.mockRestore()
+  })
+
+  it('returns flagged=false with mapped categories for clean input', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse(moderationBody(false)))
+    const result = await service.checkInput({ text: 'hello', apiKey: 'sk-test' })
+    expect(result.flagged).toBe(false)
+    expect(result.categories.hate).toEqual({ flagged: false, score: 0.01 })
+    expect(result.categories.violence).toEqual({ flagged: false, score: 0.002 })
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns flagged=true with category flags + scores for flagged input', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse(moderationBody(true)))
+    const result = await service.checkInput({ text: 'bad', apiKey: 'sk-test' })
+    expect(result.flagged).toBe(true)
+    expect(result.categories.hate).toEqual({ flagged: true, score: 0.97 })
+  })
+
+  it('sends the configured model + base URL and bearer auth', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse(moderationBody(false)))
+    await service.checkInput({
+      text: 'hi',
+      apiKey: 'sk-secret',
+      baseURL: 'https://proxy.example.com/v1/',
+      model: 'omni-moderation-2026',
+    })
+    const [url, init] = fetchSpy.mock.calls[0] as [string, RequestInit]
+    expect(url).toBe('https://proxy.example.com/v1/moderations')
+    expect((init.headers as Record<string, string>).Authorization).toBe('Bearer sk-secret')
+    expect(JSON.parse(init.body as string)).toEqual({ model: 'omni-moderation-2026', input: 'hi' })
+  })
+
+  it('defaults to omni-moderation-latest when no model is supplied', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse(moderationBody(false)))
+    await service.checkInput({ text: 'hi', apiKey: 'sk-test' })
+    const init = fetchSpy.mock.calls[0][1] as RequestInit
+    expect(JSON.parse(init.body as string).model).toBe(DEFAULT_MODERATION_MODEL)
+  })
+
+  it('retries once on a 5xx and succeeds', async () => {
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse({ error: 'boom' }, 503))
+      .mockResolvedValueOnce(jsonResponse(moderationBody(false)))
+    const result = await service.checkInput({ text: 'hi', apiKey: 'sk-test' })
+    expect(result.flagged).toBe(false)
+    expect(fetchSpy).toHaveBeenCalledTimes(2)
+  })
+
+  it('throws AiModerationUnavailableError after a 5xx on both attempts', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ error: 'boom' }, 500))
+    await expect(service.checkInput({ text: 'hi', apiKey: 'sk-test' })).rejects.toBeInstanceOf(
+      AiModerationUnavailableError,
+    )
+    expect(fetchSpy).toHaveBeenCalledTimes(2)
+  })
+
+  it('throws AiModerationUnavailableError on repeated network/timeout errors', async () => {
+    fetchSpy.mockRejectedValue(new Error('AbortError: timed out'))
+    await expect(service.checkInput({ text: 'hi', apiKey: 'sk-test' })).rejects.toBeInstanceOf(
+      AiModerationUnavailableError,
+    )
+    expect(fetchSpy).toHaveBeenCalledTimes(2)
+  })
+
+  it('does not retry a 4xx (credential/config error) and fails closed', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ error: 'unauthorized' }, 401))
+    await expect(service.checkInput({ text: 'hi', apiKey: 'bad' })).rejects.toBeInstanceOf(
+      AiModerationUnavailableError,
+    )
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('throws AiModerationUnavailableError when the response schema is unexpected', async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ unexpected: true }))
+    await expect(service.checkInput({ text: 'hi', apiKey: 'sk-test' })).rejects.toBeInstanceOf(
+      AiModerationUnavailableError,
+    )
+  })
+})