@usewhisper/mcp-server 1.0.0 → 1.4.0

package/README.md

@@ -5,7 +5,7 @@ Whisper MCP is the universal context bridge for coding agents. It connects Claud
 ## What's New (Major)
 
 - Canonical namespaced tool surface (breaking rename)
-- Source multiplexer in `context.add_source` for `github|web|pdf|local|slack`
+- Source multiplexer in `context.add_source` for `github|web|pdf|local|slack|video`
 - Auto-index by default for created sources
 - Runtime modes: `remote` (default), `local`, `auto`
 - Degraded retrieval behavior: lexical fallback with explicit `degraded_mode`
@@ -25,6 +25,19 @@ npm i -g @usewhisper/mcp-server
 - `WHISPER_BASE_URL` (optional, defaults to `https://context.usewhisper.dev`)
 - `WHISPER_MCP_MODE` (optional: `remote|local|auto`, default `remote`)
 - `WHISPER_LOCAL_ALLOWLIST` (optional comma-separated roots for local ingest)
+- `SLACK_BOT_TOKEN` (required for Slack connector runs)
+- `SLACK_CHANNEL_ID` (required for Slack connector runs)
+
+## Connector Status + Credentials
+
+| Connector | Status | Minimum required config/creds |
+|---|---|---|
+| GitHub | Production-ready | `type=github`, `owner`, `repo` (optional `token`, `branch`, `paths`) |
+| Web | Production-ready | `type=web`, `url` (optional `crawl_depth`, `include_paths`, `exclude_paths`) |
+| PDF | Production-ready | `type=pdf`, `url` or `file_path` |
+| Slack | Production-ready (requires Slack auth) | `type=slack`, `token`, `channel_ids[]` (optional `since`, `workspace_id`) |
+| Local | Production-ready | `type=local`, `path` (optional `glob`, `max_files`) |
+| Video | Production-ready | `type=video`, `url` (optional `platform`, `language`, `allow_stt_fallback`, `max_duration_minutes`, `max_chunks`) |
 
 ## Canonical Tools
 
@@ -52,6 +65,21 @@ npm i -g @usewhisper/mcp-server
 22. `code.search_text`
 23. `code.search_semantic`
 
+## Agent-Friendly Aliases
+
+These aliases sit on top of the canonical namespaced tools and are easier for coding agents to pick correctly:
+
+- `search` -> `context.query`
+- `search_code` -> `code.search_semantic`
+- `grep` -> `code.search_text`
+- `read` -> local file read with optional line ranges
+- `explore` -> local repository tree browsing
+- `research` -> `research.oracle`
+- `index` -> source add or workspace refresh
+- `remember` -> `memory.add`
+- `recall` -> `memory.search`
+- `share_context` -> `context.share`
+
 ## Source Contract (`context.add_source`)
 
 Input:
@@ -60,7 +88,8 @@ Input:
 - `type=web`: `url`, `crawl_depth?`, `include_paths?`, `exclude_paths?`
 - `type=pdf`: `url?`, `file_path?`
 - `type=local`: `path`, `glob?`, `max_files?`
-- `type=slack`: `workspace_id?`, `channel_ids?`, `since?`
+- `type=slack`: `token`, `channel_ids[]`, `workspace_id?`, `since?`, `auth_ref?`
+- `type=video`: `url`, `platform?`, `language?`, `allow_stt_fallback?`, `max_duration_minutes?`, `max_chunks?`
 
 Output:
 - `source_id`
@@ -98,6 +127,21 @@ Local ingest (`index.local_scan_ingest` and `type=local`) enforces:
 - secret/sensitive path filters (`.env`, `.pem`, `.key`, `.aws`, `.ssh`, build artifacts)
 - content redaction pass for likely secrets
 
+## 30-Second Demo
+
+One-command wizard + production MCP connectors + scoped config:
+
+```bash
+npx whisper-wizard
+```
+
+Flow:
+1. Run wizard and complete auth/project setup.
+2. Add a source with MCP:
+`context.add_source` (for example GitHub/Web/PDF/Slack/Local/Video).
+3. Ask a grounded question:
+`context.query` or `context.evidence_answer` for citation-locked output.
+
 ## License
 
