@finchagentic/mcp 4.1.0 → 4.4.1

package/dist/tools/agents.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AGENT_TOOLS = void 0;
-exports.buildAgentList = buildAgentList;
 exports.buildAgentLedger = buildAgentLedger;
-exports.buildAgentRuns = buildAgentRuns;
 exports.handleAgentTool = handleAgentTool;
 const zod_1 = require("zod");
-const ethers_1 = require("ethers");
 const convex_js_1 = require("../convex.js");
 const llm_js_1 = require("../llm.js");
+const local_vault_js_1 = require("../local-vault.js");
+const memory_js_1 = require("./memory.js");
+const project_js_1 = require("../project.js");
 // ─── Agent Learning Memory (v3.25) ──────────────────────────────────────────
 // After every agent_update, an LLM reviews the new progress in context of the
 // agent's goal + prior learnings to extract a single repeatable insight. The
@@ -42,7 +42,7 @@ async function extractLearning(goal, priorUpdates, priorLearnings, latest) {
     // immediately rather than proxying through Finch (BYOK is required), and
     // the catch below swallows that into a silent skip. This early return just
     // avoids building the prompt for a call we already know will fail.
-    const hasLLM = !!(process.env.BANKR_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GROK_API_KEY);
+    const hasLLM = !!(process.env.BANKR_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GROK_API_KEY);
     if (!hasLLM && !process.env.FINCH_SESSION_TOKEN) {
         return null;
     }
@@ -104,42 +104,24 @@ function withAgentLock(agentName, fn) {
     });
     return next;
 }
+// list_agents/hire_agent were removed (not disabled - deleted) because their
+// backend routes, /agents/list and /agents/hire, were never actually
+// registered in app/convex/http.ts - only dangling section-header comments
+// exist there, no matching http.route(...) call. Every call to either tool
+// always 404'd. Re-add them (and the matching handler blocks below) only
+// alongside building those two routes for real.
+//
+// Same story, same fix, applied again here: agent_identity, agent_schedule,
+// agent_unschedule, agent_pause, agent_resume and agent_runs called
+// /agents/identity, /agents/schedule, /agents/unschedule, /agents/pause and
+// /agents/runs - none of which exist in http.ts, and none of which have any
+// backing data model in schema.ts (no agent-identity table, no scheduler,
+// no run-history table; there isn't even a cron for it in crons.ts). This
+// isn't a missing route, it's an unbuilt subsystem, so the tools were
+// removed rather than stubbed. Re-add only alongside building that
+// autonomous-scheduling backend for real: identity/schedule storage, a cron
+// that actually wakes agents up, and run-history writes.
 exports.AGENT_TOOLS = [
-    {
-        name: "list_agents",
-        description: "List all available specialist agents you can hire - built-in experts (analyst, risk-manager, researcher, executor, scout) plus any community-published agents.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
-    {
-        name: "hire_agent",
-        description: "Load a specialist agent's expertise and apply it to a task YOURSELF — the tool returns the agent's " +
-            "full persona (its framework, thresholds and house rules) scoped to your task, and you answer in that " +
-            "voice. Built-in: analyst, risk-manager, researcher, executor, scout; use list_agents for the rest. " +
-            "No API key needed. Pass `execute: true` only when you need the agent's own model to answer instead " +
-            "(costs a server-side LLM call and you cannot steer the reasoning).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agentId: {
-                    type: "string",
-                    description: "Agent ID from list_agents. Built-in: analyst, risk-manager, researcher, executor, scout. Or a custom agent ID.",
-                },
-                task: {
-                    type: "string",
-                    description: "The task or question for the agent. Be specific - better input = better output.",
-                },
-                execute: {
-                    type: "boolean",
-                    description: "Run the agent server-side instead of returning its persona for you to apply. Default false. Requires a server LLM key.",
-                },
-                maxTokens: {
-                    type: "number",
-                    description: "execute:true only. Max response tokens (default 800, max 1200).",
-                },
-            },
-            required: ["agentId", "task"],
-        },
-    },
     {
         name: "agent_spawn",
         description: "Create a persistent NAMED agent with a goal - survives across sessions, state saved to vault under `agent/<name>` key. " +
@@ -153,6 +135,12 @@ exports.AGENT_TOOLS = [
                 name: { type: "string", description: "Unique agent name (e.g. 'market-researcher', 'onboarding-helper')" },
                 goal: { type: "string", description: "What this agent is trying to accomplish" },
                 context: { type: "string", description: "Optional starting context, data, or notes for the agent" },
+                workspaceProject: {
+                    type: "string",
+                    description: "Optional: file this agent into a named Finch workspace project (visible on the Agents page's " +
+                        "project switcher). Matched case-insensitively by name; created automatically if it doesn't exist " +
+                        "yet. Hosted vault only (no effect in local-vault mode).",
+                },
             },
             required: ["name", "goal"],
         },
