larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/lib/chat/assistant-source-scope.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import type { SourceDocument } from '@larkup/core/types';
+import { assistantSourceScopeFingerprint } from './assistant-source-scope';
+
+const document: SourceDocument = {
+  id: 'preference-1',
+  title: 'Preferences',
+  content: 'Favorite anime: Naruto.',
+  source: 'text',
+  charCount: 23,
+  groupId: 'default',
+  enabled: true,
+  status: 'indexed',
+  createdAt: '2026-01-01T00:00:00.000Z',
+};
+
+describe('Assistant source scope fingerprint', () => {
+  it('is stable across document ordering', () => {
+    const another = { ...document, id: 'preference-2', content: 'Favorite color: blue.' };
+    expect(assistantSourceScopeFingerprint([document, another])).toBe(
+      assistantSourceScopeFingerprint([another, document]),
+    );
+  });
+
+  it('changes when source content, availability, or Assistant configuration changes', () => {
+    const baseline = assistantSourceScopeFingerprint([document], {
+      configUpdatedAt: '2026-01-01T00:00:00.000Z',
+    });
+    expect(
+      assistantSourceScopeFingerprint([{ ...document, content: 'Favorite anime: Frieren.' }], {
+        configUpdatedAt: '2026-01-01T00:00:00.000Z',
+      }),
+    ).not.toBe(baseline);
+    expect(
+      assistantSourceScopeFingerprint([], { configUpdatedAt: '2026-01-01T00:00:00.000Z' }),
+    ).not.toBe(baseline);
+    expect(
+      assistantSourceScopeFingerprint([document], {
+        configUpdatedAt: '2026-01-02T00:00:00.000Z',
+      }),
+    ).not.toBe(baseline);
+  });
+});

