@finchagentic/mcp 4.2.0 → 4.5.0

package/dist/tools/stake.js

@@ -134,6 +134,21 @@ exports.STAKE_TOOLS = [
             required: ["stakeId", "confirm"],
         },
     },
+    {
+        name: "claim_vested_rewards",
+        description: "Claim all your fully-vested USDG staking rewards to your custodial wallet. Daily rewards split " +
+            "50% instant / 50% vested over 3 days - this claims whatever portion has finished vesting across " +
+            "ALL your stakes in one call (check stake_finch_status for accrued totals; you'll also get a " +
+            "notification when rewards become claimable). Does nothing to the stake itself - principal stays " +
+            "staked and earning. Requires `finch login` and `confirm: true`.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                confirm: { type: "boolean", description: "Must be true to claim - this moves real USDG into your custodial wallet." },
+            },
+            required: ["confirm"],
+        },
+    },
     {
         name: "stake_auto_restake",
         description: "Turn auto-restake on/off for one of your stakes. When ON, the moment the lock-up ends the stake " +
@@ -143,7 +158,7 @@ exports.STAKE_TOOLS = [
             "the stake is unlockable and it just sits there earning nothing until you run unstake_finch. " +
             "Does NOT auto-compound rewards into the stake - that would require signing from your custodial " +
             "wallet unattended, which this intentionally does not do; claim rewards yourself with " +
-            "claimVestedRewards (you'll get a notification when they're ready). Requires `finch login`.",
+            "claim_vested_rewards (you'll get a notification when they're ready). Requires `finch login`.",
         inputSchema: {
             type: "object",
             properties: {
@@ -246,7 +261,7 @@ async function handleStakeTool(name, args) {
                 isError: true,
             };
         }
-        const result = await (0, convex_js_1.callConvex)("/mcp/stake/stake", "POST", { amountWei: amountWei.toString(), lockTier }, "stake_finch");
+        const result = await (0, convex_js_1.callConvex)("/mcp/stake/stake", "POST", { amountWei: amountWei.toString(), lockTier }, "stake_finch", 30000, true);
         if (result.error)
             return { content: [{ type: "text", text: `Stake failed: ${result.error}` }], isError: true };
         const tier = STAKING_TIERS[lockTier ?? 7];
@@ -294,7 +309,7 @@ async function handleStakeTool(name, args) {
         }
         const lines = [];
         for (const id of targetIds) {
-            const result = await (0, convex_js_1.callConvex)("/mcp/stake/unstake", "POST", { stakeId: id }, "unstake_finch");
+            const result = await (0, convex_js_1.callConvex)("/mcp/stake/unstake", "POST", { stakeId: id }, "unstake_finch", 30000, true);
             if (result.error) {
                 lines.push(`🔴 \`${id}\`: ${result.error}`);
             }
@@ -304,6 +319,31 @@ async function handleStakeTool(name, args) {
         }
         return { content: [{ type: "text", text: lines.join("\n") }] };
     }
+    if (name === "claim_vested_rewards") {
+        const { confirm } = (args ?? {});
+        if (confirm !== true) {
+            return {
+                content: [{ type: "text", text: "Refusing to claim without confirmation - pass `confirm: true`." }],
+                isError: true,
+            };
+        }
+        const login = requireLogin();
+        if (!login)
+            return { content: [{ type: "text", text: NOT_LOGGED_IN_MSG }], isError: true };
+        const result = await (0, convex_js_1.callConvex)("/mcp/stake/claim-rewards", "POST", {}, "claim_vested_rewards", 30000, true);
+        if (result.error)
+            return { content: [{ type: "text", text: `Claim failed: ${result.error}` }], isError: true };
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `✅ Claimed ${(result.claimedAmount ?? 0).toFixed(4)} USDG vested rewards`,
+                        `Tx: \`${result.txHash}\``,
+                        `${rh_mcp_js_1.RH_EXPLORER}/tx/${result.txHash}`,
+                    ].join("\n"),
+                }],
+        };
+    }
     if (name === "stake_auto_restake") {
         const { stakeId, enabled } = (args ?? {});
         if (!stakeId)

package/dist/tools/vault.js

@@ -9,14 +9,16 @@ const convex_js_1 = require("../convex.js");
 const memory_js_1 = require("./memory.js");
 const local_vault_js_1 = require("../local-vault.js");
 const local_memory_js_1 = require("../local-memory.js");
-const VAULT_TYPES = ["research", "execution", "workflow", "prompt", "file", "memory", "credential"];
+const project_js_1 = require("../project.js");
+const VAULT_TYPES = ["research", "execution", "workflow", "prompt", "file", "memory", "code", "credential"];
 exports.VAULT_TOOLS = [
     {
         name: "vault_save",
         description: "Save or update a versioned artifact in Finch Vault. Same key = update (git-style: prior version snapshotted, patched to v+1). " +
-            "Types: research | execution | workflow | prompt | file | memory. " +
+            "Types: research | execution | workflow | prompt | file | memory | code. " +
             "Entries up to 10MB - content over 600KB auto-offloads to blob storage. " +
-            "For quick unstructured notes, use memory_add instead.",
+            "For quick unstructured notes, use memory_add instead. For coding sessions specifically, " +
+            "prefer code_session_save - same versioning, but a structured template and auto-linking built in.",
         inputSchema: {
             type: "object",
             properties: {
@@ -29,10 +31,37 @@ exports.VAULT_TOOLS = [
                 tags: { type: "array", items: { type: "string" }, description: "Tags for filtering and search" },
                 commitMsg: { type: "string", description: "Commit message for this version, e.g. 'initial research', 'refined with on-chain data'" },
                 metadata: { type: "string", description: "Optional JSON string for extra structured fields" },
+                workspaceProject: {
+                    type: "string",
+                    description: "Optional: file this entry into a named Finch workspace project (the same Projects a user " +
+                        "organizes their Agents/vault into on the Agents page). Matched case-insensitively by name; " +
+                        "created automatically if it doesn't exist yet. Not the same thing as a `key` path segment - " +
+                        "this tags the entry in Finch's own project system. Hosted vault only (no effect in local-vault mode).",
+                },
             },
             required: ["type", "content"],
         },
     },
+    {
+        name: "code_session_save",
+        description: "Persist a coding/debugging session as a versioned Markdown snapshot in Finch Vault, keyed by " +
+            "project (`code/<project>`) - so the next session (yours, or another agent's) has real context " +
+            "instead of starting cold. Same project = new version, full history kept (git-style, like vault_save). " +
+            "Auto-links to related past code and research entries. " +
+            "Call this at the end of a substantive coding task - not for every single file read or trivial edit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                project: { type: "string", description: "Project or repo slug, e.g. 'finch-webapp', 'mcp-server'. Becomes the vault key: code/<project>." },
+                summary: { type: "string", description: "What was done this session - the task, the approach, the outcome." },
+                filesChanged: { type: "array", items: { type: "string" }, description: "Files touched, e.g. ['app/convex/vault.ts', 'app/src/App.tsx']" },
+                decisions: { type: "string", description: "Notable decisions or tradeoffs made and why - the part a future session can't re-derive from a diff alone." },
+                nextSteps: { type: "string", description: "What's left, or what to pick up next session." },
+                tags: { type: "array", items: { type: "string" }, description: "Extra tags for search, e.g. ['bugfix', 'refactor']" },
+            },
+            required: ["project", "summary"],
+        },
+    },
     {
         name: "vault_read",
         description: "Read a Finch Vault entry by its key. Returns full content, version, tags, and any linked entries.",
@@ -232,6 +261,14 @@ exports.VAULT_TOOLS = [
             required: ["key"],
         },
     },
+    {
+        name: "list_projects",
+        description: "List your Finch workspace projects - the same Projects used to organize Agents and vault content on the " +
+            "webapp Agents page. Read-only. Check this before passing `workspaceProject` to vault_save/agent_spawn if " +
+            "you want to reuse an existing project rather than relying on the automatic case-insensitive name match. " +
+            "No effect / nothing to list in local-vault mode.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
 ];
 // ─── Zod schemas ─────────────────────────────────────────────────────────────
 const SaveSchema = zod_1.z.object({
@@ -244,6 +281,15 @@ const SaveSchema = zod_1.z.object({
     tags: zod_1.z.array(zod_1.z.string()).optional(),
     commitMsg: zod_1.z.string().optional(),
     metadata: zod_1.z.string().optional(),
+    workspaceProject: zod_1.z.string().optional(),
+});
+const CodeSessionSchema = zod_1.z.object({
+    project: zod_1.z.string().min(1).max(80),
+    summary: zod_1.z.string().min(1),
+    filesChanged: zod_1.z.array(zod_1.z.string()).max(100).optional(),
+    decisions: zod_1.z.string().optional(),
+    nextSteps: zod_1.z.string().optional(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
 });
 const ReadSchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
 const ListSchema = zod_1.z.object({
@@ -322,7 +368,7 @@ async function handleVaultTool(name, args) {
         case "vault_save": {
             const parsed = SaveSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             if (parsed.data.type === "credential") {
                 // vault_save writes plaintext to disk/DB - "credential" is only a
                 // valid FILTER value for vault_list/search/export (which correctly
@@ -340,7 +386,19 @@ async function handleVaultTool(name, args) {
             // Auto-generate title from content if not provided
             const firstLine = parsed.data.content.split("\n")[0].replace(/^#+\s*/, "").slice(0, 80);
             const autoTitle = parsed.data.title ?? (firstLine || `${parsed.data.type} - ${new Date().toISOString().slice(0, 10)}`);
-            const savePayload = { ...parsed.data, title: autoTitle };
+            const { workspaceProject, ...rest } = parsed.data;
+            const savePayload = { ...rest, title: autoTitle };
+            // Resolve the project name -> id server-side (auto-creates on first use).
+            // Local vault has no project concept at all - workspaceProject is
+            // silently a no-op there rather than a confusing network error.
+            let resolvedProjectName = null;
+            if (workspaceProject && !localVault) {
+                const resolved = await (0, project_js_1.resolveProjectId)(workspaceProject);
+                if (resolved) {
+                    savePayload.projectId = resolved.projectId;
+                    resolvedProjectName = resolved.name;
+                }
+            }
             const data = localVault
                 ? (0, local_vault_js_1.localVaultSave)(localVault, savePayload)
                 : await (0, convex_js_1.callConvex)("/vault/save", "POST", savePayload, "vault_save");
@@ -380,6 +438,7 @@ async function handleVaultTool(name, args) {
                 `Key: \`${key}\``,
                 `Version: v${version}`,
                 changed && version > 1 ? `Previous version auto-snapshotted.` : "",
+                resolvedProjectName ? `📁 Project: ${resolvedProjectName}` : "",
                 mirrorToMemory ? `🧠 Synced to searchable memory` : (localVault ? `💾 Stored locally at ~/.finch/vault` : ""),
                 ...linkSummary,
                 ``,
@@ -387,10 +446,99 @@ async function handleVaultTool(name, args) {
             ].filter(Boolean);
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
+        case "code_session_save": {
+            const parsed = CodeSessionSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
+            const { project, summary, filesChanged, decisions, nextSteps, tags } = parsed.data;
+            const projectSlug = project.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "session";
+            const key = `code/${projectSlug}`;
+            const content = [
+                `# Code session: ${project}`,
+                ``,
+                `_${new Date().toISOString()}_`,
+                ``,
+                `## Summary`,
+                summary,
+                filesChanged?.length ? `\n## Files changed\n${filesChanged.map((f) => `- \`${f}\``).join("\n")}` : "",
+                decisions ? `\n## Decisions\n${decisions}` : "",
+                nextSteps ? `\n## Next steps\n${nextSteps}` : "",
+            ].filter(Boolean).join("\n");
+            const savePayload = {
+                type: "code",
+                key,
+                title: `Code: ${project}`,
+                content,
+                contentType: "markdown",
+                agentId: "code-session",
+                tags: ["code-session", ...(tags ?? [])],
+                commitMsg: summary.slice(0, 80),
+            };
+            const data = localVault
+                ? (0, local_vault_js_1.localVaultSave)(localVault, savePayload)
+                : await (0, convex_js_1.callConvex)("/vault/save", "POST", savePayload, "vault_save");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const { version, changed } = data;
+            // Same mirror-to-memory rule as vault_save: skip only when local vault
+            // is on WITHOUT local memory, so query terms never phone home for a
+            // fully offline setup.
+            const mirrorToMemory = !localVault || !!(0, local_memory_js_1.getLocalMemoryConfig)();
+            if (mirrorToMemory) {
+                (0, memory_js_1.syncToSupermemory)(content, {
+                    vaultKey: key, title: savePayload.title, type: "code",
+                    tags: savePayload.tags, version, source: "code_session_save",
+                });
+            }
+            // Auto-link to related past code/research entries - same idea as
+            // deep_research's auto-linking, so a project's session history and any
+            // research that informed it stay connected instead of sitting as
+            // disconnected entries. Purely additive - never blocks the save.
+            const linked = [];
+            try {
+                const searchQuery = `${project} ${summary}`.slice(0, 200);
+                let hits = [];
+                if (localVault) {
+                    const searchResult = (0, local_vault_js_1.localVaultSearch)(localVault, searchQuery, { limit: 6 });
+                    hits = (searchResult.results ?? [])
+                        .filter((r) => !!r.key && r.key !== key)
+                        .map((r) => ({ key: r.key, title: r.title ?? "(untitled)" }));
+                }
+                else {
+                    const searchResult = (await (0, convex_js_1.callConvex)("/vault/search", "POST", { q: searchQuery, n: 8 }, "vault_search"));
+                    hits = (searchResult?.results ?? [])
+                        .map((r) => {
+                        const hitKey = r.metadata?.vaultKey ?? r.metadata?.key ?? null;
+                        return hitKey ? { key: hitKey, title: r.metadata?.title ?? "(untitled)" } : null;
+                    })
+                        .filter((h) => !!h && h.key !== key);
+                }
+                for (const hit of hits.slice(0, 3)) {
+                    try {
+                        if (localVault)
+                            (0, local_vault_js_1.localVaultLink)(localVault, key, hit.key, "related");
+                        else
+                            await (0, convex_js_1.callConvex)("/vault/link", "POST", { fromKey: key, toKey: hit.key, relation: "related" }, "vault_link");
+                        linked.push(hit.key);
+                    }
+                    catch { /* skip individual link failures */ }
+                }
+            }
+            catch { /* auto-link is purely additive */ }
+            const lines = [
+                `📦 **Code session ${changed ? (version === 1 ? "saved" : "updated") : "unchanged"}** - \`${key}\` (v${version})`,
+                filesChanged?.length ? `Files: ${filesChanged.length}` : "",
+                linked.length ? `🔗 Linked to ${linked.length} related entr${linked.length === 1 ? "y" : "ies"}: ${linked.map((k) => `\`${k}\``).join(", ")}` : "",
+                mirrorToMemory ? `🧠 Synced to searchable memory` : "",
+                ``,
+                `Next session: \`vault_read key="${key}"\` for the latest state, or \`vault_history key="${key}"\` for the full timeline.`,
+            ].filter(Boolean);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
         case "vault_read": {
             const parsed = ReadSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const vaultReadKey = parsed.data.key;
             let data;
             try {
@@ -440,12 +588,26 @@ async function handleVaultTool(name, args) {
             const backlinksBlock = Array.isArray(data.backlinks) && data.backlinks.length > 0
                 ? `\n🔙 Linked from (${data.backlinks.length}):\n${data.backlinks.map((b) => `  ← \`${b.key}\`${b.title ? ` - ${b.title}` : ""}`).join("\n")}`
                 : "";
+            // A raw projectId means nothing to a reader - resolve it to a name.
+            // One extra call only when the entry is actually tagged; skipped
+            // entirely for the common case (unassigned) and in local-vault mode.
+            let projectLabel = "";
+            if (data.projectId && !localVault) {
+                try {
+                    const projData = await (0, convex_js_1.callConvex)("/projects/list", "GET", undefined, "list_projects");
+                    const match = projData?.projects?.find((p) => p.id === data.projectId);
+                    if (match)
+                        projectLabel = `📁 Project: ${match.name}`;
+                }
+                catch { /* best-effort - never block the read over this */ }
+            }
             const lines = [
                 `📂 **${data.title}**`,
                 `Key: \`${data.key}\`  ·  Type: ${data.type}  ·  v${data.version}  ·  ${sizeLabel}${data.contentFileId ? " · blob" : ""}`,
                 data.tags?.length ? `Tags: ${data.tags.join(", ")}` : "",
                 data.isPinned ? "📌 Pinned" : "",
                 data.agentId ? `Agent: ${data.agentId}` : "",
+                projectLabel,
                 `Updated: ${formatDate(data.updatedAt)}`,
                 data.linkedKeys?.length ? `\nLinks out:\n${data.linkedKeys.map((l) => `  → ${l}`).join("\n")}` : "",
                 backlinksBlock,
@@ -459,7 +621,7 @@ async function handleVaultTool(name, args) {
         case "vault_list": {
             const parsed = ListSchema.safeParse(args ?? {});
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const params = new URLSearchParams();
             if (parsed.data.type)
                 params.set("type", parsed.data.type);
@@ -491,7 +653,7 @@ async function handleVaultTool(name, args) {
         case "vault_search": {
             const parsed = SearchSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             // Full-text search, proxied through Convex (searchSupermemory is a
             // legacy name - it calls Finch's own /memory/search endpoint, not a
             // third-party semantic service; there is no embedding step here). Large vault
@@ -592,7 +754,7 @@ async function handleVaultTool(name, args) {
         case "vault_history": {
             const parsed = HistorySchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const histKey = parsed.data.key;
             let data;
             try {
@@ -632,7 +794,7 @@ async function handleVaultTool(name, args) {
         case "vault_diff": {
             const parsed = DiffSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const { key, fromVersion, toVersion } = parsed.data;
             let data;
             try {
@@ -676,7 +838,7 @@ async function handleVaultTool(name, args) {
         case "vault_export": {
             const parsed = ExportSchema.safeParse(args ?? {});
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const params = parsed.data.type ? `?type=${parsed.data.type}` : "";
             const data = localVault
                 ? (0, local_vault_js_1.localVaultExport)(localVault, parsed.data.type)
@@ -695,7 +857,7 @@ async function handleVaultTool(name, args) {
         case "vault_store_credential": {
             const parsed = StoreCredentialSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const data = localVault
                 ? (0, local_vault_js_1.localVaultStoreCredential)(localVault, parsed.data.name, parsed.data.value, parsed.data.description)
                 : await (0, convex_js_1.callConvex)("/vault/credential/store", "POST", parsed.data, "vault_store_credential");
@@ -706,7 +868,7 @@ async function handleVaultTool(name, args) {
         case "vault_get_credential": {
             const parsed = GetCredentialSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const params = new URLSearchParams({ name: parsed.data.name });
             let data;
             try {
@@ -729,7 +891,7 @@ async function handleVaultTool(name, args) {
         case "vault_pin": {
             const parsed = PinSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const { key, pinned = true } = parsed.data;
             const data = localVault
                 ? (0, local_vault_js_1.localVaultPin)(localVault, key, pinned)
@@ -741,7 +903,7 @@ async function handleVaultTool(name, args) {
         case "vault_unpublish": {
             const parsed = UnpublishSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             // Publishing is a hosted/marketplace concept - a local vault is private
             // by construction, so there is nothing to retract.
             if (localVault) {
@@ -762,7 +924,7 @@ async function handleVaultTool(name, args) {
         case "vault_delete": {
             const parsed = DeleteSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             if (args?.confirm !== true) {
                 return {
                     content: [{
@@ -797,7 +959,7 @@ async function handleVaultTool(name, args) {
         case "vault_tag": {
             const parsed = TagSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const { key, tags, replace = false } = parsed.data;
             const data = localVault
                 ? (0, local_vault_js_1.localVaultTag)(localVault, key, tags, replace)
@@ -809,7 +971,7 @@ async function handleVaultTool(name, args) {
         case "vault_link": {
             const parsed = LinkSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const { fromKey, toKey, relation } = parsed.data;
             const data = localVault
                 ? (0, local_vault_js_1.localVaultLink)(localVault, fromKey, toKey, relation)
@@ -822,7 +984,7 @@ async function handleVaultTool(name, args) {
         case "vault_related": {
             const parsed = RelatedSchema.safeParse(args);
             if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+                return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
             const { key, relation } = parsed.data;
             const params = new URLSearchParams({ key });
             if (relation)
@@ -838,6 +1000,20 @@ async function handleVaultTool(name, args) {
             const lines = items.map(r => `- **${r.title}** (\`${r.key}\`) [${r.type}] - ${r.direction} \`${r.relation}\``);
             return { content: [{ type: "text", text: `## Related entries for \`${key}\` (${items.length})\n\n${lines.join("\n")}` }] };
         }
+        case "list_projects": {
+            if (localVault) {
+                return { content: [{ type: "text", text: "Local vault mode has no project concept - `workspaceProject` has no effect, and there's nothing to list here." }] };
+            }
+            const data = await (0, convex_js_1.callConvex)("/projects/list", "GET", undefined, "list_projects");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const projects = data.projects ?? [];
+            if (!projects.length) {
+                return { content: [{ type: "text", text: "No projects yet. Pass `workspaceProject: \"name\"` to `vault_save` or `agent_spawn` and one is created automatically." }] };
+            }
+            const lines = projects.map((p) => `- **${p.name}** (\`${p.slug}\`)${p.description ? ` - ${p.description}` : ""}`);
+            return { content: [{ type: "text", text: `📁 **Your projects** (${projects.length})\n\n${lines.join("\n")}` }] };
+        }
         default:
             return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finchagentic/mcp",
-  "version": "4.2.0",
+  "version": "4.5.0",
   "description": "The runtime layer for Agentic AI. Persistent memory, autonomous agents, and workflows that survive every session.",
   "main": "dist/index.js",
   "bin": {
@@ -50,9 +50,8 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "ethers": "^6.16.0",
-    "node-fetch": "^3.3.2",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "ethers": "^6.17.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {