larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/lib/chat/data-export.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from 'vitest';
+import * as XLSX from 'xlsx';
+import { PDFDocument } from 'pdf-lib';
+import {
+  answerScopedDataExportSource,
+  createDataExport,
+  dataExportNeedsFreshData,
+  dataExportUsesAnswerText,
+  requestedDataExportFormat,
+  selectDataExportSource,
+} from './data-export';
+import { normalizeTableData, plainTableLabel } from './table-presentation';
+
+describe('chat data exports', () => {
+  it('recognizes direct file-format follow-ups without treating ordinary PDF questions as exports', () => {
+    expect(requestedDataExportFormat('Can you export this data in pdf format?')).toBe('pdf');
+    expect(requestedDataExportFormat('In excel table maybe?')).toBe('xlsx');
+    expect(requestedDataExportFormat('In an Excel table, please.')).toBe('xlsx');
+    expect(requestedDataExportFormat('What does the PDF say about renewal?')).toBeUndefined();
+    expect(
+      requestedDataExportFormat('Create a bar chart of totals from release-readiness.csv.'),
+    ).toBeUndefined();
+  });
+
+  it('distinguishes direct exports from requests that require fresh filtering', () => {
+    expect(dataExportNeedsFreshData('Can you create a PDF out of this list?')).toBe(false);
+    expect(
+      dataExportNeedsFreshData('This answer is good. Create a PDF with this last answer only.'),
+    ).toBe(false);
+    expect(dataExportNeedsFreshData('Export only rows where Country is Germany to Excel.')).toBe(
+      true,
+    );
+    expect(
+      dataExportNeedsFreshData('Give me a PDF with the 25 matches for those first 25 people.'),
+    ).toBe(true);
+  });
+
+  it('distinguishes an answer/list export from an authoritative table export', () => {
+    expect(dataExportUsesAnswerText('Create a PDF out of this list.')).toBe(true);
+    expect(dataExportUsesAnswerText('Export the last answer only.')).toBe(true);
+    expect(dataExportUsesAnswerText('Export this filtered data to Excel.')).toBe(false);
+    expect(dataExportUsesAnswerText('Download the results as a PDF.')).toBe(false);
+  });
+
+  it('removes markdown from headers while preserving distinct columns', () => {
+    expect(plainTableLabel('**Name**')).toBe('Name');
+    expect(
+      normalizeTableData(
+        ['**Name**', '__Name__', '`Organization`'],
+        [{ '**Name**': 'Ada', __Name__: 'Lovelace', '`Organization`': 'Analytical Engine' }],
+      ),
+    ).toEqual({
+      columns: ['Name', 'Name (2)', 'Organization'],
+      rows: [{ Name: 'Ada', 'Name (2)': 'Lovelace', Organization: 'Analytical Engine' }],
+    });
+  });
+
+  it('creates a real Excel workbook with clean answer headers', async () => {
+    const artifact = await createDataExport({
+      format: 'xlsx',
+      title: 'Participant answer',
+      columns: ['**Name**', '**Organization**'],
+      rows: [{ '**Name**': 'Ada Lovelace', '**Organization**': 'Analytical Engine' }],
+    });
+    const workbook = XLSX.read(Buffer.from(artifact.fileBase64, 'base64'));
+    const rows = XLSX.utils.sheet_to_json(workbook.Sheets.Answer!);
+    expect(artifact.fileName).toBe('Participant-answer.xlsx');
+    expect(rows).toEqual([{ Name: 'Ada Lovelace', Organization: 'Analytical Engine' }]);
+  });
+
+  it('creates a valid PDF artifact', async () => {
+    const artifact = await createDataExport({
+      format: 'pdf',
+      title: 'Participant answer',
+      columns: ['**Name**'],
+      rows: [{ '**Name**': 'Ada Lovelace' }],
+    });
+    expect(Buffer.from(artifact.fileBase64, 'base64').subarray(0, 5).toString()).toBe('%PDF-');
+  });
+
+  it('keeps a long answer cell across multiple PDF pages instead of truncating it', async () => {
+    const artifact = await createDataExport({
+      format: 'pdf',
+      title: 'Complete answer',
+      columns: ['Answer'],
+      rows: [{ Answer: Array.from({ length: 1_000 }, (_, index) => `detail-${index}`).join(' ') }],
+    });
+    const document = await PDFDocument.load(Buffer.from(artifact.fileBase64, 'base64'));
+    expect(document.getPageCount()).toBeGreaterThan(1);
+    expect(artifact.rowCount).toBe(1);
+  });
+
+  it('exports only rows explicitly included in the answer', () => {
+    const source = answerScopedDataExportSource({
+      table: {
+        columns: ['University', 'Cost'],
+        rows: Array.from({ length: 100 }, (_, index) => ({
+          University: `Campus ${index + 1}`,
+          Cost: index + 1,
+        })),
+      },
+      answerText: 'The relevant results are Campus 4 and Campus 19.',
+    });
+
+    expect(source?.rows).toEqual([
+      { University: 'Campus 4', Cost: 4 },
+      { University: 'Campus 19', Cost: 19 },
+    ]);
+  });
+
+  it('uses the exact Markdown table rendered in an answer', () => {
+    const source = answerScopedDataExportSource({
+      table: {
+        columns: ['University', 'Cost'],
+        rows: Array.from({ length: 100 }, (_, index) => ({
+          University: `Campus ${index + 1}`,
+          Cost: index + 1,
+        })),
+      },
+      answerText: [
+        'Here are the requested rows:',
+        '',
+        '| University | Cost |',
+        '| --- | ---: |',
+        '| Campus 8 | €8m |',
+        '| Campus 11 | €11m |',
+      ].join('\n'),
+    });
+
+    expect(source).toEqual({
+      columns: ['University', 'Cost'],
+      rows: [
+        { University: 'Campus 8', Cost: '€8m' },
+        { University: 'Campus 11', Cost: '€11m' },
+      ],
+    });
+  });
+
+  it('exports every section of a rendered matching list as its own row', async () => {
+    const answer = Array.from({ length: 25 }, (_, index) =>
+      [
+        `**Person ${index + 1}**`,
+        `Needs: Topic ${index + 1}`,
+        '',
+        `- Match A${index + 1} - relevant expertise`,
+        `- Match B${index + 1} - complementary experience`,
+      ].join('\n'),
+    ).join('\n\n---\n\n');
+
+    const source = answerScopedDataExportSource({ answerText: answer });
+    expect(source?.rows).toHaveLength(25);
+    expect(source?.rows[0]).toEqual({
+      Answer:
+        'Person 1\nNeeds: Topic 1\n\n- Match A1 - relevant expertise\n- Match B1 - complementary experience',
+    });
+    expect(source?.rows[24].Answer).toContain('Person 25');
+
+    const spreadsheet = await createDataExport({
+      format: 'xlsx',
+      title: 'Matches',
+      ...source!,
+    });
+    const workbook = XLSX.read(Buffer.from(spreadsheet.fileBase64, 'base64'));
+    expect(XLSX.utils.sheet_to_json(workbook.Sheets.Answer!)).toHaveLength(25);
+
+    const pdf = await createDataExport({ format: 'pdf', title: 'Matches', ...source! });
+    expect(pdf.rowCount).toBe(25);
+  });
+
+  it('falls back to the complete bounded query result instead of an arbitrary first page', async () => {
+    const source = answerScopedDataExportSource({
+      table: {
+        columns: ['University', 'Cost'],
+        rows: Array.from({ length: 100 }, (_, index) => ({
+          University: `Campus ${index + 1}`,
+          Cost: index + 1,
+        })),
+      },
+      answerText: 'These are the strongest results from the analysis.',
+    });
+    expect(source?.rows).toHaveLength(100);
+
+    const csv = await createDataExport({ format: 'csv', title: 'Answer', ...source! });
+    const csvLines = Buffer.from(csv.fileBase64, 'base64')
+      .toString('utf8')
+      .replace(/^\uFEFF/, '')
+      .split('\r\n');
+    expect(csv.rowCount).toBe(100);
+    expect(csvLines).toHaveLength(101);
+
+    const pdf = await createDataExport({ format: 'pdf', title: 'Answer', ...source! });
+    expect(pdf.rowCount).toBe(100);
+    expect(Buffer.from(pdf.fileBase64, 'base64').subarray(0, 5).toString()).toBe('%PDF-');
+  });
+
+  it('prefers authoritative current-turn data over model-copied or previous rows', () => {
+    expect(
+      selectDataExportSource({
+        currentTurnTable: {
+          columns: ['Value'],
+          rows: [{ Value: 'current 1' }, { Value: 'current 2' }],
+        },
+        explicitTable: { columns: ['Value'], rows: [{ Value: 'current 1' }] },
+        recentTable: { columns: ['Value'], rows: [{ Value: 'previous' }] },
+      }),
+    ).toEqual({
+      columns: ['Value'],
+      rows: [{ Value: 'current 1' }, { Value: 'current 2' }],
+    });
+    expect(
+      selectDataExportSource({
+        currentTurnTable: { columns: ['Value'], rows: [{ Value: 'current' }] },
+        recentTable: { columns: ['Value'], rows: [{ Value: 'previous' }] },
+      }),
+    ).toEqual({ columns: ['Value'], rows: [{ Value: 'current' }] });
+  });
+
+  it('exports a non-tabular answer as one answer row', () => {
+    expect(answerScopedDataExportSource({ answerText: 'The renewal date is 1 January.' })).toEqual({
+      columns: ['Answer'],
+      rows: [{ Answer: 'The renewal date is 1 January.' }],
+    });
+  });
+});