@@ -160,6 +148,8 @@ exports.AGENT_TOOLS = [
     {
         name: "agent_recall",
         description: "Recall a persistent agent by name - loads its goal, current progress, findings, full history, and accumulated learnings (patterns the agent extracted from past runs). " +
+            "Also pulls related context from memory/vault (code_session_save entries, deep_research reports, notes) matching the agent's goal, " +
+            "so recall reflects everything relevant to the goal - not just what agent_update explicitly logged. " +
             "Use this to resume a long-running task, check what an agent last did, or hand context to a fresh LLM session. " +
             "Learnings compound over time - the more an agent runs, the smarter recall becomes.",
         inputSchema: {
@@ -187,27 +177,6 @@ exports.AGENT_TOOLS = [
             required: ["name", "progress"],
         },
     },
-    {
-        name: "agent_identity",
-        description: "Get or create a persistent on-chain identity (wallet address) for a named agent. " +
-            "Every agent gets a unique Base address that acts as its digital identity - visible in the app, " +
-            "usable for receiving payments, and permanently tied to that agent name. " +
-            "Call once per agent; calling again returns the same address.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agentId: {
-                    type: "string",
-                    description: "Agent ID or name (e.g. 'market-researcher', 'analyst')",
-                },
-                agentName: {
-                    type: "string",
-                    description: "Human-readable agent name for display (optional)",
-                },
-            },
-            required: ["agentId"],
-        },
-    },
     {
         name: "agent_ledger",
         description: "View the full activity ledger for a persistent agent - every update, status change, and finding logged in order. " +
@@ -228,83 +197,12 @@ exports.AGENT_TOOLS = [
             required: ["name"],
         },
     },
-    {
-        name: "agent_schedule",
-        description: "Attach an autonomous schedule to an existing agent. The agent wakes up on cron cadence, executes a workflow, " +
-            "saves the result to vault under `agent/<name>/runs/<date>`, and optionally pings you on Telegram. " +
-            "Workflows: " +
-            "deep_research (LLM brief on agent's goal) · " +
-            "packet (run a named packet) · " +
-            "llm (agentic loop with restricted tools) · " +
-            "reflection (walk recent vault activity → update profile/state for persistent context). " +
-            "Cron shorthand: hourly | daily | weekly | every-2-minutes | every-5-minutes (last two for testing).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Agent name (must already exist via agent_spawn)" },
-                cron: { type: "string", description: "Schedule: hourly | daily | weekly | every-2-minutes | every-5-minutes" },
-                workflow: { type: "string", enum: ["deep_research", "packet", "llm", "reflection"], description: "Workflow type" },
-                topic: { type: "string", description: "[deep_research] Research topic (defaults to agent's goal)" },
-                packetName: { type: "string", description: "[packet] Name of packet to run (must exist via packet_create)" },
-                prompt: { type: "string", description: "[llm] Instructions for the autonomous agent loop" },
-                allowedTools: { type: "array", items: { type: "string" }, description: "[llm] Tool whitelist - subset of: vault_save, vault_search, get_market_data, web_search" },
-                windowDays: { type: "number", description: "[reflection] Days of vault activity to walk (default 7)" },
-                maxRunsPerDay: { type: "number", description: "Cost ceiling - default 4 (daily), 24 (hourly), 1 (weekly)" },
-            },
-            required: ["name", "cron", "workflow"],
-        },
-    },
-    {
-        name: "agent_unschedule",
-        description: "Remove the autonomous schedule from an agent. The agent itself remains in vault - only its scheduled execution is cleared.",
-        inputSchema: {
-            type: "object",
-            properties: { name: { type: "string", description: "Agent name" } },
-            required: ["name"],
-        },
-    },
-    {
-        name: "agent_pause",
-        description: "Pause an agent's autonomous schedule without deleting it. Use agent_resume to re-enable.",
-        inputSchema: {
-            type: "object",
-            properties: { name: { type: "string", description: "Agent name" } },
-            required: ["name"],
-        },
-    },
-    {
-        name: "agent_resume",
-        description: "Re-enable a paused agent's schedule. Resets the consecutive-failure counter.",
-        inputSchema: {
-            type: "object",
-            properties: { name: { type: "string", description: "Agent name" } },
-            required: ["name"],
-        },
-    },
-    {
-        name: "agent_runs",
-        description: "View recent autonomous run history for a scheduled agent - when it ran, success/failure status, " +
-            "vault key where the output was saved, and duration. Use this to verify the autonomous loop is healthy.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Agent name" },
-                limit: { type: "number", description: "Max runs to return (default 10, max 50)" },
-            },
-            required: ["name"],
-        },
-    },
 ];
