@sylphx/video-reader-mcp 0.1.0 → 0.1.1

package/src/utils/scenes.ts

@@ -0,0 +1,63 @@
+import type { SceneInfo } from '../types/timeline.js';
+import { execBinary, isBinaryAvailable } from './exec.js';
+
+const SCENE_PTS_TIME_RE = /pts_time:([0-9.]+)/g;
+
+export const parseSceneFilterOutput = (stderr: string, threshold: number): SceneInfo[] => {
+  const scenes: SceneInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  while ((match = SCENE_PTS_TIME_RE.exec(stderr)) !== null) {
+    const seconds = Number.parseFloat(match[1]);
+    if (!Number.isFinite(seconds)) continue;
+
+    scenes.push({
+      index: scenes.length,
+      time_ms: Math.round(seconds * 1000),
+      provenance: {
+        method: 'ffmpeg_scene_filter',
+        threshold,
+      },
+    });
+  }
+
+  return scenes;
+};
+
+export const detectScenes = async (
+  videoPath: string,
+  threshold: number
+): Promise<{ scenes: SceneInfo[]; warning?: string }> => {
+  const available = await isBinaryAvailable('ffmpeg');
+  if (!available) {
+    return {
+      scenes: [],
+      warning: 'ffmpeg is not installed; scene detection skipped.',
+    };
+  }
+
+  try {
+    const { stderr } = await execBinary(
+      'ffmpeg',
+      [
+        '-hide_banner',
+        '-i',
+        videoPath,
+        '-vf',
+        `select='gt(scene,${threshold})',showinfo`,
+        '-f',
+        'null',
+        '-',
+      ],
+      { timeoutMs: 300_000 }
+    );
+
+    return { scenes: parseSceneFilterOutput(stderr, threshold) };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      scenes: [],
+      warning: `Scene detection failed: ${message}`,
+    };
+  }
+};

package/src/utils/subtitles.ts

@@ -0,0 +1,101 @@
+import type { SubtitleCue } from '../types/timeline.js';
+
+const parseTimestampToMs = (timestamp: string): number => {
+  const normalized = timestamp.trim().replace(',', '.');
+  const parts = normalized.split(':');
+  if (parts.length !== 3) return 0;
+
+  const [hours, minutes, secondsPart] = parts;
+  const [seconds, millis = '0'] = secondsPart.split('.');
+  const h = Number.parseInt(hours, 10);
+  const m = Number.parseInt(minutes, 10);
+  const s = Number.parseInt(seconds, 10);
+  const ms = Number.parseInt(millis.padEnd(3, '0').slice(0, 3), 10);
+
+  return ((h * 60 + m) * 60 + s) * 1000 + ms;
+};
+
+const stripTags = (text: string): string =>
+  text
+    .replace(/<[^>]+>/g, '')
+    .replace(/\{[^}]+\}/g, '')
+    .trim();
+
+export const parseSrt = (content: string): SubtitleCue[] => {
+  const blocks = content
+    .replace(/\r\n/g, '\n')
+    .split(/\n{2,}/)
+    .map((block) => block.trim())
+    .filter(Boolean);
+
+  const cues: SubtitleCue[] = [];
+
+  for (const block of blocks) {
+    const lines = block.split('\n');
+    if (lines.length < 2) continue;
+
+    const timingLine = lines.find((line) => line.includes('-->'));
+    if (!timingLine) continue;
+
+    const [startRaw, endRaw] = timingLine.split('-->').map((part) => part.trim());
+    const textLines = lines.filter((line) => line !== lines[0] && !line.includes('-->'));
+    const text = stripTags(textLines.join('\n'));
+    if (!text) continue;
+
+    cues.push({
+      index: cues.length,
+      start_ms: parseTimestampToMs(startRaw),
+      end_ms: parseTimestampToMs(endRaw),
+      text,
+      provenance: {
+        method: 'embedded_parse',
+        format: 'srt',
+      },
+    });
+  }
+
+  return cues;
+};
+
+export const parseVtt = (content: string): SubtitleCue[] => {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const blocks = normalized
+    .split(/\n{2,}/)
+    .map((block) => block.trim())
+    .filter((block) => block && !block.startsWith('WEBVTT') && !block.startsWith('NOTE'));
+
+  const cues: SubtitleCue[] = [];
+
+  for (const block of blocks) {
+    const lines = block.split('\n');
+    const timingLine = lines.find((line) => line.includes('-->'));
+    if (!timingLine) continue;
+
+    const timing = timingLine.split('-->')[0]?.trim() ?? '';
+    const endTiming = timingLine.split('-->')[1]?.trim().split(' ')[0] ?? '';
+    const textLines = lines.filter((line) => !line.includes('-->') && !/^\d+$/.test(line));
+    const text = stripTags(textLines.join('\n'));
+    if (!text) continue;
+
+    cues.push({
+      index: cues.length,
+      start_ms: parseTimestampToMs(timing),
+      end_ms: parseTimestampToMs(endTiming),
+      text,
+      provenance: {
+        method: 'embedded_parse',
+        format: 'vtt',
+      },
+    });
+  }
+
+  return cues;
+};
+
+export const parseSubtitleContent = (
+  content: string,
+  format: 'srt' | 'vtt' | 'webvtt'
+): SubtitleCue[] => {
+  if (format === 'srt') return parseSrt(content);
+  return parseVtt(content);
+};