package/.next/standalone/apps/web/lib/chat/live-tool-progress.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import {
+  isIndeterminateProgress,
+  keepToolProgressMonotonic,
+  PENDING_PROGRESS_CEILING,
+  RUNNING_PROGRESS_CEILING,
+  smoothLiveToolProgress,
+  smoothPendingToolProgress,
+} from './live-tool-progress';
+
+describe('smoothLiveToolProgress', () => {
+  it('keeps an analyzing bar moving between sparse cloud updates', () => {
+    const activity = {
+      phase: 'analyzing' as const,
+      percent: 5,
+      label: 'Video Intelligence',
+      message: 'Perceiving',
+      updatedAt: '2026-08-30T12:00:00.000Z',
+    };
+    expect(smoothLiveToolProgress(activity, Date.parse(activity.updatedAt))).toBe(5);
+    expect(
+      smoothLiveToolProgress(activity, Date.parse(activity.updatedAt) + 60_000),
+    ).toBeGreaterThan(5);
+    expect(smoothLiveToolProgress(activity, Date.parse(activity.updatedAt) + 60_000)).toBeLessThan(
+      RUNNING_PROGRESS_CEILING,
+    );
+  });
+
+  it('never fabricates completion before the worker reports it', () => {
+    const activity = {
+      phase: 'analyzing' as const,
+      percent: 5,
+      label: 'Video Intelligence',
+      message: 'Perceiving',
+      updatedAt: '2026-08-30T12:00:00.000Z',
+    };
+    expect(
+      smoothLiveToolProgress(activity, Date.parse(activity.updatedAt) + 20 * 60_000),
+    ).toBeLessThanOrEqual(RUNNING_PROGRESS_CEILING);
+  });
+
+  // The worker reports 100 when its own pass ends, but the chat turn still has
+  // to validate, store, activate and re-query that evidence -- and may then run
+  // another range. A full bar through all of that is what read as hung.
+  it('does not show a completed bar while the tool call is still running', () => {
+    const finished = {
+      phase: 'analyzing' as const,
+      percent: 100,
+      label: 'Video Intelligence',
+      message: 'Composing',
+      updatedAt: '2026-08-30T12:00:00.000Z',
+    };
+    expect(smoothLiveToolProgress(finished, Date.now())).toBe(RUNNING_PROGRESS_CEILING);
+    expect(keepToolProgressMonotonic(100, 100)).toBe(RUNNING_PROGRESS_CEILING);
+  });
+
+  it('does not rewind when the same chat call begins its next bounded range', () => {
+    expect(keepToolProgressMonotonic(42, 5)).toBe(42);
+    expect(keepToolProgressMonotonic(42, 53)).toBe(53);
+  });
+
+  it('switches to an indeterminate bar once the remaining work has no size', () => {
+    expect(isIndeterminateProgress(40)).toBe(false);
+    expect(isIndeterminateProgress(89)).toBe(false);
+    expect(isIndeterminateProgress(RUNNING_PROGRESS_CEILING)).toBe(true);
+  });
+
+  it('moves a tool bar before worker telemetry exists without claiming completion', () => {
+    const startedAt = Date.parse('2026-08-30T12:00:00.000Z');
+    expect(smoothPendingToolProgress(startedAt, startedAt)).toBe(4);
+    expect(smoothPendingToolProgress(startedAt, startedAt + 2_000)).toBeGreaterThan(4);
+    expect(smoothPendingToolProgress(startedAt, startedAt + 20 * 60_000)).toBeLessThanOrEqual(
+      PENDING_PROGRESS_CEILING,
+    );
+  });
+});

