@4da/mcp-server 5.0.0 → 5.0.2

package/dist/http-transport.js

@@ -10,30 +10,145 @@
  * no express or other framework needed.
  *
  * Security:
- * - Binds to 127.0.0.1 only (localhost)
- * - DNS rebinding protection via Origin header check
+ * - Binds to 127.0.0.1 by default. `--host` can widen that; a non-loopback
+ *   bind is refused unless a shared auth secret is configured, and forces
+ *   authentication on for every request.
+ * - DNS rebinding protection via a `Host` header allowlist, applied to EVERY
+ *   request. This is the primary guard: a rebinding attack necessarily
+ *   presents the attacker's hostname in `Host`, and unlike `Origin` the header
+ *   is mandatory, so a request cannot skip the check by omitting it.
+ * - `Origin`, when present, must also be localhost-class. A missing `Origin`
+ *   is not a pass — it is simply not additional evidence, so such requests are
+ *   admitted only on the strength of the `Host` check above, and only ever
+ *   without credentials on a loopback bind.
+ * - Bearer tokens are HMAC-SHA256 verified (see auth.ts) before any claim is
+ *   read, and the verified role is enforced on tool dispatch.
  * - Stateless (no session tracking)
  */
 import { createServer } from "node:http";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createMcpHandler } from "@modelcontextprotocol/server";
+import { createMcpHandler, localhostAllowedHostnames, localhostAllowedOrigins, validateHostHeader, validateOriginHeader, } from "@modelcontextprotocol/server";
 import { toNodeHandler } from "@modelcontextprotocol/node";
-import { extractAuthClaims } from "./auth.js";
+import { extractAuthClaims, getAuthSecret } from "./auth.js";
+import { runWithAuthContext } from "./auth-context.js";
 const DEFAULT_PORT = 4840;
 const DEFAULT_HOST = "127.0.0.1";
 const __ht_dirname = dirname(fileURLToPath(import.meta.url));
 const SERVER_VERSION = JSON.parse(readFileSync(join(__ht_dirname, "..", "package.json"), "utf-8")).version;