package/src/video/readCoordinator.ts

@@ -0,0 +1,165 @@
+import { access } from 'node:fs/promises';
+import {
+  assembleProbeTimelineViaRustEngine,
+  buildCacheKeyViaRustEngine,
+  hashSourceViaRustEngine,
+  shouldUseRustTimelineEngine,
+} from '../engine/rust-timeline.js';
+import type { ReadVideoArgs } from '../schemas/readVideo.js';
+import type { TimelineDocument, VideoSourceResult } from '../types/timeline.js';
+import { tryAsrTranscript } from '../utils/asr.js';
+import { extractSubtitles } from '../utils/ffmpeg.js';
+import {
+  collectProbeWarnings,
+  findSubtitleStreams,
+  mapChapters,
+  mapStreams,
+  runFfprobe,
+  secondsToMs,
+} from '../utils/ffprobe.js';
+import { extractKeyframes } from '../utils/frames.js';
+import { resolvePath } from '../utils/pathUtils.js';
+import { detectScenes } from '../utils/scenes.js';
+
+const DEFAULT_SCENE_THRESHOLD = 0.4;
+const DEFAULT_KEYFRAME_LIMIT = 8;
+
+export const buildTimelineDocument = async (
+  sourcePath: string,
+  args: ReadVideoArgs,
+  version: string
+): Promise<TimelineDocument> => {
+  const includeStreams = args.include_streams ?? true;
+  const includeChapters = args.include_chapters ?? true;
+  const includeSubtitles = args.include_subtitles ?? true;
+  const includeScenes = args.include_scenes ?? true;
+  const includeTranscript = args.include_transcript ?? false;
+  const includeKeyframes = args.include_keyframes ?? false;
+  const includeKeyframeImages = args.include_keyframe_images ?? false;
+  const keyframeLimit = args.keyframe_limit ?? DEFAULT_KEYFRAME_LIMIT;
+  const keyframeMaxDimension = args.keyframe_max_dimension;
+  const sceneThreshold = args.scene_threshold ?? DEFAULT_SCENE_THRESHOLD;
+
+  const warnings: string[] = [];
+  const probe = await runFfprobe(sourcePath);
+
+  let format: TimelineDocument['format'];
+  let streams: TimelineDocument['streams'];
+  let chapters: TimelineDocument['chapters'];
+  let assemblyRoute = 'typescript-timeline-v1';
+  let sourceHash: string | undefined;
+  let cacheKey: string | undefined;
+
+  if (shouldUseRustTimelineEngine()) {
+    const assembled = assembleProbeTimelineViaRustEngine(probe, {
+      includeStreams,
+      includeChapters,
+    });
+    format = assembled.format;
+    streams = assembled.streams;
+    chapters = assembled.chapters;
+    warnings.push(...assembled.warnings);
+    assemblyRoute = assembled.route;
+    sourceHash = hashSourceViaRustEngine(sourcePath);
+    cacheKey = buildCacheKeyViaRustEngine(sourceHash, {
+      includeStreams,
+      includeChapters,
+      includeSubtitles,
+      includeScenes,
+      includeTranscript,
+      includeKeyframes,
+      includeKeyframeImages,
+      keyframeLimit,
+      keyframeMaxDimension,
+      sceneThreshold,
+    });
+  } else {
+    warnings.push(...collectProbeWarnings(probe, includeStreams));
+    format = {
+      ...(probe.format.format_name ? { format_name: probe.format.format_name } : {}),
+      duration_ms: secondsToMs(probe.format.duration),
+      ...(probe.format.bit_rate ? { bit_rate: Number.parseInt(probe.format.bit_rate, 10) } : {}),
+      ...(probe.format.size ? { size_bytes: Number.parseInt(probe.format.size, 10) } : {}),
+      ...(probe.format.tags ? { tags: probe.format.tags } : {}),
+    };
+    streams = includeStreams ? mapStreams(probe.streams) : [];
+    chapters = includeChapters ? mapChapters(probe.chapters) : [];
+  }
+
+  let subtitles: TimelineDocument['subtitles'] = [];
+  if (includeSubtitles) {
+    const subtitleStreams = findSubtitleStreams(probe.streams);
+    const extracted = await extractSubtitles(sourcePath, subtitleStreams);
+    subtitles = extracted.subtitles;
+    warnings.push(...extracted.warnings);
+  }
+
+  let scenes: TimelineDocument['scenes'] = [];
+  if (includeScenes) {
+    const detected = await detectScenes(sourcePath, sceneThreshold);
+    scenes = detected.scenes;
+    if (detected.warning) warnings.push(detected.warning);
+  }
+
+  let transcript: TimelineDocument['transcript'] = [];
+  if (includeTranscript) {
+    const asr = await tryAsrTranscript(sourcePath, true);
+    transcript = asr.transcript;
+    if (asr.warning) warnings.push(asr.warning);
+  }
+
+  let keyframes: TimelineDocument['keyframes'] = [];
+  if (includeKeyframes) {
+    const extracted = await extractKeyframes(sourcePath, keyframeLimit, {
+      includeImages: includeKeyframeImages,
+      ...(keyframeMaxDimension !== undefined ? { maxDimension: keyframeMaxDimension } : {}),
+    });
+    keyframes = extracted.keyframes;
+    if (extracted.warning) warnings.push(extracted.warning);
+  }
+
+  return {
+    provenance: {
+      source: sourcePath,
+      tool: 'read_video',
+      version,
+      extracted_at: new Date().toISOString(),
+      ...(sourceHash ? { source_hash: sourceHash } : {}),
+      ...(cacheKey ? { cache_key: cacheKey } : {}),
+      ...(shouldUseRustTimelineEngine() ? { assembly_route: assemblyRoute } : {}),
+    },
+    format,
+    streams,
+    chapters,
+    scenes,
+    subtitles,
+    transcript,
+    keyframes,
+    warnings,
+  };
+};
+
+export const processVideoSource = async (
+  userPath: string,
+  args: ReadVideoArgs,
+  version: string
+): Promise<VideoSourceResult> => {
+  try {
+    const sourcePath = resolvePath(userPath);
+    await access(sourcePath);
+
+    const data = await buildTimelineDocument(sourcePath, args, version);
+    return {
+      source: userPath,
+      success: true,
+      data,
+    };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      source: userPath,
+      success: false,
+      error: message,
+    };
+  }
+};