package/.next/standalone/apps/web/lib/chat/live-tool-progress.ts

@@ -0,0 +1,69 @@
+export type LiveToolActivity = {
+  toolCallId?: string;
+  phase?: 'waking-up' | 'analyzing';
+  percent: number;
+  label: string;
+  message: string;
+  startedAt?: string;
+  updatedAt?: string;
+};
+
+/**
+ * A worker reports 100% when *its* pass is done, but the chat turn is not:
+ * the evidence still has to be validated, stored, activated, and re-queried,
+ * and a second range may follow. Showing a full bar through all of that reads
+ * as a hang, so a running tool call never displays a completed bar -- the row
+ * disappears when the call actually returns.
+ */
+export const RUNNING_PROGRESS_CEILING = 97;
+
+/** Past this the bar stops claiming a position and just shows motion. */
+export const INDETERMINATE_THRESHOLD = 90;
+
+/** A tool can be working through local indexed context before a worker exists. */
+export const PENDING_PROGRESS_CEILING = 82;
+
+/**
+ * Give every executing tool visible motion immediately, even before it has a
+ * worker percentage to report. This is deliberately time-based UX, not a
+ * completion estimate; authoritative activity replaces it as soon as one is
+ * available and only the tool result removes the row.
+ */
+export function smoothPendingToolProgress(startedAt: number, now = Date.now()) {
+  const elapsedMs = Math.max(0, now - startedAt);
+  const initial = 4;
+  const estimated =
+    initial + (PENDING_PROGRESS_CEILING - initial) * (1 - Math.exp(-elapsedMs / 55_000));
+  return Math.max(initial, Math.min(PENDING_PROGRESS_CEILING, estimated));
+}
+
+/**
+ * Cloud workers publish real stage boundaries, not a progress event for every
+ * second of GPU work. Keep the bar alive between those events without
+ * pretending the job is complete: the estimate asymptotically approaches a
+ * pre-completion ceiling and an actual worker update always wins.
+ */
+export function smoothLiveToolProgress(activity: LiveToolActivity, now = Date.now()) {
+  const reported = Math.max(0, Math.min(RUNNING_PROGRESS_CEILING, activity.percent));
+  const changedAt = Date.parse(activity.updatedAt ?? activity.startedAt ?? '');
+  if (!Number.isFinite(changedAt)) return reported;
+  const elapsedMs = Math.max(0, now - changedAt);
+  const ceiling = activity.phase === 'waking-up' ? 28 : RUNNING_PROGRESS_CEILING;
+  if (reported >= ceiling) return reported;
+  const estimated = reported + (ceiling - reported) * (1 - Math.exp(-elapsedMs / 75_000));
+  return Math.round(Math.max(reported, Math.min(ceiling, estimated)));
+}
+
+/** A consecutive bounded source read belongs to the same chat tool call. */
+export function keepToolProgressMonotonic(previous: number | undefined, current: number) {
+  return Math.min(RUNNING_PROGRESS_CEILING, Math.max(previous ?? 0, current));
+}
+
+/**
+ * Near the ceiling the remaining work has no measurable position -- the bar
+ * would sit still while real work continues. Swing it instead: motion without
+ * a false claim about how much is left.
+ */
+export function isIndeterminateProgress(percent: number) {
+  return percent >= INDETERMINATE_THRESHOLD;
+}