-MIT
+MIT

package/dist/server.js

@@ -1365,6 +1365,18 @@ var TOOL_MIGRATION_MAP = [
   { old: "search_files", next: "code.search_text" },
   { old: "semantic_search_codebase", next: "code.search_semantic" }
 ];
+var ALIAS_TOOL_MAP = [
+  { alias: "search", target: "context.query" },
+  { alias: "search_code", target: "code.search_semantic" },
+  { alias: "grep", target: "code.search_text" },
+  { alias: "read", target: "local.file_read" },
+  { alias: "explore", target: "local.tree" },
+  { alias: "research", target: "research.oracle" },
+  { alias: "index", target: "context.add_source | index.workspace_run" },
+  { alias: "remember", target: "memory.add" },
+  { alias: "recall", target: "memory.search" },
+  { alias: "share_context", target: "context.share" }
+];
 function ensureStateDir() {
   if (!existsSync(STATE_DIR)) {
     mkdirSync(STATE_DIR, { recursive: true });
@@ -1715,7 +1727,7 @@ async function ingestLocalPath(params) {
   return { ingested, scanned: files.length, queued: docs.length, skipped, workspace_id: workspaceId };
 }
 async function createSourceByType(params) {
-  const connector_type = params.type === "github" ? "github" : params.type === "web" ? "website" : params.type === "pdf" ? "pdf" : params.type === "local" ? "local-folder" : "slack";
+  const connector_type = params.type === "github" ? "github" : params.type === "web" ? "website" : params.type === "pdf" ? "pdf" : params.type === "local" ? "local-folder" : params.type === "slack" ? "slack" : "video";
   const config = {};
   if (params.type === "github") {
     if (!params.owner || !params.repo) throw new Error("github source requires owner and repo");
@@ -1755,6 +1767,14 @@ async function createSourceByType(params) {
     if (params.workspace_id) config.workspace_id = params.workspace_id;
     if (params.token) config.token = params.token;
     if (params.auth_ref) config.auth_ref = params.auth_ref;
+  } else if (params.type === "video") {
+    if (!params.url) throw new Error("video source requires url");
+    config.url = params.url;
+    if (params.platform) config.platform = params.platform;
+    if (params.language) config.language = params.language;
+    if (params.allow_stt_fallback !== void 0) config.allow_stt_fallback = params.allow_stt_fallback;
+    if (params.max_duration_minutes !== void 0) config.max_duration_minutes = params.max_duration_minutes;
+    if (params.max_chunks !== void 0) config.max_chunks = params.max_chunks;
   }
   if (params.metadata) config.metadata = params.metadata;
   config.auto_index = params.auto_index ?? true;
@@ -1798,6 +1818,10 @@ function printToolMap() {
   for (const row of TOOL_MIGRATION_MAP) {
     console.log(`- ${row.old} => ${row.next}`);
   }
+  console.log("\nAgent-friendly aliases:");
+  for (const row of ALIAS_TOOL_MAP) {
+    console.log(`- ${row.alias} => ${row.target}`);
+  }
 }
 server.tool(
   "index.workspace_resolve",
@@ -2309,7 +2333,7 @@ server.tool(
   "Add a source to a project with normalized source contract and auto-index by default.",
   {
     project: z.string().optional().describe("Project name or slug"),
-    type: z.enum(["github", "web", "pdf", "local", "slack"]).default("github"),
+    type: z.enum(["github", "web", "pdf", "local", "slack", "video"]).default("github"),
     name: z.string().optional(),
     auto_index: z.boolean().optional().default(true),
     metadata: z.record(z.string()).optional(),
@@ -2329,7 +2353,12 @@ server.tool(
     channel_ids: z.array(z.string()).optional(),
     since: z.string().optional(),
     token: z.string().optional(),
-    auth_ref: z.string().optional()
+    auth_ref: z.string().optional(),
+    platform: z.enum(["youtube", "loom", "generic"]).optional(),
+    language: z.string().optional(),
+    allow_stt_fallback: z.boolean().optional(),
+    max_duration_minutes: z.number().optional(),
+    max_chunks: z.number().optional()
   },
   async (input) => {
     try {
@@ -2359,7 +2388,12 @@ server.tool(
         channel_ids: input.channel_ids,
         since: input.since,
         token: input.token,
-        auth_ref: input.auth_ref
+        auth_ref: input.auth_ref,
+        platform: input.platform,
+        language: input.language,
+        allow_stt_fallback: input.allow_stt_fallback,
+        max_duration_minutes: input.max_duration_minutes,
+        max_chunks: input.max_chunks
       });
       return toTextResult(result);
     } catch (error) {
@@ -3208,6 +3242,39 @@ function* walkDir(dir, fileTypes) {
     }
   }
 }
+function listTree(rootPath, maxDepth = 3, maxEntries = 200) {
+  const lines = [];
+  let seen = 0;
+  function walk(dir, depth) {
+    if (seen >= maxEntries || depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const filtered = entries.filter((entry) => !SKIP_DIRS.has(entry.name)).sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+    for (const entry of filtered) {
+      if (seen >= maxEntries) return;
+      const indent = "  ".repeat(depth);
+      lines.push(`${indent}${entry.isDirectory() ? "d" : "f"} ${entry.name}`);
+      seen += 1;
+      if (entry.isDirectory()) {
+        walk(join(dir, entry.name), depth + 1);
+      }
+    }
+  }
+  walk(rootPath, 0);
+  return lines;
+}
+function readFileWindow(filePath, startLine = 1, endLine = 200) {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const safeStart = Math.max(1, startLine);
+  const safeEnd = Math.max(safeStart, endLine);
+  const excerpt = lines.slice(safeStart - 1, safeEnd).map((line, index) => `${safeStart + index}: ${line}`).join("\n");
+  return excerpt || "(empty file)";
+}
 server.tool(
   "code.search_text",
   "Search files and content in a local directory without requiring pre-indexing. Uses ripgrep when available, falls back to Node.js. Great for finding files, functions, patterns, or any text across a codebase instantly.",
@@ -3391,6 +3458,377 @@ server.tool(
     }
   }
 );
+server.tool(
+  "search",
+  "Search indexed code, docs, and connected sources with one obvious verb. Use this first for most retrieval tasks.",
+  {
+    project: z.string().optional().describe("Project name or slug"),
+    query: z.string().describe("What you want to find"),
+    top_k: z.number().optional().default(10),
+    include_memories: z.boolean().optional().default(false),
+    include_graph: z.boolean().optional().default(false),
+    user_id: z.string().optional(),
+    session_id: z.string().optional()
+  },
+  async ({ project, query, top_k, include_memories, include_graph, user_id, session_id }) => {
+    try {
+      const resolvedProject = await resolveProjectRef(project);
+      if (!resolvedProject) {
+        return { content: [{ type: "text", text: "Error: No project resolved. Set WHISPER_PROJECT or pass project." }] };
+      }
+      const queryResult = await queryWithDegradedFallback({
+        project: resolvedProject,
+        query,
+        top_k,
+        include_memories,
+        include_graph,
+        user_id,
+        session_id
+      });
+      const response = queryResult.response;
+      if (!response.results?.length) {
+        return { content: [{ type: "text", text: `No relevant results found for "${query}".` }] };
+      }
+      const suffix = queryResult.degraded_mode ? `
+
+[degraded_mode=true] ${queryResult.degraded_reason}` : "";
+      return { content: [{ type: "text", text: response.context + suffix }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "search_code",
+  "Semantically search a local codebase by meaning. Use this for questions like 'where is auth handled?' or 'find retry logic'.",
+  {
+    query: z.string().describe("Natural-language code search query"),
+    path: z.string().optional().describe("Codebase root. Defaults to current working directory."),
+    file_types: z.array(z.string()).optional(),
+    top_k: z.number().optional().default(10),
+    threshold: z.number().optional().default(0.2),
+    max_files: z.number().optional().default(150)
+  },
+  async ({ query, path, file_types, top_k, threshold, max_files }) => {
+    const rootPath = path || process.cwd();
+    const allowedExts = file_types ? new Set(file_types) : CODE_EXTENSIONS;
+    const files = [];
+    function collect(dir) {
+      if (files.length >= (max_files ?? 150)) return;
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (files.length >= (max_files ?? 150)) break;
+        if (SKIP_DIRS.has(entry.name)) continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) collect(full);
+        else if (entry.isFile()) {
+          const ext = extname(entry.name).replace(".", "");
+          if (allowedExts.has(ext)) files.push(full);
+        }
+      }
+    }
+    collect(rootPath);
+    if (files.length === 0) {
+      return { content: [{ type: "text", text: `No code files found in ${rootPath}` }] };
+    }
+    const documents = [];
+    for (const filePath of files) {
+      try {
+        const stat = statSync(filePath);
+        if (stat.size > 500 * 1024) continue;
+        const content = readFileSync(filePath, "utf-8");
+        const relPath = relative(rootPath, filePath);
+        documents.push({ id: relPath, content: extractSignature(relPath, content) });
+      } catch {
+      }
+    }
+    try {
+      const response = await whisper.semanticSearch({
+        query,
+        documents,
+        top_k: top_k ?? 10,
+        threshold: threshold ?? 0.2
+      });
+      if (!response.results?.length) {
+        return { content: [{ type: "text", text: `No semantically relevant files found for "${query}".` }] };
+      }
+      const lines = response.results.map((result) => `${result.id} (score: ${result.score})${result.snippet ? `
+${result.snippet}` : ""}`);
+      return { content: [{ type: "text", text: lines.join("\n\n") }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Semantic search failed: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "grep",
+  "Regex or text search across a local codebase. Use this when you know the symbol, string, or pattern you want.",
+  {
+    query: z.string().describe("Text or regex-like pattern to search for"),
+    path: z.string().optional().describe("Search root. Defaults to current working directory."),
+    file_types: z.array(z.string()).optional(),
+    max_results: z.number().optional().default(20),
+    case_sensitive: z.boolean().optional().default(false)
+  },
+  async ({ query, path, file_types, max_results, case_sensitive }) => {
+    const rootPath = path || process.cwd();
+    const results = [];
+    const regex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), case_sensitive ? "g" : "gi");
+    for (const filePath of walkDir(rootPath, file_types)) {
+      if (results.length >= (max_results ?? 20)) break;
+      try {
+        const stat = statSync(filePath);
+        if (stat.size > 512 * 1024) continue;
+        const text = readFileSync(filePath, "utf-8");
+        const lines2 = text.split("\n");
+        const matches = [];
+        lines2.forEach((line, index) => {
+          regex.lastIndex = 0;
+          if (regex.test(line)) {
+            matches.push({ line: index + 1, content: line.trimEnd() });
+          }
+        });
+        if (matches.length > 0) {
+          results.push({ file: relative(rootPath, filePath), matches: matches.slice(0, 10) });
+        }
+      } catch {
+      }
+    }
+    if (!results.length) {
+      return { content: [{ type: "text", text: `No matches found for "${query}" in ${rootPath}` }] };
+    }
+    const lines = results.flatMap((result) => [
+      `FILE ${result.file}`,
+      ...result.matches.map((match) => `L${match.line}: ${match.content}`),
+      ""
+    ]);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+server.tool(
+  "read",
+  "Read a local file with optional line ranges. Use this after search or grep when you want the actual source.",
+  {
+    path: z.string().describe("Absolute or relative path to the file to read."),
+    start_line: z.number().optional().default(1),
+    end_line: z.number().optional().default(200)
+  },
+  async ({ path, start_line, end_line }) => {
+    try {
+      const fullPath = path.includes(":") || path.startsWith("/") ? path : join(process.cwd(), path);
+      const stats = statSync(fullPath);
+      if (!stats.isFile()) {
+        return { content: [{ type: "text", text: `Error: ${path} is not a file.` }] };
+      }
+      return { content: [{ type: "text", text: readFileWindow(fullPath, start_line, end_line) }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "explore",
+  "Browse a repository tree or directory structure. Use this to orient yourself before reading files.",
+  {
+    path: z.string().optional().describe("Root directory to inspect. Defaults to current working directory."),
+    max_depth: z.number().optional().default(3),
+    max_entries: z.number().optional().default(200)
+  },
+  async ({ path, max_depth, max_entries }) => {
+    try {
+      const rootPath = path || process.cwd();
+      const tree = listTree(rootPath, max_depth, max_entries);
+      if (!tree.length) {
+        return { content: [{ type: "text", text: `No visible files found in ${rootPath}` }] };
+      }
+      return { content: [{ type: "text", text: [`TREE ${rootPath}`, ...tree].join("\n") }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "research",
+  "Run deeper research over indexed sources. Use this when search is not enough and you want synthesis or multi-step investigation.",
+  {
+    project: z.string().optional(),
+    query: z.string().describe("Research question"),
+    mode: z.enum(["search", "research"]).optional().default("research"),
+    max_results: z.number().optional().default(5),
+    max_steps: z.number().optional().default(5)
+  },
+  async ({ project, query, mode, max_results, max_steps }) => {
+    try {
+      const results = await whisper.oracleSearch({ project, query, mode, max_results, max_steps });
+      if (mode === "research" && results.answer) {
+        return { content: [{ type: "text", text: results.answer }] };
+      }
+      if (!results.results?.length) {
+        return { content: [{ type: "text", text: "No research results found." }] };
+      }
+      const text = results.results.map((r, i) => `${i + 1}. ${r.path || r.source}
+${String(r.content || "").slice(0, 200)}...`).join("\n\n");
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "index",
+  "Index a new source or refresh a workspace. Use action='source' to add GitHub/web/pdf/local/slack/video. Use action='workspace' to refresh local workspace metadata.",
+  {
+    action: z.enum(["source", "workspace"]).default("source"),
+    project: z.string().optional(),
+    type: z.enum(["github", "web", "pdf", "local", "slack", "video"]).optional(),
+    name: z.string().optional(),
+    owner: z.string().optional(),
+    repo: z.string().optional(),
+    branch: z.string().optional(),
+    url: z.string().optional(),
+    file_path: z.string().optional(),
+    path: z.string().optional(),
+    glob: z.string().optional(),
+    max_files: z.number().optional(),
+    channel_ids: z.array(z.string()).optional(),
+    token: z.string().optional(),
+    workspace_id: z.string().optional(),
+    mode: z.enum(["full", "incremental"]).optional().default("incremental"),
+    platform: z.enum(["youtube", "loom", "generic"]).optional(),
+    language: z.string().optional(),
+    allow_stt_fallback: z.boolean().optional(),
+    max_duration_minutes: z.number().optional(),
+    max_chunks: z.number().optional()
+  },
+  async (input) => {
+    try {
+      if (input.action === "workspace") {
+        const rootPath = input.path || process.cwd();
+        const workspaceId = getWorkspaceIdForPath(rootPath, input.workspace_id);
+        const state = loadState();
+        const workspace = getWorkspaceState(state, workspaceId);
+        const fileStats = countCodeFiles(rootPath, input.max_files || 1500);
+        workspace.index_metadata = {
+          last_indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
+          last_indexed_commit: getGitHead(rootPath),
+          coverage: input.mode === "full" ? 1 : Math.max(0, Math.min(1, fileStats.total / Math.max(1, input.max_files || 1500)))
+        };
+        saveState(state);
+        return toTextResult({ workspace_id: workspaceId, mode: input.mode, indexed_files: fileStats.total, skipped_files: fileStats.skipped, index_metadata: workspace.index_metadata });
+      }
+      if (!input.type) {
+        return { content: [{ type: "text", text: "Error: type is required when action='source'." }] };
+      }
+      const resolvedProject = await resolveProjectRef(input.project);
+      if (!resolvedProject) {
+        return { content: [{ type: "text", text: "Error: No project resolved. Set WHISPER_PROJECT or provide project." }] };
+      }
+      const result = await createSourceByType({
+        project: resolvedProject,
+        type: input.type,
+        name: input.name,
+        owner: input.owner,
+        repo: input.repo,
+        branch: input.branch,
+        url: input.url,
+        file_path: input.file_path,
+        path: input.path,
+        glob: input.glob,
+        max_files: input.max_files,
+        channel_ids: input.channel_ids,
+        token: input.token,
+        workspace_id: input.workspace_id,
+        platform: input.platform,
+        language: input.language,
+        allow_stt_fallback: input.allow_stt_fallback,
+        max_duration_minutes: input.max_duration_minutes,
+        max_chunks: input.max_chunks,
+        auto_index: true
+      });
+      return toTextResult(result);
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "remember",
+  "Store something the agent should keep across sessions: a fact, decision, preference, or instruction.",
+  {
+    project: z.string().optional(),
+    content: z.string().describe("Memory content"),
+    memory_type: z.enum(["factual", "preference", "event", "relationship", "opinion", "goal", "instruction"]).optional().default("factual"),
+    user_id: z.string().optional(),
+    session_id: z.string().optional(),
+    agent_id: z.string().optional(),
+    importance: z.number().optional().default(0.5)
+  },
+  async ({ project, content, memory_type, user_id, session_id, agent_id, importance }) => {
+    try {
+      const result = await whisper.addMemory({ project, content, memory_type, user_id, session_id, agent_id, importance });
+      return { content: [{ type: "text", text: `Memory stored (id: ${result.id}, type: ${memory_type}).` }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "recall",
+  "Recall facts, decisions, and preferences from previous sessions or prior work.",
+  {
+    project: z.string().optional(),
+    query: z.string().describe("What to recall"),
+    user_id: z.string().optional(),
+    session_id: z.string().optional(),
+    top_k: z.number().optional().default(10),
+    memory_types: z.array(z.enum(["factual", "preference", "event", "relationship", "opinion", "goal", "instruction"])).optional()
+  },
+  async ({ project, query, user_id, session_id, top_k, memory_types }) => {
+    try {
+      const results = await whisper.searchMemoriesSOTA({ project, query, user_id, session_id, top_k, memory_types });
+      if (!results.memories?.length) {
+        return { content: [{ type: "text", text: "No memories found." }] };
+      }
+      const text = results.memories.map((r, i) => `${i + 1}. [${r.memory_type}, score: ${r.similarity?.toFixed(3) || "N/A"}]
+${r.content}`).join("\n\n");
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
+server.tool(
+  "share_context",
+  "Create a shareable snapshot of a session so another agent or teammate can continue with the same context.",
+  {
+    project: z.string().optional(),
+    session_id: z.string().describe("Session to share"),
+    title: z.string().optional(),
+    expiry_days: z.number().optional().default(30)
+  },
+  async ({ project, session_id, title, expiry_days }) => {
+    try {
+      const result = await whisper.createSharedContext({ project, session_id, title, expiry_days });
+      return {
+        content: [{
+          type: "text",
+          text: `Shared context created:
+- Share ID: ${result.share_id}
+- Expires: ${result.expires_at || "Never"}
+
+Share URL: ${result.share_url}`
+        }]
+      };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+    }
+  }
+);
 async function main() {
   const args = process.argv.slice(2);
   if (args.includes("--print-tool-map")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usewhisper/mcp-server",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "scripts": {
     "build": "tsup ../src/mcp/server.ts --format esm --out-dir dist",
     "prepublishOnly": "npm run build"