apteva 0.4.41 → 0.4.48

package/src/mcp-platform.ts

@@ -1,11 +1,11 @@
 // Built-in MCP server that exposes the Apteva platform API as MCP tools
 // This allows the meta agent (Apteva Assistant) to control the platform
 
-import { AgentDB, ProjectDB, McpServerDB, SkillDB, TelemetryDB, SubscriptionDB, SettingsDB, generateId } from "./db";
+import { AgentDB, ProjectDB, McpServerDB, McpServerToolDB, SkillDB, TelemetryDB, SubscriptionDB, SettingsDB, generateId } from "./db";
 import { TestCaseDB, TestRunDB } from "./db-tests";
 import { runTest, runAll } from "./test-runner";
 import { getProvidersWithStatus, PROVIDERS, ProviderKeys } from "./providers";
-import { startAgentProcess, setAgentStatus, toApiAgent, META_AGENT_ID, agentFetch } from "./routes/api/agent-utils";
+import { startAgentProcess, setAgentStatus, toApiAgent, META_AGENT_ID, agentFetch, fetchFromAgent } from "./routes/api/agent-utils";
 import { agentProcesses } from "./server";
 import { getTriggerProvider, getTriggerProviderIds, registerTriggerProvider } from "./triggers";
 import { ComposioTriggerProvider } from "./triggers/composio";
@@ -216,6 +216,31 @@ SKILLS & MCP SERVERS:
       required: ["name"],
     },
   },
+  {
+    name: "update_project",
+    description: "Update an existing project's name, description, or color.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_id: { type: "string", description: "The project ID to update" },
+        name: { type: "string", description: "New project name" },
+        description: { type: "string", description: "New project description" },
+        color: { type: "string", description: "New hex color code (e.g. #6366f1)" },
+      },
+      required: ["project_id"],
+    },
+  },
+  {
+    name: "delete_project",
+    description: "Delete a project. Agents, MCP servers, and skills in the project will be unassigned (not deleted).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_id: { type: "string", description: "The project ID to delete" },
+      },
+      required: ["project_id"],
+    },
+  },
   {
     name: "list_providers",
     description: "List all available LLM providers and their configuration status (which have API keys).",
@@ -250,12 +275,13 @@ SKILLS & MCP SERVERS:
     description: `Create a new MCP server configuration. MCP servers provide tools that agents can use (web search, file access, APIs, etc).
 
 SERVER TYPES:
+- local: Runs inside the apteva server — no external process needed. Add tools with add_tool_to_local_server. Ready to use immediately after adding tools.
 - http: Remote MCP server accessible via URL. Provide url and optional auth headers. Ready to use immediately.
 - npm: Node.js MCP server from npm. Provide package name (e.g. '@modelcontextprotocol/server-filesystem'). Needs to be started.
 - pip: Python MCP server from PyPI. Provide package name. Needs to be started.
 - custom: Custom command. Provide command and args. Needs to be started.
 
-After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers work immediately; npm/pip/custom servers need to be started from the MCP page in the UI.`,
+After creating, assign to agents with assign_mcp_server_to_agent. Local and HTTP servers work immediately; npm/pip/custom servers need to be started from the MCP page in the UI.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -282,6 +308,59 @@ After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers w
       required: ["server_id"],
     },
   },