package/.next/standalone/apps/web/lib/chat/media-retrieval-routing.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { explicitMediaEvidenceAssetId, leadingMediaAssetId } from './media-retrieval-routing';
+
+describe('leadingMediaAssetId', () => {
+  const activeAssets = new Set(['video-1']);
+  const documents = new Map([['video-document', 'video-1']]);
+
+  it('does not let a lower-ranked video hijack a PDF question', () => {
+    expect(
+      leadingMediaAssetId(
+        {
+          hits: [
+            { documentId: 'pdf-document' },
+            { documentId: 'video-document', metadata: { mediaAssetId: 'video-1' } },
+          ],
+        },
+        activeAssets,
+        documents,
+      ),
+    ).toBeUndefined();
+  });
+
+  it('routes a leading media hit through its active evidence source', () => {
+    expect(
+      leadingMediaAssetId({ hits: [{ documentId: 'video-document' }] }, activeAssets, documents),
+    ).toBe('video-1');
+  });
+
+  it('ignores media metadata on an unrouted secondary search hit', () => {
+    expect(
+      explicitMediaEvidenceAssetId({
+        hits: [
+          { documentId: 'pdf-document' },
+          { documentId: 'video-document', metadata: { mediaAssetId: 'video-1' } },
+        ],
+      }),
+    ).toBeNull();
+    expect(explicitMediaEvidenceAssetId({ videoEvidence: { mediaAssetId: 'video-1' } })).toBe(
+      'video-1',
+    );
+  });
+});

