larkup 0.1.14 → 0.1.21

package/lib/chat-model-provider.ts

@@ -0,0 +1,115 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createCohere } from '@ai-sdk/cohere';
+import { createDeepSeek } from '@ai-sdk/deepseek';
+import { createGateway } from '@ai-sdk/gateway';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createMistral } from '@ai-sdk/mistral';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { getDefaultChatModel, toChatDescriptor } from '@larkup/core/chat-models/registry';
+import type { GatewayModel } from '@larkup/core/models-cache';
+import type { CustomModelConfig, RagConfig } from '@larkup/core/types';
+
+const FALLBACK_CHAT_MODELS: Record<string, string> = {
+  openai: 'openai/gpt-4o-mini',
+  anthropic: 'anthropic/claude-3-5-sonnet-latest',
+  google: 'google/gemini-2.5-flash',
+  cohere: 'cohere/command-r-plus',
+  mistral: 'mistral/mistral-large-latest',
+  deepseek: 'deepseek/deepseek-chat',
+};
+
+export interface ResolvedChatModel {
+  provider: string;
+  modelId: string;
+  apiKey?: string;
+}
+
+export interface ResolveChatModelOptions {
+  requiredTag?: string;
+}
+
+/**
+ * Resolve an LLM from persisted settings. The configured provider is
+ * authoritative: a gateway key must never be passed to a model vendor SDK.
+ */
+export function resolveConfiguredChatModel(
+  config: RagConfig,
+  availableModels: GatewayModel[] = [],
+  options: ResolveChatModelOptions = {},
+): ResolvedChatModel {
+  const provider = config.chatProvider || config.embeddingProvider || 'openai';
+  let modelId = config.chatModelId?.trim();
+
+  if (!modelId && provider === 'custom' && config.customChatModels?.[0]) {
+    modelId = `custom:${config.customChatModels[0].modelName}`;
+  }
+
+  if (!modelId && availableModels.length > 0) {
+    const requiredTag = options.requiredTag;
+    const taggedModels = requiredTag
+      ? availableModels.filter((model) => model.tags?.includes(requiredTag))
+      : availableModels;
+    const candidates = taggedModels.length > 0 ? taggedModels : availableModels;
+    modelId = getDefaultChatModel(candidates.map(toChatDescriptor), provider)?.id;
+  }
+
+  if (!modelId && provider === 'vercel_ai_gateway') {
+    throw new Error('No gateway model is available. Choose a chat model before processing media.');
+  }
+
+  modelId ||= FALLBACK_CHAT_MODELS[provider] || FALLBACK_CHAT_MODELS.openai;
+
+  return {
+    provider,
+    modelId,
+    apiKey: config.chatApiKey || config.embeddingApiKey || undefined,
+  };
+}
+
+export function createChatModel(
+  provider: string,
+  modelId: string,
+  apiKey?: string,
+  customChatModels: CustomModelConfig[] = [],
+) {
+  if (modelId.startsWith('custom:')) {
+    const customName = modelId.slice('custom:'.length);
+    const custom = customChatModels.find((candidate) => candidate.modelName === customName);
+    if (!custom) {
+      throw new Error(`Custom chat model "${customName}" is not configured.`);
+    }
+
+    const customProvider = createOpenAICompatible({
+      name: 'custom_chat_provider',
+      baseURL: custom.baseUrl,
+      apiKey: custom.apiKey || apiKey || undefined,
+    });
+    return customProvider(custom.modelName);
+  }
+
+  const modelName = modelId.includes('/') ? modelId.split('/').slice(1).join('/') : modelId;
+
+  switch (provider) {
+    case 'google':
+      return createGoogleGenerativeAI({ apiKey })(modelName);
+    case 'cohere':
+      return createCohere({ apiKey })(modelName);
+    case 'mistral':
+      return createMistral({ apiKey })(modelName);
+    case 'deepseek':
+      return createDeepSeek({ apiKey })(modelName);
+    case 'anthropic':
+      return createAnthropic({ apiKey })(modelName);
+    case 'openai':
+      return createOpenAI({ apiKey })(modelName);
+    case 'vercel_ai_gateway':
+      // Gateway model IDs retain their vendor prefix (for example,
+      // "openai/gpt-4o-mini") because routing happens at the gateway.
+      return createGateway({ apiKey })(modelId);
+    case 'custom':
+      throw new Error('Choose a configured custom chat model before processing media.');
+    default:
+      throw new Error(`Unsupported chat provider "${provider}".`);
+  }
+}