-const HireAgentSchema = zod_1.z.object({
-    agentId: zod_1.z.string().min(1),
-    task: zod_1.z.string().min(1),
-    execute: zod_1.z.boolean().optional(),
-    maxTokens: zod_1.z.number().int().min(100).max(1200).optional(),
-});
 const SpawnAgentSchema = zod_1.z.object({
     name: zod_1.z.string().min(1).max(60).regex(/^[a-z0-9-]+$/, "name must be lowercase alphanumeric with hyphens"),
     goal: zod_1.z.string().min(1),
     context: zod_1.z.string().optional(),
+    workspaceProject: zod_1.z.string().optional(),
 });
 const RecallAgentSchema = zod_1.z.object({ name: zod_1.z.string().min(1) });
 const UpdateAgentSchema = zod_1.z.object({
@@ -315,19 +213,6 @@ const UpdateAgentSchema = zod_1.z.object({
     nextStep: zod_1.z.string().optional(),
 });
 // ── Structured output builders (schemas in output-schemas.ts) ───────────────
-function buildAgentList(agents) {
-    return {
-        count: agents.length,
-        agents: agents.map((a) => ({
-            id: a.id,
-            name: a.name,
-            description: a.description ?? null,
-            category: a.category ?? null,
-            pricingType: a.pricingType ?? null,
-            runs: a.runs ?? null,
-        })),
-    };
-}
 function buildAgentLedger(name, versions) {
     return {
         name,
@@ -339,102 +224,12 @@ function buildAgentLedger(name, versions) {
         })),
     };
 }