package/dist/handlers/readVideo.js

@@ -1,24 +0,0 @@
-import { text, tool, toolError } from '../mcp.js';
-import { readVideoArgsSchema } from '../schemas/readVideo.js';
-import { processVideoSource } from '../video/readCoordinator.js';
-const MAX_CONCURRENT_SOURCES = 2;
-export const createReadVideoHandler = (version) => tool()
-    .description('Primary video reader. Returns a timeline document with ffprobe metadata, embedded subtitles, optional scene boundaries, and warnings — no per-frame vision LLM.')
-    .input(readVideoArgsSchema)
-    .handler(async ({ input }) => {
-    const results = [];
-    for (let i = 0; i < input.sources.length; i += MAX_CONCURRENT_SOURCES) {
-        const batch = input.sources.slice(i, i + MAX_CONCURRENT_SOURCES);
-        const batchResults = await Promise.all(batch.map((source) => processVideoSource(source.path, input, version)));
-        results.push(...batchResults);
-    }
-    const allFailed = results.every((result) => !result.success);
-    if (allFailed) {
-        const errorMessages = results.map((result) => result.error).join('; ');
-        return toolError(`All video sources failed to process: ${errorMessages}`);
-    }
-    return text(JSON.stringify({
-        results,
-    }, null, 2));
-});
-export const readVideo = createReadVideoHandler('0.1.0');