+  {
+    name: "add_tool_to_local_server",
+    description: `Add a tool to a local MCP server. Only works for servers with type "local".
+
+HANDLER TYPES:
+- mock: Returns a static/templated response. Use mock_response with template variables: {{args.field}}, {{uuid()}}, {{now}}, {{timestamp}}, {{random_int(min,max)}}.
+- http: Makes a real HTTP API call. Provide http_config with method, url, headers, and optional body. Templates work in url/headers/body. Use {{credential.KEY}} to reference server env vars for auth.
+- javascript: Runs custom JavaScript code. The code receives args, credentials, and helper functions (uuid, now, timestamp, random_int, random_float). Return a value or JSON object.
+
+EXAMPLES:
+- Mock: handler_type="mock", mock_response={"greeting": "Hello {{args.name}}!", "id": "{{uuid()}}"}
+- HTTP: handler_type="http", http_config={"method": "GET", "url": "https://api.example.com/users/{{args.user_id}}", "headers": {"Authorization": "Bearer {{credential.API_KEY}}"}}
+- JavaScript: handler_type="javascript", code="return { sum: args.a + args.b, computed_at: now }"`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        server_id: { type: "string", description: "The local MCP server ID" },
+        name: { type: "string", description: "Tool name (snake_case, e.g. 'get_weather', 'create_ticket')" },
+        description: { type: "string", description: "What this tool does (shown to the agent)" },
+        input_schema: {
+          type: "object",
+          description: "JSON Schema for tool parameters. Must have type='object' with properties.",
+        },
+        handler_type: { type: "string", description: "How the tool executes: mock, http, or javascript" },
+        mock_response: { type: "object", description: "For mock handler: the response template (supports {{args.field}}, {{uuid()}}, {{now}})" },
+        http_config: {
+          type: "object",
+          description: "For http handler: { method, url, headers?, body? }. Templates supported in all fields.",
+        },
+        code: { type: "string", description: "For javascript handler: JS code to execute. Has access to args, credentials, uuid, now, timestamp, random_int, random_float. Must return a value." },
+      },
+      required: ["server_id", "name", "description", "input_schema", "handler_type"],
+    },
+  },
+  {
+    name: "update_tool_on_local_server",
+    description: `Update an existing tool on a local MCP server. Only provide fields you want to change. Only works for servers with type "local".`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        tool_id: { type: "string", description: "The tool ID to update" },
+        name: { type: "string", description: "New tool name" },
+        description: { type: "string", description: "New description" },
+        input_schema: { type: "object", description: "New JSON Schema for tool parameters" },
+        handler_type: { type: "string", description: "New handler type: mock, http, or javascript" },
+        mock_response: { type: "object", description: "New mock response template" },
+        http_config: { type: "object", description: "New HTTP config: { method, url, headers?, body? }" },
+        code: { type: "string", description: "New JavaScript code" },
+        enabled: { type: "boolean", description: "Enable or disable the tool" },
+      },
+      required: ["tool_id"],
+    },
+  },
   {
     name: "get_dashboard_stats",
     description: "Get platform overview stats: agent counts, task counts, provider counts.",
@@ -302,14 +381,69 @@ After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers w
       required: ["agent_id", "message"],
     },
   },
+  // Task management on agents
+  {
+    name: "list_agent_tasks",
+    description: "List tasks on a running agent. Tasks are scheduled work items that agents execute autonomously.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agent_id: { type: "string", description: "The agent ID to list tasks from" },
+        status: { type: "string", description: "Filter by status: all, pending, running, completed, failed, cancelled (default: all)" },
+      },
+      required: ["agent_id"],
+    },
+  },
+  {
+    name: "create_agent_task",
+    description: "Create a new task on a running agent. The agent must have the tasks feature enabled.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agent_id: { type: "string", description: "The agent ID to create the task on" },
+        title: { type: "string", description: "Task title" },
+        description: { type: "string", description: "Task description / instructions for the agent" },
+        type: { type: "string", description: "Task type: once (one-time) or recurring (default: once)" },
+        priority: { type: "number", description: "Priority 1-10, higher = more important (default: 5)" },
+        execute_at: { type: "string", description: "ISO timestamp for scheduled execution (optional, for one-time tasks)" },
+        recurrence: { type: "string", description: "Cron expression for recurring tasks (e.g. '*/30 * * * *' = every 30 min)" },
+      },
+      required: ["agent_id", "title"],
+    },
+  },
+  {
+    name: "delete_agent_task",
+    description: "Delete a task from a running agent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agent_id: { type: "string", description: "The agent ID" },
+        task_id: { type: "string", description: "The task ID to delete" },
+      },
+      required: ["agent_id", "task_id"],
+    },
+  },
+  {
+    name: "execute_agent_task",
+    description: "Immediately execute a task on a running agent, regardless of its schedule.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agent_id: { type: "string", description: "The agent ID" },
+        task_id: { type: "string", description: "The task ID to execute" },
+      },
+      required: ["agent_id", "task_id"],
+    },
+  },
   // Skills management
   {
     name: "list_skills",
-    description: "List all installed skills. Skills are reusable instruction sets (like prompt templates with tool permissions) that give agents specialized capabilities. Skills can be installed from the SkillsMP marketplace or created locally.",
+    description: "List all installed skills. Skills are reusable instruction sets (like prompt templates with tool permissions) that give agents specialized capabilities. Skills can be installed from the SkillsMP marketplace or created locally. Pass project_id to only see skills scoped to that project (plus global skills).",
     inputSchema: {
       type: "object",
       properties: {
         enabled_only: { type: "boolean", description: "Only return enabled skills (optional, default false)" },
+        project_id: { type: "string", description: "Filter by project ID — returns skills scoped to this project plus global skills" },
       },
     },
   },
