larkup 0.4.12 → 0.4.14

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

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { decodeToolOutput } from './tool-output';
+
+describe('decodeToolOutput', () => {
+  it('unwraps a provider structured JSON output', () => {
+    expect(
+      decodeToolOutput({
+        type: 'json',
+        value: { chartType: 'bar', data: [{ label: 'A', value: 1 }] },
+      }),
+    ).toEqual({ chartType: 'bar', data: [{ label: 'A', value: 1 }] });
+  });
+
+  it('unwraps a JSON-encoded structured output', () => {
+    expect(decodeToolOutput('{"type":"json","value":{"rows":[{"id":1}]}}')).toEqual({
+      rows: [{ id: 1 }],
+    });
+  });
+
+  it('leaves plain text output undecoded', () => {
+    expect(decodeToolOutput('completed')).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,14 @@
+/** Decode the transport wrappers AI providers may use for structured tool output. */
+export function decodeToolOutput(value: unknown): unknown {
+  if (typeof value === 'string') {
+    try {
+      return decodeToolOutput(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
+  if (value && typeof value === 'object' && (value as { type?: string }).type === 'json') {
+    return decodeToolOutput((value as { value?: unknown }).value);
+  }
+  return value && typeof value === 'object' ? value : undefined;
+}

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

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { executableTools } from './tool-registry';
+
+describe('executableTools', () => {
+  it('keeps available tools and removes missing optional capabilities', () => {
+    const search = { type: 'function', execute: () => 'result' };
+    expect(
+      executableTools({
+        searchKnowledgeBase: search,
+        inspectPdfPages: undefined,
+        analyzePdfPages: null,
+      }),
+    ).toEqual({ searchKnowledgeBase: search });
+  });
+
+  it('returns an empty registry when no capability is available', () => {
+    expect(executableTools({ first: undefined, second: null })).toEqual({});
+  });
+});

package/.next/standalone/apps/web/lib/chat/video-rag-routing.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it } from 'vitest';
+import {
+  collectExhaustiveVideoEvidencePages,
+  indexedVideoEvidenceIsSufficient,
+} from './video-rag-routing';
+
+const visual = (startSecs: number, text = 'A source-grounded visual account.') => ({
+  modality: 'visual',
+  text,
+  confidenceScore: 0.8,
+  startSecs,
+  endSecs: startSecs + 10,
+});
+
+describe('video RAG fallback routing', () => {
+  it('collects every available exhaustive page without duplicating evidence', async () => {
+    const execute = async (input: Record<string, unknown>) => {
+      const cursor = Number(input.cursor);
+      return {
+        success: true,
+        mediaAssetId: 'asset-1',
+        evidence: [{ id: cursor === 2 ? 'b' : 'c' }, { id: cursor === 2 ? 'c' : 'd' }],
+        continuation: {
+          exhaustive: true,
+          cursor,
+          nextCursor: cursor + 2,
+          hasMore: cursor < 4,
+        },
+      };
+    };
+    const result = (await collectExhaustiveVideoEvidencePages(
+      execute,
+      { mediaAssetId: 'asset-1', query: 'list everything' },
+      {
+        success: true,
+        mediaAssetId: 'asset-1',
+        claimVerification: { status: 'directly-established' },
+        evidence: [{ id: 'a' }, { id: 'b' }],
+        continuation: { exhaustive: true, nextCursor: 2, hasMore: true },
+      },
+      'call-1',
+    )) as any;
+
+    expect(result.evidence.map((item: any) => item.id)).toEqual(['a', 'b', 'c', 'd']);
+    expect(result.continuation).toMatchObject({
+      exhaustive: true,
+      hasMore: false,
+      aggregatedItems: 4,
+      contextLimitReached: false,
+    });
+    expect(result.claimVerification).toEqual({ status: 'directly-established' });
+  });
+
+  it('collects structured inventory rows outside the answer-model evidence limit', async () => {
+    const execute = async (input: Record<string, unknown>) => {
+      const cursor = Number(input.cursor);
+      return {
+        success: true,
+        rows: [
+          { id: cursor === 2 ? 'question-b' : 'question-c', Content: `Item ${cursor}` },
+          { id: cursor === 2 ? 'question-c' : 'question-d', Content: `Item ${cursor + 1}` },
+        ],
+        continuation: {
+          exhaustive: true,
+          cursor,
+          nextCursor: cursor + 2,
+          hasMore: cursor < 4,
+        },
+      };
+    };
+    const result = (await collectExhaustiveVideoEvidencePages(
+      execute,
+      { mediaAssetId: 'asset-1', query: 'enumerate source units' },
+      {
+        success: true,
+        columns: ['Content'],
+        rows: [
+          { id: 'question-a', Content: 'Item 0' },
+          { id: 'question-b', Content: 'Item 1' },
+        ],
+        continuation: { exhaustive: true, nextCursor: 2, hasMore: true },
+      },
+      'call-1',
+    )) as any;
+
+    expect(result.rows.map((row: any) => row.id)).toEqual([
+      'question-a',
+      'question-b',
+      'question-c',
+      'question-d',
+    ]);
+    expect(result.totalRows).toBe(4);
+    expect(result.continuation).toMatchObject({
+      exhaustive: true,
+      hasMore: false,
+      aggregatedItems: 4,
+      contextLimitReached: false,
+    });
+  });
+
+  it('uses a semantically located indexed visual answer without live analysis', () => {
+    expect(
+      indexedVideoEvidenceIsSufficient({
+        verificationStatus: 'supported',
+        questionKinds: ['person-attribute'],
+        evidence: [visual(30, 'The left participant wears a yellow shirt.')],
+        focusSources: ['semantic'],
+      }),
+    ).toBe(true);
+  });
+
+  it('uses a reconciled computed answer without requiring another provider call', () => {
+    expect(
+      indexedVideoEvidenceIsSufficient({
+        verificationStatus: 'supported',
+        questionKinds: ['outcome'],
+        evidence: [{ ...visual(500, 'Reconciled final state: A leads B.'), modality: 'computed' }],
+      }),
+    ).toBe(true);
+  });
+
+  it('uses a broad indexed timeline for ordered-change questions', () => {
+    expect(
+      indexedVideoEvidenceIsSufficient({
+        verificationStatus: 'supported',
+        questionKinds: ['state-change'],
+        evidence: [visual(10), visual(310), visual(590)],
+        durationSecs: 600,
+        hierarchyRanges: 3,
+      }),
+    ).toBe(true);
+  });
+
+  it.each(['conflicted', 'insufficient', 'needs_inspection'] as const)(
+    'falls back when verification is %s',
+    (verificationStatus) => {
+      expect(
+        indexedVideoEvidenceIsSufficient({
+          verificationStatus,
+          questionKinds: ['outcome'],
+          evidence: [visual(30, 'Claim verdict: direct\nClaim answer: A')],
+          focusSources: ['semantic'],
+        }),
+      ).toBe(false);
+    },
+  );
+
+  it('does not promote a weak transcript neighbour into a visual answer', () => {
+    expect(
+      indexedVideoEvidenceIsSufficient({
+        verificationStatus: 'supported',
+        questionKinds: ['person-attribute'],
+        evidence: [{ ...visual(30, 'People are talking nearby.'), modality: 'transcript' }],
+        focusSources: ['lexical'],
+      }),
+    ).toBe(false);
+  });
+});

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

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import {
+  hasRetrievedImageEvidence,
+  hasRetrievedPdfEvidence,
+  hasNumberedDocumentReference,
+  findRetrievedPdfSource,
+  findIndexedImageSource,
+  latestNumberedDocumentReferenceText,
+  preferredPdfPagesForInspection,
+  requiresPdfVisualAnalysis,
+  requestsImagePresentation,
+  shouldInspectRetrievedImage,
+} from './visual-routing';
+
+describe('PDF visual routing', () => {
+  it('resolves previews from legacy standalone indexed-image records', () => {
+    expect(
+      findIndexedImageSource(
+        [
+          {
+            metadata: {
+              imageUrl: '/api/uploads/schema.png',
+              pageNumber: 3,
+              index: 0,
+            },
+          },
+        ],
+        '/api/uploads/schema.png',
+      ),
+    ).toMatchObject({ image: { pageNumber: 3, index: 0 } });
+  });
+
+  it('visually verifies exhaustive diagram requests instead of trusting a partial caption', () => {
+    expect(
+      shouldInspectRetrievedImage(
+        "list every view and routine name shown, and tell me how many routines are under 'Resources'.",
+        {
+          hits: [
+            {
+              images: [
+                {
+                  imageUrl: '/api/uploads/schema.png',
+                  description:
+                    'Views: film_list and staff_list. Resources routines: get_customer and film_in_stock.',
+                },
+              ],
+            },
+          ],
+        },
+      ),
+    ).toBe(true);
+  });
+
+  it('requires a fresh visual read when indexed descriptions do not cover the question', () => {
+    expect(
+      shouldInspectRetrievedImage('What color is the connector between the billing tables?', {
+        hits: [
+          {
+            images: [
+              {
+                imageUrl: '/api/uploads/schema.png',
+                description: 'A database overview with user account labels.',
+              },
+            ],
+          },
+        ],
+      }),
+    ).toBe(true);
+  });
+
+  it('routes an explicit visual preview to presentation instead of analysis', () => {
+    expect(requestsImagePresentation('show me diagram preview')).toBe(true);
+    expect(
+      shouldInspectRetrievedImage('show me diagram preview', {
+        hits: [{ images: [{ imageUrl: '/api/uploads/schema.png' }] }],
+      }),
+    ).toBe(false);
+  });
+
+  it('recognizes an extracted PDF image in a compact retrieval result', () => {
+    expect(
+      hasRetrievedImageEvidence({
+        hits: [{ images: [{ imageUrl: '/api/uploads/schema.png', pageNumber: 2 }] }],
+      }),
+    ).toBe(true);
+  });
+
+  it('recognizes a retrieved PDF even if no images were indexed', () => {
+    expect(
+      hasRetrievedPdfEvidence({ hits: [{ documentId: 'doc-1', url: '/api/uploads/source.pdf' }] }),
+    ).toBe(true);
+  });
+
+  it('prefers the matched visual page over an earlier document image', () => {
+    expect(
+      findRetrievedPdfSource({
+        hits: [
+          { documentId: 'paper', title: 'paper.pdf', url: '/api/uploads/paper.pdf' },
+          {
+            documentId: 'paper',
+            title: 'paper.pdf - Page 17',
+            url: '/api/uploads/paper.pdf',
+            metadata: { isImage: true, pageNumber: 17 },
+          },
+        ],
+      }),
+    ).toEqual({ documentId: 'paper', pageNumber: 17, title: 'paper.pdf - Page 17' });
+  });
+
+  it('uses rendered-page analysis for layout-dependent document requests', () => {
+    expect(requiresPdfVisualAnalysis('Explain the two panels in Figure 3.1.')).toBe(true);
+    expect(requiresPdfVisualAnalysis('Write the \"softmax(QKᵀ/√dₖ)V\" formula.')).toBe(true);
+    expect(requiresPdfVisualAnalysis('Summarize the introduction.')).toBe(false);
+  });
+
+  it('recognizes render requests as image presentation', () => {
+    expect(requestsImagePresentation('can you render it here?')).toBe(true);
+  });
+
+  it('lets the local PDF index resolve an explicit numbered object reference', () => {
+    expect(hasNumberedDocumentReference('Please render Figure 2.1 here.')).toBe(true);
+    expect(hasNumberedDocumentReference('Compare Table 3.1.')).toBe(true);
+    expect(hasNumberedDocumentReference('Write Eq. (2.24).')).toBe(true);
+    expect(preferredPdfPagesForInspection(43, 'Please render Figure 2.1 here.')).toBeUndefined();
+  });
+
+  it('keeps a retrieved page hint when the user did not name a document object', () => {
+    expect(preferredPdfPagesForInspection(43, 'Please render that page here.')).toEqual([43]);
+  });
+
+  it('retains the nearest named object for a later deictic preview request', () => {
+    expect(
+      latestNumberedDocumentReferenceText([
+        'What does Figure 2.1 show?',
+        'It is the vectorized attention flow.',
+        'Can you render it here?',
+      ]),
+    ).toBe('What does Figure 2.1 show?');
+  });
+});

package/.next/standalone/apps/web/lib/chat-supporting-clip.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { shouldAutoOpenSupportingClip } from './chat-supporting-clip';
+
+describe('shouldAutoOpenSupportingClip', () => {
+  it('opens only the first assistant message', () => {
+    const messages = [{ role: 'user' }, { role: 'assistant' }, { role: 'user' }, { role: 'assistant' }];
+
+    expect(shouldAutoOpenSupportingClip(messages, 0)).toBe(false);
+    expect(shouldAutoOpenSupportingClip(messages, 1)).toBe(true);
+    expect(shouldAutoOpenSupportingClip(messages, 3)).toBe(false);
+  });
+
+  it('does not open a clip when no assistant response exists yet', () => {
+    expect(shouldAutoOpenSupportingClip([{ role: 'user' }], 0)).toBe(false);
+  });
+});

package/.next/standalone/apps/web/lib/chat-supporting-clip.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns true only for the first assistant response in a chat transcript,
+ * so its first supporting clip (if a video search produced one) auto-opens
+ * instead of staying collapsed behind a "Watch supporting clip" click. This
+ * has no memory across reloads (no sessionStorage) — the first message's
+ * clip auto-opens the same way every time the chat is loaded.
+ */
+export function shouldAutoOpenSupportingClip(
+  messages: readonly { role: string }[],
+  messageIndex: number,
+): boolean {
+  return (
+    messages[messageIndex]?.role === 'assistant' &&
+    messageIndex === messages.findIndex((message) => message.role === 'assistant')
+  );
+}

package/.next/standalone/apps/web/lib/constants/stores.ts

@@ -0,0 +1,12 @@
+export type StoreMeta = { iconSrc: string; pillBg: string };
+
+export const STORE_META: Record<string, StoreMeta> = {
+  lancedb: {
+    iconSrc: '/icons/lancedb2.png',
+    pillBg: 'bg-yellow-50 dark:bg-yellow-950/40',
+  },
+  pinecone: {
+    iconSrc: '/icons/pinecone.png',
+    pillBg: 'bg-green-50 dark:bg-green-950/40',
+  },
+};

package/.next/standalone/apps/web/lib/constants/tools.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { getChatToolBehavior } from './tools';
+
+describe('chat tool progress behavior', () => {
+  it('keeps fast spreadsheet queries indeterminate', () => {
+    expect(getChatToolBehavior('queryTabularData').showProgressBar).toBe(false);
+  });
+
+  it('keeps measurable long-running tool progress enabled by default', () => {
+    expect(getChatToolBehavior('queryVideoKnowledge').showProgressBar).not.toBe(false);
+  });
+
+  it('renders structured media inventories with the generic data table', () => {
+    expect(getChatToolBehavior('queryVideoEvidence')).toMatchObject({
+      resultView: 'data-table',
+      compactResult: false,
+    });
+  });
+
+  it('renders answer exports as downloadable files without a fake text link', () => {
+    expect(getChatToolBehavior('createDataExport')).toMatchObject({
+      resultView: 'file-export',
+      showProgressBar: false,
+    });
+  });
+});

package/.next/standalone/apps/web/lib/constants/tools.ts

@@ -0,0 +1,178 @@
+import { Search, Table, BarChart3, Code2, Files, FileEdit, FileDown } from 'lucide-react';
+import type { LucideIcon } from 'lucide-react';
+
+export type Tool = {
+  id: string;
+  name: string;
+  description: string;
+  icon: LucideIcon;
+  plugin?: boolean;
+};
+
+/**
+ * Chat-facing behavior for every first-party tool. Keep tool progress copy and
+ * presentation decisions here so adding a tool does not require scattered
+ * name checks throughout the chat UI.
+ */
+export type ChatToolPlacement = 'source' | 'web-search' | 'visualization' | 'media' | 'inline';
+
+export type ChatToolResultView =
+  | 'none'
+  | 'data-table'
+  | 'sandbox'
+  | 'corpus'
+  | 'document-edit'
+  | 'file-export'
+  | 'signature'
+  | 'image-analysis'
+  | 'media';
+
+export interface ChatToolBehavior {
+  placement: ChatToolPlacement;
+  pendingLabel?: string;
+  resultView: ChatToolResultView;
+  compactResult?: boolean;
+  /** Keep quick operations moving without implying a measurable percentage. */
+  showProgressBar?: boolean;
+}
+
+export const CHAT_TOOL_BEHAVIORS: Record<string, ChatToolBehavior> = {
+  searchKnowledgeBase: { placement: 'source', resultView: 'none' },
+  // Renders through the generic output.ui.kind:'citations' contract
+  // (message-item.tsx / chat-citations.tsx), same as any other tool --
+  // nothing video-specific is hardcoded in the placement/resultView here.
+  queryVideoKnowledge: {
+    placement: 'inline',
+    pendingLabel: 'Reviewing the video…',
+    resultView: 'none',
+  },
+  queryVideoEvidence: {
+    placement: 'inline',
+    pendingLabel: 'Reviewing indexed video context…',
+    // Generic structured rows are rendered through ChatDataTable. Ordinary
+    // evidence results have no rows and remain citation/answer driven.
+    resultView: 'data-table',
+    compactResult: false,
+  },
+  inspectVideoKnowledge: {
+    placement: 'inline',
+    pendingLabel: 'Checking the relevant moment…',
+    resultView: 'none',
+  },
+  webSearch: { placement: 'web-search', resultView: 'none' },
+  presentMedia: { placement: 'media', resultView: 'media' },
+  queryTabularData: {
+    placement: 'inline',
+    pendingLabel: 'Checking data…',
+    resultView: 'data-table',
+    compactResult: true,
+    showProgressBar: false,
+  },
+  generateVisualization: {
+    placement: 'visualization',
+    pendingLabel: 'Preparing chart…',
+    resultView: 'none',
+  },
+  createDataExport: {
+    placement: 'inline',
+    pendingLabel: 'Preparing file…',
+    resultView: 'file-export',
+    showProgressBar: false,
+  },
+  executeAnalysis: {
+    placement: 'inline',
+    pendingLabel: 'Running analysis…',
+    resultView: 'sandbox',
+  },
+  analyzeCorpusWithCode: {
+    placement: 'inline',
+    pendingLabel: 'Analyzing documents…',
+    resultView: 'sandbox',
+  },
+  getIndexedData: {
+    placement: 'inline',
+    pendingLabel: 'Checking documents…',
+    resultView: 'corpus',
+  },
+  analyzeImageDeeply: {
+    placement: 'inline',
+    pendingLabel: 'Analyzing image…',
+    resultView: 'image-analysis',
+  },
+  fillDocumentForm: {
+    placement: 'inline',
+    pendingLabel: 'Updating document…',
+    resultView: 'document-edit',
+  },
+  editDocument: {
+    placement: 'inline',
+    pendingLabel: 'Updating document…',
+    resultView: 'document-edit',
+  },
+  requestDocumentSignature: {
+    placement: 'inline',
+    pendingLabel: 'Preparing signature…',
+    resultView: 'signature',
+  },
+};
+
+const FALLBACK_CHAT_TOOL_BEHAVIOR: ChatToolBehavior = {
+  placement: 'inline',
+  pendingLabel: 'Working…',
+  resultView: 'none',
+};
+
+export function getChatToolBehavior(toolId: string): ChatToolBehavior {
+  return CHAT_TOOL_BEHAVIORS[toolId] ?? FALLBACK_CHAT_TOOL_BEHAVIOR;
+}
+
+export const BUILT_IN_TOOLS: Tool[] = [
+  {
+    id: 'searchKnowledgeBase',
+    name: 'Semantic Search',
+    description: 'Search the RAG knowledge base for text.',
+    icon: Search,
+  },
+  {
+    id: 'queryTabularData',
+    name: 'Tabular Data Query',
+    description: 'Filter, group, and aggregate tabular data.',
+    icon: Table,
+  },
+  {
+    id: 'generateVisualization',
+    name: 'Generate Charts',
+    description: 'Create interactive charts from Assistant results.',
+    icon: BarChart3,
+  },
+  {
+    id: 'createDataExport',
+    name: 'Export Answer',
+    description: 'Create a downloadable Excel, CSV, or PDF file from an Assistant result.',
+    icon: FileDown,
+  },
+  {
+    id: 'executeAnalysis',
+    name: 'Python Sandbox',
+    description: 'Execute Python code for complex analysis.',
+    icon: Code2,
+  },
+  {
+    id: 'getIndexedData',
+    name: 'Indexed Data',
+    description: 'List and filter source documents.',
+    icon: Files,
+  },
+  {
+    id: 'analyzeCorpusWithCode',
+    name: 'Corpus Analysis',
+    description: 'Run code against the full indexed corpus.',
+    icon: Code2,
+  },
+  {
+    id: 'fillDocumentForm',
+    name: 'Form Filler',
+    description: 'Fill forms in the active document.',
+    icon: FileEdit,
+  },
+];

package/.next/standalone/apps/web/lib/error-formatter.ts

@@ -0,0 +1,30 @@
+export function formatErrorMessage(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  const normalized = message.toLowerCase();
+
+  // Provider SDKs sometimes echo the submitted key or a URL-encoded request
+  // URL in authentication failures. Besides being unreadable, that can expose
+  // credential material in a toast. Keep the actionable part instead.
+  if (
+    normalized.includes('authentication failed') ||
+    normalized.includes('invalid api key') ||
+    normalized.includes('invalid api_key') ||
+    normalized.includes('invalid token') ||
+    normalized.includes('unauthorized') ||
+    normalized.includes('status code 401')
+  ) {
+    return 'Authentication failed. Check the API key for the selected provider.';
+  }
+
+  if (message.includes('Is the docker daemon running?')) {
+    return 'Docker is not running. Please make sure the Docker daemon is started.';
+  }
+
+  if (message.includes('fetch failed') || message.includes('Failed to fetch')) {
+    return 'Network error. Please check your connection and try again.';
+  }
+
+  // Add more common error mappings here as needed
+
+  return message;
+}

package/.next/standalone/apps/web/lib/jobs-client.ts

@@ -0,0 +1,25 @@
+import type { CrawlJob } from '@larkup/core/types';
+
+export interface JobsResponse {
+  jobs: CrawlJob[];
+  configured: boolean;
+}
+
+export async function fetchJobsWithSync(url: string): Promise<JobsResponse> {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error('Could not load jobs.');
+  const { jobs, configured } = (await response.json()) as JobsResponse;
+  const active = jobs.filter((job) => job.status === 'running' || job.status === 'queued');
+  if (active.length === 0) return { jobs, configured };
+
+  const advanced = await Promise.all(
+    active.map((job) =>
+      fetch(`/api/jobs/${job.id}`)
+        .then((result) => result.json())
+        .then((result) => result.job as CrawlJob)
+        .catch(() => job),
+    ),
+  );
+  const advancedById = new Map(advanced.map((job) => [job.id, job]));
+  return { jobs: jobs.map((job) => advancedById.get(job.id) ?? job), configured };
+}