package/dist/index.js

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'node:module';
-import { createReadVideoHandler } from './handlers/readVideo.js';
-import { createServer, http, stdio } from './mcp.js';
-const require = createRequire(import.meta.url);
-const packageJson = require('../package.json');
-const transportType = process.env['MCP_TRANSPORT'] ?? 'stdio';
-const httpPort = Number.parseInt(process.env['MCP_HTTP_PORT'] ?? '8080', 10);
-const httpHost = process.env['MCP_HTTP_HOST'] ?? '127.0.0.1';
-const apiKey = process.env['MCP_API_KEY'];
-const corsOrigin = process.env['MCP_CORS_ORIGIN'];
-const isLoopbackHost = (host) => host === 'localhost' || host === '::1' || host === '127.0.0.1' || host.startsWith('127.');
-function createTransport() {
-    if (transportType === 'http') {
-        return http({
-            port: httpPort,
-            hostname: httpHost,
-            ...(corsOrigin ? { cors: corsOrigin } : {}),
-            ...(apiKey ? { apiKey } : {}),
-        });
-    }
-    return stdio();
-}
-const server = createServer({
-    name: 'video-reader-mcp',
-    version: packageJson.version,
-    instructions: 'Evidence-first video reader. Use read_video to extract ffprobe metadata, embedded subtitles, scene boundaries, and timeline warnings without frame-by-frame vision LLM calls.',
-    tools: {
-        read_video: createReadVideoHandler(packageJson.version),
-    },
-    transport: createTransport(),
-});
-async function main() {
-    await server.start();
-    if (transportType === 'http') {
-        console.log(`[Video Reader MCP] Server running on http://${httpHost}:${httpPort}/mcp`);
-        console.log(`[Video Reader MCP] Health check: http://${httpHost}:${httpPort}/mcp/health`);
-        if (apiKey) {
-            console.log('[Video Reader MCP] API key authentication enabled (X-API-Key header)');
-        }
-        else if (!isLoopbackHost(httpHost)) {
-            console.warn(`[Video Reader MCP] WARNING: bound to non-loopback host ${httpHost} with no API key. ` +
-                'Any client that can reach this port can read every video this process can access. ' +
-                'Set MCP_API_KEY to require an X-API-Key header, or bind MCP_HTTP_HOST=127.0.0.1.');
-        }
-        if (corsOrigin) {
-            console.log(`[Video Reader MCP] CORS allowed origin: ${corsOrigin}`);
-        }
-        console.log('[Video Reader MCP] Project root:', process.cwd());
-    }
-    else if (process.env['DEBUG_MCP']) {
-        console.error('[Video Reader MCP] Server running on stdio');
-        console.error('[Video Reader MCP] Project root:', process.cwd());
-    }
-}
-main().catch((error) => {
-    console.error('[Video Reader MCP] Server error:', error);
-    process.exit(1);
-});

package/dist/mcp.js

