assistme 0.3.0 → 0.3.2

package/src/agent/mcp-servers.ts

@@ -1,1021 +1,7 @@
-import {
-  createSdkMcpServer,
-  tool,
-  type McpSdkServerConfigWithInstance,
-} from "@anthropic-ai/claude-agent-sdk";
-import { z } from "zod/v4";
-import { executeTool } from "../tools/index.js";
-import { getLimiterForTool } from "../utils/rate-limiter.js";
-import { log } from "../utils/logger.js";
-import type { MemoryManager, MemoryCategory } from "./memory.js";
-import type { SkillManager } from "./skills.js";
-import { substituteArguments, preprocessDynamicContext, validateSkillName } from "./skills.js";
-import { emitEvent, setActionRequest, pollActionResponse } from "../db/supabase.js";
-import { callMcpHandler } from "../db/api-client.js";
-import { JobRunner } from "./job-runner.js";
-import {
-  createScheduledTask,
-  getNextRunTime,
-} from "./scheduler.js";
+/**
+ * Re-export barrel — preserves backward compatibility while the actual logic
+ * lives in focused modules under mcp/.
+ */
 
-// ── Helper ──────────────────────────────────────────────────────────
-
-/** Wrap executeTool with rate limiting and text result. */
-async function callTool(
-  name: string,
-  input: Record<string, unknown>
-): Promise<{ content: Array<{ type: "text"; text: string }> }> {
-  const limiter = getLimiterForTool(name);
-  if (limiter) await limiter.acquire();
-  const result = await executeTool(name, input);
-  return { content: [{ type: "text", text: result }] };
-}
-
-// ── Browser MCP Server ──────────────────────────────────────────────
-
-export const BROWSER_TOOL_NAMES = [
-  "browser_connect",
-  "browser_navigate",
-  "browser_read_page",
-  "browser_screenshot",
-  "browser_click",
-  "browser_type",
-  "browser_press_key",
-  "browser_scroll",
-  "browser_get_elements",
-  "browser_evaluate",
-  "browser_list_tabs",
-  "browser_switch_tab",
-  "browser_new_tab",
-  "browser_request_user_action",
-] as const;
-
-export function createBrowserMcpServer(): McpSdkServerConfigWithInstance {
-  return createSdkMcpServer({
-    name: "assistme-browser",
-    version: "1.0.0",
-    tools: [
-      tool(
-        "browser_connect",
-        "Connect to the user's real Chrome browser via CDP. Chrome will be auto-launched if not already running.",
-        { tab_index: z.number().optional().describe("Tab index (default: 0)") },
-        async (args) => callTool("browser_connect", args)
-      ),
-      tool(
-        "browser_navigate",
-        "Navigate the user's browser to a URL, using the user's real browser with all their cookies and logins.",
-        { url: z.string().describe("URL to navigate to") },
-        async (args) => callTool("browser_navigate", args)
-      ),
-      tool(
-        "browser_read_page",
-        "Read the text content of the currently open page. Returns page title, URL, and main text content.",
-        {},
-        async () => callTool("browser_read_page", {})
-      ),
-      tool(
-        "browser_screenshot",
-        "Take a screenshot of the current browser page. Returns a base64-encoded PNG image.",
-        {},
-        async () => {
-          const limiter = getLimiterForTool("browser_screenshot");
-          if (limiter) await limiter.acquire();
-          const base64 = await executeTool("browser_screenshot", {});
-          if (base64.length > 100) {
-            return {
-              content: [
-                {
-                  type: "image" as const,
-                  data: base64,
-                  mimeType: "image/png",
-                } as unknown as { type: "text"; text: string },
-              ],
-            };
-          }
-          return { content: [{ type: "text", text: base64 }] };
-        }
-      ),
-      tool(
-        "browser_click",
-        "Click on an element in the user's browser using a CSS selector.",
-        { selector: z.string().describe("CSS selector of the element to click") },
-        async (args) => callTool("browser_click", args)
-      ),
-      tool(
-        "browser_type",
-        "Type text into an input field in the user's browser.",
-        {
-          selector: z.string().describe("CSS selector of the input element"),
-          text: z.string().describe("Text to type"),
-        },
-        async (args) => callTool("browser_type", args)
-      ),
-      tool(
-        "browser_press_key",
-        "Press a keyboard key in the browser. Supports: Enter, Tab, Escape, Backspace, ArrowDown, ArrowUp.",
-        { key: z.string().describe("Key to press") },
-        async (args) => callTool("browser_press_key", args)
-      ),
-      tool(
-        "browser_scroll",
-        "Scroll the page up or down.",
-        { direction: z.string().describe("'down' or 'up'") },
-        async (args) => callTool("browser_scroll", args)
-      ),
-      tool(
-        "browser_get_elements",
-        "Find all interactive elements (links, buttons, inputs) on the current page.",
-        {},
-        async () => callTool("browser_get_elements", {})
-      ),
-      tool(
-        "browser_evaluate",
-        "Execute JavaScript in the browser page context.",
-        { expression: z.string().describe("JavaScript expression to evaluate") },
-        async (args) => callTool("browser_evaluate", args)
-      ),
-      tool("browser_list_tabs", "List all open tabs in the user's browser.", {}, async () =>
-        callTool("browser_list_tabs", {})
-      ),
-      tool(
-        "browser_switch_tab",
-        "Switch to a different browser tab by index.",
-        { index: z.number().describe("Tab index") },
-        async (args) => callTool("browser_switch_tab", args)
-      ),
-      tool(
-        "browser_new_tab",
-        "Open a new tab in the user's browser, optionally navigating to a URL.",
-        { url: z.string().optional().describe("URL to open (default: blank)") },
-        async (args) => callTool("browser_new_tab", args)
-      ),
-      tool(
-        "browser_request_user_action",
-        "Request the user to perform an action in their browser (login, CAPTCHA, 2FA, etc.).",
-        {
-          message: z.string().describe("Clear description of what the user needs to do"),
-          wait_seconds: z.number().optional().describe("How long to wait (default: 60)"),
-        },
-        async (args) => callTool("browser_request_user_action", args)
-      ),
-    ],
-  });
-}
-
-// ── Agent Tools MCP Server (memory, skills) ─────────────────────────
-
-export interface AgentToolsDeps {
-  memoryManager: MemoryManager | null;
-  skillManager: SkillManager;
-  taskId: string;
-  sessionId?: string;
-  userId?: string;
-}
-
-export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfigWithInstance {
-  const { memoryManager, skillManager, taskId, sessionId, userId } = deps;
-
-  return createSdkMcpServer({
-    name: "assistme-agent",
-    version: "1.0.0",
-    tools: [
-      tool(
-        "memory_store",
-        "Store a memory about the user that persists across conversations. Use when you learn preferences, habits, or standing instructions.",
-        {
-          content: z.string().describe("What to remember (concise, factual statement)"),
-          category: z
-            .string()
-            .optional()
-            .describe("Category: general, preference, instruction, context, skill_learned, fact"),
-          importance: z
-            .number()
-            .optional()
-            .describe("Importance 1-10 (default: 5). Use 8+ for instructions"),
-          tags: z.array(z.string()).optional().describe("Optional tags for searchability"),
-        },
-        async (args) => {
-          if (!memoryManager) {
-            return {
-              content: [{ type: "text", text: "Memory manager not available." }],
-            };
-          }
-          const mem = await memoryManager.remember(
-            args.content,
-            (args.category as MemoryCategory) || "general",
-            {
-              importance: args.importance || 5,
-              tags: args.tags || [],
-              sourceMessageId: taskId,
-            }
-          );
-          const result = `Memory stored: "${mem.content}" [${mem.category}, importance: ${mem.importance}]`;
-          return { content: [{ type: "text", text: result }] };
-        }
-      ),
-      tool(
-        "skill_create",
-        "Create a new skill and add it to the user's collection. Returns the skill ID on success.",
-        {
-          name: z.string().describe("Skill name in kebab-case, e.g. 'flight-booking'"),
-          description: z.string().describe("One-line description of what this skill does"),
-          instructions: z.string().describe("Markdown step-by-step instructions"),
-          emoji: z.string().optional().describe("Single emoji representing this skill"),
-        },
-        async (args) => {
-          // Validate skill name format
-          const nameError = validateSkillName(args.name);
-          if (nameError) {
-            return {
-              content: [{
-                type: "text",
-                text: `Invalid skill name: ${nameError}. Use lowercase kebab-case like "flight-booking".`,
-              }],
-            };
-          }
-
-          // Check for duplicates in user's collection
-          const existing = skillManager.findSimilar(args.name);
-          if (existing) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `A similar skill "${existing.name}" already exists in your collection. Use skill_improve to update it instead.`,
-                },
-              ],
-            };
-          }
-
-          // Create in skills table (repository)
-          const result = await skillManager.create(
-            args.name,
-            args.description,
-            args.instructions,
-            { source: "manual", emoji: args.emoji }
-          );
-
-          if (!result) {
-            return {
-              content: [{ type: "text", text: `Failed to create skill "${args.name}".` }],
-            };
-          }
-
-          // Auto-add to user's collection via upsert_agent_skill RPC
-          await skillManager.syncToAgentSkills(
-            args.name,
-            args.description,
-            args.instructions,
-            "1.0.0",
-            {
-              source: "manual",
-              emoji: args.emoji,
-              sourceSkillId: result.id,
-            }
-          );
-
-          log.success(`Skill "${args.name}" created and added to collection`);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`,
-              },
-            ],
-          };
-        }
-      ),
-      tool(
-        "skill_improve",
-        "Improve an existing skill with better instructions based on what you just learned. Version auto-bumped.",
-        {
-          name: z.string().describe("Name of the existing skill to improve"),
-          improved_instructions: z
-            .string()
-            .describe("Full updated markdown instructions (not a diff)"),
-          description: z.string().optional().describe("Updated description (optional)"),
-        },
-        async (args) => {
-          const existing = skillManager.get(args.name);
-          if (!existing) {
-            const available = skillManager
-              .getAll()
-              .map((s) => s.name)
-              .join(", ");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Skill "${args.name}" not found. Available skills: ${available}`,
-                },
-              ],
-            };
-          }
-
-          const updated = skillManager.update(
-            args.name,
-            args.improved_instructions,
-            args.description
-          );
-          if (updated) {
-            log.success(`Self-improvement: improved skill "${args.name}"`);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Skill "${args.name}" improved and version bumped.`,
-                },
-              ],
-            };
-          }
-
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Failed to update skill "${args.name}".`,
-              },
-            ],
-          };
-        }
-      ),
-      tool(
-        "skill_invoke",
-        "Load a skill's full instructions when relevant to the current task. " +
-          "Call this when you determine a skill from the Available Skills list matches the user's request.",
-        {
-          name: z.string().describe("Skill name from the Available Skills list"),
-          arguments: z.string().optional().describe("Arguments to pass to the skill (replaces $ARGUMENTS placeholders)"),
-        },
-        async (args) => {
-          const skill = skillManager.get(args.name);
-          if (!skill) {
-            const available = skillManager
-              .getAll()
-              .map((s) => s.name)
-              .join(", ");
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Skill "${args.name}" not found. Available skills: ${available}`,
-                },
-              ],
-            };
-          }
-
-          let content = skill.content;
-
-          // Substitute $ARGUMENTS placeholders
-          if (args.arguments) {
-            content = substituteArguments(content, args.arguments);
-          }
-
-          // Preprocess dynamic context (!`command` syntax)
-          content = preprocessDynamicContext(content);
-
-          // Build response with skill content
-          let response = `## Skill: ${skill.name}\n`;
-          if (skill.description) {
-            response += `*${skill.description}*\n`;
-          }
-          response += `\n${content}`;
-
-          // Note allowed tools restriction if specified
-          if (skill.allowedTools.length > 0) {
-            response += `\n\n**Allowed tools for this skill:** ${skill.allowedTools.join(", ")}\n`;
-          }
-
-          log.info(`Skill invoked: "${args.name}"`);
-
-          // Log invocation to DB (fire-and-forget)
-          skillManager.logInvocation(args.name, {
-            messageId: taskId,
-            sessionId,
-            arguments: args.arguments,
-          }).catch(() => {});
-
-          return {
-            content: [{ type: "text", text: response }],
-          };
-        }
-      ),
-      tool(
-        "skill_search",
-        "Search for skills by keyword. Uses full-text search across skill names, descriptions, and content. " +
-          "Use this to discover relevant skills when the Available Skills list doesn't have an obvious match.",
-        {
-          query: z.string().describe("Search query (keywords, topic, or task description)"),
-          limit: z.number().optional().describe("Max results (default: 5)"),
-        },
-        async (args) => {
-          const results = await skillManager.searchDb(args.query, args.limit || 5);
-
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: `No skills found for "${args.query}".` }],
-            };
-          }
-
-          let response = `## Skills matching "${args.query}"\n\n`;
-          for (const r of results) {
-            const emoji = r.emoji ? `${r.emoji} ` : "";
-            const usage = r.invocationCount > 0 ? ` (used ${r.invocationCount}x)` : "";
-            response += `- **${emoji}${r.name}**${usage}: ${r.description}\n`;
-          }
-          response += "\nUse skill_invoke to load any of these skills.";
-
-          return { content: [{ type: "text", text: response }] };
-        }
-      ),
-      tool(
-        "skill_generate",
-        "Prepare context for generating skills from a job description. Returns existing skills and job info " +
-          "so you can analyze the job and create skills using skill_create (which auto-adds to user's collection). " +
-          "After creating all skills, call skill_link_job to link them to the job and mark it as analyzed.",
-        {
-          job_name: z.string().describe(
-            "Short name for this job/role. Example: '电商运营', 'Frontend Dev', 'Data Analyst'"
-          ),
-          job_description: z.string().describe(
-            "Description of the user's job, role, and daily tasks. Can be in any language. " +
-              "Example: '我是电商运营，每天要看竞品价格、写商品文案、回复客户评论'"
-          ),
-        },
-        async (args) => {
-          const existingNames = skillManager.getAll().map((s) => s.name);
-
-          let response = `## Job: ${args.job_name}\n`;
-          response += `**Description:** ${args.job_description}\n\n`;
-
-          if (existingNames.length > 0) {
-            response += `**Existing skills (do NOT duplicate):** ${existingNames.join(", ")}\n\n`;
-          }
-
-          response += `**Your task:** Analyze this job description and decompose it into 4-10 automatable skills.\n\n`;
-          response += `**IMPORTANT — You MUST use request_user_confirmation before creating skills:**\n`;
-          response += `1. Analyze the job and draft a list of proposed skills (name, emoji, one-line description for each).\n`;
-          response += `2. Call \`request_user_confirmation\` with the formatted skill list as "message" and these options:\n`;
-          response += `   - options: [{label: "Approve All", action_key: "approve_all", description: "Create all proposed skills"}, {label: "Cancel", action_key: "cancel", description: "Do not create any skills"}]\n`;
-          response += `3. WAIT for the response. If action_key is "approve_all", create all skills using \`skill_create\`. If "cancel", stop.\n`;
-          response += `4. Do NOT ask for confirmation in text. Do NOT create skills without calling request_user_confirmation first.\n\n`;
-          response += `For each skill, call \`skill_create\` with:\n`;
-          response += `- name: kebab-case name (e.g. "slack-message-check")\n`;
-          response += `- description: one-line description\n`;
-          response += `- instructions: detailed step-by-step markdown instructions the agent can follow\n`;
-          response += `- emoji: a single emoji representing the skill\n\n`;
-          response += `skill_create automatically adds the skill to the user's collection — no need to call skill_add.\n\n`;
-          response += `After ALL skills are created, call \`skill_link_job\` with job_name="${args.job_name}" and the list of created skill names to link them and mark the job as analyzed.\n\n`;
-          response += `**Guidelines for skill instructions:**\n`;
-          response += `- Write clear, actionable markdown steps\n`;
-          response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks\n`;
-          response += `- Include error handling steps\n`;
-          response += `- Use placeholders like {query}, {date} for variable inputs\n`;
-          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n`;
-
-          return { content: [{ type: "text", text: response }] };
-        }
-      ),
-      tool(
-        "skill_link_job",
-        "Link created skills to a job and mark it as analyzed. Call this after creating all skills for a job via skill_create + skill_add.",
-        {
-          job_name: z.string().describe("Name of the job to link skills to"),
-          job_description: z.string().describe("Job description (used if job doesn't exist yet)"),
-          skill_names: z.array(z.string()).describe("Names of skills to link to this job"),
-        },
-        async (args) => {
-          if (!userId) {
-            return {
-              content: [{ type: "text", text: "Not authenticated. Cannot link job." }],
-            };
-          }
-
-          try {
-            await saveJobToDb(userId, args.job_name, args.job_description, args.skill_names);
-            log.success(`Job "${args.job_name}": linked ${args.skill_names.length} skills and marked as analyzed`);
-            return {
-              content: [{
-                type: "text",
-                text: `Job "${args.job_name}" linked with ${args.skill_names.length} skills and marked as analyzed.`,
-              }],
-            };
-          } catch (err) {
-            return {
-              content: [{
-                type: "text",
-                text: `Failed to link job: ${err instanceof Error ? err.message : err}`,
-              }],
-            };
-          }
-        }
-      ),
-      tool(
-        "skill_browse",
-        "Browse the skill marketplace to discover skills published by the community. " +
-          "Search by keyword, filter by category, and sort by popularity or rating.",
-        {
-          query: z.string().optional().describe("Search keywords"),
-          category: z.string().optional().describe("Filter by category (e.g. 'productivity', 'ecommerce', 'dev-tools')"),
-          sort: z.enum(["popular", "recent", "rating"]).optional().describe("Sort order (default: popular)"),
-          limit: z.number().optional().describe("Max results (default: 10)"),
-        },
-        async (args) => {
-          const results = await skillManager.browse({
-            query: args.query,
-            category: args.category,
-            sort: args.sort,
-            limit: args.limit || 10,
-          });
-
-          if (results.length === 0) {
-            const hint = args.query ? ` for "${args.query}"` : "";
-            return {
-              content: [{ type: "text", text: `No skills found in marketplace${hint}.` }],
-            };
-          }
-
-          let response = "## Skill Marketplace\n\n";
-          for (const s of results) {
-            const emoji = s.emoji ? `${s.emoji} ` : "";
-            const rating = s.avgRating ? ` ★${s.avgRating}` : "";
-            const installs = s.installCount > 0 ? ` (${s.installCount} installs)` : "";
-            const author = s.authorName ? ` by ${s.authorName}` : "";
-            response += `- **${emoji}${s.name}** v${s.version}${author}${installs}${rating}\n`;
-            response += `  ${s.description}\n`;
-            response += `  ID: \`${s.id}\`\n\n`;
-          }
-          response += "Use `skill_add` with the skill ID to add any of these to your collection.";
-
-          return { content: [{ type: "text", text: response }] };
-        }
-      ),
-      tool(
-        "skill_add",
-        "Add a skill to your personal collection. Works for both marketplace skills and newly created drafts. " +
-          "This is the approval step — after adding, the skill becomes available for use via skill_invoke.",
-        {
-          skill_id: z.string().describe("The skill UUID (from skill_browse or skill_create results)"),
-        },
-        async (args) => {
-          const added = await skillManager.addSkill(args.skill_id);
-          if (!added) {
-            return {
-              content: [{ type: "text", text: `Failed to add skill. Check that the ID is correct.` }],
-            };
-          }
-
-          const emoji = added.metadata.emoji ? `${added.metadata.emoji} ` : "";
-          return {
-            content: [{
-              type: "text",
-              text: `Added **${emoji}${added.name}** v${added.version} to your collection. It's now available for use via skill_invoke.`,
-            }],
-          };
-        }
-      ),
-      tool(
-        "skill_publish",
-        "Publish one of your skills to the marketplace so others can discover and install it.",
-        {
-          name: z.string().describe("Name of your skill to publish"),
-          category: z.string().optional().describe("Category (e.g. 'productivity', 'ecommerce', 'dev-tools')"),
-          author_name: z.string().optional().describe("Your display name as the author"),
-        },
-        async (args) => {
-          const skill = skillManager.get(args.name);
-          if (!skill) {
-            return {
-              content: [{ type: "text", text: `Skill "${args.name}" not found in your collection.` }],
-            };
-          }
-
-          if (skill.source === "external") {
-            return {
-              content: [{ type: "text", text: `Cannot publish external skills.` }],
-            };
-          }
-
-          const result = await skillManager.publish(args.name, {
-            category: args.category,
-            authorName: args.author_name,
-          });
-
-          if (!result) {
-            return {
-              content: [{ type: "text", text: `Failed to publish "${args.name}". The name may already be taken by another author.` }],
-            };
-          }
-
-          return {
-            content: [{
-              type: "text",
-              text: `Skill "${args.name}" published to the marketplace! Others can now find and install it.`,
-            }],
-          };
-        }
-      ),
-
-      // ── User Interaction Tools ──────────────────────────────────
-
-      tool(
-        "request_user_input",
-        "Ask the user a clarifying question and wait for their free-text response. " +
-          "Use this when you need information that cannot be inferred from context, memory, or the workspace — " +
-          "e.g. which account to use, specific preferences, ambiguous instructions, or missing parameters for a skill. " +
-          "Do NOT use this for information you can discover yourself (git remote, file contents, etc.).",
-        {
-          question: z.string().describe("The question to ask the user (supports markdown). Be specific about what you need and why."),
-          placeholder: z.string().optional().describe("Placeholder text for the input field (e.g. 'https://github.com/owner/repo')"),
-          timeout_seconds: z.number().optional().describe("How long to wait for response (default: 300)"),
-        },
-        async (args) => {
-          const actionId = `input_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-          const timeout = (args.timeout_seconds || 300) * 1000;
-
-          const actionData = {
-            id: actionId,
-            type: "input",
-            message: args.question,
-            placeholder: args.placeholder || "",
-            created_at: new Date().toISOString(),
-          };
-
-          try {
-            await setActionRequest(taskId, actionData);
-            log.info(`Input request ${actionId}: "${args.question.slice(0, 80)}..."`);
-
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {});
-
-            const startTime = Date.now();
-            const pollInterval = 2000;
-
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              // Match response to this specific request by action_id
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                const text = (response.text || response.value || "") as string;
-                log.info(`User input received: "${text.slice(0, 80)}"`);
-                return {
-                  content: [{
-                    type: "text",
-                    text: JSON.stringify({ status: "responded", text }),
-                  }],
-                };
-              }
-
-              await new Promise((resolve) => setTimeout(resolve, pollInterval));
-            }
-
-            log.warn(`Input request ${actionId} timed out`);
-            return {
-              content: [{
-                type: "text",
-                text: JSON.stringify({
-                  status: "timeout",
-                  message: "User did not respond within the timeout period.",
-                }),
-              }],
-            };
-          } catch (err) {
-            log.error(`request_user_input failed: ${err}`);
-            return {
-              content: [{
-                type: "text",
-                text: `Failed to request user input: ${err instanceof Error ? err.message : err}`,
-              }],
-            };
-          }
-        }
-      ),
-
-      tool(
-        "request_user_confirmation",
-        "Pause and ask the user for approval or input via the web UI. " +
-          "Returns the user's chosen action_key. Use this BEFORE creating skills, making irreversible changes, etc. " +
-          "The agent will block until the user responds or the timeout expires.",
-        {
-          message: z.string().describe("What to show the user (supports markdown)"),
-          options: z.array(z.object({
-            label: z.string().describe("Button label shown to user"),
-            action_key: z.string().describe("Machine-readable key returned when selected"),
-            description: z.string().optional().describe("Tooltip/description for this option"),
-          })).describe("Buttons/options to show the user"),
-          timeout_seconds: z.number().optional().describe("How long to wait for response (default: 300)"),
-        },
-        async (args) => {
-          const actionId = `action_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-          const timeout = (args.timeout_seconds || 300) * 1000;
-
-          const actionData = {
-            id: actionId,
-            type: "confirmation",
-            message: args.message,
-            options: args.options,
-            created_at: new Date().toISOString(),
-          };
-
-          try {
-            // Store action request in message metadata via RPC — UI reads this
-            await setActionRequest(taskId, actionData);
-            log.info(`Action request ${actionId} stored in metadata, waiting for user response...`);
-
-            // Also emit event for real-time notification (best-effort)
-            emitEvent(taskId, "user_action_request", actionData).catch(() => {});
-
-            // Poll for response
-            const startTime = Date.now();
-            const pollInterval = 2000;
-
-            while (Date.now() - startTime < timeout) {
-              const response = await pollActionResponse(taskId);
-              // Match response to this specific request by action_id
-              if (response && (!response.action_id || response.action_id === actionId)) {
-                const actionKey = (response.action_key || response.action || "") as string;
-                const label = (response.label || actionKey) as string;
-                log.info(`User responded: ${label} (${actionKey})`);
-                return {
-                  content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                      status: "responded",
-                      action_key: actionKey,
-                      label,
-                    }),
-                  }],
-                };
-              }
-
-              await new Promise((resolve) => setTimeout(resolve, pollInterval));
-            }
-
-            log.warn(`Action request ${actionId} timed out after ${args.timeout_seconds || 300}s`);
-            return {
-              content: [{
-                type: "text",
-                text: JSON.stringify({
-                  status: "timeout",
-                  message: "User did not respond within the timeout period.",
-                }),
-              }],
-            };
-          } catch (err) {
-            log.error(`request_user_confirmation failed: ${err}`);
-            return {
-              content: [{
-                type: "text",
-                text: `Failed to request user confirmation: ${err instanceof Error ? err.message : err}`,
-              }],
-            };
-          }
-        }
-      ),
-
-      // ── Job Automation Tools ──────────────────────────────────────
-
-      tool(
-        "job_run",
-        "Run a job by loading its goal and available skills as capabilities. " +
-          "You then decide dynamically which skills to use, in what order, and how to chain them based on what you discover. " +
-          "Use this when the user asks to run their job, or when a scheduled job fires.",
-        {
-          job_name: z.string().describe(
-            "Name of the job to run (e.g. 'software-engineer', 'Frontend Dev')"
-          ),
-        },
-        async (args) => {
-          if (!userId) {
-            return {
-              content: [{ type: "text", text: "Not authenticated. Cannot run job." }],
-            };
-          }
-
-          const runner = new JobRunner(userId);
-          const job = await runner.loadJob(args.job_name);
-
-          if (!job) {
-            // Try to list available jobs
-            const jobs = await runner.listJobs();
-            const available = jobs.length > 0
-              ? `Available jobs: ${jobs.map((j) => `"${j.name}" (${j.skillCount} skills)`).join(", ")}`
-              : "No jobs defined yet. Use skill_generate to create a job from a job description.";
-            return {
-              content: [{ type: "text", text: `Job "${args.job_name}" not found. ${available}` }],
-            };
-          }
-
-          if (job.skills.length === 0) {
-            return {
-              content: [{
-                type: "text",
-                text: `Job "${args.job_name}" has no linked skills. Use skill_generate to add skills to this job.`,
-              }],
-            };
-          }
-
-          // Create a job run record (execution trace lives in conversation transcript)
-          const runId = await runner.createRun(job.jobId, {
-            sessionId: sessionId,
-            messageId: taskId,
-            triggerType: "manual",
-          });
-
-          if (!runId) {
-            // Still return the prompt even if tracking fails
-            log.debug("Failed to create job run record, proceeding without tracking");
-          }
-
-          // Build the structured prompt
-          const prompt = runner.buildJobPrompt(job, runId || "untracked");
-
-          log.info(`Job "${args.job_name}" started with ${job.skills.length} skills (run: ${runId?.slice(0, 8) || "untracked"})`);
-
-          return {
-            content: [{ type: "text", text: prompt }],
-          };
-        }
-      ),
-      tool(
-        "job_schedule",
-        "Schedule a job to run automatically on a recurring basis using a cron expression. " +
-          "For example, schedule your 'software-engineer' job to run every morning at 9am.",
-        {
-          job_name: z.string().describe("Name of the job to schedule"),
-          cron: z.string().describe(
-            "Cron expression: 'minute hour day-of-month month day-of-week'. " +
-              "Examples: '0 9 * * *' (daily 9am), '0 9 * * 1-5' (weekdays 9am), '0 */2 * * *' (every 2 hours)"
-          ),
-          timezone: z.string().optional().describe("Timezone (default: UTC). Examples: 'UTC', 'America/New_York'"),
-          schedule_name: z.string().optional().describe("Custom name for this schedule (default: 'Job: <job_name>')"),
-        },
-        async (args) => {
-          if (!userId) {
-            return {
-              content: [{ type: "text", text: "Not authenticated. Cannot schedule job." }],
-            };
-          }
-
-          const runner = new JobRunner(userId);
-          const job = await runner.loadJob(args.job_name);
-
-          if (!job) {
-            return {
-              content: [{ type: "text", text: `Job "${args.job_name}" not found. Create it first with skill_generate.` }],
-            };
-          }
-
-          // Validate cron expression
-          try {
-            getNextRunTime(args.cron, args.timezone || "UTC");
-          } catch {
-            return {
-              content: [{
-                type: "text",
-                text: `Invalid cron expression: "${args.cron}". Use format: "minute hour day-of-month month day-of-week"`,
-              }],
-            };
-          }
-
-          // Create the scheduled task with a job-run prompt
-          const name = args.schedule_name || `Job: ${args.job_name}`;
-          const prompt = `[JobRun: ${args.job_name}] Run the "${args.job_name}" job. Use job_run to execute it.`;
-          const tz = args.timezone || "UTC";
-
-          try {
-            const task = await createScheduledTask(userId, name, prompt, args.cron, tz);
-
-            // Link the job_id to the scheduled task
-            await callMcpHandler("schedule.link_job", {
-              task_id: task.id,
-              job_id: job.jobId,
-            });
-
-            const nextRun = task.next_run_at
-              ? new Date(task.next_run_at).toLocaleString()
-              : "calculating...";
-
-            let response = `## Job Scheduled: ${args.job_name}\n\n`;
-            response += `- **Schedule:** ${args.cron} (${tz})\n`;
-            response += `- **Next run:** ${nextRun}\n`;
-            response += `- **Skills:** ${job.skills.length}\n\n`;
-            response += `The job "${args.job_name}" will automatically run on this schedule. `;
-            response += `Each run will execute ${job.skills.length} skills in sequence:\n`;
-            for (const skill of job.skills) {
-              const emoji = skill.skillEmoji ? `${skill.skillEmoji} ` : "";
-              response += `  - ${emoji}${skill.skillName}\n`;
-            }
-
-            log.success(`Job "${args.job_name}" scheduled: ${args.cron}`);
-            return { content: [{ type: "text", text: response }] };
-          } catch (err) {
-            return {
-              content: [{
-                type: "text",
-                text: `Failed to schedule job: ${err instanceof Error ? err.message : err}`,
-              }],
-            };
-          }
-        }
-      ),
-      tool(
-        "job_status",
-        "Check the status and run history of a job. Shows recent executions, success rates, and details.",
-        {
-          job_name: z.string().optional().describe("Job name to check (omit for all jobs)"),
-          limit: z.number().optional().describe("Max number of runs to show (default: 5)"),
-        },
-        async (args) => {
-          if (!userId) {
-            return {
-              content: [{ type: "text", text: "Not authenticated." }],
-            };
-          }
-
-          const runner = new JobRunner(userId);
-
-          // If no job specified, list all jobs
-          if (!args.job_name) {
-            const jobs = await runner.listJobs();
-            if (jobs.length === 0) {
-              return {
-                content: [{
-                  type: "text",
-                  text: "No jobs defined. Use skill_generate to create a job from your job description.",
-                }],
-              };
-            }
-
-            let response = "## Your Jobs\n\n";
-            for (const job of jobs) {
-              response += `- **${job.name}** (${job.skillCount} skills): ${job.description.slice(0, 100)}\n`;
-            }
-            response += "\nUse `job_run` to execute a job, or `job_schedule` to automate it.";
-            return { content: [{ type: "text", text: response }] };
-          }
-
-          // Show run history for specific job
-          const runs = await runner.getRunHistory(args.job_name, args.limit || 5);
-
-          if (runs.length === 0) {
-            return {
-              content: [{
-                type: "text",
-                text: `No runs found for job "${args.job_name}". Use job_run to execute it.`,
-              }],
-            };
-          }
-
-          let response = `## Job Status: ${args.job_name}\n\n`;
-          response += `### Recent Runs\n\n`;
-
-          for (const run of runs) {
-            const statusIcon =
-              run.status === "completed" ? "+" :
-              run.status === "failed" ? "x" :
-              run.status === "running" ? "~" : "-";
-            const date = new Date(run.startedAt).toLocaleString();
-            const duration = run.completedAt
-              ? `${Math.round((new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime()) / 1000)}s`
-              : "in progress";
-
-            response += `[${statusIcon}] ${date} | ${run.triggerType} | ${duration}\n`;
-            if (run.summary) {
-              response += `    ${run.summary.slice(0, 100)}\n`;
-            }
-          }
-
-          // Stats
-          const total = runs.length;
-          const completed = runs.filter((r) => r.status === "completed").length;
-          const failed = runs.filter((r) => r.status === "failed").length;
-          response += `\n**Stats:** ${completed}/${total} successful`;
-          if (failed > 0) response += `, ${failed} failed`;
-          response += "\n";
-
-          return { content: [{ type: "text", text: response }] };
-        }
-      ),
-    ],
-  });
-}
-
-// ── Helper: persist job and link skills ────────────────────────────
-
-async function saveJobToDb(
-  _userId: string,
-  jobName: string,
-  jobDescription: string,
-  createdSkillNames: string[]
-): Promise<void> {
-  try {
-    const data = await callMcpHandler("job.save_with_skills", {
-      job_name: jobName,
-      job_description: jobDescription,
-      skill_names: createdSkillNames,
-    });
-
-    log.debug(`Job "${jobName}" saved via edge function (id: ${data}), ${createdSkillNames.length} skill(s) linked`);
-  } catch (err) {
-    log.debug(`saveJobToDb error: ${err}`);
-  }
-}
+export { BROWSER_TOOL_NAMES, createBrowserMcpServer } from "../mcp/browser-server.js";
+export { type AgentToolsDeps, createAgentToolsServer } from "../mcp/agent-tools-server.js";