package/lib/deployments.ts

@@ -0,0 +1,119 @@
+export type DeploymentRecord = {
+  id: string;
+  provider: 'vercel' | 'hetzner' | 'azure' | 'aws' | 'gcp';
+  project: string;
+  url: string;
+  status?: 'queued' | 'building' | 'ready' | 'error' | 'unknown';
+  apiKeyVersion?: number;
+  createdAt: string;
+  updatedAt: string;
+};
+
+function storageKey(serverId: string) {
+  return `larkup_deployments_${serverId}`;
+}
+
+export function deploymentEndpoint(deployment: DeploymentRecord) {
+  return deployment.url.replace(/\/$/, '');
+}
+
+function apiKeyVersionKey(serverId: string) {
+  return `larkup_api_key_version_${serverId}`;
+}
+
+export function getApiKeyVersion(serverId: string) {
+  return Number.parseInt(localStorage.getItem(apiKeyVersionKey(serverId)) || '0', 10) || 0;
+}
+
+export function incrementApiKeyVersion(serverId: string) {
+  const version = getApiKeyVersion(serverId) + 1;
+  localStorage.setItem(apiKeyVersionKey(serverId), String(version));
+  return version;
+}
+
+function legacyDeployment(serverId: string): DeploymentRecord[] {
+  const url = localStorage.getItem(`vercel_deployed_url_${serverId}`);
+  if (!url) return [];
+  const provider = (localStorage.getItem(`vercel_deployed_provider_${serverId}`) ||
+    'vercel') as DeploymentRecord['provider'];
+  return [
+    {
+      id: `${provider}:${url}`,
+      provider,
+      project: localStorage.getItem(`vercel_project_${serverId}`) || url,
+      url,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    },
+  ];
+}
+
+export function getDeployments(serverId: string): DeploymentRecord[] {
+  try {
+    const saved = localStorage.getItem(storageKey(serverId));
+    if (saved) {
+      return JSON.parse(saved) as DeploymentRecord[];
+    }
+  } catch {
+    // Fall through to the legacy single-deployment storage.
+  }
+  const deployments = legacyDeployment(serverId);
+  if (deployments.length) {
+    localStorage.setItem(storageKey(serverId), JSON.stringify(deployments));
+  }
+  return deployments;
+}
+
+function writeDeployments(serverId: string, deployments: DeploymentRecord[]) {
+  localStorage.setItem(storageKey(serverId), JSON.stringify(deployments));
+  window.dispatchEvent(new CustomEvent('larkup-deployments-change', { detail: serverId }));
+}
+
+export function saveDeployment(
+  serverId: string,
+  deployment: Omit<DeploymentRecord, 'id' | 'createdAt' | 'updatedAt'>,
+) {
+  const deployments = getDeployments(serverId);
+  const existingIndex = deployments.findIndex(
+    (item) => item.provider === deployment.provider && item.project === deployment.project,
+  );
+  const now = new Date().toISOString();
+  const record: DeploymentRecord = {
+    ...deployment,
+    apiKeyVersion: deployment.apiKeyVersion ?? getApiKeyVersion(serverId),
+    id:
+      existingIndex >= 0
+        ? deployments[existingIndex].id
+        : `${deployment.provider}:${deployment.project}`,
+    createdAt: existingIndex >= 0 ? deployments[existingIndex].createdAt : now,
+    updatedAt: now,
+  };
+  if (existingIndex >= 0) deployments[existingIndex] = record;
+  else deployments.unshift(record);
+  writeDeployments(serverId, deployments);
+  return deployments;
+}
+
+export function updateDeploymentUrl(serverId: string, id: string, url: string) {
+  return updateDeployment(serverId, id, { url });
+}
+
+export function updateDeployment(
+  serverId: string,
+  id: string,
+  patch: Pick<Partial<DeploymentRecord>, 'url' | 'status'>,
+) {
+  const deployments = getDeployments(serverId).map((deployment) =>
+    deployment.id === id
+      ? { ...deployment, ...patch, updatedAt: new Date().toISOString() }
+      : deployment,
+  );
+  writeDeployments(serverId, deployments);
+  return deployments;
+}
+
+export function removeDeployment(serverId: string, id: string) {
+  const deployments = getDeployments(serverId).filter((deployment) => deployment.id !== id);
+  writeDeployments(serverId, deployments);
+  return deployments;
+}