package/.next/standalone/apps/web/lib/chat/chart-config.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeChartConfig, normalizeChartConfigWithEvidence } from './chart-config';
+
+describe('normalizeChartConfig', () => {
+  it('drops placeholder fields and infers real axes and series from all rows', () => {
+    const chart = normalizeChartConfig({
+      chartType: 'line',
+      title: 'Dropout comparison',
+      data: [
+        { University: 'North', __EMPTY: 0.55, International: '16%', Domestic: '13%' },
+        { University: 'South', __EMPTY: 0.27, International: '49%', Domestic: '26%' },
+      ],
+      xAxisKey: '__EMPTY',
+      series: [
+        { dataKey: '__EMPTY', label: '__EMPTY' },
+        { dataKey: 'does not exist', label: 'EMPTY_1' },
+      ],
+    });
+
+    expect(chart.error).toBeUndefined();
+    expect(chart.xAxisKey).toBe('University');
+    expect(chart.series).toEqual([
+      { dataKey: 'International', label: 'International' },
+      { dataKey: 'Domestic', label: 'Domestic' },
+    ]);
+    expect(chart.data).toEqual([
+      { University: 'North', International: 16, Domestic: 13 },
+      { University: 'South', International: 49, Domestic: 26 },
+    ]);
+    expect(chart.xAxisLabel).toBe('University');
+    expect(chart.yAxisLabel).toBe('International / Domestic');
+  });
+
+  it('derives clear axis names when the model omits them', () => {
+    const chart = normalizeChartConfig({
+      chartType: 'line',
+      title: 'Dropout comparison',
+      data: [
+        { Year: 2016, Bachelors: 0.3, Masters: 0.2 },
+        { Year: 2017, Bachelors: 0.28, Masters: 0.19 },
+      ],
+      xAxisKey: 'Year',
+      series: [
+        { dataKey: 'Bachelors', label: "Bachelor's Dropout Rate" },
+        { dataKey: 'Masters', label: "Master's Dropout Rate" },
+      ],
+    });
+
+    expect(chart.xAxisLabel).toBe('Year');
+    expect(chart.yAxisLabel).toBe('Dropout Rate');
+  });
+
+  it('preserves explicit axis names and units', () => {
+    const chart = normalizeChartConfig({
+      chartType: 'line',
+      title: 'Costs',
+      data: [{ Year: 2016, Cost: 20 }],
+      xAxisKey: 'Year',
+      series: [{ dataKey: 'Cost' }],
+      xAxisLabel: 'Fiscal year',
+      yAxisLabel: 'Cost (EUR billion)',
+    });
+
+    expect(chart.xAxisLabel).toBe('Fiscal year');
+    expect(chart.yAxisLabel).toBe('Cost (EUR billion)');
+  });
+
+  it('does not turn an invalid second series into a duplicate of a valid one', () => {
+    const chart = normalizeChartConfig({
+      chartType: 'bar',
+      title: 'Revenue',
+      data: [
+        { Region: 'East', Revenue: 40, Cost: 22 },
+        { Region: 'West', Revenue: 52, Cost: 31 },
+      ],
+      xAxisKey: 'Region',
+      series: [
+        { dataKey: 'Revenue', label: 'Revenue' },
+        { dataKey: 'not-a-column', label: 'EMPTY' },
+      ],
+    });
+
+    expect(chart.series).toEqual([{ dataKey: 'Revenue', label: 'Revenue' }]);
+    expect(chart.data).toEqual([
+      { Region: 'East', Revenue: 40 },
+      { Region: 'West', Revenue: 52 },
+    ]);
+  });
+
+  it('reports unusable data instead of producing a blank Recharts canvas', () => {
+    const chart = normalizeChartConfig({
+      chartType: 'bar',
+      title: 'Broken chart',
+      data: [{ __EMPTY: 1 }, { __EMPTY: 2 }],
+      xAxisKey: '__EMPTY',
+      series: [{ dataKey: '__EMPTY' }],
+    });
+
+    expect(chart.data).toEqual([]);
+    expect(chart.series).toEqual([]);
+    expect(chart.error).toBe('No usable category or X-axis field was provided.');
+  });
+});
+
+describe('normalizeChartConfigWithEvidence', () => {
+  const chart = {
+    chartType: 'bar',
+    title: 'Monthly sales',
+    data: [
+      { Month: 'January', Sales: 5000 },
+      { Month: 'February', Sales: 6000 },
+    ],
+    xAxisKey: 'Month',
+    series: [{ dataKey: 'Sales' }],
+  };
+
+  it('accepts rows copied from verified table evidence', () => {
+    expect(
+      normalizeChartConfigWithEvidence(chart, [
+        { Month: 'January', Sales: '$5,000' },
+        { Month: 'February', Sales: '$6,000' },
+      ]).error,
+    ).toBeUndefined();
+  });
+
+  it('rejects chart generation when no table evidence exists', () => {
+    expect(normalizeChartConfigWithEvidence(chart, undefined)).toMatchObject({
+      data: [],
+      error: 'No verified tabular data was available for this chart.',
+    });
+  });
+
+  it('rejects invented values that differ from the verified rows', () => {
+    expect(
+      normalizeChartConfigWithEvidence(chart, [
+        { Month: 'January', Sales: 5 },
+        { Month: 'February', Sales: 6 },
+      ]),
+    ).toMatchObject({
+      data: [],
+      error: 'The requested chart contained values that were not present in the verified data.',
+    });
+  });
+});

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

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getProviderEmbedUrl,
+  timestampedMediaUrl,
+} from '../../components/chat/tools/chat-media-preview';
+
+describe('getProviderEmbedUrl', () => {
+  it('uses YouTube’s browser-supported player with the cited range', () => {
+    expect(getProviderEmbedUrl('https://www.youtube.com/watch?v=video-id', 81, 117)).toBe(
+      'https://www.youtube-nocookie.com/embed/video-id?start=81&rel=0&end=117',
+    );
+  });
+
+  it('does not convert a local media endpoint into a provider embed', () => {
+    expect(getProviderEmbedUrl('/api/media/asset-1', 81, 117)).toBeUndefined();
+  });
+});
+
+describe('timestampedMediaUrl', () => {
+  it('keeps project scoping and uses a media fragment for indexed files', () => {
+    expect(timestampedMediaUrl('/api/media/asset-1?projectId=project-1', 840, 870)).toBe(
+      '/api/media/asset-1?projectId=project-1#t=840,870',
+    );
+  });
+
+  it('uses the provider timestamp parameter for YouTube sources', () => {
+    expect(timestampedMediaUrl('https://www.youtube.com/watch?v=video-id', 840)).toBe(
+      'https://www.youtube.com/watch?v=video-id&t=840s',
+    );
+  });
+});

package/.next/standalone/apps/web/lib/chat/conversation-memory.test.ts

