@finchagentic/mcp 4.0.0 → 4.2.0

package/dist/convex.js

@@ -4,7 +4,6 @@ exports.PaymentRequiredError = exports.CONVEX_SITE = void 0;
 exports.buildPaymentHeader = buildPaymentHeader;
 exports.callConvex = callConvex;
 exports.callConvexRaw = callConvexRaw;
-exports.notifyTelegram = notifyTelegram;
 const wallet_js_1 = require("./wallet.js");
 const config_js_1 = require("./config.js");
 exports.CONVEX_SITE = process.env.FINCH_CONVEX_URL ?? "https://befitting-porcupine-276.convex.site";
@@ -66,10 +65,6 @@ async function callConvex(path, method, body, toolName = "unknown", timeoutMs =
         headers["X-User-Grok-Key"] = process.env.GROK_API_KEY;
     if (process.env.BANKR_API_KEY)
         headers["X-User-Bankr-Key"] = process.env.BANKR_API_KEY;
-    if (process.env.TELEGRAM_BOT_TOKEN)
-        headers["X-User-Telegram-Token"] = process.env.TELEGRAM_BOT_TOKEN;
-    if (process.env.TELEGRAM_CHAT_ID)
-        headers["X-User-Telegram-Chat"] = process.env.TELEGRAM_CHAT_ID;
     let lastError = null;
     for (let attempt = 0; attempt < RETRY_DELAYS.length; attempt++) {
         if (attempt > 0) {
@@ -95,7 +90,13 @@ async function callConvex(path, method, body, toolName = "unknown", timeoutMs =
                 `${b.alternative ? `Alternative: ${b.alternative}` : ""}`);
         }
         if (RETRY_STATUSES.has(res.status) && attempt < RETRY_DELAYS.length) {
-            lastError = new Error(`Finch API error: ${res.status}`);
+            // Capture the actual body so a deterministic error (e.g. "unknown
+            // token") that happens to come back on a 500 still surfaces its real
+            // message if retries exhaust - previously this discarded the body
+            // entirely and threw a bare "Finch API error: 500", hiding exactly the
+            // information the caller needed to fix the request.
+            const bodyText = await res.text().catch(() => "");
+            lastError = new Error(`Finch API error ${res.status}: ${bodyText.slice(0, 300) || "(no body)"}`);
             continue;
         }
         if (!res.ok)
@@ -112,10 +113,14 @@ async function callConvexRaw(path, toolName = "unknown", timeoutMs = 60000) {
     const headers = {};
     const apiKey = process.env.FINCH_API_KEY;
     const sessionToken = (0, config_js_1.getSavedToken)();
-    const authHeader = apiKey
-        ? `Bearer ${apiKey}`
-        : sessionToken
-            ? `Bearer ${sessionToken}`
+    // Same precedence as callConvex() above - prefer session token over API
+    // key. These two functions previously disagreed (this one checked apiKey
+    // first), so the same env/config could pick a different credential
+    // depending on which helper a tool happened to call.
+    const authHeader = sessionToken
+        ? `Bearer ${sessionToken}`
+        : apiKey
+            ? `Bearer ${apiKey}`
             : null;
     if (authHeader) {
         headers["Authorization"] = authHeader;
@@ -141,11 +146,3 @@ async function callConvexRaw(path, toolName = "unknown", timeoutMs = 60000) {
         throw new Error(`Finch API error: ${res.status}`);
     return res.text();
 }
-async function notifyTelegram(userId, message) {
-    try {
-        return await callConvex("/user/telegram/notify", "POST", { userId, message }, "set_telegram");
-    }
-    catch (error) {
-        return { sent: false, reason: error.message ?? String(error) };
-    }
-}

package/dist/index.js

@@ -108,24 +108,23 @@ async function main() {
     (0, config_js_1.hydrateEnvFromConfig)();
     process.stderr.write(BANNER);
     const CAT_RULES = [
-        { label: "Market", match: n => /^(get_market_data|get_token_data|compare_tokens|market_overview|token_history)$/.test(n) },
+        { label: "Market", match: n => /^(get_market_data|get_token_data|compare_tokens|market_overview|token_history|get_base_token_data|stock_fundamentals|stock_insider|stock_events)$/.test(n) },
         { label: "Insight", match: n => /^(ask_finch|market_thesis|trade_plan)$/.test(n) },
         { label: "DeFi", match: n => n === "get_defi_yields" },
         { label: "Base MCP", match: n => n.startsWith("base_mcp_") },
         { label: "RH MCP", match: n => n.startsWith("rh_") },
         { label: "Automation", match: n => /^(create_automation|list_automations|pause_automation|delete_automation|get_automation_runs|run_automation)$/.test(n) },
-        { label: "Framework", match: n => /^(list_playbooks|run_playbook|get_finch_ledger)$/.test(n) },
         { label: "Vault", match: n => n.startsWith("vault_") },
         { label: "Wallet", match: n => /^(get_wallet_address|get_wallet_balance|wallet_sign_message)$/.test(n) },
+        { label: "Staking", match: n => /^(stake_finch|unstake_finch|stake_finch_status|stake_auto_restake)$/.test(n) },
         { label: "MiroShark", match: n => n.startsWith("miroshark_") },
         { label: "Scanner", match: n => /^(scan_market|score_token|check_token)$/.test(n) },
-        { label: "Agents", match: n => n.startsWith("agent_") || n === "list_agents" || n === "hire_agent" },
+        { label: "Agents", match: n => n.startsWith("agent_") },
         { label: "Coder", match: n => n === "audit_contract" },
-        { label: "Base", match: n => /^(query_vaults|list_markets|prepare_deposit|chain_stats)$/.test(n) },
         { label: "Memory", match: n => n.startsWith("memory_") },
         { label: "OS", match: n => /^(finch_status|finch_diagnostics|finch_shell_chat)$/.test(n) },
         { label: "Research", match: n => /^(web_scrape|web_search|deep_research|research_compare|research_chain)$/.test(n) },
-        { label: "Monitor", match: n => /^(schedule_research|create_monitor|list_monitors|cancel_monitor)$/.test(n) },
+        { label: "Monitor", match: n => /^(schedule_research|list_monitors|cancel_monitor)$/.test(n) },
         { label: "GitHub", match: n => n.startsWith("github_") },
         { label: "Chronicle", match: n => n.startsWith("chronicle_") },
         { label: "Packets", match: n => n.startsWith("packet_") },

package/dist/llm.js

@@ -4,13 +4,10 @@ exports.hasDirectLLMKey = hasDirectLLMKey;
 exports.grokLiveSearchHits = grokLiveSearchHits;
 exports.isGrokActive = isGrokActive;
 exports.callLLM = callLLM;
-const wallet_js_1 = require("./wallet.js");
-const config_js_1 = require("./config.js");
 const ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 const BANKR_URL = "https://llm.bankr.bot/v1/chat/completions";
 const GROK_URL = "https://api.x.ai/v1/chat/completions";
 const OPENAI_URL = "https://api.openai.com/v1/chat/completions";
-const CONVEX_SITE = process.env.FINCH_CONVEX_URL ?? "https://befitting-porcupine-276.convex.site";
 /**
  * Returns true if Grok is the currently active LLM provider, based on env.
  * Useful for tools that want to conditionally enable Grok-specific features
@@ -145,51 +142,18 @@ async function callLLM(systemPrompt, userPrompt, maxTokens = 1024, history = [],
         return callOpenAI(openaiKey, systemPrompt, userPrompt, maxTokens, history, timeoutMs, options.model);
     if (grokKey)
         return callGrok(grokKey, systemPrompt, userPrompt, maxTokens, history, timeoutMs, options.liveSearch, options.model);
-    // Fallback: route through Convex backend - owner covers cost
-    return callViaConvex(systemPrompt, userPrompt, history, timeoutMs);
-}
-async function callViaConvex(systemPrompt, userPrompt, history, timeoutMs) {
-    const fullQuestion = systemPrompt
-        ? `[System: ${systemPrompt}]\n\n${userPrompt}`
-        : userPrompt;
-    const headers = { "Content-Type": "application/json" };
-    const apiKey = process.env.FINCH_API_KEY;
-    let sessionToken = process.env.FINCH_SESSION_TOKEN;
-    // Read from config file — this is the resolved session token after login
-    try {
-        const cfg = (0, config_js_1.readConfig)();
-        if (cfg.sessionToken)
-            sessionToken = cfg.sessionToken;
-    }
-    catch { /* ignore */ }
-    // Prefer session token (resolved by backend) over API key for /mcp/chat
-    if (sessionToken) {
-        headers["Authorization"] = `Bearer ${sessionToken}`;
-    }
-    else if (apiKey) {
-        headers["Authorization"] = `Bearer ${apiKey}`;
-    }
-    else {
-        try {
-            const { address, signature, timestamp } = await (0, wallet_js_1.signRequest)("ask_finch");
-            headers["X-Wallet-Address"] = address;
-            headers["X-Wallet-Signature"] = signature;
-            headers["X-Wallet-Timestamp"] = timestamp;
-        }
-        catch { /* proceed without wallet auth */ }
-    }
-    const res = await fetch(`${CONVEX_SITE}/mcp/chat`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ question: fullQuestion, messages: history }),
-        signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        throw new Error(`LLM error ${res.status}: ${body.slice(0, 200)}`);
-    }
-    const data = await res.json();
-    return data.answer ?? "";
+    // No provider key configured - BYOK is required. This tool needs its own
+    // multi-step reasoning (planning, synthesis, critique) that an MCP host's
+    // model cannot do on the tool's behalf, so there is no free path: bring
+    // your own key or don't use tools that need one (ask_finch, deep_research,
+    // market_thesis, trade_plan, scheduled agent runs). Fails clearly instead
+    // of silently billing the Finch deployment owner for every anonymous
+    // install of this package.
+    throw new Error("No LLM provider configured. This tool needs its own key to do multi-step " +
+        "reasoning server-side - set one of BANKR_API_KEY, ANTHROPIC_API_KEY, " +
+        "OPENAI_API_KEY, or GROK_API_KEY as an environment variable (see the " +
+        "Configuration section of the README), then retry. Most other Finch tools " +
+        "don't need this - only ones that do their own internal LLM reasoning do.");
 }
 async function callAnthropic(apiKey, systemPrompt, userPrompt, maxTokens, history, timeoutMs, modelOverride) {
     const messages = [...history, { role: "user", content: userPrompt }];
@@ -263,7 +227,18 @@ async function callOpenAI(apiKey, systemPrompt, userPrompt, maxTokens, history,
         throw new Error(`OpenAI error ${res.status}: ${body.slice(0, 200)}`);
     }
     const data = await res.json();
-    return data.choices?.[0]?.message?.content ?? "";
+    // Most OpenAI-compatible gateways put `choices` at the top level, but
+    // OPENAI_BASE_URL can point at anything that speaks this API shape - at
+    // least one (9Router) wraps the whole payload in `{ data: {...}, success:
+    // true }` for some models (confirmed live: routers9/glm5.2 returns this
+    // wrapper while routers9/tencent/hy3 on the SAME endpoint/key returns
+    // top-level choices). Without this fallback the call silently returns ""
+    // instead of throwing - worse than an error, since every caller of
+    // callLLM() just gets an empty synthesis with no indication anything failed.
+    const content = data.choices?.[0]?.message?.content ?? data.data?.choices?.[0]?.message?.content;
+    if (!content)
+        throw new Error(`OpenAI-compatible endpoint returned no content (model: ${model})`);
+    return content;
 }
 async function callGrok(apiKey, systemPrompt, userPrompt, maxTokens, history, timeoutMs, liveSearch, modelOverride) {
     const model = modelOverride ?? process.env.FINCH_MODEL ?? process.env.GROK_MODEL ?? "grok-4-fast-reasoning";

package/dist/local-memory-file.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalMemoryFileConfig = getLocalMemoryFileConfig;
+exports.fileMemoryAdd = fileMemoryAdd;
+exports.fileMemoryDeleteByVaultKey = fileMemoryDeleteByVaultKey;
+exports.fileMemorySearch = fileMemorySearch;
+exports.fileMemoryList = fileMemoryList;
+exports.fileMemoryDelete = fileMemoryDelete;
+exports.fileMemoryProfile = fileMemoryProfile;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+function getLocalMemoryFileConfig() {
+    return { dir: path.join(os.homedir(), ".finch", "memory") };
+}
+function indexPath(cfg) {
+    return path.join(cfg.dir, "index.json");
+}
+function readIndex(cfg) {
+    try {
+        const raw = fs.readFileSync(indexPath(cfg), "utf8");
+        const parsed = JSON.parse(raw);
+        return { memories: parsed.memories ?? [] };
+    }
+    catch {
+        return { memories: [] };
+    }
+}
+// Atomic write: temp file + rename, matching local-vault.ts's pattern so a
+// crash mid-write can't corrupt the index every memory depends on.
+function writeIndex(cfg, idx) {
+    fs.mkdirSync(cfg.dir, { recursive: true });
+    const tmp = indexPath(cfg) + `.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(idx, null, 2), "utf8");
+    fs.renameSync(tmp, indexPath(cfg));
+}
+function toResult(m) {
+    return {
+        id: m.id,
+        content: m.content,
+        metadata: { title: m.title, tags: m.tags, source: m.source, sourceUrl: m.sourceUrl, contentHash: m.contentHash, pinned: m.pinned, addedAt: m.addedAt, vaultKey: m.vaultKey },
+    };
+}
+function fileMemoryAdd(cfg, content, metadata, sourceUrl) {
+    const idx = readIndex(cfg);
+    const id = crypto.randomBytes(8).toString("hex");
+    const row = {
+        id,
+        content,
+        title: metadata.title,
+        tags: metadata.tags,
+        source: metadata.source,
+        sourceUrl,
+        contentHash: metadata.contentHash ?? "",
+        pinned: metadata.pinned,
+        addedAt: metadata.addedAt ?? Date.now(),
+        vaultKey: metadata.vaultKey,
+    };
+    idx.memories.push(row);
+    writeIndex(cfg, idx);
+    return { id };
+}
+/** Remove every memory row mirroring a given vault entry - called by
+ * vault_delete so its "PERMANENT... cannot be undone" claim is actually true,
+ * instead of leaving the content fully recoverable via memory_search. */
+function fileMemoryDeleteByVaultKey(cfg, vaultKey) {
+    const idx = readIndex(cfg);
+    const next = idx.memories.filter((m) => m.vaultKey !== vaultKey);
+    const removed = idx.memories.length - next.length;
+    if (removed > 0)
+        writeIndex(cfg, { memories: next });
+    return removed;
+}
+function fileMemorySearch(cfg, query, limit) {
+    const idx = readIndex(cfg);
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const scored = [];
+    for (const m of idx.memories) {
+        const hay = `${m.title ?? ""}\n${(m.tags ?? []).join(" ")}\n${m.content}`.toLowerCase();
+        let score = 0;
+        for (const t of terms) {
+            if ((m.title ?? "").toLowerCase().includes(t))
+                score += 3;
+            if ((m.tags ?? []).some((tag) => tag.toLowerCase().includes(t)))
+                score += 2;
+            score += Math.min(hay.split(t).length - 1, 5);
+        }
+        if (score > 0)
+            scored.push({ m, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, limit);
+    const maxScore = top[0]?.score || 1;
+    return top.map(({ m, score }) => ({ ...toResult(m), score: score / maxScore }));
+}
+function fileMemoryList(cfg, limit, tag) {
+    const idx = readIndex(cfg);
+    let rows = [...idx.memories].sort((a, b) => b.addedAt - a.addedAt);
+    if (tag)
+        rows = rows.filter((m) => (m.tags ?? []).includes(tag));
+    return rows.slice(0, limit).map(toResult);
+}
+function fileMemoryDelete(cfg, id) {
+    const idx = readIndex(cfg);
+    const next = idx.memories.filter((m) => m.id !== id);
+    if (next.length === idx.memories.length)
+        throw new Error(`Memory not found: ${id}`);
+    writeIndex(cfg, { memories: next });
+}
+function fileMemoryProfile(cfg) {
+    const idx = readIndex(cfg);
+    return { total: idx.memories.length, status: "ok", space: "local" };
+}

package/dist/local-memory.js

@@ -6,20 +6,25 @@ exports.localMemoryAdd = localMemoryAdd;
 exports.localMemorySearch = localMemorySearch;
 exports.localMemoryList = localMemoryList;
 exports.localMemoryDelete = localMemoryDelete;
+exports.localMemoryDeleteByVaultKey = localMemoryDeleteByVaultKey;
 exports.localMemoryProfile = localMemoryProfile;
 const config_js_1 = require("./config.js");
+const local_memory_file_js_1 = require("./local-memory-file.js");
 const DEFAULT_URL = "http://localhost:6767";
 const REACHABILITY_TIMEOUT_MS = 1500;
 const CALL_TIMEOUT_MS = 15000;
-// Returns config only when the user has explicitly opted into local memory
-// (memoryBackend: "local") and a key is present. Callers should still treat
-// a null return as "use Convex" - this never throws.
+// Returns config only when the user has explicitly opted into a local
+// backend. Callers should still treat a null return as "use Convex" - this
+// never throws.
 function getLocalMemoryConfig() {
     try {
         const cfg = (0, config_js_1.readConfig)();
-        if (cfg.memoryBackend !== "local" || !cfg.supermemoryApiKey)
-            return null;
-        return { url: cfg.supermemoryUrl ?? DEFAULT_URL, apiKey: cfg.supermemoryApiKey };
+        if (cfg.memoryBackend === "local-file")
+            return { kind: "file", ...(0, local_memory_file_js_1.getLocalMemoryFileConfig)() };
+        if (cfg.memoryBackend === "local" && cfg.supermemoryApiKey) {
+            return { kind: "supermemory", url: cfg.supermemoryUrl ?? DEFAULT_URL, apiKey: cfg.supermemoryApiKey };
+        }
+        return null;
     }
     catch {
         return null;
@@ -28,7 +33,10 @@ function getLocalMemoryConfig() {
 // Requires a genuine 2xx, not just "something answered" - a stale/wrong
 // supermemoryApiKey returns 401 (server is up, but every real memory call
 // will fail the same way), and that must show as unhealthy, not healthy.
+// The file backend is always "reachable" - it's a directory, not a server.
 async function isLocalMemoryReachable(cfg) {
+    if (cfg.kind === "file")
+        return true;
     try {
         const res = await fetch(`${cfg.url}/v3/search`, {
             method: "POST",
@@ -43,6 +51,8 @@ async function isLocalMemoryReachable(cfg) {
     }
 }
 async function localMemoryAdd(cfg, content, metadata, sourceUrl) {
+    if (cfg.kind === "file")
+        return (0, local_memory_file_js_1.fileMemoryAdd)(cfg, content, metadata, sourceUrl);
     const res = await fetch(`${cfg.url}/v3/documents`, {
         method: "POST",
         headers: { "Content-Type": "application/json", Authorization: `Bearer ${cfg.apiKey}` },
@@ -55,6 +65,8 @@ async function localMemoryAdd(cfg, content, metadata, sourceUrl) {
     return { id: data.id ?? data.documentId ?? "saved" };
 }
 async function localMemorySearch(cfg, query, limit) {
+    if (cfg.kind === "file")
+        return (0, local_memory_file_js_1.fileMemorySearch)(cfg, query, limit);
     const res = await fetch(`${cfg.url}/v3/search`, {
         method: "POST",
         headers: { "Content-Type": "application/json", Authorization: `Bearer ${cfg.apiKey}` },
@@ -76,6 +88,8 @@ async function localMemorySearch(cfg, query, limit) {
 // server, so callers pass "*" and post-filter by tag client-side, matching
 // how the Convex-side /memory/list already does its own tag post-filter.
 async function localMemoryList(cfg, limit, tag) {
+    if (cfg.kind === "file")
+        return (0, local_memory_file_js_1.fileMemoryList)(cfg, limit, tag);
     const rows = await localMemorySearch(cfg, "*", Math.max(limit * (tag ? 3 : 1), limit));
     const filtered = tag ? rows.filter((r) => Array.isArray(r.metadata?.tags) && r.metadata.tags.includes(tag)) : rows;
     return filtered.slice(0, limit);
@@ -84,6 +98,10 @@ async function localMemoryList(cfg, limit, tag) {
 // time this was written - throws a distinct error so callers can surface a
 // clear "not supported locally yet" message instead of a generic failure.
 async function localMemoryDelete(cfg, id) {
+    if (cfg.kind === "file") {
+        (0, local_memory_file_js_1.fileMemoryDelete)(cfg, id);
+        return;
+    }
     const res = await fetch(`${cfg.url}/v3/documents/${encodeURIComponent(id)}`, {
         method: "DELETE",
         headers: { Authorization: `Bearer ${cfg.apiKey}` },
@@ -92,11 +110,26 @@ async function localMemoryDelete(cfg, id) {
     if (!res.ok)
         throw new Error(`local supermemory delete failed: HTTP ${res.status}`);
 }
-// No dedicated count endpoint is documented for the local server, so this
-// approximates via a capped wildcard search - accurate up to `SAMPLE_LIMIT`,
-// reported as a floor ("200+") beyond that rather than a false exact count.
+/**
+ * Remove memory rows mirroring a deleted vault entry - called by vault_delete.
+ * "file" backend: direct filter+delete, exact. Self-hosted supermemory server:
+ * no documented "delete by metadata filter" endpoint, so this is a no-op that
+ * returns 0 rather than guessing at an unconfirmed API - vault_delete surfaces
+ * that count so a 0 on that backend doesn't get silently mistaken for success.
+ */
+function localMemoryDeleteByVaultKey(cfg, vaultKey) {
+    if (cfg.kind === "file")
+        return (0, local_memory_file_js_1.fileMemoryDeleteByVaultKey)(cfg, vaultKey);
+    return 0;
+}
+// No dedicated count endpoint is documented for the local supermemory server,
+// so that path approximates via a capped wildcard search - accurate up to
+// `PROFILE_SAMPLE_LIMIT`, reported as a floor ("200+") beyond that rather
+// than a false exact count. The file backend counts exactly.
 const PROFILE_SAMPLE_LIMIT = 200;
 async function localMemoryProfile(cfg) {
+    if (cfg.kind === "file")
+        return { ...(0, local_memory_file_js_1.fileMemoryProfile)(cfg), approximate: false };
     const rows = await localMemorySearch(cfg, "*", PROFILE_SAMPLE_LIMIT);
     return { total: rows.length, status: "ok", space: "local", approximate: rows.length >= PROFILE_SAMPLE_LIMIT };
 }

package/dist/output-schemas.js

@@ -200,6 +200,30 @@ exports.OUTPUT_SCHEMAS = {
         required: ["input", "resolved"],
     },
     // ── SEC equities ────────────────────────────────────────────────────────────
+    stock_fundamentals: {
+        type: "object",
+        properties: {
+            ticker: { type: "string" },
+            companyName: string_null,
+            cik: string_null,
+            quote: {
+                type: ["object", "null"],
+                additionalProperties: true,
+                description: "{ price, currency, prevClose, prevDate } - null when a live quote wasn't available",
+            },
+            quarterly: {
+                type: "object",
+                additionalProperties: { type: "array", items: { type: "object", additionalProperties: true } },
+                description: "Per-concept arrays of { end, val, form, fy, fp } facts, most recent last",
+            },
+            annual: {
+                type: "object",
+                additionalProperties: { type: "array", items: { type: "object", additionalProperties: true } },
+                description: "Per-concept arrays of { end, val, form, fy, fp } facts, most recent last",
+            },
+        },
+        required: ["ticker", "quarterly", "annual"],
+    },
     stock_events: {
         type: "object",
         properties: {
@@ -415,6 +439,53 @@ exports.OUTPUT_SCHEMAS = {
         },
         required: ["count", "packets"],
     },
+    // ── vault ───────────────────────────────────────────────────────────────────
+    vault_list: {
+        type: "object",
+        properties: {
+            type: string_null,
+            count: { type: "number" },
+            entries: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        title: string_null,
+                        type: string_null,
+                        version: { type: "number" },
+                        size: number_null,
+                        updatedAt: number_null,
+                        isPinned: { type: "boolean" },
+                    },
+                    required: ["key"],
+                },
+            },
+        },
+        required: ["count", "entries"],
+    },
+    vault_search: {
+        type: "object",
+        properties: {
+            query: { type: "string" },
+            count: { type: "number" },
+            results: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        title: string_null,
+                        type: string_null,
+                        score: number_null,
+                        preview: string_null,
+                    },
+                    required: ["key"],
+                },
+            },
+        },
+        required: ["query", "count", "results"],
+    },
     // ── memory ──────────────────────────────────────────────────────────────────
     memory_search: {
         type: "object",
@@ -453,14 +524,6 @@ exports.OUTPUT_SCHEMAS = {
         required: ["count", "memories"],
     },
     // ── agents ──────────────────────────────────────────────────────────────────
-    list_agents: {
-        type: "object",
-        properties: {
-            count: { type: "number" },
-            agents: { type: "array", items: { type: "object", additionalProperties: true } },
-        },
-        required: ["count", "agents"],
-    },
     agent_ledger: {
         type: "object",
         properties: {
@@ -470,15 +533,6 @@ exports.OUTPUT_SCHEMAS = {
         },
         required: ["name", "count", "versions"],
     },
-    agent_runs: {
-        type: "object",
-        properties: {
-            name: { type: "string" },
-            count: { type: "number" },
-            runs: { type: "array", items: { type: "object", additionalProperties: true } },
-        },
-        required: ["name", "count", "runs"],
-    },
     // ── scanner / orders / wallet ────────────────────────────────────────────────
     scan_market: {
         type: "object",

package/dist/resources.js

@@ -50,7 +50,7 @@ async function listVaultResources(cursor) {
     try {
         const offset = decodeCursor(cursor);
         // Over-fetch by 1 so we can tell if there's another page without a count call.
-        const data = await (0, convex_js_1.callConvex)(`/vault/list?limit=${PAGE_SIZE + 1}&offset=${offset}`, "GET", undefined, "list_resources");
+        const data = await (0, convex_js_1.callConvex)(`/vault/list?limit=${PAGE_SIZE + 1}&offset=${offset}`, "GET", undefined, "vault_list");
         const allEntries = data.entries ?? data.results ?? [];
         const hasMore = allEntries.length > PAGE_SIZE;
         const entries = hasMore ? allEntries.slice(0, PAGE_SIZE) : allEntries;
@@ -77,21 +77,16 @@ async function readVaultResource(uri) {
         throw new Error(`Unknown resource URI: ${uri}`);
     }
     const key = decodeURIComponent(uri.slice(URI_PREFIX.length));
-    const data = await (0, convex_js_1.callConvex)(`/vault/entry?key=${encodeURIComponent(key)}`, "GET", undefined, "read_resource");
+    const data = await (0, convex_js_1.callConvex)(`/vault/entry?key=${encodeURIComponent(key)}`, "GET", undefined, "vault_read");
     if (data.error) {
         throw new Error(`Vault entry not found: ${key}`);
     }
-    // Blob-backed entry - preview lives in `content`, real payload streams
-    // from /vault/blob. Same flow vault_read uses internally.
-    let body = data.content ?? "";
-    if (data.contentFileId) {
-        try {
-            body = await (0, convex_js_1.callConvexRaw)(`/vault/blob?id=${encodeURIComponent(data.contentFileId)}`, "read_resource");
-        }
-        catch (err) {
-            body = (data.content ?? "") + `\n\n_(could not load full blob: ${err.message})_`;
-        }
-    }
+    // No blob-storage tier exists on the backend (see app/convex/vault.ts) -
+    // oversized content is rejected at save time, so `contentFileId` never
+    // comes back here. A `/vault/blob` fallback used to live here but the route
+    // was never registered in http.ts either; removed as dead code rather than
+    // fixed against a storage tier that doesn't exist.
+    const body = data.content ?? "";
     const mime = mimeForContentType(data.contentType);
     // Only prepend a friendly header for markdown (the default) - JSON/code
     // payloads must remain valid in their own grammar so consuming tools can