package/lib/env-utils.ts

@@ -0,0 +1,27 @@
+import { existsSync } from 'node:fs';
+
+/**
+ * Runtime environment the app is running in.
+ *
+ * - "web"     → local dev / standalone Next.js on the host
+ * - "desktop" → bundled inside Tauri as a sidecar
+ * - "docker"  → running inside a Docker container
+ */
+export type RuntimeEnv = 'web' | 'desktop' | 'docker';
+
+/** Detect the current runtime environment (server-side only). */
+export function getRuntimeEnv(): RuntimeEnv {
+  if (process.env.TAURI_ENV_PLATFORM || process.env.TAURI_ENV_ARCH) {
+    return 'desktop';
+  }
+
+  if (
+    process.env.DOCKER_ENV === 'true' ||
+    process.env.DOCKER_BUILD === '1' ||
+    existsSync('/.dockerenv')
+  ) {
+    return 'docker';
+  }
+
+  return 'web';
+}

package/lib/media-knowledge.ts

@@ -0,0 +1,431 @@
+import { generateText } from 'ai';
+import { getModelsByType } from '@larkup/core/models-cache';
+import type { NewDocumentInput } from '@larkup/core/documents-store';
+import type { RagConfig } from '@larkup/core/types';
+import { createChatModel, resolveConfiguredChatModel } from './chat-model-provider';
+
+export interface MediaEvidenceSegment {
+  text: string;
+  transcript?: string;
+  visualContext?: string;
+  startSecs: number;
+  endSecs: number;
+  sequence: number;
+}
+
+interface SummaryOptions {
+  title: string;
+  mediaType: 'video' | 'audio';
+  durationSecs: number;
+  segments: MediaEvidenceSegment[];
+  config: RagConfig;
+  onProgress?: (completed: number, total: number, message: string) => void | Promise<void>;
+}
+
+interface MediaDocumentOptions {
+  assetId: string;
+  title: string;
+  mediaType: 'video' | 'audio';
+  localUrl: string;
+  originalUrl?: string;
+  durationSecs: number;
+  summary: string;
+  segments: MediaEvidenceSegment[];
+  fileName: string;
+  mimeType: string;
+  transcriptSource: string;
+  transcriptProvider?: string;
+  transcriptLanguage?: string;
+}
+
+const SYNTHESIS_BATCH_CHARS = 14_000;
+const FINAL_SYNTHESIS_CHARS = 32_000;
+
+/**
+ * Produce human-style notes from the complete evidence timeline. Long media is
+ * reduced in bounded batches first, so the final pass can connect events and
+ * outcomes without dropping the ending of the recording.
+ */
+export async function createMediaKnowledgeSummary(options: SummaryOptions): Promise<string> {
+  const batches = batchSegments(options.segments, SYNTHESIS_BATCH_CHARS);
+  const models = await getModelsByType('language');
+  const resolved = resolveConfiguredChatModel(options.config, models);
+  const model = createChatModel(
+    resolved.provider,
+    resolved.modelId,
+    resolved.apiKey,
+    options.config.customChatModels,
+  ) as any;
+
+  const batchNotes: string[] = [];
+  let completedCalls = 0;
+  for (let index = 0; index < batches.length; index++) {
+    await options.onProgress?.(
+      completedCalls,
+      batches.length + 1,
+      `Reviewing evidence section ${index + 1} of ${batches.length}...`,
+    );
+    const prompt = buildBatchPrompt(options, batches[index], index, batches.length);
+    const note = await generateAndTrack(model, prompt, resolved, options.mediaType);
+    batchNotes.push(note);
+    completedCalls++;
+    await options.onProgress?.(
+      completedCalls,
+      Math.max(completedCalls + 1, batches.length + 1),
+      `Reviewed evidence section ${index + 1} of ${batches.length}.`,
+    );
+  }
+
+  let reducedNotes = batchNotes;
+  let reductionLevel = 0;
+  while (reducedNotes.join('\n\n').length > FINAL_SYNTHESIS_CHARS) {
+    reductionLevel++;
+    const groups = batchTexts(reducedNotes, SYNTHESIS_BATCH_CHARS);
+    const nextLevel: string[] = [];
+    for (let index = 0; index < groups.length; index++) {
+      const estimatedTotal = completedCalls + (groups.length - index) + 1;
+      await options.onProgress?.(
+        completedCalls,
+        estimatedTotal,
+        `Connecting note group ${index + 1} of ${groups.length}...`,
+      );
+      nextLevel.push(
+        await generateAndTrack(
+          model,
+          buildReductionPrompt(options, groups[index], reductionLevel, index, groups.length),
+          resolved,
+          options.mediaType,
+        ),
+      );
+      completedCalls++;
+    }
+    reducedNotes = nextLevel;
+  }
+
+  await options.onProgress?.(
+    completedCalls,
+    completedCalls + 1,
+    'Connecting people, events, decisions, and outcomes...',
+  );
+  const finalPrompt = buildFinalPrompt(options, reducedNotes);
+  const summary = await generateAndTrack(model, finalPrompt, resolved, options.mediaType);
+  completedCalls++;
+  await options.onProgress?.(completedCalls, completedCalls, 'Created searchable media notes.');
+  return summary.trim();
+}
+
+/** Keep the full timeline searchable even when the configured summarizer is temporarily unavailable. */
+export function createFallbackMediaSummary(
+  title: string,
+  mediaType: 'video' | 'audio',
+  segments: MediaEvidenceSegment[],
+): string {
+  const selected = [
+    ...segments.slice(0, 2),
+    ...segments.slice(
+      Math.max(2, Math.floor(segments.length / 2) - 1),
+      Math.floor(segments.length / 2) + 1,
+    ),
+    ...segments.slice(-3),
+  ].filter(
+    (segment, index, all) =>
+      all.findIndex((candidate) => candidate.sequence === segment.sequence) === index,
+  );
+  return [
+    `Overview: ${mediaType === 'video' ? 'Video' : 'Audio'} evidence notes for "${title}".`,
+    'Representative timeline evidence:',
+    ...selected.map(formatSegmentForPrompt),
+    'The timestamped evidence documents contain the complete timeline.',
+  ].join('\n\n');
+}
+
+/**
+ * Persist one overview plus independently searchable, timestamped evidence
+ * units. Retrieval can then fetch adjacent moments and the actual ending.
+ */
+export function buildMediaDocumentInputs(options: MediaDocumentOptions): NewDocumentInput[] {
+  const baseMetadata = {
+    mediaAssetId: options.assetId,
+    mediaType: options.mediaType,
+    fileName: options.fileName,
+    mimeType: options.mimeType,
+    mediaUrl: options.localUrl,
+    originalUrl: options.originalUrl,
+    durationSecs: options.durationSecs,
+    transcriptSource: options.transcriptSource,
+    transcriptProvider: options.transcriptProvider,
+    transcriptLanguage: options.transcriptLanguage,
+  };
+  const baseUrl = options.originalUrl || options.localUrl;
+  const label = options.mediaType === 'video' ? 'Video' : 'Audio';
+
+  return [
+    {
+      title: options.title,
+      content: [
+        `${label}: ${options.title}`,
+        `Duration: ${formatTime(options.durationSecs)}`,
+        '## Human-style evidence notes',
+        options.summary,
+      ].join('\n\n'),
+      source: 'media',
+      url: baseUrl,
+      metadata: {
+        ...baseMetadata,
+        contentKind: `${options.mediaType}-summary`,
+        isMediaSummary: true,
+        segmentCount: options.segments.length,
+      },
+    },
+    ...options.segments.map((segment) => ({
+      title: `${options.title} — ${formatTime(segment.startSecs)}`,
+      content: [
+        `${label}: ${options.title}`,
+        `Evidence at ${formatTime(segment.startSecs)}–${formatTime(segment.endSecs)}`,
+        segment.text,
+      ].join('\n\n'),
+      source: 'media' as const,
+      url: timestampMediaUrl(baseUrl, segment.startSecs),
+      metadata: {
+        ...baseMetadata,
+        contentKind:
+          options.mediaType === 'video' ? 'multimodal-segment' : 'audio-transcript-segment',
+        isMediaSummary: false,
+        sequence: segment.sequence,
+        startSecs: segment.startSecs,
+        endSecs: segment.endSecs,
+        evidenceKinds: [
+          ...(segment.transcript?.trim() ? ['speech'] : []),
+          ...(segment.visualContext?.trim() ? ['visual', 'ocr'] : []),
+        ],
+      },
+    })),
+  ];
+}
+
+export function timestampMediaUrl(url: string, startSecs: number): string {
+  const seconds = Math.max(0, Math.floor(startSecs));
+  try {
+    const parsed = new URL(url);
+    if (
+      /(^|\.)youtube\.com$|(^|\.)youtu\.be$/.test(parsed.hostname) ||
+      parsed.searchParams.has('v')
+    ) {
+      parsed.searchParams.set('t', `${seconds}s`);
+      return parsed.toString();
+    }
+  } catch {
+    // Relative media URLs are handled with a media fragment below.
+  }
+  return `${url.split('#')[0]}#t=${seconds}`;
+}
+
+export function normalizeMediaCitationRange(
+  mediaType: 'image' | 'video' | 'audio',
+  durationSecs?: number,
+  startSecs?: number,
+  endSecs?: number,
+): { startSecs?: number; endSecs?: number } {
+  if (mediaType === 'image' || startSecs === undefined || !Number.isFinite(startSecs)) {
+    return {};
+  }
+
+  const duration =
+    durationSecs !== undefined && Number.isFinite(durationSecs)
+      ? Math.max(0, durationSecs)
+      : Number.POSITIVE_INFINITY;
+  const start = Math.min(Math.max(0, startSecs), duration);
+  const end =
+    endSecs !== undefined && Number.isFinite(endSecs)
+      ? Math.min(Math.max(start, endSecs), duration)
+      : undefined;
+
+  return { startSecs: start, endSecs: end };
+}
+
+export function formatTime(seconds: number): string {
+  const safeSeconds = Math.max(0, Math.floor(seconds));
+  const hours = Math.floor(safeSeconds / 3600);
+  const minutes = Math.floor((safeSeconds % 3600) / 60);
+  const secs = safeSeconds % 60;
+  return hours > 0
+    ? `${hours}:${String(minutes).padStart(2, '0')}:${String(secs).padStart(2, '0')}`
+    : `${minutes}:${String(secs).padStart(2, '0')}`;
+}
+
+/** Return a bounded excerpt centered on query terms, or on the ending when requested. */
+export function queryAwareExcerpt(
+  text: string,
+  query: string,
+  maxChars: number,
+  preferEnd = false,
+): string {
+  if (text.length <= maxChars) return text;
+  const terms =
+    query
+      .normalize('NFKC')
+      .toLocaleLowerCase()
+      .match(/[\p{Letter}\p{Number}][\p{Letter}\p{Mark}\p{Number}_-]{2,}/gu) ?? [];
+  const normalizedText = text.normalize('NFKC').toLocaleLowerCase();
+  const matches = [...new Set(terms)]
+    .map((term) => normalizedText.indexOf(term))
+    .filter((index) => index >= 0);
+  if (matches.length > 0) {
+    const center = Math.min(...matches);
+    const start = Math.max(0, Math.min(text.length - maxChars, center - Math.floor(maxChars / 3)));
+    return `${start > 0 ? '…' : ''}${text.slice(start, start + maxChars)}${
+      start + maxChars < text.length ? '…' : ''
+    }`;
+  }
+  return preferEnd ? `…${text.slice(-maxChars)}` : `${text.slice(0, maxChars)}…`;
+}
+
+function batchSegments(
+  segments: MediaEvidenceSegment[],
+  maxChars: number,
+): MediaEvidenceSegment[][] {
+  const batches: MediaEvidenceSegment[][] = [];
+  let current: MediaEvidenceSegment[] = [];
+  let currentChars = 0;
+  for (const originalSegment of segments) {
+    const textParts = splitText(originalSegment.text, maxChars);
+    for (let partIndex = 0; partIndex < textParts.length; partIndex++) {
+      const segment = {
+        ...originalSegment,
+        text:
+          textParts.length === 1
+            ? textParts[partIndex]
+            : `${textParts[partIndex]}\n[Continuation ${partIndex + 1} of ${
+                textParts.length
+              } for this timestamp range]`,
+      };
+      if (current.length > 0 && currentChars + segment.text.length > maxChars) {
+        batches.push(current);
+        current = [];
+        currentChars = 0;
+      }
+      current.push(segment);
+      currentChars += segment.text.length;
+    }
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+
+function splitText(text: string, maxChars: number): string[] {
+  if (text.length <= maxChars) return [text];
+  const parts: string[] = [];
+  let offset = 0;
+  while (offset < text.length) {
+    let end = Math.min(text.length, offset + maxChars);
+    if (end < text.length) {
+      const boundary = text.lastIndexOf('\n', end);
+      if (boundary > offset + maxChars / 2) end = boundary;
+    }
+    parts.push(text.slice(offset, end));
+    offset = end;
+  }
+  return parts;
+}
+
+function batchTexts(texts: string[], maxChars: number): string[][] {
+  const groups: string[][] = [];
+  let current: string[] = [];
+  let currentChars = 0;
+  for (const text of texts.flatMap((value) => splitText(value, maxChars))) {
+    if (current.length > 0 && currentChars + text.length > maxChars) {
+      groups.push(current);
+      current = [];
+      currentChars = 0;
+    }
+    current.push(text);
+    currentChars += text.length;
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+
+function buildBatchPrompt(
+  options: SummaryOptions,
+  segments: MediaEvidenceSegment[],
+  index: number,
+  count: number,
+): string {
+  return `You are carefully watching section ${index + 1} of ${count} from a ${
+    options.mediaType
+  } titled "${options.title}".
+
+Write compact factual viewing notes that remain useful for later questions. CRITICAL: Every single factual claim, event, score change, or action MUST be prefixed with its exact [HH:MM:SS-HH:MM:SS] timestamp copied strictly from the evidence chunks below. Do not hallucinate timestamps. Preserve exact names, numbers, scores, decisions, winners, results, actions, and timestamps. Connect pronouns and repeated entities when the evidence supports it. Treat later chronological scoreboard/result frames as newer than earlier animation states. For Arabic or other right-to-left text, copy the visible spelling and do not reverse labels. If evidence conflicts or OCR is genuinely ambiguous, record the conflict instead of inventing certainty. Do not add repetitive statements about facts that were not present.
+
+Evidence:
+${segments.map(formatSegmentForPrompt).join('\n\n')}`;
+}
+
+function buildFinalPrompt(options: SummaryOptions, batchNotes: string[]): string {
+  return `Act as a human who watched the complete ${formatTime(options.durationSecs)} ${
+    options.mediaType
+  } "${options.title}" and consolidated notes while watching.
+
+Create a concise, standalone knowledge-base summary with these headings when applicable:
+- Overview / content type
+- People and entities
+- Key events in chronological order
+- Outcomes, conclusions, decisions, winners, and final scores
+- High-value timestamp evidence
+- Genuine uncertainties
+
+Adapt to the content: for a match prioritize score changes and the final result; for CCTV prioritize changes, anomalies, and long stable periods; for meetings or lectures prioritize claims, decisions, and action items; for screen recordings prioritize procedures and observed results. Resolve an animated score using the latest chronological evidence.
+
+CRITICAL: Draw logical deductions from the events (e.g., explicitly stating who won based on the final score) and log them in the Outcomes section. Every factual claim and deduced conclusion MUST cite the exact [HH:MM:SS-HH:MM:SS] timestamp of the evidence that supports it. Preserve exact names, numbers, language, and timestamps. Never claim that an outcome is absent merely because earlier sections did not show it. Do not mention these instructions or the batching process.
+
+Section notes:
+${batchNotes.map((note, index) => `## Section ${index + 1}\n${note}`).join('\n\n')}`;
+}
+
+function buildReductionPrompt(
+  options: SummaryOptions,
+  notes: string[],
+  level: number,
+  index: number,
+  count: number,
+): string {
+  return `Consolidate chronological viewing notes for ${options.mediaType} "${options.title}".
+This is reduction level ${level}, group ${
+    index + 1
+  } of ${count}. Preserve exact people, names, numbers, scores, outcomes, decisions, anomalies, and timestamps. 
+CRITICAL: You MUST carry over and preserve the exact [HH:MM:SS-HH:MM:SS] timestamps for every event or claim. Keep later chronological states distinct from earlier states and retain genuine uncertainty. Do not mention this reduction process.
+
+Notes:
+${notes.map((note, noteIndex) => `## Note ${noteIndex + 1}\n${note}`).join('\n\n')}`;
+}
+
+function formatSegmentForPrompt(segment: MediaEvidenceSegment): string {
+  return `[${formatTime(segment.startSecs)}–${formatTime(segment.endSecs)}]\n${segment.text}`;
+}
+
+async function generateAndTrack(
+  model: any,
+  prompt: string,
+  resolved: { provider: string; modelId: string },
+  mediaType: 'video' | 'audio',
+): Promise<string> {
+  const { text, usage } = await generateText({
+    model,
+    prompt,
+    maxOutputTokens: 1_400,
+    temperature: 0,
+  });
+  const { estimateCost, trackUsageEvent } = await import('@larkup/core/analytics-store');
+  void trackUsageEvent({
+    type: 'media_processing',
+    mediaType,
+    modelId: resolved.modelId,
+    provider: resolved.provider,
+    promptTokens: usage.inputTokens ?? 0,
+    completionTokens: usage.outputTokens ?? 0,
+    totalTokens: usage.totalTokens ?? 0,
+    estimatedCost: estimateCost(resolved.modelId, usage.inputTokens ?? 0, usage.outputTokens ?? 0),
+    timestamp: new Date().toISOString(),
+  }).catch((error) => console.error('Failed to record media synthesis usage:', error));
+  return text;
+}