@@ -0,0 +1,390 @@
+import { describe, expect, it } from 'vitest';
+import {
+  continuesRecentMediaTopic,
+  compactTabularRowsForConversation,
+  contextualizeKnowledgeFollowUpQuery,
+  extractConversationEvidence,
+  extractLatestTabularExportResult,
+  findImmediateExactGroundedAnswer,
+  isTabularFollowUp,
+  resolveParallelPreferenceQuestion,
+} from './conversation-memory';
+
+describe('exact grounded answer reuse', () => {
+  const firstTurn = [
+    { role: 'user', parts: [{ type: 'text', text: 'What is my favorite anime?' }] },
+    {
+      role: 'assistant',
+      parts: [
+        {
+          type: 'tool-searchKnowledgeBase',
+          output: {
+            sourceScopeFingerprint: 'scope-1',
+            hits: [{ documentId: 'preferences', title: 'Preferences', text: 'Naruto.' }],
+          },
+        },
+        { role: 'assistant', type: 'text', text: 'Your favorite anime is Naruto.' },
+      ],
+    },
+  ];
+
+  it('reuses only the immediately repeated grounded question', () => {
+    expect(
+      findImmediateExactGroundedAnswer(
+        [
+          ...firstTurn,
+          { role: 'user', parts: [{ type: 'text', text: '  what is my favorite ANIME? ' }] },
+        ],
+        'what is my favorite ANIME?',
+      ),
+    ).toEqual({ answer: 'Your favorite anime is Naruto.', sourceScopeFingerprint: 'scope-1' });
+  });
+
+  it('does not reuse an answer for a changed question or a media result', () => {
+    expect(
+      findImmediateExactGroundedAnswer(
+        [
+          ...firstTurn,
+          { role: 'user', parts: [{ type: 'text', text: 'What is my favorite game?' }] },
+        ],
+        'What is my favorite game?',
+      ),
+    ).toBeUndefined();
+    const mediaTurn = structuredClone(firstTurn) as any[];
+    mediaTurn[1].parts[0].output.hits[0].metadata = { mediaAssetId: 'video-1' };
+    expect(
+      findImmediateExactGroundedAnswer(
+        [
+          ...mediaTurn,
+          { role: 'user', parts: [{ type: 'text', text: 'What is my favorite anime?' }] },
+        ],
+        'What is my favorite anime?',
+      ),
+    ).toBeUndefined();
+  });
+
+  it('keeps liked answers reusable and refreshes a disliked exact repeat', () => {
+    const repeatedQuestion = {
+      role: 'user',
+      parts: [{ type: 'text', text: 'What is my favorite anime?' }],
+    };
+    const likedTurn = structuredClone(firstTurn) as any[];
+    likedTurn[1].metadata = { answerFeedback: 'liked' };
+    expect(
+      findImmediateExactGroundedAnswer(
+        [...likedTurn, repeatedQuestion],
+        'What is my favorite anime?',
+      ),
+    ).toEqual({ answer: 'Your favorite anime is Naruto.', sourceScopeFingerprint: 'scope-1' });
+
+    const dislikedTurn = structuredClone(firstTurn) as any[];
+    dislikedTurn[1].metadata = { answerFeedback: 'disliked' };
+    expect(
+      findImmediateExactGroundedAnswer(
+        [...dislikedTurn, repeatedQuestion],
+        'What is my favorite anime?',
+      ),
+    ).toBeUndefined();
+  });
+
+  it('keeps consecutive cache-hit answers tied to the original grounded search', () => {
+    expect(
+      findImmediateExactGroundedAnswer(
+        [
+          ...firstTurn,
+          {
+            role: 'user',
+            parts: [{ type: 'text', text: 'What is my favorite anime?' }],
+          },
+          {
+            role: 'assistant',
+            metadata: { answerFeedback: 'liked' },
+            parts: [{ type: 'text', text: 'Your favorite anime is Naruto.' }],
+          },
+          {
+            role: 'user',
+            parts: [{ type: 'text', text: 'What is my favorite anime?' }],
+          },
+        ],
+        'What is my favorite anime?',
+      ),
+    ).toEqual({ answer: 'Your favorite anime is Naruto.', sourceScopeFingerprint: 'scope-1' });
+  });
+});
+
+describe('continuesRecentMediaTopic', () => {
+  const video = { sources: [], images: [], mediaAssetIds: ['video-1'] };
+
+  it('keeps the active video for a standalone factual follow-up', () => {
+    expect(continuesRecentMediaTopic('Who scored all goals in order?', video)).toBe(true);
+  });
+
+  it('does not infer a source switch from user-language vocabulary', () => {
+    expect(continuesRecentMediaTopic('What happened in another video?', video)).toBe(true);
+  });
+});
+
+describe('media conversation evidence', () => {
+  it('keeps an indexed PDF image below the compact text-source summary', () => {
+    const evidence = extractConversationEvidence([
+      {
+        role: 'assistant',
+        parts: [
+          {
+            type: 'tool-searchKnowledgeBase',
+            output: {
+              hits: [
+                { title: 'Schema text', text: 'Views and routines' },
+                { title: 'More schema text', text: 'Resources' },
+                {
+                  title: 'Schema diagram',
+                  images: [{ imageUrl: '/api/uploads/schema.png', pageNumber: 3 }],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ]);
+
+    expect(evidence.images).toEqual([
+      expect.objectContaining({
+        imageUrl: '/api/uploads/schema.png',
+        pageNumber: 3,
+        title: 'Schema diagram',
+      }),
+    ]);
+  });
+
+  it('does not turn a secondary video search hit into the active conversation topic', () => {
+    const evidence = extractConversationEvidence([
+      {
+        role: 'assistant',
+        parts: [
+          {
+            type: 'tool-searchKnowledgeBase',
+            output: {
+              hits: [
+                {
+                  title: 'NVIDIA GTC AI Conference Berlin',
+                  text: 'The event is scheduled for October 2026.',
+                },
+                {
+                  title: 'Unrelated football highlights',
+                  text: 'A football match.',
+                  metadata: { mediaAssetId: 'video-secondary' },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ]);
+
+    expect(evidence.mediaAssetIds).toEqual([]);
+    expect(contextualizeKnowledgeFollowUpQuery('What will it be about?', evidence)).toContain(
+      'NVIDIA GTC AI Conference Berlin',
+    );
+  });
+
+  it('keeps a title-matched media source when vector retrieval has no document hits', () => {
+    const evidence = extractConversationEvidence([
+      {
+        role: 'assistant',
+        parts: [
+          {
+            type: 'tool-searchKnowledgeBase',
+            input: { query: 'Who appears at the requested point?' },
+            output: {
+              hits: [],
+              videoEvidence: {
+                mediaAssetId: 'video-1',
+                retrievalFallback: 'title-matched-media-source',
+                evidence: [{ payload: { text: 'The final display establishes the answer.' } }],
+              },
+            },
+          },
+        ],
+      },
+    ]);
+    expect(evidence.mediaAssetIds).toEqual(['video-1']);
+    expect(evidence.mediaQuestion).toBe('Who appears at the requested point?');
+    expect(evidence.sources).toEqual([
+      { title: 'Video evidence', text: 'The final display establishes the answer.' },
+    ]);
+    expect(continuesRecentMediaTopic('Which team had two goals?', evidence)).toBe(true);
+  });
+
+  it('keeps the media source from a dynamic evidence action after reload', () => {
+    const evidence = extractConversationEvidence([
+      {
+        role: 'assistant',
+        parts: [
+          {
+            type: 'dynamic-tool',
+            toolName: 'queryVideoEvidence',
+            state: 'output-available',
+            input: { mediaAssetId: 'video-2', query: 'Who appears near the middle?' },
+            output: { success: true, mediaAssetId: 'video-2', evidence: [] },
+          },
+        ],
+      },
+    ]);
+    expect(evidence.mediaAssetIds).toEqual(['video-2']);
+    expect(evidence.mediaQuestion).toBe('Who appears near the middle?');
+    expect(continuesRecentMediaTopic('What did each person wear?', evidence)).toBe(true);
+  });
+});
+
+describe('generic source conversation evidence', () => {
+  const event = {
+    sources: [
+      {
+        title: 'NVIDIA GTC AI Conference Berlin',
+        text: 'The conference is scheduled for October 2026 and covers AI infrastructure.',
+      },
+    ],
+    images: [],
+    mediaAssetIds: [],
+  };
+
+  it('qualifies an anaphoric event follow-up before retrieval', () => {
+    expect(contextualizeKnowledgeFollowUpQuery('What will it be about?', event)).toContain(
+      'NVIDIA GTC AI Conference Berlin',
+    );
+  });
+
+  it('keeps a short immediate follow-up on the established source topic', () => {
+    expect(contextualizeKnowledgeFollowUpQuery('How do I participate?', event)).toContain(
+      'scheduled for October 2026',
+    );
+  });
+
+  it('does not carry source context into an explicitly different source', () => {
+    expect(
+      contextualizeKnowledgeFollowUpQuery('What about another website?', event),
+    ).toBeUndefined();
+  });
+});
+
+describe('parallel preference follow-ups', () => {
+  it('turns a new explicit subject into a fresh parallel question', () => {
+    expect(resolveParallelPreferenceQuestion('and fruits', 'what is my fav anime')).toBe(
+      'what is my fav fruits?',
+    );
+    expect(
+      resolveParallelPreferenceQuestion('also favorite color', 'what is my favorite anime'),
+    ).toBe('what is my favorite color?');
+  });
+
+  it('does not rewrite pronouns or unrelated prior question shapes', () => {
+    expect(
+      resolveParallelPreferenceQuestion('and it?', 'what is my favorite anime'),
+    ).toBeUndefined();
+    expect(resolveParallelPreferenceQuestion('and fruits', 'tell me about anime')).toBeUndefined();
+  });
+});
+
+describe('tabular conversation evidence', () => {
+  const messages = [
+    {
+      role: 'assistant',
+      parts: [
+        {
+          type: 'tool-queryTabularData',
+          input: { datasetId: 'sales-1' },
+          output: {
+            columns: ['Region', 'Net Revenue'],
+            rows: [
+              { Region: 'North', 'Net Revenue': 720000 },
+              { Region: 'East', 'Net Revenue': 530000 },
+              { Region: 'South', 'Net Revenue': 800000 },
+              { Region: 'West', 'Net Revenue': 720000 },
+            ],
+            totalRows: 4,
+          },
+        },
+      ],
+    },
+    { role: 'assistant', parts: [{ type: 'text', text: 'Here is the distribution by region.' }] },
+  ];
+
+  it('retains a bounded table result after a text-only assistant answer', () => {
+    const evidence = extractConversationEvidence(messages);
+    expect(evidence.tabular).toMatchObject({
+      datasetId: 'sales-1',
+      columns: ['Region', 'Net Revenue'],
+      totalRows: 4,
+    });
+    expect(evidence.tabular?.rows).toHaveLength(4);
+  });
+
+  it('treats a misspelled comparison as a follow-up to the shown table', () => {
+    const evidence = extractConversationEvidence(messages);
+    expect(isTabularFollowUp('what was the begisst area?', evidence)).toBe(true);
+  });
+
+  it('recognizes a meaningful word inside a descriptive table column on a follow-up', () => {
+    const evidence = extractConversationEvidence([
+      {
+        role: 'assistant',
+        parts: [
+          {
+            type: 'tool-queryTabularData',
+            input: { datasetId: 'education-1' },
+            output: {
+              columns: ['International Bachelor dropout, first 3 semesters'],
+              rows: [{ 'International Bachelor dropout, first 3 semesters': '16%' }],
+              totalRows: 1,
+            },
+          },
+        ],
+      },
+    ]);
+
+    expect(isTabularFollowUp('Are the dropout rates administratively observed?', evidence)).toBe(
+      true,
+    );
+  });
+
+  it('bounds verbose table rows before they become follow-up context', () => {
+    const rows = compactTabularRowsForConversation(
+      Array.from({ length: 100 }, (_, index) => ({
+        Institution: `University ${index}`,
+        Notes: 'reported metric '.repeat(200),
+      })),
+      ['Institution', 'Notes'],
+    );
+
+    expect(rows).toHaveLength(25);
+    expect(JSON.stringify(rows).length).toBeLessThanOrEqual(12_000);
+    expect(String(rows[0].Notes)).toHaveLength(360);
+  });
+
+  it('keeps the complete bounded tool result available for an export follow-up', () => {
+    const rows = Array.from({ length: 80 }, (_, index) => ({
+      guest_id: `guest-${index + 1}`,
+      name: `Guest ${index + 1}`,
+    }));
+    const messages = [
+      {
+        role: 'assistant',
+        parts: [
+          {
+            type: 'tool-queryTabularData',
+            input: { datasetId: 'guests' },
+            output: { columns: ['guest_id', 'name'], rows, totalRows: 80 },
+          },
+        ],
+      },
+    ];
+
+    expect(extractConversationEvidence(messages).tabular?.rows).toHaveLength(25);
+    expect(extractLatestTabularExportResult(messages)?.rows).toHaveLength(80);
+  });
+
+  it('does not reuse an active table when the user explicitly changes datasets', () => {
+    const evidence = extractConversationEvidence(messages);
+    expect(isTabularFollowUp('What is biggest in another dataset?', evidence)).toBe(false);
+  });
+});