@@ -336,6 +470,25 @@ After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers w
       required: ["skill_id", "enabled"],
     },
   },
+  {
+    name: "update_skill",
+    description: "Update an existing skill. Only provide fields you want to change.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        skill_id: { type: "string", description: "The skill ID to update" },
+        name: { type: "string", description: "New name" },
+        description: { type: "string", description: "New description" },
+        content: { type: "string", description: "New instructions content (markdown)" },
+        allowed_tools: {
+          type: "array",
+          items: { type: "string" },
+          description: "New list of allowed MCP tool names",
+        },
+      },
+      required: ["skill_id"],
+    },
+  },
   {
     name: "create_skill",
     description: "Create a new skill. Skills are reusable instruction sets (markdown content) that give agents specialized capabilities. Provide a name, description, and the full instructions content (markdown). Optionally specify allowed MCP tools. If the user is working within a project, set project_id to scope the skill to that project.",
@@ -468,18 +621,6 @@ Use this to find trigger slugs before creating a subscription.`,
       required: ["provider"],
     },
   },
-  {
-    name: "list_connected_accounts",
-    description: "List connected accounts (OAuth connections) for a provider. You need a connected_account_id to create a subscription. Each account represents a user's authenticated connection to a service (e.g. GitHub, Slack, Stripe).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        provider: { type: "string", description: "Integration provider ID: composio or agentdojo" },
-        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
-      },
-      required: ["provider"],
-    },
-  },
   {
     name: "list_subscriptions",
     description: "List local trigger subscriptions. Subscriptions route incoming webhook events to agents. Each subscription maps a trigger (e.g. github:push) to a specific agent.",
@@ -493,22 +634,21 @@ Use this to find trigger slugs before creating a subscription.`,
   },
   {
     name: "create_subscription",
-    description: `Create a trigger subscription: registers a webhook with the external service (via the provider) and creates a local subscription to route events to an agent.
+    description: `Create a trigger subscription: registers a webhook with the external service and routes events to an agent. The webhook URL is auto-configured — you do NOT need to provide a callback URL.
 
-WORKFLOW:
-1. Use list_trigger_providers to check which providers have keys
-2. Use list_trigger_types to find the trigger slug you want
-3. Use list_connected_accounts to find the connected_account_id
-4. Use list_agents to find the agent_id to route events to
-5. Call create_subscription with all the above
+Just provide all 4 required fields in a single call:
+- provider: "agentdojo" or "composio"
+- trigger_slug: from list_trigger_types
+- connected_account_id: from list_integration_connections
+- agent_id: from list_agents
 
-IMPORTANT: Some triggers require extra config fields (e.g. GitHub triggers need "owner" and "repo"). Check the trigger type's config_schema and pass required fields in the config object.`,
+Some triggers require extra config fields (e.g. GitHub needs "owner" and "repo") — pass them in the config object.`,
     inputSchema: {
       type: "object",
       properties: {
         provider: { type: "string", description: "Trigger provider ID: composio or agentdojo" },
         trigger_slug: { type: "string", description: "Trigger type slug (e.g. 'github:push', 'GITHUB_PUSH_EVENT'). Use list_trigger_types to find slugs." },
-        connected_account_id: { type: "string", description: "Connected account ID that owns the integration. Use list_connected_accounts to find IDs." },
+        connected_account_id: { type: "string", description: "Connected account ID that owns the integration. Use list_integration_connections to find IDs." },
         agent_id: { type: "string", description: "Agent ID to route trigger events to. Use list_agents to find IDs." },
         project_id: { type: "string", description: "Project ID for scoping (optional)" },
         config: {
@@ -690,10 +830,15 @@ After adding, use assign_mcp_server_to_agent to give an agent access to these to
   },
 ];
 
+// Project-only tools — hidden entirely when PROJECTS_ENABLED is not set
+const PROJECT_ONLY_TOOLS = new Set(["list_projects", "create_project", "update_project", "delete_project"]);
+
 // Build tools list — when PROJECTS_ENABLED, add project_id to required for all tools that accept it
 function getPlatformTools() {
   const projectsEnabled = process.env.PROJECTS_ENABLED === "true";
-  if (!projectsEnabled) return PLATFORM_TOOLS;
+  if (!projectsEnabled) {
+    return PLATFORM_TOOLS.filter(tool => !PROJECT_ONLY_TOOLS.has(tool.name));
+  }
 
   return PLATFORM_TOOLS.map(tool => {
     const props = tool.inputSchema.properties as Record<string, unknown> | undefined;
@@ -907,6 +1052,36 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `Project created: ${JSON.stringify({ id: project.id, name: project.name, color: project.color }, null, 2)}` }] };
       }
 
+      case "update_project": {
+        const project = ProjectDB.findById(args.project_id);
+        if (!project) return { content: [{ type: "text", text: `Project not found: ${args.project_id}` }], isError: true };
+
+        const updates: Record<string, unknown> = {};
+        if (args.name !== undefined) updates.name = args.name;
+        if (args.description !== undefined) updates.description = args.description;
+        if (args.color !== undefined) updates.color = args.color;
+
+        if (Object.keys(updates).length === 0) {
+          return { content: [{ type: "text", text: "No updates provided" }], isError: true };
+        }
+
+        const updated = ProjectDB.update(args.project_id, updates);
+        return { content: [{ type: "text", text: `Project updated: ${JSON.stringify({ id: updated!.id, name: updated!.name, description: updated!.description, color: updated!.color }, null, 2)}` }] };
+      }
+
+      case "delete_project": {
+        const project = ProjectDB.findById(args.project_id);
+        if (!project) return { content: [{ type: "text", text: `Project not found: ${args.project_id}` }], isError: true };
+
+        const agentCounts = ProjectDB.getAgentCounts();
+        const agentCount = agentCounts.get(args.project_id) || 0;
+
+        const deleted = ProjectDB.delete(args.project_id);
+        if (!deleted) return { content: [{ type: "text", text: "Failed to delete project" }], isError: true };
+
+        return { content: [{ type: "text", text: `Project "${project.name}" deleted. ${agentCount} agent(s) were unassigned.` }] };
+      }
+
       case "list_providers": {
         const providers = getProvidersWithStatus();
         const llmProviders = providers.filter(p => p.type === "llm");
@@ -940,7 +1115,7 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         if (!server) {
           return { content: [{ type: "text", text: `MCP server not found: ${args.server_id}` }], isError: true };
         }
-        return { content: [{ type: "text", text: JSON.stringify({
+        const serverInfo: Record<string, any> = {
           id: server.id,
           name: server.name,
           type: server.type,
@@ -952,7 +1127,23 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
           port: server.port,
           source: server.source,
           projectId: server.project_id,
-        }, null, 2) }] };
+        };
+        // Include tools with full details for local servers
+        if (server.type === "local") {
+          const tools = McpServerToolDB.findByServer(server.id);
+          serverInfo.tools = tools.map(t => ({
+            id: t.id,
+            name: t.name,
+            description: t.description,
+            handler_type: t.handler_type,
+            enabled: t.enabled,
+            input_schema: t.input_schema,
+            mock_response: t.mock_response,
+            http_config: t.http_config,
+            code: t.code,
+          }));
+        }
+        return { content: [{ type: "text", text: JSON.stringify(serverInfo, null, 2) }] };
       }
 
       case "create_mcp_server": {
@@ -986,6 +1177,59 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `MCP server deleted: ${server.name} (${server.id})` }] };
       }
 
+      case "add_tool_to_local_server": {
+        const server = McpServerDB.findById(args.server_id);
+        if (!server) {
+          return { content: [{ type: "text", text: `MCP server not found: ${args.server_id}` }], isError: true };
+        }
+        if (server.type !== "local") {
+          return { content: [{ type: "text", text: `Server "${server.name}" is type "${server.type}" — add_tool_to_local_server only works for local servers.` }], isError: true };
+        }
+        // Check for duplicate tool name
+        const existing = McpServerToolDB.findByServerAndName(args.server_id, args.name);
+        if (existing) {
+          return { content: [{ type: "text", text: `Tool "${args.name}" already exists on this server (ID: ${existing.id}). Use a different name or delete the existing tool first.` }], isError: true };
+        }
+        const tool = McpServerToolDB.create({
+          id: generateId(),
+          server_id: args.server_id,
+          name: args.name,
+          description: args.description,
+          input_schema: args.input_schema || { type: "object", properties: {} },
+          handler_type: args.handler_type || "mock",
+          mock_response: args.mock_response || null,
+          http_config: args.http_config || null,
+          code: args.code || null,
+          enabled: true,
+        });
+        return { content: [{ type: "text", text: `Tool added: ${JSON.stringify({ id: tool.id, name: tool.name, handler_type: tool.handler_type, server: server.name }, null, 2)}` }] };
+      }
+
+      case "update_tool_on_local_server": {
+        const tool = McpServerToolDB.findById(args.tool_id);
+        if (!tool) {
+          return { content: [{ type: "text", text: `Tool not found: ${args.tool_id}` }], isError: true };
+        }
+        const server = McpServerDB.findById(tool.server_id);
+        if (!server || server.type !== "local") {
+          return { content: [{ type: "text", text: `Tool belongs to a non-local server — update_tool_on_local_server only works for local servers.` }], isError: true };
+        }
+        const updates: Record<string, unknown> = {};
+        if (args.name !== undefined) updates.name = args.name;
+        if (args.description !== undefined) updates.description = args.description;
+        if (args.input_schema !== undefined) updates.input_schema = args.input_schema;
+        if (args.handler_type !== undefined) updates.handler_type = args.handler_type;
+        if (args.mock_response !== undefined) updates.mock_response = args.mock_response;
+        if (args.http_config !== undefined) updates.http_config = args.http_config;
+        if (args.code !== undefined) updates.code = args.code;
+        if (args.enabled !== undefined) updates.enabled = args.enabled;
+        const updated = McpServerToolDB.update(args.tool_id, updates);
+        if (!updated) {
+          return { content: [{ type: "text", text: `Failed to update tool ${args.tool_id}` }], isError: true };
+        }
+        return { content: [{ type: "text", text: `Tool updated: ${JSON.stringify({ id: updated.id, name: updated.name, handler_type: updated.handler_type, enabled: updated.enabled, server: server.name }, null, 2)}` }] };
+      }
+
       case "get_dashboard_stats": {
         const agentCount = AgentDB.count();
         const runningCount = AgentDB.countRunning();
@@ -1023,7 +1267,7 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ message: args.message }),
-            signal: AbortSignal.timeout(60000),
+            signal: AbortSignal.timeout(120000),
           });
 
           if (!res.ok) {
@@ -1031,16 +1275,129 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
             return { content: [{ type: "text", text: `Agent responded with error: ${err}` }], isError: true };
           }
 
-          const data = await res.json();
-          const reply = data.response || data.message || JSON.stringify(data);
+          // Agent returns SSE stream — consume and assemble content chunks
+          const reader = res.body?.getReader();
+          if (!reader) {
+            return { content: [{ type: "text", text: "No response stream from agent" }], isError: true };
+          }
+
+          const decoder = new TextDecoder();
+          const contentChunks: string[] = [];
+          let raw = "";
+
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            raw += decoder.decode(value, { stream: true });
+          }
+
+          // Parse SSE lines: "data: {...}"
+          for (const line of raw.split("\n")) {
+            const sseData = line.startsWith("data: ") ? line.slice(6) : line.trim();
+            if (!sseData) continue;
+            try {
+              const evt = JSON.parse(sseData);
+              if (evt.type === "content" && evt.content) {
+                contentChunks.push(evt.content);
+              }
+            } catch {
+              // Not valid JSON — skip
+            }
+          }
+
+          const reply = contentChunks.join("") || "(no response)";
           return { content: [{ type: "text", text: reply }] };
         } catch (err) {
           return { content: [{ type: "text", text: `Failed to communicate with agent: ${err}` }], isError: true };
         }
       }
 
+      case "list_agent_tasks": {
+        const agent = AgentDB.findById(args.agent_id);
+        if (!agent) return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
+        if (agent.status !== "running" || !agent.port) return { content: [{ type: "text", text: `Agent ${agent.name} is not running` }], isError: true };
+
+        const status = args.status || "all";
+        const data = await fetchFromAgent(agent.id, agent.port, `/tasks?status=${status}`);
+        if (!data) return { content: [{ type: "text", text: "Failed to fetch tasks from agent" }], isError: true };
+
+        const tasks = (data.tasks || []).map((t: any) => ({
+          id: t.id, title: t.title, type: t.type, status: t.status, priority: t.priority,
+          recurrence: t.recurrence, next_run: t.next_run, execute_at: t.execute_at, created_at: t.created_at,
+        }));
+        return { content: [{ type: "text", text: JSON.stringify({ tasks, count: tasks.length }, null, 2) }] };
+      }
+
+      case "create_agent_task": {
+        const agent = AgentDB.findById(args.agent_id);
+        if (!agent) return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
+        if (agent.status !== "running" || !agent.port) return { content: [{ type: "text", text: `Agent ${agent.name} is not running` }], isError: true };
+
+        const body: Record<string, unknown> = {
+          title: args.title,
+          description: args.description,
+          type: args.type || "once",
+          priority: args.priority || 5,
+        };
+        if (args.execute_at) body.execute_at = args.execute_at;
+        if (args.recurrence) body.recurrence = args.recurrence;
+
+        try {
+          const res = await agentFetch(agent.id, agent.port, "/tasks", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5000),
+          });
+          const data = await res.json();
+          if (!res.ok) return { content: [{ type: "text", text: `Failed to create task: ${data.error || res.status}` }], isError: true };
+          return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        } catch (err) {
+          return { content: [{ type: "text", text: `Failed to create task: ${err}` }], isError: true };
+        }
+      }
+
+      case "delete_agent_task": {
+        const agent = AgentDB.findById(args.agent_id);
+        if (!agent) return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
+        if (agent.status !== "running" || !agent.port) return { content: [{ type: "text", text: `Agent ${agent.name} is not running` }], isError: true };
+
+        try {
+          const res = await agentFetch(agent.id, agent.port, `/tasks/${args.task_id}`, {
+            method: "DELETE",
+            signal: AbortSignal.timeout(5000),
+          });
+          const data = await res.json();
+          if (!res.ok) return { content: [{ type: "text", text: `Failed to delete task: ${data.error || res.status}` }], isError: true };
+          return { content: [{ type: "text", text: `Task ${args.task_id} deleted successfully` }] };
+        } catch (err) {
+          return { content: [{ type: "text", text: `Failed to delete task: ${err}` }], isError: true };
+        }
+      }
+
+      case "execute_agent_task": {
+        const agent = AgentDB.findById(args.agent_id);
+        if (!agent) return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
+        if (agent.status !== "running" || !agent.port) return { content: [{ type: "text", text: `Agent ${agent.name} is not running` }], isError: true };
+
+        try {
+          const res = await agentFetch(agent.id, agent.port, `/tasks/${args.task_id}/execute`, {
+            method: "POST",
+            signal: AbortSignal.timeout(5000),
+          });
+          const data = await res.json();
+          if (!res.ok) return { content: [{ type: "text", text: `Failed to execute task: ${data.error || res.status}` }], isError: true };
+          return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+        } catch (err) {
+          return { content: [{ type: "text", text: `Failed to execute task: ${err}` }], isError: true };
+        }
+      }
+
       case "list_skills": {
-        const skills = args.enabled_only ? SkillDB.findEnabled() : SkillDB.findAll();
+        let skills = args.enabled_only ? SkillDB.findEnabled() : SkillDB.findAll();
+        if (args.project_id) {
+          skills = skills.filter(s => !s.project_id || s.project_id === args.project_id);
+        }
         const result = skills.map(s => ({
           id: s.id,
           name: s.name,
@@ -1080,6 +1437,20 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `Skill "${skill.name}" ${args.enabled ? "enabled" : "disabled"}` }] };
       }
 
+      case "update_skill": {
+        const skill = SkillDB.findById(args.skill_id);
+        if (!skill) {
+          return { content: [{ type: "text", text: `Skill not found: ${args.skill_id}` }], isError: true };
+        }
+        const updates: Record<string, any> = {};
+        if (args.name !== undefined) updates.name = args.name;
+        if (args.description !== undefined) updates.description = args.description;
+        if (args.content !== undefined) updates.content = args.content;
+        if (args.allowed_tools !== undefined) updates.allowed_tools = args.allowed_tools;
+        const updated = SkillDB.update(args.skill_id, updates);
+        return { content: [{ type: "text", text: `Skill "${updated?.name || skill.name}" updated.` }] };
+      }
+
       case "create_skill": {
         if (!args.name || !args.description || !args.content) {
           return { content: [{ type: "text", text: "name, description, and content are required" }], isError: true };
@@ -1241,26 +1612,6 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
       }
 
-      case "list_connected_accounts": {
-        const providerId = args.provider;
-        const projectId = args.project_id || null;
-        const integrationProvider = getProvider(providerId);
-        if (!integrationProvider) {
-          return { content: [{ type: "text", text: `Unknown integration provider: ${providerId}` }], isError: true };
-        }
-        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
-        if (!apiKey) {
-          return { content: [{ type: "text", text: `${integrationProvider.name} API key not configured` }], isError: true };
-        }
-        const accounts = await integrationProvider.listConnectedAccounts(apiKey, "platform-agent");
-        const result = accounts.map(a => ({
-          id: a.id,
-          appName: a.appName,
-          status: a.status,
-          createdAt: a.createdAt,
-        }));
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      }
 
       case "list_subscriptions": {
         let subscriptions;
@@ -1321,9 +1672,11 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
           }
         }
 
-        // Create remote trigger on the provider
+        // Create remote trigger on the provider — auto-inject callback_url
+        const webhookUrl = SettingsDB.get(`${providerId}_webhook_url`);
         const config: Record<string, unknown> = {
           agent_id: args.agent_id,
+          ...(webhookUrl ? { callback_url: webhookUrl } : {}),
           ...(args.config || {}),
         };
         const triggerResult = await triggerProvider.createTrigger(apiKey, args.trigger_slug, args.connected_account_id, config);
@@ -1732,20 +2085,22 @@ export async function handlePlatformMcpRequest(req: Request): Promise<Response>
         instructions: `This MCP server controls the Apteva AI agent management platform.
 
 You can manage:
-- AGENTS: Create, configure, start, stop, and delete AI agents. Each agent has a provider (LLM), model, system prompt, and optional features (memory, tasks, vision, MCP tools, files).
-- PROJECTS: Organize agents into projects for grouping.
-- MCP SERVERS: Tool integrations that give agents capabilities (web search, file access, APIs). Assign servers to agents.
-- SKILLS: Reusable instruction sets that specialize agent behavior. Use create_skill to create new skills (pass project_id from context to scope to the current project), then assign them to agents. Use list_skills, get_skill, create_skill, toggle_skill, assign_skill_to_agent, unassign_skill_from_agent, delete_skill.
+- AGENTS: Create, configure, start, stop, and delete AI agents. Each agent has a provider (LLM), model, system prompt, and optional features (memory, tasks, vision, MCP tools, files). Use update_agent to assign/remove MCP servers (add_mcp_servers, remove_mcp_servers) and skills (add_skills, remove_skills).
+- TASKS: List, create, delete, and execute tasks on running agents. Tasks are scheduled work items that agents execute autonomously. Agents must have the tasks feature enabled. Tools: list_agent_tasks, create_agent_task, delete_agent_task, execute_agent_task.
+- PROJECTS: Organize agents into projects. Tools: list_projects, create_project, update_project, delete_project. Use project tools when the user is viewing All Projects. Deleting a project unassigns its agents (does not delete them).
+- MCP SERVERS: Tool integrations that give agents capabilities (web search, file access, APIs). Use update_agent with add_mcp_servers to assign servers to agents.
+- SKILLS: Reusable instruction sets that specialize agent behavior. Use create_skill to create new skills (pass project_id from context to scope to the current project). Use update_agent with add_skills/remove_skills to assign/unassign skills to agents. Tools: list_skills, get_skill, create_skill, update_skill, toggle_skill, delete_skill.
 - PROVIDERS: View which LLM providers have API keys configured.
-- TESTS: Create and run automated tests for agent workflows. Tests send a message to an agent, then an LLM judge evaluates the response against success criteria. Use list_tests, create_test, run_test, run_all_tests, get_test_results, delete_test.
-- SUBSCRIPTIONS & TRIGGERS: Subscribe agents to external events (webhooks). Supports multiple providers (composio, agentdojo). Use list_trigger_providers → list_trigger_types → list_connected_accounts → create_subscription. Manage with enable_subscription, disable_subscription, delete_subscription, list_subscriptions.
-- INTEGRATIONS: Connect third-party apps and create MCP servers from them. Supports agentdojo and composio providers. Use list_integration_providers → list_integration_apps → connect_integration_app (API key) → create_integration_config → add_integration_config_locally → assign_mcp_server_to_agent. For OAuth apps, direct the user to the Browse Toolkits UI.
+- TESTS: Create and run automated tests for agent workflows. Tests send a message to an agent, then an LLM judge evaluates the response against success criteria. Tools: list_tests, create_test, run_test, run_all_tests, get_test_results, delete_test.
+- SUBSCRIPTIONS & TRIGGERS: Subscribe agents to external events (webhooks). Supports multiple providers (composio, agentdojo). Use list_trigger_providers → list_trigger_types → list_integration_connections → create_subscription. Manage with enable_subscription, disable_subscription, delete_subscription, list_subscriptions.
+- INTEGRATIONS: Connect third-party apps and create MCP servers from them. Supports agentdojo and composio providers. Use list_integration_providers → list_integration_apps → connect_integration_app (API key) → create_integration_config → add_integration_config_locally → then update_agent with add_mcp_servers to assign to an agent. For OAuth apps, direct the user to the Browse Toolkits UI.
 
 CRITICAL: ALWAYS pass project_id to every tool call that accepts it. API keys and resources are scoped per project — calls without project_id will fail. The chat context tells you the current project id.
 
-Typical workflow: list_providers → create_agent → assign MCP servers/skills → start_agent.
-Integration workflow: list_integration_providers → list_integration_apps (browse) → connect_integration_app (API key) → create_integration_config → add_integration_config_locally → assign_mcp_server_to_agent.
-Subscription workflow: list_trigger_providers → list_trigger_types (pick trigger) → list_connected_accounts (pick account) → create_subscription (link trigger to agent).
+Typical workflow: list_providers → create_agent → update_agent (add_mcp_servers/add_skills) → start_agent.
+Task workflow: list_agent_tasks → create_agent_task (schedule work) → execute_agent_task (run immediately).
+Integration workflow: list_integration_providers → list_integration_apps (browse) → connect_integration_app (API key) → create_integration_config → add_integration_config_locally → update_agent (add_mcp_servers).
+Subscription workflow: list_trigger_providers → list_trigger_types (pick trigger) → list_integration_connections (pick account) → create_subscription (link trigger to agent).
 Test workflow: create_test (set agent, message, eval criteria) → run_test → check results.
 Always use list_providers first to check which providers have API keys before creating agents.`,
       };