package/.next/standalone/apps/web/lib/chat/media-source-routing.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import {
+  activeMediaFollowUpResult,
+  clearlyTitleMatchedMediaAsset,
+  clearlyUnavailableTitleMatchedMediaAsset,
+  shouldKeepActiveMediaSource,
+  type RoutableMediaAsset,
+} from './media-source-routing';
+
+const asset = (id: string, fileName: string): RoutableMediaAsset => ({
+  id,
+  fileName,
+  processingStatus: 'completed',
+  activeVideoKnowledgeRevisionId: `revision-${id}`,
+  type: 'video',
+  documentIds: [`document-${id}`],
+});
+
+describe('media source routing', () => {
+  it('keeps a follow-up on the active source without exposing unrelated global hits', () => {
+    expect(
+      activeMediaFollowUpResult(
+        'score of each phase',
+        asset('active', 'Active video'),
+        'A chronological indexed account.',
+      ),
+    ).toEqual({
+      query: 'score of each phase',
+      hits: [
+        {
+          title: 'Active video',
+          url: '/api/media/active',
+          score: 1,
+          text: 'A chronological indexed account.',
+          context: 'A chronological indexed account.',
+          metadata: {
+            mediaAssetId: 'active',
+            mediaType: 'video',
+            fileName: 'Active video',
+          },
+        },
+      ],
+      videoEvidence: {
+        mediaAssetId: 'active',
+        fileName: 'Active video',
+        retrievalFallback: 'active-conversation-media-source',
+      },
+    });
+  });
+
+  it('selects an explicitly named source when its title has a clear lead', () => {
+    const selected = clearlyTitleMatchedMediaAsset(
+      'who won Mohamed Hazem and Omar Khaled in Seventy Q&A',
+      [
+        asset('other', 'Mohamed Tarek and Mostafa Sedky in Seventy Q&A'),
+        asset('target', 'Mohamed Hazem and Omar Khaled in Seventy Q&A'),
+      ],
+    );
+    expect(selected?.id).toBe('target');
+  });
+
+  it('does not guess when two titles tie', () => {
+    expect(
+      clearlyTitleMatchedMediaAsset('the weekly episode', [
+        asset('a', 'The weekly episode A'),
+        asset('b', 'The weekly episode B'),
+      ]),
+    ).toBeUndefined();
+  });
+
+  it('does not replace an explicitly named unavailable source with an unrelated enabled one', () => {
+    const enabled = asset('enabled', 'Discussing the Frontier of Particle Physics');
+    const unavailable = asset('unavailable', 'Highlights Spain 1-0 Argentina Final');
+
+    expect(
+      clearlyUnavailableTitleMatchedMediaAsset(
+        'Who won in Highlights Spain 1-0 Argentina Final?',
+        [enabled],
+        [enabled, unavailable],
+      )?.id,
+    ).toBe('unavailable');
+    expect(
+      clearlyUnavailableTitleMatchedMediaAsset(
+        'What is discussed in Particle Physics?',
+        [enabled],
+        [enabled, unavailable],
+      ),
+    ).toBeUndefined();
+  });
+
+  it('identifies another explicit video instead of treating it as the active follow-up', () => {
+    expect(
+      clearlyTitleMatchedMediaAsset('what happened in the Spain semifinal', [
+        asset('final', 'Spain vs Argentina final highlights'),
+        asset('semi', 'France vs Spain semifinal highlights'),
+      ])?.id,
+    ).toBe('semi');
+  });
+
+  it('keeps an explicit conversation source even with other indexed videos', () => {
+    const final = asset('final', 'Spain vs Argentina final highlights');
+    const semifinal = asset('semi', 'France vs Spain semifinal highlights');
+
+    expect(
+      shouldKeepActiveMediaSource('what happened in the Spain semifinal', final, [
+        final,
+        semifinal,
+      ]),
+    ).toBe(true);
+    expect(shouldKeepActiveMediaSource('who won?', final, [final, semifinal])).toBe(true);
+    expect(
+      shouldKeepActiveMediaSource('what happened in the Argentina final', final, [
+        final,
+        semifinal,
+      ]),
+    ).toBe(true);
+  });
+});