-function buildAgentRuns(name, runs) {
-    return {
-        name,
-        count: runs.length,
-        runs: runs.map((r) => ({
-            startedAt: r.startedAt ?? null,
-            endedAt: r.endedAt ?? null,
-            status: r.status ?? null,
-            workflow: r.workflow ?? null,
-            durationMs: r.durationMs ?? null,
-            toolCallCount: r.toolCallCount ?? null,
-            resultSummary: r.resultSummary ?? null,
-            errorMsg: r.errorMsg ?? null,
-        })),
-    };
-}
 async function handleAgentTool(name, args) {
-    if (name === "list_agents") {
-        const data = await (0, convex_js_1.callConvex)("/agents/list", "GET", undefined, "list_agents");
-        const agents = data.agents ?? [];
-        const lines = agents.map((a) => {
-            const badge = a.pricingType === "free" ? "free" : "token-based";
-            const runs = a.runs != null ? ` · ${a.runs} runs` : "";
-            return `**${a.name}** (\`${a.id}\`) [${badge}${runs}]\n  ${a.description}`;
-        });
-        return {
-            content: [{
-                    type: "text",
-                    text: `## Available Agents (${agents.length})\n\n${lines.join("\n\n")}`,
-                }],
-            structuredContent: buildAgentList(agents),
-        };
-    }
-    if (name === "hire_agent") {
-        const parsed = HireAgentSchema.safeParse(args);
-        if (!parsed.success) {
-            return {
-                content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }],
-                isError: true,
-            };
-        }
-        const { agentId, task, maxTokens, execute = false } = parsed.data;
-        const data = await (0, convex_js_1.callConvex)("/agents/hire", "POST", { agentId, task, maxTokens, mode: execute ? "run" : "brief" }, "hire_agent");
-        if (data.error) {
-            return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-        }
-        if (execute) {
-            const footer = data.tokensUsed ? `\n\n*Tokens used: ${data.tokensUsed}*` : "";
-            return {
-                content: [{
-                        type: "text",
-                        text: `## ${data.agent ?? agentId} - Response\n\n${data.result}${footer}`,
-                    }],
-            };
-        }
-        // The registry lookup is the tool's real work - it holds each agent's
-        // persona, thresholds and hard rules. Applying them is model work, and the
-        // caller's model is the better one *and* the one the user can redirect.
-        if (!data.systemPrompt) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `Agent \`${agentId}\` returned no persona. The backend may predate brief mode — retry with \`execute: true\`.`,
-                    }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{
-                    type: "text",
-                    text: [
-                        `## Adopt: ${data.agent ?? agentId}`,
-                        ``,
-                        `You are now this specialist. Answer the task below **in this persona**, applying its framework, ` +
-                            `thresholds and hard rules exactly as written — including the ones that tell you to refuse, ` +
-                            `skip or downgrade a setup. Those gates are the reason the persona exists; do not soften them ` +
-                            `to give a more agreeable answer.`,
-                        ``,
-                        `---`,
-                        ``,
-                        data.systemPrompt,
-                        ``,
-                        `---`,
-                        ``,
-                        `### Task`,
-                        ``,
-                        task,
-                    ].join("\n"),
-                }],
-        };
-    }
     if (name === "agent_spawn") {
         const parsed = SpawnAgentSchema.safeParse(args);
         if (!parsed.success)
-            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-        const { name: agentName, goal, context } = parsed.data;
+            return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
+        const { name: agentName, goal, context, workspaceProject } = parsed.data;
         const content = JSON.stringify({
             goal,
             status: "active",
@@ -442,7 +237,7 @@ async function handleAgentTool(name, args) {
             context: context ?? null,
             updates: [],
         }, null, 2);
-        const data = await (0, convex_js_1.callConvex)("/vault/save", "POST", {
+        const savePayload = {
             type: "memory",
             key: `agent/${agentName}`,
             title: `Agent: ${agentName}`,
@@ -451,18 +246,42 @@ async function handleAgentTool(name, args) {
             agentId: agentName,
             tags: ["persistent-agent"],
             commitMsg: "spawned",
-        }, "vault_save");
+        };
+        const localVault = (0, local_vault_js_1.getLocalVaultConfig)();
+        // Resolve the project name -> id server-side (auto-creates on first use).
+        // No-op in local-vault mode - there is no project concept there.
+        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");
         if (data.error)
             return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+        const projectLine = resolvedProjectName ? `\n**Project:** ${resolvedProjectName}` : "";
         return {
-            content: [{ type: "text", text: `🤖 Agent **${agentName}** spawned.\n\n**Goal:** ${goal}\n\nRecall with \`agent_recall\` · Update progress with \`agent_update\`` }],
+            content: [{ type: "text", text: `🤖 Agent **${agentName}** spawned${localVault ? " locally" : ""}.\n\n**Goal:** ${goal}${projectLine}\n\nRecall with \`agent_recall\` · Update progress with \`agent_update\`` }],
         };
     }
     if (name === "agent_recall") {
         const parsed = RecallAgentSchema.safeParse(args);
         if (!parsed.success)
-            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-        const data = await (0, convex_js_1.callConvex)(`/vault/entry?key=agent/${parsed.data.name}`, "GET", undefined, "vault_read");
+            return { content: [{ type: "text", text: `${parsed.error.issues[0].message}` }], isError: true };
+        const localVault = (0, local_vault_js_1.getLocalVaultConfig)();
+        let data;
+        try {
+            data = localVault
+                ? (0, local_vault_js_1.localVaultRead)(localVault, `agent/${parsed.data.name}`)
+                : await (0, convex_js_1.callConvex)(`/vault/entry?key=agent/${parsed.data.name}`, "GET", undefined, "vault_read");
+        }
+        catch {
+            data = { error: "not found" };
+        }
         if (data.error || !data.content) {
             return { content: [{ type: "text", text: `Agent \`${parsed.data.name}\` not found. Spawn it first with \`agent_spawn\`.` }], isError: true };
         }
@@ -494,17 +313,44 @@ async function handleAgentTool(name, args) {
             lines.push(`\n**Recent updates:**\n${updates.join("\n")}`);
         if (state.nextStep)
             lines.push(`\n**Next step:** ${state.nextStep}`);
+        // Related context - best-effort pull of relevant memory/vault knowledge
+        // (code_session_save entries, deep_research reports, manual notes) so the
+        // agent isn't blind to work done on its goal outside its own update log.
+        // This is what makes recall "continuously have context" rather than only
+        // ever knowing what agent_update explicitly logged.
+        if (state.goal) {
+            try {
+                const related = await (0, memory_js_1.hybridMemorySearch)(state.goal, 4);
+                if (related.length) {
+                    lines.push(`\n**📎 Related context (${related.length}):**`);
+                    related.forEach((r) => {
+                        const title = r.metadata?.title ?? r.content.slice(0, 70).replace(/\n/g, " ");
+                        lines.push(`  • ${title}`);
+                    });
+                }
+            }
+            catch { /* best-effort - recall must never fail because of this */ }
+        }
         return { content: [{ type: "text", text: lines.join("\n") }] };
     }
     if (name === "agent_update") {
         const parsed = UpdateAgentSchema.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 { name: agentName, progress, findings, status = "active", nextStep } = parsed.data;
         return withAgentLock(agentName, async () => {
+            const localVault = (0, local_vault_js_1.getLocalVaultConfig)();
             // Load current state - inside the lock so two parallel updates can't
             // both read v=N and both write v=N+1 (the second silently loses).
-            const current = await (0, convex_js_1.callConvex)(`/vault/entry?key=agent/${agentName}`, "GET", undefined, "vault_read");
+            let current;
+            try {
+                current = localVault
+                    ? (0, local_vault_js_1.localVaultRead)(localVault, `agent/${agentName}`)
+                    : await (0, convex_js_1.callConvex)(`/vault/entry?key=agent/${agentName}`, "GET", undefined, "vault_read");
+            }
+            catch {
+                current = { error: "not found" };
+            }
             if (current.error || !current.content) {
                 return { content: [{ type: "text", text: `Agent \`${agentName}\` not found. Spawn it first.` }], isError: true };
             }
@@ -534,7 +380,7 @@ async function handleAgentTool(name, args) {
                 const entry = { learned: newLearning, ts: Date.now(), fromUpdate: state.updates.length - 1 };
                 state.learnings = [...(state.learnings ?? []), entry].slice(-MAX_LEARNINGS);
             }
-            const data = await (0, convex_js_1.callConvex)("/vault/save", "POST", {
+            const savePayload = {
                 type: "memory",
                 key: `agent/${agentName}`,
                 title: `Agent: ${agentName}`,
@@ -542,7 +388,10 @@ async function handleAgentTool(name, args) {
                 contentType: "json",
                 agentId: agentName,
                 commitMsg: `[${status}] ${progress.slice(0, 60)}${newLearning ? " · +learning" : ""}`,
-            }, "vault_save");
+            };
+            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 statusEmoji = status === "complete" ? "✅" : status === "blocked" ? "🚫" : "🔄";
@@ -559,10 +408,19 @@ async function handleAgentTool(name, args) {
         if (!agentName)
             return { content: [{ type: "text", text: "name is required" }], isError: true };
         const cap = Math.min(Math.max(1, limit), 50);
-        const data = await (0, convex_js_1.callConvex)(`/vault/history?key=agent/${encodeURIComponent(agentName)}&limit=${cap}`, "GET", undefined, "vault_history");
+        const localVault = (0, local_vault_js_1.getLocalVaultConfig)();
+        let data;
+        try {
+            data = localVault
+                ? (0, local_vault_js_1.localVaultHistory)(localVault, `agent/${agentName}`)
+                : await (0, convex_js_1.callConvex)(`/vault/history?key=agent/${encodeURIComponent(agentName)}&limit=${cap}`, "GET", undefined, "vault_history");
+        }
+        catch {
+            data = { history: [] };
+        }
         if (data.error)
             return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-        const versions = data.history ?? [];
+        const versions = (data.history ?? []).slice(0, cap);
         if (!versions.length) {
             return { content: [{ type: "text", text: `No ledger entries found for agent \`${agentName}\`. Spawn it first with \`agent_spawn\`.` }], structuredContent: buildAgentLedger(agentName, []) };
         }
@@ -579,151 +437,5 @@ async function handleAgentTool(name, args) {
             structuredContent: buildAgentLedger(agentName, versions),
         };
     }
-    if (name === "agent_identity") {
-        const { agentId, agentName } = args;
-        // Check if identity already exists
-        const existing = await (0, convex_js_1.callConvex)(`/agents/identity?agentId=${encodeURIComponent(agentId)}`, "GET", undefined, "agent_identity");
-        if (existing?.identity) {
-            const id = existing.identity;
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `🤖 **Agent Identity: \`${agentId}\`**`,
-                            ``,
-                            `**Address:** \`${id.walletAddress}\``,
-                            `**Network:** Base mainnet`,
-                            ``,
-                            `This address is permanent and tied to this agent.`,
-                            `Share it to receive funds · Track spending · Verify agent actions`,
-                        ].join("\n"),
-                    }],
-            };
-        }
-        // Generate new wallet address for the agent
-        const wallet = ethers_1.ethers.Wallet.createRandom();
-        await (0, convex_js_1.callConvex)("/agents/identity", "POST", {
-            agentId,
-            walletAddress: wallet.address,
-            agentName: agentName ?? agentId,
-        }, "agent_identity");
-        return {
-            content: [{
-                    type: "text",
-                    text: [
-                        `🤖 **Agent Identity Created: \`${agentId}\`**`,
-                        ``,
-                        `**Address:** \`${wallet.address}\``,
-                        `**Network:** Base mainnet`,
-                        ``,
-                        `This identity is now permanently linked to \`${agentId}\`.`,
-                        `Visible in the Agents page of your Finch app.`,
-                    ].join("\n"),
-                }],
-        };
-    }
-    // ─── Autonomous schedule tools ──────────────────────────────────────────────
-    if (name === "agent_schedule") {
-        const a = args;
-        if (!a.name || !a.cron || !a.workflow) {
-            return { content: [{ type: "text", text: "name, cron, workflow required" }], isError: true };
-        }
-        const agentKey = `agent/${a.name}`;
-        const workflowConfig = {};
-        if (a.workflow === "deep_research" && a.topic)
-            workflowConfig.topic = a.topic;
-        if (a.workflow === "packet")
-            workflowConfig.packetName = a.packetName;
-        if (a.workflow === "llm") {
-            workflowConfig.prompt = a.prompt;
-            workflowConfig.allowedTools = a.allowedTools ?? ["vault_save", "vault_search"];
-        }
-        if (a.workflow === "reflection") {
-            workflowConfig.windowDays = typeof a.windowDays === "number" ? a.windowDays : 7;
-        }
-        const result = await (0, convex_js_1.callConvex)("/agents/schedule", "POST", {
-            agentKey, cron: a.cron, workflow: a.workflow, workflowConfig,
-            maxRunsPerDay: a.maxRunsPerDay,
-        }, "agent_schedule");
-        if (result.error)
-            return { content: [{ type: "text", text: `Schedule failed: ${result.error}` }], isError: true };
-        return {
-            content: [{
-                    type: "text",
-                    text: [
-                        `🤖 **Schedule attached to \`${a.name}\`**`,
-                        ``,
-                        `Workflow: ${a.workflow}${a.topic ? `\nTopic: ${a.topic}` : ""}${a.packetName ? `\nPacket: ${a.packetName}` : ""}`,
-                        `Cron: ${a.cron}`,
-                        `Next run: ${result.nextRunIso}`,
-                        ``,
-                        `The agent will run autonomously. Check progress with \`agent_runs name=${a.name}\`.`,
-                    ].filter(Boolean).join("\n"),
-                }],
-        };
-    }
-    if (name === "agent_unschedule") {
-        const a = args;
-        if (!a.name)
-            return { content: [{ type: "text", text: "name required" }], isError: true };
-        const result = await (0, convex_js_1.callConvex)("/agents/unschedule", "POST", { agentKey: `agent/${a.name}` }, "agent_unschedule");
-        if (result.error)
-            return { content: [{ type: "text", text: `Unschedule failed: ${result.error}` }], isError: true };
-        return {
-            content: [{
-                    type: "text",
-                    text: result.deleted
-                        ? `🗑️ Schedule removed from \`${a.name}\`. Agent itself remains in vault.`
-                        : `\`${a.name}\` had no active schedule.`,
-                }],
-        };
-    }
-    if (name === "agent_pause" || name === "agent_resume") {
-        const a = args;
-        if (!a.name)
-            return { content: [{ type: "text", text: "name required" }], isError: true };
-        const enabled = name === "agent_resume";
-        const result = await (0, convex_js_1.callConvex)("/agents/pause", "POST", { agentKey: `agent/${a.name}`, enabled }, name);
-        if (result.error)
-            return { content: [{ type: "text", text: `${name} failed: ${result.error}` }], isError: true };
-        if (!result.changed)
-            return { content: [{ type: "text", text: `\`${a.name}\` has no schedule to ${enabled ? "resume" : "pause"}.` }] };
-        return {
-            content: [{
-                    type: "text",
-                    text: enabled
-                        ? `▶️ Resumed schedule for \`${a.name}\`. Failure counter reset.`
-                        : `⏸️ Paused schedule for \`${a.name}\`. Use \`agent_resume name=${a.name}\` to re-enable.`,
-                }],
-        };
-    }
-    if (name === "agent_runs") {
-        const a = args;
-        if (!a.name)
-            return { content: [{ type: "text", text: "name required" }], isError: true };
-        const limit = Math.min(Math.max(a.limit ?? 10, 1), 50);
-        const result = await (0, convex_js_1.callConvex)(`/agents/runs?agentKey=${encodeURIComponent(`agent/${a.name}`)}&limit=${limit}`, "GET", undefined, "agent_runs");
-        if (result.error)
-            return { content: [{ type: "text", text: `agent_runs failed: ${result.error}` }], isError: true };
-        const runs = (result.runs ?? []);
-        if (!runs.length) {
-            return { content: [{ type: "text", text: `No autonomous runs yet for \`${a.name}\`. The agent runs on its cron schedule - be patient.` }], structuredContent: buildAgentRuns(a.name, []) };
-        }
-        const lines = [`## Recent runs for \`${a.name}\` (${runs.length})`, ""];
-        for (const r of runs) {
-            const when = new Date(r.startedAt).toISOString().replace("T", " ").slice(0, 19);
-            const dur = r.durationMs ? `${Math.round(r.durationMs / 1000)}s` : "-";
-            const icon = r.status === "success" ? "✅" : r.status === "failed" ? "❌" : r.status === "timeout" ? "⏱️" : "⏳";
-            lines.push(`${icon} **${when}** · ${r.workflow} · ${dur}${r.toolCallCount != null ? ` · ${r.toolCallCount} tool calls` : ""}`);
-            if (r.vaultKeyResult)
-                lines.push(`   → \`${r.vaultKeyResult}\``);
-            if (r.resultSummary)
-                lines.push(`   ${r.resultSummary.slice(0, 200)}`);
-            if (r.errorMsg)
-                lines.push(`   ⚠️ ${r.errorMsg.slice(0, 200)}`);
-            lines.push("");
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }], structuredContent: buildAgentRuns(a.name, runs) };
-    }
     return null;
 }