@open-mercato/ai-assistant 0.6.1-develop.3291.1.6fad645fd0 → 0.6.1

package/src/modules/ai_assistant/__integration__/TC-AI-TOKEN-USAGE-001-005.spec.ts

@@ -0,0 +1,231 @@
+import { test, expect } from '@playwright/test';
+import { login } from '@open-mercato/core/modules/core/__integration__/helpers/auth';
+
+/**
+ * TC-AI-TOKEN-USAGE-001 through TC-AI-TOKEN-USAGE-005
+ *
+ * Integration coverage for Phase 6 (Token Usage Tracking & Stats Page) of
+ * spec `2026-04-28-ai-agents-agentic-loop-controls`.
+ *
+ * TC-AI-TOKEN-USAGE-001 — Usage page loads and renders summary tiles (ACL gate).
+ * TC-AI-TOKEN-USAGE-002 — Date filter apply re-fetches with updated params.
+ * TC-AI-TOKEN-USAGE-003 — Sessions list renders when API returns session rows.
+ * TC-AI-TOKEN-USAGE-004 — Clicking a session row opens the detail dialog.
+ * TC-AI-TOKEN-USAGE-005 — Unauthenticated visit to usage page redirects to login.
+ *
+ * All API calls are intercepted via page.route() stubs — no real DB needed.
+ */
+
+const USAGE_PAGE = '/backend/config/ai-assistant/usage';
+
+const EMPTY_DAILY_PAYLOAD = { rows: [], total: 0 };
+const EMPTY_SESSIONS_PAYLOAD = { sessions: [], total: 0, limit: 50, offset: 0 };
+
+const DAILY_ROW = {
+  id: 'row-1',
+  tenantId: 'tenant-1',
+  organizationId: null,
+  day: '2026-05-01',
+  agentId: 'catalog.assistant',
+  modelId: 'claude-haiku-4-5',
+  providerId: 'anthropic',
+  inputTokens: '1000',
+  outputTokens: '500',
+  cachedInputTokens: '0',
+  reasoningTokens: '0',
+  stepCount: '5',
+  turnCount: '3',
+  sessionCount: '2',
+  createdAt: '2026-05-01T12:00:00.000Z',
+  updatedAt: '2026-05-01T12:00:00.000Z',
+};
+
+const SESSION_ROW = {
+  sessionId: '00000000-0000-0000-0000-000000000001',
+  agentId: 'catalog.assistant',
+  moduleId: 'catalog',
+  userId: 'user-1',
+  startedAt: '2026-05-01T10:00:00.000Z',
+  lastEventAt: '2026-05-01T10:05:00.000Z',
+  stepCount: 5,
+  turnCount: 3,
+  inputTokens: 1000,
+  outputTokens: 500,
+  cachedInputTokens: 0,
+  reasoningTokens: 0,
+};
+
+const STEP_EVENT = {
+  id: 'evt-1',
+  tenantId: 'tenant-1',
+  organizationId: null,
+  userId: 'user-1',
+  agentId: 'catalog.assistant',
+  moduleId: 'catalog',
+  sessionId: '00000000-0000-0000-0000-000000000001',
+  turnId: '00000000-0000-0000-0000-000000000002',
+  stepIndex: 0,
+  providerId: 'anthropic',
+  modelId: 'claude-haiku-4-5',
+  inputTokens: 1000,
+  outputTokens: 500,
+  cachedInputTokens: null,
+  reasoningTokens: null,
+  finishReason: 'stop',
+  loopAbortReason: null,
+  createdAt: '2026-05-01T10:00:00.000Z',
+  updatedAt: '2026-05-01T10:00:00.000Z',
+};
+
+test.describe('TC-AI-TOKEN-USAGE-001–005: token usage stats page', () => {
+  test('TC-AI-TOKEN-USAGE-001: usage page renders summary tiles for superadmin', async ({ page }) => {
+    await login(page, 'superadmin');
+
+    await page.route('**/api/ai_assistant/usage/daily**', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ rows: [DAILY_ROW], total: 1 }),
+      });
+    });
+
+    await page.route('**/api/ai_assistant/usage/sessions**', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(EMPTY_SESSIONS_PAYLOAD),
+      });
+    });
+
+    await page.goto(USAGE_PAGE, { waitUntil: 'domcontentloaded' });
+
+    const summaryTile = page.locator('p.font-semibold.text-xl', { hasText: /^(1,000|500)$/ }).first();
+    await expect(summaryTile).toBeVisible({ timeout: 15_000 });
+  });
+
+  test('TC-AI-TOKEN-USAGE-002: apply filter triggers re-fetch with new date params', async ({ page }) => {
+    await login(page, 'superadmin');
+
+    const fetchedUrls: string[] = [];
+
+    await page.route('**/api/ai_assistant/usage/daily**', async (route) => {
+      fetchedUrls.push(route.request().url());
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(EMPTY_DAILY_PAYLOAD),
+      });
+    });
+
+    await page.route('**/api/ai_assistant/usage/sessions**', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(EMPTY_SESSIONS_PAYLOAD),
+      });
+    });
+
+    await page.goto(USAGE_PAGE, { waitUntil: 'domcontentloaded' });
+
+    const fromInput = page.locator('#usage-from');
+    const toInput = page.locator('#usage-to');
+    const applyButton = page.getByRole('button', { name: /apply/i });
+
+    await expect(fromInput).toBeVisible({ timeout: 10_000 });
+
+    await fromInput.fill('2026-04-01');
+    await toInput.fill('2026-04-30');
+    await applyButton.click();
+
+    await page.waitForTimeout(500);
+
+    const hasNewDates = fetchedUrls.some((url) => url.includes('from=2026-04-01'));
+    expect(hasNewDates).toBe(true);
+  });
+
+  test('TC-AI-TOKEN-USAGE-003: sessions list renders rows when API returns sessions', async ({ page }) => {
+    await login(page, 'superadmin');
+
+    await page.route('**/api/ai_assistant/usage/daily**', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(EMPTY_DAILY_PAYLOAD),
+      });
+    });
+
+    await page.route('**/api/ai_assistant/usage/sessions**', async (route, request) => {
+      if (request.url().includes('/sessions/')) {
+        await route.continue();
+        return;
+      }
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ sessions: [SESSION_ROW], total: 1, limit: 50, offset: 0 }),
+      });
+    });
+
+    await page.goto(USAGE_PAGE, { waitUntil: 'domcontentloaded' });
+
+    const sessionCell = page.getByText('00000000').first();
+    await expect(sessionCell).toBeVisible({ timeout: 15_000 });
+  });
+
+  test('TC-AI-TOKEN-USAGE-004: clicking a session row opens the detail dialog', async ({ page }) => {
+    await login(page, 'superadmin');
+
+    await page.route('**/api/ai_assistant/usage/daily**', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(EMPTY_DAILY_PAYLOAD),
+      });
+    });
+
+    await page.route('**/api/ai_assistant/usage/sessions/00000000-0000-0000-0000-000000000001', async (route) => {
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ events: [STEP_EVENT], total: 1, sessionId: SESSION_ROW.sessionId }),
+      });
+    });
+
+    await page.route('**/api/ai_assistant/usage/sessions**', async (route, request) => {
+      if (request.url().includes('/00000000-0000-0000-0000-000000000001')) {
+        // Fall back to the previously registered (more specific) handler.
+        await route.fallback();
+        return;
+      }
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ sessions: [SESSION_ROW], total: 1, limit: 50, offset: 0 }),
+      });
+    });
+
+    await page.goto(USAGE_PAGE, { waitUntil: 'domcontentloaded' });
+
+    const sessionCell = page.getByText('00000000').first();
+    await expect(sessionCell).toBeVisible({ timeout: 15_000 });
+    await sessionCell.click();
+
+    const dialogTitle = page.getByRole('dialog');
+    await expect(dialogTitle).toBeVisible({ timeout: 10_000 });
+
+    const modelCell = page.getByText('claude-haiku-4-5').first();
+    await expect(modelCell).toBeVisible({ timeout: 5_000 });
+  });
+
+  test('TC-AI-TOKEN-USAGE-005: unauthenticated visit redirects to login', async ({ browser }) => {
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    try {
+      await page.goto(USAGE_PAGE, { waitUntil: 'domcontentloaded' });
+      await page.waitForURL(/\/login/, { timeout: 15_000 });
+      expect(page.url()).toMatch(/\/login/);
+    } finally {
+      await context.close();
+    }
+  });
+});