+/** Strip IPv6 brackets and zone id so "[::1]" and "::1" compare equal. */
+function normalizeHostname(host) {
+    return host.trim().replace(/^\[|\]$/g, "").split("%")[0].toLowerCase();
+}
+/** Loopback bind addresses — everything else reaches the network. */
+export function isLoopbackBind(host) {
+    const h = normalizeHostname(host);
+    return h === "localhost" || h === "::1" || /^127\./.test(h);
+}
+/**
+ * Extra hostnames accepted in `Host`/`Origin`, from `MCP_ALLOWED_HOSTS`
+ * (comma-separated). Needed when binding to `0.0.0.0`, where the hostname
+ * legitimate clients use is not knowable from the bind address.
+ */
+function configuredExtraHosts() {
+    return (process.env.MCP_ALLOWED_HOSTS ?? "")
+        .split(",")
+        .map((h) => normalizeHostname(h))
+        .filter((h) => h.length > 0);
+}
+/**
+ * Resolve the security policy for a bind address.
+ *
+ * A loopback bind keeps the historical behaviour: auth is opt-in via
+ * `MCP_AUTH_REQUIRED`. Any other bind is network-exposed, so authentication is
+ * mandatory regardless of that variable.
+ */
+export function resolveSecurityPolicy(host) {
+    const loopback = isLoopbackBind(host);
+    const extras = configuredExtraHosts();
+    // A concrete non-loopback bind address is itself a legitimate Host value;
+    // wildcards (0.0.0.0 / ::) name no reachable host, so they add nothing.
+    const bindHostname = normalizeHostname(host);
+    const isWildcard = bindHostname === "0.0.0.0" || bindHostname === "::" || bindHostname === "";
+    const bindExtras = loopback || isWildcard ? [] : [bindHostname];
+    return {
+        loopback,
+        authRequired: loopback ? process.env.MCP_AUTH_REQUIRED === "true" : true,
+        allowedHostnames: [...localhostAllowedHostnames(), ...bindExtras, ...extras],
+        allowedOrigins: [...localhostAllowedOrigins(), ...bindExtras, ...extras],
+    };
+}
+/**
+ * DNS rebinding guard. Runs on every request, before routing and before auth.
+ *
+ * Returns null when the request may proceed, or the rejection to send.
+ */
+export function evaluateRequestGuard(headers, policy) {
+    const pick = (v) => Array.isArray(v) ? v[0] : v;
+    // `Host` is mandatory in HTTP/1.1 and always present in HTTP/2 (as
+    // :authority, which Node surfaces here). Missing means malformed, not
+    // trusted — validateHostHeader rejects it.
+    const hostResult = validateHostHeader(pick(headers.host), policy.allowedHostnames);
+    if (!hostResult.ok) {
+        return { status: 403, error: `Forbidden: DNS rebinding protection (${hostResult.errorCode})` };
+    }
+    // `Origin` is only sent by browsers. A present-but-foreign value is a
+    // cross-origin browser request and is refused; an absent value adds no
+    // evidence either way, and the Host check above has already run.
+    const originResult = validateOriginHeader(pick(headers.origin), policy.allowedOrigins);
+    if (!originResult.ok) {
+        return { status: 403, error: `Forbidden: ${originResult.errorCode}` };
+    }
+    return null;
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+/**
+ * Refuse to start a network-exposed server that cannot authenticate anyone,
+ * and make a non-loopback bind impossible to do accidentally.
+ */
+export function enforceBindPolicy(host, policy) {
+    if (policy.loopback)
+        return;
+    if (!getAuthSecret()) {
+        throw new Error(`Refusing to bind the MCP HTTP transport to a non-loopback address (${host}) with no auth secret.\n` +
+            `  Every 4DA tool (dependency inventory, decisions, agent memory, Developer DNA) would be\n` +
+            `  readable and writable by anyone who can reach this port.\n` +
+            `  Set MCP_AUTH_SECRET (the same value as the relay's JWT_SECRET) to enable token verification,\n` +
+            `  or drop --host and serve on 127.0.0.1.`);
+    }
+    console.error("");
+    console.error("  ############################################################");
+    console.error(`  # WARNING: MCP HTTP transport is bound to ${host}`);
+    console.error("  # This exposes 4DA tools beyond this machine.");
+    console.error("  # Authentication is REQUIRED for every request on this bind.");
+    console.error("  # Put it behind TLS and a trusted network boundary.");
+    console.error("  ############################################################");
+    console.error("");
+    const extras = configuredExtraHosts();
+    const bindHostname = normalizeHostname(host);
+    if ((bindHostname === "0.0.0.0" || bindHostname === "::") && extras.length === 0) {
+        console.error("  NOTE: MCP_ALLOWED_HOSTS is unset, so only localhost-class Host headers are accepted.");
+        console.error("        Set MCP_ALLOWED_HOSTS=<hostname-or-ip[,...]> to the address clients actually use.");
+        console.error("");
+    }
+}
 /**
  * Start a Streamable HTTP server for the MCP protocol.
  *
  * Takes a server factory: `createMcpHandler` builds a fresh instance per
  * request (stateless — compatible with serverless environments and simple
  * round-robin load balancing).
+ *
+ * Resolves once the server is accepting connections.
  */
 export async function startHttpServer(factory, options = { port: DEFAULT_PORT, host: DEFAULT_HOST }) {
     const { port, host } = options;
+    const policy = resolveSecurityPolicy(host);
+    enforceBindPolicy(host, policy);
     const mcpHandler = createMcpHandler(factory);
     const handleMcpRequest = toNodeHandler(mcpHandler, {
         onerror: (err) => {
@@ -41,73 +156,68 @@ export async function startHttpServer(factory, options = { port: DEFAULT_PORT, h
         },
     });
     const httpServer = createServer(async (req, res) => {
-        // DNS rebinding protection: reject cross-origin requests from non-local origins
-        const origin = req.headers.origin;
-        if (origin) {
-            try {
-                const url = new URL(origin);
-                if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1" && url.hostname !== "::1" && url.hostname !== "[::1]") {
-                    res.writeHead(403, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Forbidden: DNS rebinding protection" }));
-                    return;
-                }
-            }
-            catch {
-                res.writeHead(403, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: "Forbidden: invalid Origin header" }));
-                return;
-            }
+        // DNS rebinding protection — every request, before routing or auth.
+        const rejection = evaluateRequestGuard(req.headers, policy);
+        if (rejection) {
+            sendJson(res, rejection.status, { error: rejection.error });
+            return;
         }
-        // Auth check: if MCP_AUTH_REQUIRED env var is set, validate JWT
-        const authRequired = process.env.MCP_AUTH_REQUIRED === "true";
+        const pathname = new URL(req.url || "/", `http://${host}:${port}`).pathname;
+        // Auth gate. Unauthenticated health checks on "/" stay open so liveness
+        // probes work; the endpoint reveals only name, version and status.
         let claims = null;
-        if (authRequired) {
-            // Allow unauthenticated health checks on root
-            const checkPath = new URL(req.url || "/", `http://${host}:${port}`).pathname;
-            if (checkPath !== "/") {
-                claims = extractAuthClaims(req);
-                if (!claims) {
-                    res.writeHead(401, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Authentication required" }));
-                    return;
-                }
+        if (policy.authRequired && pathname !== "/") {
+            claims = extractAuthClaims(req);
+            if (!claims) {
+                res.writeHead(401, {
+                    "Content-Type": "application/json",
+                    "WWW-Authenticate": 'Bearer realm="4da-mcp"',
+                });
+                res.end(JSON.stringify({ error: "Authentication required" }));
+                return;
             }
         }
-        // Route requests
-        const pathname = new URL(req.url || "/", `http://${host}:${port}`).pathname;
         // Health check endpoint
         if (pathname === "/" && req.method === "GET") {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
+            sendJson(res, 200, {
                 name: "4da-mcp",
                 version: SERVER_VERSION,
                 transport: "streamable-http",
                 status: "ok",
-            }));
+            });
             return;
         }
         // Only handle /mcp endpoint
         if (pathname !== "/mcp") {
-            res.writeHead(404, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Not Found" }));
+            sendJson(res, 404, { error: "Not Found" });
             return;
         }
         // Hand off to the MCP handler — body parsing, era classification, and
-        // per-request instance construction happen inside the entry.
-        await handleMcpRequest(req, res);
+        // per-request instance construction happen inside the entry. The auth
+        // context rides along so tool dispatch can enforce the verified role.
+        await runWithAuthContext({ claims, enforced: policy.authRequired }, () => handleMcpRequest(req, res));
     });
-    httpServer.listen(port, host, () => {
-        console.error(`4DA MCP Server v${SERVER_VERSION} (Streamable HTTP) listening on http://${host}:${port}/mcp`);
-        console.error(`Health check: http://${host}:${port}/`);
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(port, host, () => {
+            httpServer.removeListener("error", reject);
+            resolve();
+        });
     });
+    console.error(`4DA MCP Server v${SERVER_VERSION} (Streamable HTTP) listening on http://${host}:${port}/mcp`);
+    console.error(`Health check: http://${host}:${port}/`);
+    console.error(`Authentication: ${policy.authRequired ? "required (HMAC-SHA256 verified Bearer tokens)" : "disabled (loopback only)"}`);
+    const close = async () => {
+        await mcpHandler.close();
+        await new Promise((resolve) => httpServer.close(() => resolve()));
+    };
     // Graceful shutdown
     const shutdown = () => {
         console.error("Shutting down HTTP server...");
-        void mcpHandler.close();
-        httpServer.close();
-        process.exit(0);
+        void close().finally(() => process.exit(0));
     };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    return { server: httpServer, close };
 }
 //# sourceMappingURL=http-transport.js.map

package/dist/index.js

@@ -8,9 +8,12 @@
  * Claude Desktop, and other MCP hosts. Runs locally; the only data leaving the
  * machine is public package names/versions sent to registries (OSV, npm, etc.).
  *
- * SECURITY: the server trusts its local environment and does NOT implement
- * authentication. The optional --http transport is intended for localhost use;
- * do NOT expose it over a network without putting your own auth in front.
+ * SECURITY: stdio serving is unauthenticated by design — the MCP host launches
+ * this process and already holds local process rights. The optional --http
+ * transport defaults to 127.0.0.1 and applies a Host-header DNS rebinding
+ * guard to every request. Binding it anywhere else requires a shared auth
+ * secret (MCP_AUTH_SECRET) and then verifies an HMAC-SHA256-signed Bearer
+ * token on every request, enforcing the token's role at tool dispatch.
  *
  * 14 tools across 5 categories. Live vulnerability scanning (OSV.dev),
  * ecosystem news, persistent memory, and tech stack awareness for any MCP host.
@@ -338,13 +341,23 @@ async function main() {
   Options:
     --http              Use Streamable HTTP instead of stdio
     --port <number>     HTTP port (default: 4840)
-    --host <address>    HTTP bind address (default: 127.0.0.1)
+    --host <address>    HTTP bind address (default: 127.0.0.1). A non-loopback
+                        address exposes every tool to the network and is
+                        refused unless MCP_AUTH_SECRET is set; authentication
+                        is then mandatory for every request.
     --setup             Detect editors and write MCP config
     --doctor            Validate database, bindings, and LLM providers
 
   Environment:
     FOURDA_DB_PATH      Path to 4DA's SQLite database (auto-detected if omitted)
     FOURDA_OFFLINE      Set to "true" to disable all network calls (OSV.dev, HN)
+    MCP_AUTH_SECRET     Shared secret for verifying relay-issued Bearer tokens
+                        (HMAC-SHA256). Falls back to JWT_SECRET. Without it, no
+                        token is accepted.
+    MCP_AUTH_REQUIRED   Set to "true" to require auth on a loopback --http bind
+                        (always required on a non-loopback bind)
+    MCP_ALLOWED_HOSTS   Extra comma-separated hostnames accepted in the Host /
+                        Origin headers (needed when binding to 0.0.0.0)
 
   Works standalone (scans your project on startup) or with the full
   4DA desktop app for content scoring, source monitoring, and more.
@@ -365,10 +378,35 @@ async function main() {
     }
     // HTTP transport mode
     if (args.includes("--http")) {
-        const portIndex = args.indexOf("--port");
-        const port = portIndex !== -1 ? parseInt(args[portIndex + 1], 10) : 4840;
-        const host = args.includes("--host") ? args[args.indexOf("--host") + 1] : "127.0.0.1";
-        await startHttpServer(buildServer, { port, host });
+        const flagValue = (flag) => {
+            const i = args.indexOf(flag);
+            if (i === -1)
+                return undefined;
+            const value = args[i + 1];
+            // A flag with no value (or followed by another flag) is a typo, not a
+            // request to bind everywhere — refuse rather than guess.
+            if (value === undefined || value.startsWith("-")) {
+                console.error(`[4DA] ${flag} requires a value`);
+                process.exit(1);
+            }
+            return value;
+        };
+        const rawPort = flagValue("--port");
+        const port = rawPort === undefined ? 4840 : Number.parseInt(rawPort, 10);
+        if (!Number.isInteger(port) || port < 0 || port > 65535) {
+            console.error(`[4DA] Invalid --port value: ${rawPort}`);
+            process.exit(1);
+        }
+        const host = flagValue("--host") ?? "127.0.0.1";
+        try {
+            await startHttpServer(buildServer, { port, host });
+        }
+        catch (error) {
+            // Bind-policy refusals carry an actionable message; print it plainly
+            // rather than as an unhandled stack trace.
+            console.error(`[4DA] ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
         return;
     }
     // -------------------------------------------------------------------------

package/dist/tool-dispatch.d.ts

@@ -14,6 +14,10 @@ export type ToolExecutor = (db: FourDADatabase, params: any) => unknown | Promis
 /**
  * Dispatch a tool call by name. Awaits uniformly (no-op for sync executors).
  * Returns MCP-formatted response with JSON-serialized result.
+ *
+ * Authenticated HTTP callers are role-checked here — the single choke point
+ * every tool call passes through. Stdio callers are unaffected (no auth
+ * context; the host already owns the process).
  */
 export declare function dispatchTool(name: string, db: FourDADatabase, args: Record<string, unknown> | undefined): Promise<CallToolResult>;
 /** Check if a tool exists in the dispatch map */

package/dist/tool-dispatch.js

@@ -5,6 +5,7 @@
  * Map-based dispatch for the 14 active tools.
  * Adding a new tool = add to this map + schema-registry + barrel export.
  */
+import { assertToolPermission } from "./auth-context.js";
 import { executeGetRelevantContent, executeGetContext, executeRecordFeedback, executeGetActionableSignals, executeKnowledgeGaps, executeDecisionMemory, executeCheckDecisionAlignment, executeAgentMemory, executeDeveloperDna, executeWhatShouldIKnow, executeVulnerabilityScan, executeEcosystemPulse, executeDependencyHealth, executeUpgradePlanner, } from "./tools/index.js";
 import { getLiveIntelligence } from "./live-singleton.js";
 /**
@@ -46,12 +47,17 @@ const FRESHNESS_TOOLS = new Set([
 /**
  * Dispatch a tool call by name. Awaits uniformly (no-op for sync executors).
  * Returns MCP-formatted response with JSON-serialized result.
+ *
+ * Authenticated HTTP callers are role-checked here — the single choke point
+ * every tool call passes through. Stdio callers are unaffected (no auth
+ * context; the host already owns the process).
  */
 export async function dispatchTool(name, db, args) {
     const executor = DISPATCH_MAP[name];
     if (!executor) {
         throw new Error(`Unknown tool: ${name}`);
     }
+    assertToolPermission(name);
     const result = await executor(db, (args || {}));
     const payload = FRESHNESS_TOOLS.has(name) ? attachFreshness(db, result) : result;
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4da/mcp-server",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "mcpName": "io.github.4DA-Systems/4da-mcp-server",
   "description": "Dependency intelligence for AI coding agents. Live CVE scanning, dependency health, upgrade planning, ecosystem news, decision memory — zero config, privacy-first. 9 tools standalone, 14 total with desktop app.",
   "type": "module",
@@ -18,17 +18,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc && pnpm run copy-schemas",
-    "copy-schemas": "node -e \"const fs=require('fs');const path=require('path');const src='src/schemas';const dst='dist/schemas';if(!fs.existsSync(dst))fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.json')).forEach(f=>fs.copyFileSync(path.join(src,f),path.join(dst,f)))\"",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js",
-    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
-    "setup": "node dist/setup.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "prepublishOnly": "pnpm run build"
-  },
   "keywords": [
     "mcp",
     "mcp-server",
@@ -82,7 +71,8 @@
   "dependencies": {
     "better-sqlite3": "^12.9.0",
     "@modelcontextprotocol/node": "^2.0.0",
-    "@modelcontextprotocol/server": "^2.0.0"
+    "@modelcontextprotocol/server": "^2.0.0",
+    "hono": "^4.12.34"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
@@ -94,16 +84,14 @@
   "engines": {
     "node": ">=20.0.0"
   },
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "better-sqlite3",
-      "esbuild"
-    ],
-    "overrides": {
-      "fast-uri": ">=3.1.2",
-      "ip-address": "^10.1.1",
-      "vite": ">=7.3.5 <8",
-      "esbuild": ">=0.28.1"
-    }
+  "scripts": {
+    "build": "tsc && pnpm run copy-schemas",
+    "copy-schemas": "node -e \"const fs=require('fs');const path=require('path');const src='src/schemas';const dst='dist/schemas';if(!fs.existsSync(dst))fs.mkdirSync(dst,{recursive:true});fs.readdirSync(src).filter(f=>f.endsWith('.json')).forEach(f=>fs.copyFileSync(path.join(src,f),path.join(dst,f)))\"",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "setup": "node dist/setup.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/dist/llm.d.ts

@@ -1,162 +0,0 @@
-/**
- * LLM Client for 4DA MCP Server
- *
- * Provides intelligence synthesis over raw tool data.
- * Supports Anthropic Claude, OpenAI, and Ollama (local).
- *
- * Features:
- * - Tiered model selection (use smaller models for simpler tasks)
- * - Optimized prompts for local models
- * - Automatic fallback
- */
-export interface LLMConfig {
-    provider: "anthropic" | "openai" | "ollama" | null;
-    anthropic_api_key?: string;
-    openai_api_key?: string;
-    ollama_url?: string;
-    model?: string;
-    model_light?: string;
-    model_heavy?: string;
-}
-export type TaskComplexity = "light" | "medium" | "heavy";
-export interface SynthesisRequest {
-    system: string;
-    prompt: string;
-    max_tokens?: number;
-    complexity?: TaskComplexity;
-}
-export interface SynthesisResult {
-    synthesis: string;
-    model_used: string;
-    tokens_used?: number;
-    latency_ms?: number;
-}
-/**
- * Default models for different task complexities
- * Optimized for 16GB VRAM
- */
-export declare const DEFAULT_OLLAMA_MODELS: {
-    light: string;
-    medium: string;
-    heavy: string;
-};
-/**
- * Task complexity by tool
- */
-export declare const TOOL_COMPLEXITY: Record<string, TaskComplexity>;
-/**
- * Get LLM configuration from settings.json file.
- *
- * Uses a cached approach: the file is only re-read if its mtime has changed,
- * avoiding unnecessary filesystem reads on every tool invocation.
- */
-export declare function getLLMConfig(_db?: {
-    prepare: (sql: string) => {
-        get: (...args: unknown[]) => unknown;
-    };
-}): LLMConfig;
-/**
- * Check if LLM synthesis is available
- */
-export declare function canSynthesize(config: LLMConfig): boolean;
-/**
- * Synthesize insights using LLM
- *
- * Accepts an optional AbortSignal to allow timeout/cancellation of the
- * underlying fetch calls.
- */
-export declare function synthesize(config: LLMConfig, request: SynthesisRequest, signal?: AbortSignal): Promise<SynthesisResult>;
-/**
- * Synthesize with a timeout wrapper.
- *
- * Wraps the LLM API call with an AbortController + configurable timeout.
- * On timeout, throws a descriptive error so callers can fall back to
- * data-only results.
- *
- * @param config  - LLM provider configuration
- * @param request - Synthesis request (system prompt, user prompt, etc.)
- * @param timeoutMs - Timeout in milliseconds (default: 30000)
- */
-export declare function synthesizeWithTimeout(config: LLMConfig, request: SynthesisRequest, timeoutMs?: number): Promise<SynthesisResult>;
-/**
- * Prompts are optimized for:
- * 1. Clear structure (local models need explicit formatting)
- * 2. Concise output (fewer tokens = faster inference)
- * 3. Specific instructions (reduce ambiguity)
- */
-export declare const SYNTHESIS_PROMPTS: {
-    /**
-     * Daily Briefing - Executive synthesis
-     * Complexity: MEDIUM
-     */
-    dailyBriefing: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-    /**
-     * Score Autopsy - Explain the reasoning
-     * Complexity: HEAVY (needs to reason about correctness)
-     */
-    scoreAutopsy: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-    /**
-     * Trend Analysis - Predict and explain
-     * Complexity: HEAVY (needs pattern recognition + prediction)
-     */
-    trendAnalysis: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-    /**
-     * Context Analysis - Personalized optimization advice
-     * Complexity: MEDIUM (structured recommendations)
-     */
-    contextAnalysis: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown) => string;
-    };
-    /**
-     * Topic Connections - Explain the knowledge graph
-     * Complexity: HEAVY (needs graph reasoning)
-     */
-    topicConnections: {
-        complexity: TaskComplexity;
-        system: string;
-        buildPrompt: (data: unknown, context: unknown) => string;
-    };
-};
-/**
- * Check if Ollama is running and has required models
- */
-export declare function checkOllamaStatus(baseUrl?: string): Promise<{
-    available: boolean;
-    models: string[];
-    error?: string;
-}>;
-/**
- * Recommended models for 4DA synthesis tasks
- */
-export declare const RECOMMENDED_MODELS: {
-    "16GB_VRAM": {
-        primary: string;
-        fallback: string;
-        install: string;
-    };
-    "12GB_VRAM": {
-        primary: string;
-        fallback: string;
-        install: string;
-    };
-    "8GB_VRAM": {
-        primary: string;
-        fallback: string;
-        install: string;
-    };
-};
-//# sourceMappingURL=llm.d.ts.map