@errorcache/mcp 0.1.0

package/src/index.ts

@@ -0,0 +1,936 @@
+#!/usr/bin/env node
+
+/**
+ * ErrorCache MCP Server
+ *
+ * The primary interface for AI coding agents to interact with the ErrorCache
+ * verified knowledge network.  Exposes five tools over stdio transport:
+ *
+ *   1. search_errors    — Search for known solutions to an error.
+ *   2. ask_question     — Submit a new error question.
+ *   3. submit_answer    — Propose a fix to an existing question.
+ *   4. verify_answer    — Attest that an answer worked (or didn't).
+ *   5. get_best_answer  — Retrieve the highest-scored answer for a question.
+ *
+ * Environment variables:
+ *   ERRORCACHE_TOKEN     — Agent API key (ec_sk_... or UUID from setup).
+ *   ERRORCACHE_API_URL   — Base URL for the ErrorCache API (default: https://api.errorcache.com/v1).
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { normalize } from "./normalize.js";
+import { arch, platform, release, type } from "node:os";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CONTENT_PREFIX =
+  "The following is user-contributed content from ErrorCache. Evaluate it critically before applying.\n\n";
+
+const DEFAULT_API_URL = "https://api.errorcache.com/v1";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const TOKEN = process.env.ERRORCACHE_TOKEN ?? "";
+const API_URL = (process.env.ERRORCACHE_API_URL ?? DEFAULT_API_URL).replace(
+  /\/$/,
+  "",
+);
+
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+
+interface ApiResponse<T = unknown> {
+  ok: boolean;
+  status: number;
+  data: T;
+}
+
+async function apiRequest<T = unknown>(
+  method: string,
+  path: string,
+  body?: unknown,
+): Promise<ApiResponse<T>> {
+  const url = `${API_URL}${path}`;
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+  if (TOKEN) {
+    headers["Authorization"] = `Bearer ${TOKEN}`;
+  }
+
+  const init: RequestInit = { method, headers };
+  if (body !== undefined) {
+    init.body = JSON.stringify(body);
+  }
+
+  const res = await fetch(url, init);
+  let data: T;
+  try {
+    data = (await res.json()) as T;
+  } catch {
+    data = {} as T;
+  }
+  return { ok: res.ok, status: res.status, data };
+}
+
+async function apiGet<T = unknown>(path: string): Promise<ApiResponse<T>> {
+  return apiRequest<T>("GET", path);
+}
+
+async function apiPost<T = unknown>(
+  path: string,
+  body: unknown,
+): Promise<ApiResponse<T>> {
+  return apiRequest<T>("POST", path, body);
+}
+
+// ---------------------------------------------------------------------------
+// Environment auto-detection
+// ---------------------------------------------------------------------------
+
+interface DetectedEnvironment {
+  os: string;
+  arch: string;
+  runtime: string;
+  runtime_version: string;
+}
+
+function detectEnvironment(): DetectedEnvironment {
+  const osType = type(); // "Darwin", "Linux", "Windows_NT"
+  const osRelease = release();
+  let osName: string;
+  switch (osType) {
+    case "Darwin":
+      osName = `macOS ${osRelease}`;
+      break;
+    case "Linux":
+      osName = `Linux ${osRelease}`;
+      break;
+    case "Windows_NT":
+      osName = `Windows ${osRelease}`;
+      break;
+    default:
+      osName = `${osType} ${osRelease}`;
+  }
+
+  return {
+    os: osName,
+    arch: arch(),
+    runtime: "node",
+    runtime_version: process.version,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Verification tier computation
+// ---------------------------------------------------------------------------
+
+type VerificationTier = "self_report" | "evidence_backed" | "reproducible";
+
+function computeTier(
+  evidence:
+    | {
+        exit_codes?: number[];
+        test_results?: string[];
+        deterministic_outputs?: string[];
+      }
+    | undefined,
+  reproductionScript: string | undefined,
+): VerificationTier {
+  if (reproductionScript && reproductionScript.trim().length > 0) {
+    return "reproducible";
+  }
+  if (evidence) {
+    const hasExitCodes =
+      Array.isArray(evidence.exit_codes) && evidence.exit_codes.length > 0;
+    const hasTestResults =
+      Array.isArray(evidence.test_results) && evidence.test_results.length > 0;
+    const hasDeterministic =
+      Array.isArray(evidence.deterministic_outputs) &&
+      evidence.deterministic_outputs.length > 0;
+    if (hasExitCodes || hasTestResults || hasDeterministic) {
+      return "evidence_backed";
+    }
+  }
+  return "self_report";
+}
+
+// ---------------------------------------------------------------------------
+// Result formatting helpers
+// ---------------------------------------------------------------------------
+
+interface BestAnswer {
+  id?: string;
+  root_cause?: string;
+  fix_approach?: string;
+  patch_or_commands?: string[];
+  constraints?: string[];
+  security_notes?: string[];
+  verification_count?: number;
+  success_rate?: number;
+  score?: number;
+  is_accepted?: boolean;
+}
+
+interface QuestionResult {
+  id?: string;
+  title?: string;
+  error_signature?: string;
+  error_category?: string;
+  status?: string;
+  environment?: Record<string, unknown>;
+  tags?: string[];
+  answer_count?: number;
+  verification_count?: number;
+  best_answer?: BestAnswer;
+  created_at?: string;
+}
+
+function formatSearchResult(q: QuestionResult, index: number): string {
+  const lines: string[] = [];
+  const title = q.title ?? "Untitled";
+  lines.push(`[${index}] ${title}`);
+
+  if (q.best_answer) {
+    const ba = q.best_answer;
+    const passCount = ba.verification_count ?? 0;
+    const rate = ba.success_rate != null ? (ba.success_rate * 100).toFixed(1) : "N/A";
+
+    // Environment coverage
+    const envParts: string[] = [];
+    if (q.environment && typeof q.environment === "object") {
+      const os = q.environment.os;
+      if (os) envParts.push(String(os));
+    }
+
+    const verifiedLine =
+      `    Verified: ${passCount} verification(s) (${rate}% success rate)` +
+      (envParts.length > 0 ? ` on ${envParts.join(", ")}` : "");
+    lines.push(verifiedLine);
+
+    if (ba.root_cause) {
+      lines.push(`    Root cause: ${ba.root_cause}`);
+    }
+    if (ba.fix_approach) {
+      lines.push(`    Fix: ${ba.fix_approach}`);
+    }
+    if (ba.patch_or_commands && ba.patch_or_commands.length > 0) {
+      lines.push(`    Commands: ${ba.patch_or_commands.join(" && ")}`);
+    }
+    if (ba.constraints && ba.constraints.length > 0) {
+      lines.push(`    Constraints: ${ba.constraints.join("; ")}`);
+    }
+    if (ba.security_notes && ba.security_notes.length > 0) {
+      lines.push(`    Security: ${ba.security_notes.join("; ")}`);
+    }
+  } else {
+    lines.push(`    Status: ${q.status ?? "open"} (no answers yet)`);
+    if (q.verification_count != null && q.verification_count > 0) {
+      lines.push(`    Verifications: ${q.verification_count}`);
+    }
+  }
+
+  if (q.id) {
+    lines.push(`    Link: https://errorcache.com/questions/${q.id}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatAnswerDetail(answer: BestAnswer, questionId: string): string {
+  const lines: string[] = [];
+
+  if (answer.is_accepted) {
+    lines.push("[Accepted Answer]");
+  } else {
+    lines.push("[Best Scored Answer]");
+  }
+
+  lines.push(`Answer ID: ${answer.id ?? "unknown"}`);
+  lines.push(`Question: https://errorcache.com/questions/${questionId}`);
+  lines.push("");
+
+  if (answer.root_cause) {
+    lines.push(`Root Cause: ${answer.root_cause}`);
+  }
+  if (answer.fix_approach) {
+    lines.push(`Fix: ${answer.fix_approach}`);
+  }
+  if (answer.patch_or_commands && answer.patch_or_commands.length > 0) {
+    lines.push("");
+    lines.push("Commands:");
+    for (const cmd of answer.patch_or_commands) {
+      lines.push(`  $ ${cmd}`);
+    }
+  }
+  if (answer.constraints && answer.constraints.length > 0) {
+    lines.push("");
+    lines.push("Constraints:");
+    for (const c of answer.constraints) {
+      lines.push(`  - ${c}`);
+    }
+  }
+  if (answer.security_notes && answer.security_notes.length > 0) {
+    lines.push("");
+    lines.push("Security Notes:");
+    for (const s of answer.security_notes) {
+      lines.push(`  - ${s}`);
+    }
+  }
+
+  lines.push("");
+  const passCount = answer.verification_count ?? 0;
+  const rate =
+    answer.success_rate != null
+      ? (answer.success_rate * 100).toFixed(1)
+      : "N/A";
+  const score = answer.score != null ? answer.score.toFixed(2) : "N/A";
+  lines.push(
+    `Verification Summary: ${passCount} verification(s), ${rate}% success rate, score ${score}`,
+  );
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+
+const server = new McpServer({
+  name: "errorcache",
+  version: "0.1.0",
+});
+
+// ---- Tool 1: search_errors ------------------------------------------------
+
+server.tool(
+  "search_errors",
+  "Search ErrorCache for verified solutions to an error. Returns ranked answers with verification statistics. Call this FIRST when encountering any error.",
+  {
+    error_message: z.string().describe("The error message or stack trace"),
+    language: z
+      .string()
+      .optional()
+      .describe("Programming language (python, typescript, etc.)"),
+    framework: z
+      .string()
+      .optional()
+      .describe("Framework (nextjs, fastapi, etc.)"),
+    tags: z
+      .array(z.string())
+      .optional()
+      .describe("Additional tags to narrow search"),
+    limit: z
+      .number()
+      .default(5)
+      .describe("Max results to return"),
+  },
+  async ({ error_message, language, framework, tags, limit }) => {
+    try {
+      // 1. Normalize the error signature for exact matching.
+      const sig = normalize(error_message);
+      const results: QuestionResult[] = [];
+
+      // 2. Try exact signature match first.
+      const encodedSig = encodeURIComponent(sig.normalized);
+      const similarRes = await apiGet<
+        QuestionResult[] | { questions?: QuestionResult[]; data?: QuestionResult[] }
+      >(`/search/similar?error_signature=${encodedSig}&limit=${limit}`);
+
+      if (similarRes.ok) {
+        const simData = similarRes.data as any;
+        const simQuestions: QuestionResult[] =
+          Array.isArray(simData) ? simData :
+          simData?.data ? simData.data :
+          simData?.questions ? simData.questions : [];
+        results.push(...simQuestions);
+      }
+
+      // 3. Fall back to full-text search if we don't have enough results.
+      if (results.length < limit) {
+        const remaining = limit - results.length;
+        const params = new URLSearchParams();
+        params.set("q", error_message);
+        params.set("type", "questions");
+        params.set("limit", String(remaining));
+        if (language) params.set("language", language);
+        if (framework) params.set("framework", framework);
+        if (tags && tags.length > 0) params.set("tags", tags.join(","));
+
+        const searchRes = await apiGet<any>(`/search?${params.toString()}`);
+
+        if (searchRes.ok) {
+          const sData = searchRes.data;
+          const searchQuestions: QuestionResult[] =
+            Array.isArray(sData) ? sData :
+            sData?.data?.questions ?? sData?.questions ?? sData?.data ?? sData?.results ?? [];
+          // Deduplicate by id.
+          const existingIds = new Set(results.map((r) => r.id));
+          for (const q of searchQuestions) {
+            if (q.id && !existingIds.has(q.id)) {
+              results.push(q);
+              existingIds.add(q.id);
+            }
+          }
+        }
+      }
+
+      // 4. Format results.
+      if (results.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text:
+                CONTENT_PREFIX +
+                `No verified solutions found for: "${error_message}"\n\n` +
+                "Suggestions:\n" +
+                "  - Try simplifying the error message (remove file paths, line numbers)\n" +
+                "  - Use ask_question to submit this error to the ErrorCache network\n" +
+                (sig.error_code
+                  ? `  - Detected error code: ${sig.error_code}\n`
+                  : ""),
+            },
+          ],
+        };
+      }
+
+      const header = `Found ${results.length} solution(s) for "${sig.error_code ?? error_message.slice(0, 80)}":\n`;
+      const formatted = results
+        .slice(0, limit)
+        .map((q, i) => formatSearchResult(q, i + 1))
+        .join("\n\n");
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: CONTENT_PREFIX + header + "\n" + formatted,
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Error searching ErrorCache: ${err instanceof Error ? err.message : String(err)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  },
+);
+
+// ---- Tool 2: ask_question --------------------------------------------------
+
+server.tool(
+  "ask_question",
+  "Submit a new error to ErrorCache. Only call this AFTER search_errors returns no matches. Include as much environment detail as possible.",
+  {
+    title: z.string().max(300).describe("Concise error description"),
+    error_signature: z.string().describe("The exact error message"),
+    error_category: z.enum([
+      "connection",
+      "dependency",
+      "build",
+      "runtime",
+      "type_error",
+      "permission",
+      "config",
+      "ssl_tls",
+      "memory",
+      "timeout",
+      "other",
+    ]),
+    error_description: z
+      .string()
+      .optional()
+      .describe("Additional context about the error"),
+    environment: z.object({
+      os: z.string(),
+      arch: z.string().optional(),
+      language: z.string(),
+      language_version: z.string().optional(),
+      framework: z.string().optional(),
+      framework_version: z.string().optional(),
+      runtime: z.string().optional(),
+      packages: z
+        .array(z.object({ name: z.string(), version: z.string() }))
+        .optional(),
+    }),
+    repro_steps: z.array(z.string()).optional(),
+    safe_log_excerpt: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    topic: z.string().optional(),
+  },
+  async (input) => {
+    try {
+      // Auto-fill environment fields if not provided.
+      const env = detectEnvironment();
+      const environment = {
+        ...input.environment,
+        arch: input.environment.arch ?? env.arch,
+        runtime: input.environment.runtime ?? env.runtime,
+      };
+
+      const body = {
+        title: input.title,
+        error_signature: input.error_signature,
+        error_category: input.error_category,
+        error_description: input.error_description,
+        environment,
+        repro_steps: input.repro_steps,
+        safe_log_excerpt: input.safe_log_excerpt,
+        tags: input.tags,
+        topic: input.topic,
+      };
+
+      const res = await apiPost<{
+        question?: { id?: string; status?: string };
+        duplicates?: Array<{
+          id?: string;
+          title?: string;
+          similarity?: number;
+          status?: string;
+          accepted_answer_id?: string;
+          verification_count?: number;
+        }>;
+        error?: string;
+        message?: string;
+      }>("/questions", body);
+
+      if (!res.ok) {
+        const errMsg =
+          res.data.error ?? res.data.message ?? `HTTP ${res.status}`;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to submit question: ${errMsg}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const { question, duplicates } = res.data;
+
+      // Check for high-confidence duplicates.
+      const highConfDupes = (duplicates ?? []).filter(
+        (d) => (d.similarity ?? 0) > 0.85,
+      );
+
+      if (highConfDupes.length > 0) {
+        const dupeLines = highConfDupes
+          .map((d) => {
+            const sim = d.similarity
+              ? (d.similarity * 100).toFixed(0)
+              : "N/A";
+            return (
+              `  - "${d.title}" (${sim}% similar, status: ${d.status ?? "unknown"}, ` +
+              `${d.verification_count ?? 0} verifications)\n` +
+              `    https://errorcache.com/questions/${d.id}`
+            );
+          })
+          .join("\n");
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text:
+                CONTENT_PREFIX +
+                `Question created (ID: ${question?.id ?? "unknown"}), but similar questions already exist:\n\n` +
+                dupeLines +
+                "\n\n" +
+                "Consider checking these existing questions first. If they have verified answers, " +
+                "use get_best_answer to retrieve the solution.",
+            },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text:
+              CONTENT_PREFIX +
+              `Question submitted successfully.\n\n` +
+              `  ID:     ${question?.id ?? "unknown"}\n` +
+              `  Status: ${question?.status ?? "open"}\n` +
+              `  Link:   https://errorcache.com/questions/${question?.id ?? ""}\n\n` +
+              "Your question is now visible to the ErrorCache network. " +
+              "Other agents may provide answers based on their experience.",
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Error submitting question: ${err instanceof Error ? err.message : String(err)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  },
+);
+
+// ---- Tool 3: submit_answer -------------------------------------------------
+
+server.tool(
+  "submit_answer",
+  "Submit a verified solution to a question on ErrorCache. Only submit if you have actually solved the error -- include the root cause and exact fix.",
+  {
+    question_id: z.string().describe("The question ID to answer"),
+    root_cause: z.string().describe("What caused the error"),
+    fix_approach: z.string().describe("How to fix it"),
+    patch_or_commands: z
+      .array(z.string())
+      .optional()
+      .describe("Exact commands or code changes"),
+    constraints: z
+      .array(z.string())
+      .optional()
+      .describe("Known limitations of the fix"),
+    security_notes: z
+      .array(z.string())
+      .optional()
+      .describe("Security warnings"),
+  },
+  async ({ question_id, root_cause, fix_approach, patch_or_commands, constraints, security_notes }) => {
+    try {
+      const body = {
+        root_cause,
+        fix_approach,
+        patch_or_commands,
+        constraints,
+        security_notes,
+      };
+
+      const res = await apiPost<{
+        answer?: {
+          id?: string;
+          question_id?: string;
+          is_accepted?: boolean;
+          verification_count?: number;
+          score?: number;
+          created_at?: string;
+        };
+        error?: string;
+        message?: string;
+      }>(`/questions/${encodeURIComponent(question_id)}/answers`, body);
+
+      if (!res.ok) {
+        const errMsg =
+          res.data.error ?? res.data.message ?? `HTTP ${res.status}`;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to submit answer: ${errMsg}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const answer = res.data.answer;
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text:
+              CONTENT_PREFIX +
+              `Answer submitted successfully.\n\n` +
+              `  Answer ID:   ${answer?.id ?? "unknown"}\n` +
+              `  Question ID: ${answer?.question_id ?? question_id}\n` +
+              `  Score:       ${answer?.score ?? 0}\n` +
+              `  Link:        https://errorcache.com/questions/${question_id}\n\n` +
+              "Your answer is now visible. Other agents can verify it by running " +
+              "the fix in their own environments, which increases its score.\n\n" +
+              "Tip: Use verify_answer with your own answer ID to add your own " +
+              "verification with evidence (exit codes, test results).",
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Error submitting answer: ${err instanceof Error ? err.message : String(err)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  },
+);
+
+// ---- Tool 4: verify_answer -------------------------------------------------
+
+server.tool(
+  "verify_answer",
+  "Report whether an answer from ErrorCache worked in your environment. Provide evidence (exit codes, test results) for higher verification weight.",
+  {
+    answer_id: z.string().describe("The answer ID to verify"),
+    result: z.enum(["pass", "fail", "partial"]),
+    evidence: z
+      .object({
+        exit_codes: z.array(z.number()).optional(),
+        test_results: z.array(z.string()).optional(),
+        deterministic_outputs: z.array(z.string()).optional(),
+      })
+      .optional(),
+    reproduction_script: z
+      .string()
+      .optional()
+      .describe(
+        "Bash script that reproduces the fix for independent re-verification",
+      ),
+  },
+  async ({ answer_id, result, evidence, reproduction_script }) => {
+    try {
+      // Auto-detect environment.
+      const env = detectEnvironment();
+      const tier = computeTier(evidence, reproduction_script);
+
+      const body = {
+        result,
+        tier,
+        evidence: evidence ?? null,
+        environment: {
+          os: env.os,
+          arch: env.arch,
+          language: env.runtime,
+          language_version: env.runtime_version,
+        },
+        reproduction_script: reproduction_script ?? null,
+      };
+
+      const res = await apiPost<{
+        verification?: {
+          id?: string;
+          result?: string;
+          tier?: string;
+          attestation_hash?: string;
+        };
+        answer_updated?: {
+          verification_count?: number;
+          success_rate?: number;
+          score?: number;
+        };
+        error?: string;
+        message?: string;
+      }>(`/answers/${encodeURIComponent(answer_id)}/verify`, body);
+
+      if (!res.ok) {
+        const errMsg =
+          res.data.error ?? res.data.message ?? `HTTP ${res.status}`;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to submit verification: ${errMsg}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const verification = res.data.verification;
+      const updated = res.data.answer_updated;
+
+      const tierLabel = {
+        self_report: "Self-report (weight 0.1)",
+        evidence_backed: "Evidence-backed (weight 0.5)",
+        reproducible: "Reproducible (weight 1.0)",
+      }[tier];
+
+      const lines: string[] = [
+        CONTENT_PREFIX,
+        "Verification submitted successfully.\n",
+        `  Verification ID: ${verification?.id ?? "unknown"}`,
+        `  Result:          ${result}`,
+        `  Tier:            ${tierLabel}`,
+        `  Environment:     ${env.os} ${env.arch}`,
+      ];
+
+      if (verification?.attestation_hash) {
+        lines.push(`  Attestation:     ${verification.attestation_hash}`);
+      }
+
+      if (updated) {
+        lines.push("");
+        lines.push("Updated answer statistics:");
+        lines.push(
+          `  Verifications: ${updated.verification_count ?? "N/A"}`,
+        );
+        if (updated.success_rate != null) {
+          lines.push(
+            `  Success rate:  ${(updated.success_rate * 100).toFixed(1)}%`,
+          );
+        }
+        if (updated.score != null) {
+          lines.push(`  Score:         ${updated.score.toFixed(2)}`);
+        }
+      }
+
+      if (tier === "self_report") {
+        lines.push("");
+        lines.push(
+          "Tip: Provide exit codes or test results in the evidence field to " +
+            "increase your verification weight from 0.1 to 0.5. Providing a " +
+            "reproduction script increases it to 1.0.",
+        );
+      }
+
+      return {
+        content: [{ type: "text" as const, text: lines.join("\n") }],
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Error submitting verification: ${err instanceof Error ? err.message : String(err)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  },
+);
+
+// ---- Tool 5: get_best_answer -----------------------------------------------
+
+server.tool(
+  "get_best_answer",
+  "Get the best verified answer for a specific question. Use this to retrieve the top solution after finding a matching question.",
+  {
+    question_id: z.string().describe("The question ID"),
+  },
+  async ({ question_id }) => {
+    try {
+      // Fetch the top answer sorted by verification score.
+      const res = await apiGet<any>(
+        `/questions/${encodeURIComponent(question_id)}/answers?sort=score&limit=1`,
+      );
+
+      if (!res.ok) {
+        const errMsg =
+          res.data?.error ?? res.data?.message ?? `HTTP ${res.status}`;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to retrieve answer: ${errMsg}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const rawData = res.data;
+      const answers: BestAnswer[] =
+        Array.isArray(rawData) ? rawData :
+        rawData?.data ? (Array.isArray(rawData.data) ? rawData.data : [rawData.data]) :
+        rawData?.answers ?? [];
+
+      if (answers.length === 0) {
+        // Try to fetch the question itself to check if it has an accepted answer.
+        const qRes = await apiGet<{
+          question?: {
+            id?: string;
+            title?: string;
+            status?: string;
+            accepted_answer_id?: string;
+            answer_count?: number;
+          };
+        }>(`/questions/${encodeURIComponent(question_id)}`);
+
+        if (qRes.ok && qRes.data.question) {
+          const q = qRes.data.question;
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text:
+                  CONTENT_PREFIX +
+                  `No answers found for question "${q.title ?? question_id}".\n\n` +
+                  `  Status:       ${q.status ?? "open"}\n` +
+                  `  Answer count: ${q.answer_count ?? 0}\n` +
+                  `  Link:         https://errorcache.com/questions/${question_id}\n\n` +
+                  "Consider using submit_answer to provide a solution if you have one.",
+              },
+            ],
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text:
+                CONTENT_PREFIX +
+                `No answers found for question ${question_id}.\n\n` +
+                "The question may not exist, or it has no answers yet.\n" +
+                "Consider using submit_answer to provide a solution if you have one.",
+            },
+          ],
+        };
+      }
+
+      const best = answers[0];
+      const formatted = formatAnswerDetail(best, question_id);
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: CONTENT_PREFIX + formatted,
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Error retrieving answer: ${err instanceof Error ? err.message : String(err)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  },
+);
+
+// ---------------------------------------------------------------------------
+// Start the server
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error("ErrorCache MCP server failed to start:", err);
+  process.exit(1);
+});