package/src/modules/ai_assistant/__tests__/events.test.ts

@@ -29,12 +29,13 @@ const FROZEN_EVENT_IDS: ReadonlyArray<AiAssistantEventId> = [
 describe('ai_assistant events module', () => {
   it('declares the three FROZEN pending-action events under moduleId=ai_assistant', () => {
     expect(eventsConfig.moduleId).toBe('ai_assistant')
-    const declaredIds = eventsConfig.events.map((event) => event.id).sort()
-    expect(declaredIds).toEqual([...FROZEN_EVENT_IDS].sort())
+    const declaredIds = eventsConfig.events.map((event) => event.id)
+    expect(declaredIds).toEqual(expect.arrayContaining([...FROZEN_EVENT_IDS]))
   })
 
-  it('every declared event has category=system and entity=ai_pending_action', () => {
+  it('every FROZEN pending-action event has category=system and entity=ai_pending_action', () => {
     for (const event of eventsConfig.events) {
+      if (!FROZEN_EVENT_IDS.includes(event.id as AiAssistantEventId)) continue
       expect(event.category).toBe('system')
       expect(event.entity).toBe('ai_pending_action')
       expect(event.module).toBe('ai_assistant')

package/src/modules/ai_assistant/__tests__/settings-page-logic.test.ts

@@ -10,7 +10,7 @@
 type AgentResolution = {
   agentId: string
   moduleId: string
-  allowRuntimeModelOverride: boolean
+  allowRuntimeOverride: boolean
   providerId: string
   modelId: string
   baseURL: string | null
@@ -30,7 +30,7 @@ describe('AiAssistantSettingsPageClient — per-agent override detection', () =>
   const baseAgent: Omit<AgentResolution, 'source'> = {
     agentId: 'catalog.merchandising_assistant',
     moduleId: 'catalog',
-    allowRuntimeModelOverride: true,
+    allowRuntimeOverride: true,
     providerId: 'anthropic',
     modelId: 'claude-haiku-4-5',
     baseURL: null,
@@ -66,7 +66,7 @@ describe('AiAssistantSettingsPageClient — resolution table filtering', () => {
     {
       agentId: 'catalog.catalog_assistant',
       moduleId: 'catalog',
-      allowRuntimeModelOverride: true,
+      allowRuntimeOverride: true,
       providerId: 'anthropic',
       modelId: 'claude-haiku-4-5',
       baseURL: null,
@@ -75,7 +75,7 @@ describe('AiAssistantSettingsPageClient — resolution table filtering', () => {
     {
       agentId: 'catalog.merchandising_assistant',
       moduleId: 'catalog',
-      allowRuntimeModelOverride: true,
+      allowRuntimeOverride: true,
       providerId: 'openai',
       modelId: 'gpt-4o',
       baseURL: null,
@@ -84,7 +84,7 @@ describe('AiAssistantSettingsPageClient — resolution table filtering', () => {
     {
       agentId: 'customers.account_assistant',
       moduleId: 'customers',
-      allowRuntimeModelOverride: false,
+      allowRuntimeOverride: false,
       providerId: 'anthropic',
       modelId: 'claude-haiku-4-5',
       baseURL: null,

package/src/modules/ai_assistant/__tests__/token-usage-recorder.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Unit tests for the token-usage recorder (R12 compliance).
+ *
+ * Verifies that `recordTokenUsage` never throws regardless of DB/emit failures,
+ * and that a missing `tenantId` causes an early return without writing anything.
+ *
+ * Phase 6.3 of spec `2026-04-28-ai-agents-agentic-loop-controls`.
+ */
+
+import { recordTokenUsage, type RecordTokenUsageInput } from '../lib/token-usage-recorder'
+import type { AwilixContainer } from 'awilix'
+
+function makeInput(overrides: Partial<RecordTokenUsageInput> = {}): RecordTokenUsageInput {
+  return {
+    authContext: {
+      tenantId: 'tenant-1',
+      organizationId: null,
+      userId: 'user-1',
+    },
+    agentId: 'catalog.assistant',
+    moduleId: 'catalog',
+    sessionId: '00000000-0000-0000-0000-000000000001',
+    turnId: '00000000-0000-0000-0000-000000000002',
+    stepIndex: 0,
+    providerId: 'anthropic',
+    modelId: 'claude-haiku-4-5',
+    usage: {
+      inputTokens: 100,
+      outputTokens: 50,
+    },
+    ...overrides,
+  }
+}
+
+function makeContainer(options: {
+  createEventThrows?: boolean
+  upsertDailyThrows?: boolean
+}): AwilixContainer {
+  const createEvent = jest.fn(async () => {
+    if (options.createEventThrows) throw new Error('DB write failed')
+    return {}
+  })
+  const upsertDaily = jest.fn(async () => {
+    if (options.upsertDailyThrows) throw new Error('Upsert failed')
+  })
+
+  const repoInstance = { createEvent, upsertDaily }
+
+  const em = {
+    fork: () => em,
+  }
+
+  const container: Partial<AwilixContainer> = {
+    resolve: (name: string) => {
+      if (name === 'em') return em as unknown as ReturnType<AwilixContainer['resolve']>
+      throw new Error(`Unknown token: ${name}`)
+    },
+  }
+
+  jest.mock('../data/repositories/AiTokenUsageRepository', () => ({
+    AiTokenUsageRepository: jest.fn().mockImplementation(() => repoInstance),
+  }))
+
+  return container as AwilixContainer
+}
+
+describe('recordTokenUsage — R12 compliance', () => {
+  beforeEach(() => {
+    jest.resetModules()
+    jest.clearAllMocks()
+  })
+
+  it('never throws when createEvent throws', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const input = makeInput()
+    const container = makeContainer({ createEventThrows: true })
+    await expect(recordTokenUsage(input, container)).resolves.toBeUndefined()
+    warnSpy.mockRestore()
+  })
+
+  it('never throws when upsertDaily throws', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const input = makeInput()
+    const container = makeContainer({ upsertDailyThrows: true })
+    await expect(recordTokenUsage(input, container)).resolves.toBeUndefined()
+    warnSpy.mockRestore()
+  })
+
+  it('logs a warn when DB write fails', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const input = makeInput()
+    const container = makeContainer({ createEventThrows: true })
+    await recordTokenUsage(input, container)
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[AI token-usage]'),
+      expect.anything(),
+    )
+    warnSpy.mockRestore()
+  })
+
+  it('returns immediately without writing when tenantId is falsy', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    const input = makeInput({ authContext: { tenantId: null, organizationId: null, userId: 'user-1' } })
+    const container = makeContainer({})
+    await expect(recordTokenUsage(input, container)).resolves.toBeUndefined()
+    expect(warnSpy).not.toHaveBeenCalled()
+    warnSpy.mockRestore()
+  })
+})