@@ -1,181 +0,0 @@
-import { createHash, timingSafeEqual } from 'node:crypto';
-import { createServer as createHttpServer } from 'node:http';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { z } from 'zod';
-export const text = (value) => ({ type: 'text', text: value });
-export const image = (data, mimeType) => ({
-    type: 'image',
-    data,
-    mimeType,
-});
-export const toolError = (message) => ({
-    content: [text(message)],
-    isError: true,
-});
-class ToolBuilder {
-    #description;
-    #inputSchema;
-    constructor(descriptionValue, inputSchema) {
-        this.#description = descriptionValue;
-        this.#inputSchema = inputSchema;
-    }
-    description(value) {
-        return new ToolBuilder(value, this.#inputSchema);
-    }
-    input(schema) {
-        return new ToolBuilder(this.#description, schema);
-    }
-    handler(handler) {
-        return {
-            description: this.#description ?? '',
-            inputSchema: this.#inputSchema ?? z.object({}),
-            handler,
-        };
-    }
-}
-export const tool = () => new ToolBuilder();
-export const stdio = () => ({ kind: 'stdio' });
-export const http = (config) => ({ kind: 'http', ...config });
-const isCallToolResult = (result) => typeof result === 'object' && result !== null && 'content' in result;
-const isContentArray = (result) => Array.isArray(result);
-const normalizeToolResult = (result) => {
-    if (isContentArray(result))
-        return { content: [...result] };
-    if (isCallToolResult(result))
-        return result;
-    return { content: [result] };
-};
-const withCors = (res, origin) => {
-    if (!origin)
-        return;
-    res.setHeader('Access-Control-Allow-Origin', origin);
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, MCP-Protocol-Version, Mcp-Session-Id, X-API-Key');
-};
-const isApiKeyValid = (configuredKey, presented) => {
-    const provided = Array.isArray(presented) ? presented[0] : presented;
-    if (typeof provided !== 'string' || provided.length === 0)
-        return false;
-    const expected = createHash('sha256').update(configuredKey).digest();
-    const actual = createHash('sha256').update(provided).digest();
-    return timingSafeEqual(expected, actual);
-};
-const unauthorized = (res) => {
-    res.writeHead(401, { 'Content-Type': 'application/json', 'WWW-Authenticate': 'X-API-Key' });
-    res.end(JSON.stringify({
-        jsonrpc: '2.0',
-        id: null,
-        error: { code: -32001, message: 'Unauthorized: missing or invalid X-API-Key header' },
-    }));
-};
-const ensureStreamableAcceptHeader = (req) => {
-    const accept = req.headers.accept;
-    const acceptValues = Array.isArray(accept) ? accept.join(', ') : (accept ?? '');
-    if (acceptValues.includes('application/json') && acceptValues.includes('text/event-stream')) {
-        return;
-    }
-    req.headers.accept = 'application/json, text/event-stream';
-    const rawAcceptIndex = req.rawHeaders.findIndex((value, index) => index % 2 === 0 && value.toLowerCase() === 'accept');
-    if (rawAcceptIndex >= 0) {
-        req.rawHeaders[rawAcceptIndex + 1] = 'application/json, text/event-stream';
-        return;
-    }
-    req.rawHeaders.push('Accept', 'application/json, text/event-stream');
-};
-const handleNonMcpRoute = (req, res, pathname, transportConfig) => {
-    if (pathname === '/mcp/health' && req.method === 'GET') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok' }));
-        return true;
-    }
-    if (pathname !== '/mcp') {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not found' }));
-        return true;
-    }
-    if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
-        return true;
-    }
-    if (transportConfig.apiKey !== undefined &&
-        !isApiKeyValid(transportConfig.apiKey, req.headers['x-api-key'])) {
-        unauthorized(res);
-        return true;
-    }
-    return false;
-};
-const handleHttpRequest = async (req, res, mcpServer, transportConfig) => {
-    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? transportConfig.hostname}`);
-    withCors(res, transportConfig.cors);
-    if (handleNonMcpRoute(req, res, url.pathname, transportConfig))
-        return;
-    ensureStreamableAcceptHeader(req);
-    const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
-    try {
-        await mcpServer.connect(transport);
-        await transport.handleRequest(req, res);
-    }
-    finally {
-        await mcpServer.close();
-    }
-};
-const startHttpServer = async (serverInfo, transportConfig) => {
-    const mcpServer = buildMcpServer(serverInfo);
-    const httpServer = createHttpServer((req, res) => {
-        void handleHttpRequest(req, res, mcpServer, transportConfig);
-    });
-    await new Promise((resolve, reject) => {
-        httpServer.once('error', reject);
-        httpServer.listen(transportConfig.port, transportConfig.hostname, () => {
-            httpServer.off('error', reject);
-            resolve();
-        });
-    });
-    return { mcpServer, httpServer };
-};
-const buildMcpServer = ({ name, version, instructions, tools, }) => {
-    const mcpServer = new McpServer({ name, version }, {
-        ...(instructions ? { instructions } : {}),
-    });
-    for (const [toolName, definition] of Object.entries(tools)) {
-        mcpServer.registerTool(toolName, {
-            description: definition.description,
-            inputSchema: definition.inputSchema,
-        }, async (input, ctx) => normalizeToolResult(await definition.handler({ input, ctx })));
-    }
-    return mcpServer;
-};
-export const createServer = (options) => {
-    let mcpServer;
-    let httpServer;
-    return {
-        async start() {
-            if (options.transport.kind === 'stdio') {
-                mcpServer = buildMcpServer(options);
-                await mcpServer.connect(new StdioServerTransport());
-                return;
-            }
-            const started = await startHttpServer(options, options.transport);
-            mcpServer = started.mcpServer;
-            httpServer = started.httpServer;
-        },
-        async close() {
-            await mcpServer?.close();
-            const serverToClose = httpServer;
-            if (!serverToClose)
-                return;
-            await new Promise((resolve, reject) => {
-                serverToClose.close((error) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-        },
-    };
-};

package/dist/schemas/readVideo.js

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-export const videoSourceSchema = z.object({
-    path: z.string().min(1).describe('Path to the local video file (absolute or relative to cwd).'),
-});
-export const readVideoArgsSchema = z.object({
-    sources: z.array(videoSourceSchema).min(1).describe('One or more local video sources to read.'),
-    include_streams: z
-        .boolean()
-        .optional()
-        .describe('Include stream metadata from ffprobe. Defaults to true.'),
-    include_chapters: z
-        .boolean()
-        .optional()
-        .describe('Include chapter markers when present. Defaults to true.'),
-    include_subtitles: z
-        .boolean()
-        .optional()
-        .describe('Extract embedded subtitles when available. Defaults to true.'),
-    include_scenes: z
-        .boolean()
-        .optional()
-        .describe('Detect scene boundaries with ffmpeg scene filter. Defaults to true.'),
-    scene_threshold: z
-        .number()
-        .min(0)
-        .max(1)
-        .optional()
-        .describe('Scene detection sensitivity for ffmpeg gt(scene,threshold). Defaults to 0.4.'),
-    include_transcript: z
-        .boolean()
-        .optional()
-        .describe('Attempt optional local ASR transcript when an adapter is installed. Defaults to false.'),
-});

package/dist/types/timeline.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/asr.js

@@ -1,26 +0,0 @@
-import { isBinaryAvailable } from './exec.js';
-const ASR_CANDIDATES = ['whisper', 'whisper-cpp', 'vosk-transcriber'];
-export const detectAsrAdapter = async () => {
-    for (const candidate of ASR_CANDIDATES) {
-        if (await isBinaryAvailable(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-};
-export const tryAsrTranscript = async (_videoPath, enabled) => {
-    if (!enabled) {
-        return { transcript: [] };
-    }
-    const adapter = await detectAsrAdapter();
-    if (!adapter) {
-        return {
-            transcript: [],
-            warning: 'ASR requested but no local adapter found (checked whisper, whisper-cpp, vosk-transcriber); transcript skipped.',
-        };
-    }
-    return {
-        transcript: [],
-        warning: `ASR adapter "${adapter}" detected but transcription is not wired in v0.1.0; transcript skipped.`,
-    };
-};

package/dist/utils/errors.js

@@ -1,14 +0,0 @@
-export var ErrorCode;
-(function (ErrorCode) {
-    ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
-    ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
-    ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
-})(ErrorCode || (ErrorCode = {}));
-export class VideoError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options?.cause ? { cause: options.cause } : undefined);
-        this.code = code;
-        this.name = 'VideoError';
-    }
-}