package/.next/standalone/apps/web/lib/chat/message-feedback.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import {
+  answerFeedbackForMessage,
+  groundedAnswerFeedbackContext,
+  updateAnswerFeedback,
+  withAnswerFeedback,
+} from './message-feedback';
+
+describe('chat answer feedback', () => {
+  it('stores feedback without replacing other message metadata', () => {
+    const message = withAnswerFeedback(
+      { id: 'answer-1', metadata: { provider: 'local' } },
+      'liked',
+    );
+
+    expect(message.metadata).toEqual({ provider: 'local', answerFeedback: 'liked' });
+    expect(answerFeedbackForMessage(message)).toBe('liked');
+  });
+
+  it('can switch or clear one message rating immutably', () => {
+    const messages = [
+      { id: 'answer-1', metadata: { answerFeedback: 'liked' } },
+      { id: 'answer-2', metadata: { answerFeedback: 'liked' } },
+    ];
+    const disliked = updateAnswerFeedback(messages, 'answer-1', 'disliked');
+    const cleared = updateAnswerFeedback(disliked, 'answer-1', undefined);
+
+    expect(answerFeedbackForMessage(disliked[0])).toBe('disliked');
+    expect(answerFeedbackForMessage(disliked[1])).toBe('liked');
+    expect(answerFeedbackForMessage(cleared[0])).toBeUndefined();
+    expect(messages[0].metadata.answerFeedback).toBe('liked');
+  });
+
+  it('extracts an eligible grounded answer from current and legacy search results', () => {
+    expect(
+      groundedAnswerFeedbackContext(
+        [
+          { id: 'question', role: 'user', parts: [{ type: 'text', text: 'Favorite anime?' }] },
+          {
+            id: 'answer',
+            role: 'assistant',
+            parts: [
+              {
+                type: 'tool-searchKnowledgeBase',
+                output: {
+                  hits: [{ documentId: 'preferences', text: 'Naruto' }],
+                  sourceScopeFingerprint: 'scope-1',
+                },
+              },
+              { type: 'text', text: 'Naruto.' },
+            ],
+          },
+        ],
+        'answer',
+      ),
+    ).toEqual({
+      question: 'Favorite anime?',
+      answer: 'Naruto.',
+      sourceScopeFingerprint: 'scope-1',
+    });
+
+    expect(
+      groundedAnswerFeedbackContext(
+        [
+          { id: 'question', role: 'user', parts: [{ type: 'text', text: 'Favorite anime?' }] },
+          {
+            id: 'answer',
+            role: 'assistant',
+            parts: [
+              {
+                type: 'tool-searchKnowledgeBase',
+                output: { hits: [{ documentId: 'preferences', text: 'Naruto' }] },
+              },
+              { type: 'text', text: 'Naruto.' },
+            ],
+          },
+        ],
+        'answer',
+      )?.answer,
+    ).toBe('Naruto.');
+  });
+
+  it('does not cache media or multi-tool answers through generic feedback', () => {
+    const base = [
+      { id: 'question', role: 'user', parts: [{ type: 'text', text: 'Who won?' }] },
+      {
+        id: 'answer',
+        role: 'assistant',
+        parts: [
+          {
+            type: 'tool-searchKnowledgeBase',
+            output: {
+              hits: [{ metadata: { mediaAssetId: 'video-1' }, text: 'A clip' }],
+            },
+          },
+          { type: 'text', text: 'The red team.' },
+        ],
+      },
+    ];
+    expect(groundedAnswerFeedbackContext(base, 'answer')).toBeUndefined();
+  });
+});

package/.next/standalone/apps/web/lib/chat/message-input.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeIncomingMessages } from './message-input';
+
+describe('normalizeIncomingMessages', () => {
+  it('accepts the curl-friendly role/content message shape', () => {
+    expect(normalizeIncomingMessages([{ role: 'user', content: 'hi' }])).toEqual([
+      expect.objectContaining({
+        id: 'incoming-0',
+        role: 'user',
+        parts: [{ type: 'text', text: 'hi' }],
+      }),
+    ]);
+  });
+
+  it('drops null parts and messages without usable content', () => {
+    expect(
+      normalizeIncomingMessages([
+        { id: 'one', role: 'user', parts: [undefined, { type: 'text', text: 'question' }] },
+        { role: 'assistant', parts: [null] },
+        { role: 'unknown', content: 'ignored' },
+      ]),
+    ).toEqual([
+      expect.objectContaining({
+        id: 'one',
+        role: 'user',
+        parts: [{ type: 'text', text: 'question' }],
+      }),
+    ]);
+  });
+});