apteva 0.4.32 → 0.4.44

package/src/mcp-platform.ts

@@ -1,18 +1,30 @@
 // 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";
 import { AgentDojoTriggerProvider } from "./triggers/agentdojo";
-import { getProvider, registerProvider } from "./integrations";
+import { getProvider, getProviderIds, registerProvider } from "./integrations";
 import { ComposioProvider } from "./integrations/composio";
-import { AgentDojoProvider } from "./integrations/agentdojo";
+import {
+  AgentDojoProvider,
+  listServers as listAgentDojoServers,
+  createServer as createAgentDojoServer,
+  getServer as getAgentDojoServer,
+} from "./integrations/agentdojo";
+import {
+  listMcpServers as listComposioServers,
+  createMcpServer as createComposioServer,
+  getAuthConfigForToolkit as getComposioAuthConfig,
+  getUserIdForAuthConfig as getComposioUserForAuth,
+  createMcpServerInstance as createComposioInstance,
+} from "./integrations/composio";
 
 // Register trigger + integration providers on module load
 registerTriggerProvider(ComposioTriggerProvider);
@@ -30,6 +42,7 @@ interface JsonRpcRequest {
   params?: any;
 }
 
+
 interface JsonRpcResponse {
   jsonrpc: "2.0";
   id: number;
@@ -65,7 +78,7 @@ const PLATFORM_TOOLS = [
     description: `Create a new AI agent. The provider must have an API key configured — use list_providers first to check.
 
 PROVIDERS & MODELS (use list_providers to see which have keys):
-- anthropic: claude-sonnet-4-5 (recommended), claude-haiku-4-5 (fast/cheap)
+- anthropic: claude-sonnet-4-6 (recommended), claude-sonnet-4-5, claude-haiku-4-5 (fast/cheap)
 - openai: gpt-4o (recommended), gpt-4o-mini (fast/cheap)
 - groq: llama-3.3-70b-versatile (recommended), llama-3.1-8b-instant (fast)
 - gemini: gemini-3-pro-preview (recommended), gemini-3-flash-preview (fast)
@@ -111,7 +124,14 @@ TIPS:
   },
   {
     name: "update_agent",
-    description: "Update an existing agent's configuration. Only provide fields you want to change. If the agent is running, restart it after updating for changes to take effect.",
+    description: `Update an existing agent's configuration. Only provide fields you want to change. If the agent is running, restart it after updating for changes to take effect.
+
+SKILLS & MCP SERVERS:
+- Pass skill_ids or mcp_server_ids to SET the full list (replaces existing).
+- Use add_skills / remove_skills to add/remove individual skills without replacing the whole list.
+- Use add_mcp_servers / remove_mcp_servers to add/remove individual MCP servers.
+- Adding MCP servers automatically enables the mcp feature.
+- Use list_skills and list_mcp_servers to find IDs.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -132,6 +152,12 @@ TIPS:
             files: { type: "boolean" },
           },
         },
+        skill_ids: { type: "array", items: { type: "string" }, description: "Set the full list of skill IDs (replaces existing)" },
+        add_skills: { type: "array", items: { type: "string" }, description: "Skill IDs to add (keeps existing)" },
+        remove_skills: { type: "array", items: { type: "string" }, description: "Skill IDs to remove" },
+        mcp_server_ids: { type: "array", items: { type: "string" }, description: "Set the full list of MCP server IDs (replaces existing)" },
+        add_mcp_servers: { type: "array", items: { type: "string" }, description: "MCP server IDs to add (keeps existing)" },
+        remove_mcp_servers: { type: "array", items: { type: "string" }, description: "MCP server IDs to remove" },
       },
       required: ["agent_id"],
     },
@@ -190,6 +216,31 @@ TIPS:
       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).",
@@ -224,12 +275,13 @@ TIPS:
     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: {
@@ -257,27 +309,56 @@ After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers w
     },
   },
   {
-    name: "assign_mcp_server_to_agent",
-    description: "Assign an MCP server to an agent so the agent can use its tools. This automatically enables the MCP feature on the agent. If the agent is running, restart it for changes to take effect.",
+    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: {
-        agent_id: { type: "string", description: "The agent ID" },
-        server_id: { type: "string", description: "The MCP server ID to assign" },
+        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: ["agent_id", "server_id"],
+      required: ["server_id", "name", "description", "input_schema", "handler_type"],
     },
   },
   {
-    name: "unassign_mcp_server_from_agent",
-    description: "Remove an MCP server from an agent.",
+    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: {
-        agent_id: { type: "string", description: "The agent ID" },
-        server_id: { type: "string", description: "The MCP server ID to remove" },
+        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: ["agent_id", "server_id"],
+      required: ["tool_id"],
     },
   },
   {
@@ -300,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" },
       },
     },
   },
@@ -335,27 +471,22 @@ After creating, assign to agents with assign_mcp_server_to_agent. HTTP servers w
     },
   },
   {
-    name: "assign_skill_to_agent",
-    description: "Assign a skill to an agent. The skill's instructions and tool permissions will be pushed to the agent on next start/restart.",
+    name: "update_skill",
+    description: "Update an existing skill. Only provide fields you want to change.",
     inputSchema: {
       type: "object",
       properties: {
-        agent_id: { type: "string", description: "The agent ID" },
-        skill_id: { type: "string", description: "The skill ID to assign" },
-      },
-      required: ["agent_id", "skill_id"],
-    },
-  },
-  {
-    name: "unassign_skill_from_agent",
-    description: "Remove a skill from an agent.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        agent_id: { type: "string", description: "The agent ID" },
-        skill_id: { type: "string", description: "The skill ID to remove" },
+        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: ["agent_id", "skill_id"],
+      required: ["skill_id"],
     },
   },
   {
@@ -490,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.",
@@ -515,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: {
@@ -581,8 +699,164 @@ IMPORTANT: Some triggers require extra config fields (e.g. GitHub triggers need
       required: ["subscription_id"],
     },
   },
+  // Integration management tools
+  {
+    name: "list_integration_providers",
+    description: "List available integration providers (e.g. agentdojo, composio) and whether they have API keys configured. Integration providers give access to third-party apps, OAuth connections, and MCP server creation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+      },
+    },
+  },
+  {
+    name: "list_integration_apps",
+    description: `List available apps/toolkits from an integration provider. Each app represents a service (e.g. GitHub, Slack, Stripe) that can be connected via OAuth or API key.
+
+Returns apps with their auth schemes (OAUTH2, API_KEY), connection status, and categories.
+Use this to browse what's available before connecting an app.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+        search: { type: "string", description: "Optional search filter for app name/slug" },
+      },
+      required: ["provider"],
+    },
+  },
+  {
+    name: "connect_integration_app",
+    description: `Connect/authenticate an app by storing credentials on the integration provider. This enables the app's tools to be used in MCP servers.
+
+NOTE: Only API_KEY auth is supported from the assistant. For OAuth apps, direct the user to the Browse Toolkits UI.
+
+Some apps require multiple credential fields (e.g. Pushover needs appToken + userKey). Use list_integration_apps to see credentialFields for each app — if present, pass all required fields in the "credentials" object. If the app has no credentialFields, pass a single "api_key".
+
+WORKFLOW:
+1. list_integration_apps to find the app and its credentialFields
+2. connect_integration_app with the app slug and credentials
+3. create_integration_config to create an MCP server from the connected app
+4. add_integration_config_locally to add it as a local MCP server`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        app_slug: { type: "string", description: "App slug (from list_integration_apps)" },
+        api_key: { type: "string", description: "Single API key (for apps with no credentialFields)" },
+        credentials: {
+          type: "object",
+          description: "Credential fields as key-value pairs (e.g. { appToken: '...', userKey: '...' }). Use this for apps with multiple credentialFields. Takes priority over api_key.",
+        },
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+      },
+      required: ["provider", "app_slug"],
+    },
+  },
+  {
+    name: "list_integration_connections",
+    description: "List connected accounts (credentials) for an integration provider. Shows which apps have been authenticated and their status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+      },
+      required: ["provider"],
+    },
+  },
+  {
+    name: "disconnect_integration_app",
+    description: "Disconnect/revoke a connected account (credential) from an integration provider.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        connection_id: { type: "string", description: "Connection/credential ID (from list_integration_connections)" },
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+      },
+      required: ["provider", "connection_id"],
+    },
+  },
+  {
+    name: "list_integration_configs",
+    description: "List MCP server configs on an integration provider. These are remote MCP servers hosted by the provider that can be added locally.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+      },
+      required: ["provider"],
+    },
+  },
+  {
+    name: "create_integration_config",
+    description: `Create an MCP server config on an integration provider from a connected app/toolkit. This creates a remote MCP server on the provider that bundles the app's tools.
+
+After creation, use add_integration_config_locally to add it as a local MCP server.
+
+WORKFLOW:
+1. list_integration_apps → find the app slug
+2. Ensure app is connected (list_integration_connections or connect_integration_app)
+3. create_integration_config → creates remote MCP server
+4. add_integration_config_locally → adds it locally so agents can use it`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        name: { type: "string", description: "Name for the MCP config (e.g. 'GitHub MCP', 'Slack Tools')" },
+        toolkit_slug: { type: "string", description: "Toolkit/app slug to create the config from" },
+        project_id: { type: "string", description: "Project ID for project-scoped API keys (optional)" },
+      },
+      required: ["provider", "name", "toolkit_slug"],
+    },
+  },
+  {
+    name: "add_integration_config_locally",
+    description: `Add a remote integration MCP config as a local MCP server. This creates a local MCP server entry that connects to the provider's hosted MCP endpoint, making its tools available to agents.
+
+After adding, use assign_mcp_server_to_agent to give an agent access to these tools.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        provider: { type: "string", description: "Integration provider ID: agentdojo or composio" },
+        config_id: { type: "string", description: "Config/server ID on the provider (from list_integration_configs or create_integration_config)" },
+        project_id: { type: "string", description: "Project ID to scope the local server to (optional)" },
+      },
+      required: ["provider", "config_id"],
+    },
+  },
 ];
 
+// 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.filter(tool => !PROJECT_ONLY_TOOLS.has(tool.name));
+  }
+
+  return PLATFORM_TOOLS.map(tool => {
+    const props = tool.inputSchema.properties as Record<string, unknown> | undefined;
+    if (!props || !("project_id" in props)) return tool;
+
+    const existing = (tool.inputSchema as any).required || [];
+    if (existing.includes("project_id")) return tool;
+
+    return {
+      ...tool,
+      inputSchema: {
+        ...tool.inputSchema,
+        required: [...existing, "project_id"],
+      },
+    };
+  });
+}
+
 // Tool execution handlers
 async function executeTool(name: string, args: Record<string, any>): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
   try {
@@ -662,8 +936,46 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
           updates.features = { ...agent.features, ...args.features };
         }
 
+        // Skills: set, add, or remove
+        let skills = agent.skills || [];
+        if (args.skill_ids !== undefined) {
+          skills = args.skill_ids;
+        }
+        if (args.add_skills) {
+          for (const sid of args.add_skills) {
+            if (!skills.includes(sid)) skills.push(sid);
+          }
+        }
+        if (args.remove_skills) {
+          skills = skills.filter((id: string) => !args.remove_skills.includes(id));
+        }
+        if (args.skill_ids !== undefined || args.add_skills || args.remove_skills) {
+          updates.skills = skills;
+        }
+
+        // MCP servers: set, add, or remove
+        let mcpServers = agent.mcp_servers || [];
+        if (args.mcp_server_ids !== undefined) {
+          mcpServers = args.mcp_server_ids;
+        }
+        if (args.add_mcp_servers) {
+          for (const sid of args.add_mcp_servers) {
+            if (!mcpServers.includes(sid)) mcpServers.push(sid);
+          }
+        }
+        if (args.remove_mcp_servers) {
+          mcpServers = mcpServers.filter((id: string) => !args.remove_mcp_servers.includes(id));
+        }
+        if (args.mcp_server_ids !== undefined || args.add_mcp_servers || args.remove_mcp_servers) {
+          updates.mcp_servers = mcpServers;
+          // Auto-enable MCP feature if servers are being added
+          if (mcpServers.length > 0 && !agent.features.mcp) {
+            updates.features = { ...(updates.features || agent.features), mcp: true };
+          }
+        }
+
         const updated = AgentDB.update(args.agent_id, updates);
-        return { content: [{ type: "text", text: `Agent updated: ${JSON.stringify({ id: updated?.id, name: updated?.name }, null, 2)}` }] };
+        return { content: [{ type: "text", text: `Agent updated: ${JSON.stringify({ id: updated?.id, name: updated?.name, skills: updates.skills !== undefined ? updates.skills.length + " skills" : "unchanged", mcp_servers: updates.mcp_servers !== undefined ? updates.mcp_servers.length + " servers" : "unchanged" }, null, 2)}` }] };
       }
 
       case "delete_agent": {
@@ -740,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");
@@ -754,8 +1096,8 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
 
       case "list_mcp_servers": {
         const servers = args.project_id
-          ? McpServerDB.findByProject(args.project_id)
-          : McpServerDB.findAll();
+          ? McpServerDB.findByProjectLight(args.project_id)
+          : McpServerDB.findAllLight();
         const result = servers.map(s => ({
           id: s.id,
           name: s.name,
@@ -773,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,
@@ -785,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": {
@@ -819,38 +1177,57 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `MCP server deleted: ${server.name} (${server.id})` }] };
       }
 
-      case "assign_mcp_server_to_agent": {
-        const agent = AgentDB.findById(args.agent_id);
-        if (!agent) {
-          return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
-        }
+      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 };
         }
-        const mcpServers = agent.mcp_servers || [];
-        if (mcpServers.includes(args.server_id)) {
-          return { content: [{ type: "text", text: `Server ${server.name} is already assigned to ${agent.name}` }] };
+        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 };
         }
-        AgentDB.update(args.agent_id, { mcp_servers: [...mcpServers, args.server_id] });
-        // Enable MCP feature if not already
-        if (!agent.features.mcp) {
-          AgentDB.update(args.agent_id, { features: { ...agent.features, mcp: 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 };
         }
-        return { content: [{ type: "text", text: `Assigned MCP server "${server.name}" to agent "${agent.name}". Restart the agent for changes to take effect.` }] };
+        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 "unassign_mcp_server_from_agent": {
-        const agent = AgentDB.findById(args.agent_id);
-        if (!agent) {
-          return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
+      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 mcpServers = agent.mcp_servers || [];
-        if (!mcpServers.includes(args.server_id)) {
-          return { content: [{ type: "text", text: `Server is not assigned to this agent` }] };
+        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 };
         }
-        AgentDB.update(args.agent_id, { mcp_servers: mcpServers.filter((id: string) => id !== args.server_id) });
-        return { content: [{ type: "text", text: `Removed MCP server from agent "${agent.name}". Restart the agent for changes to take effect.` }] };
+        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": {
@@ -859,7 +1236,7 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         const projectCount = ProjectDB.count();
         const providers = getProvidersWithStatus().filter(p => p.type === "llm");
         const configuredProviders = providers.filter(p => p.hasKey).length;
-        const mcpServerCount = McpServerDB.findAll().length;
+        const mcpServerCount = McpServerDB.count();
         const skillCount = SkillDB.count();
 
         return {
@@ -890,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) {
@@ -898,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,
@@ -947,34 +1437,18 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `Skill "${skill.name}" ${args.enabled ? "enabled" : "disabled"}` }] };
       }
 
-      case "assign_skill_to_agent": {
-        const agent = AgentDB.findById(args.agent_id);
-        if (!agent) {
-          return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
-        }
+      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 skills = agent.skills || [];
-        if (skills.includes(args.skill_id)) {
-          return { content: [{ type: "text", text: `Skill "${skill.name}" is already assigned to "${agent.name}"` }] };
-        }
-        AgentDB.update(args.agent_id, { skills: [...skills, args.skill_id] });
-        return { content: [{ type: "text", text: `Assigned skill "${skill.name}" to agent "${agent.name}". Restart the agent for changes to take effect.` }] };
-      }
-
-      case "unassign_skill_from_agent": {
-        const agent = AgentDB.findById(args.agent_id);
-        if (!agent) {
-          return { content: [{ type: "text", text: `Agent not found: ${args.agent_id}` }], isError: true };
-        }
-        const skills = agent.skills || [];
-        if (!skills.includes(args.skill_id)) {
-          return { content: [{ type: "text", text: `Skill is not assigned to this agent` }] };
-        }
-        AgentDB.update(args.agent_id, { skills: skills.filter((id: string) => id !== args.skill_id) });
-        return { content: [{ type: "text", text: `Removed skill from agent "${agent.name}". Restart the agent for changes to take effect.` }] };
+        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": {
@@ -1138,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;
@@ -1218,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);
@@ -1313,6 +1769,272 @@ async function executeTool(name: string, args: Record<string, any>): Promise<{ c
         return { content: [{ type: "text", text: `Subscription "${sub.trigger_slug}" deleted` }] };
       }
 
+      // Integration management tools
+      case "list_integration_providers": {
+
+        const providerIds = getProviderIds();
+        const projectId = args.project_id || null;
+        const result = providerIds.map(id => {
+          const provider = getProvider(id);
+          const hasKey = !!ProviderKeys.getDecryptedForProject(id, projectId);
+          return { id, name: provider?.name || id, hasKey };
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+
+      case "list_integration_apps": {
+
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const provider = getProvider(providerId);
+        if (!provider) {
+          return { content: [{ type: "text", text: `Unknown integration provider: ${providerId}. Available: ${getProviderIds().join(", ")}` }], isError: true };
+        }
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${provider.name} API key not configured` }], isError: true };
+        }
+        let apps = await provider.listApps(apiKey);
+        if (args.search) {
+          const s = args.search.toLowerCase();
+          apps = apps.filter(a =>
+            a.name.toLowerCase().includes(s) ||
+            a.slug.toLowerCase().includes(s) ||
+            a.description?.toLowerCase().includes(s)
+          );
+        }
+        // Also check which are connected
+        let connectedIds = new Set<string>();
+        try {
+          const accounts = await provider.listConnectedAccounts(apiKey, "platform-agent");
+          connectedIds = new Set(accounts.filter(a => a.status === "active").map(a => a.appId));
+        } catch {}
+        const result = apps.slice(0, 50).map(a => ({
+          slug: a.slug,
+          name: a.name,
+          description: a.description,
+          authSchemes: a.authSchemes,
+          categories: a.categories,
+          connected: connectedIds.has(a.slug) || (a.providerSlug ? connectedIds.has(a.providerSlug) : false),
+          credentialFields: a.credentialFields || undefined,
+        }));
+        return { content: [{ type: "text", text: `Found ${apps.length} apps (showing ${result.length}):\n${JSON.stringify(result, null, 2)}` }] };
+      }
+
+      case "connect_integration_app": {
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const provider = getProvider(providerId);
+        if (!provider) {
+          return { content: [{ type: "text", text: `Unknown integration provider: ${providerId}` }], isError: true };
+        }
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${provider.name} API key not configured` }], isError: true };
+        }
+        if (!args.api_key && !args.credentials) {
+          return { content: [{ type: "text", text: `Either api_key or credentials is required` }], isError: true };
+        }
+        // Build credential object — prefer multi-field credentials over single api_key
+        const creds: any = { authScheme: "API_KEY" as const };
+        if (args.credentials && Object.keys(args.credentials).length > 0) {
+          creds.fields = args.credentials;
+        } else {
+          creds.apiKey = args.api_key;
+        }
+        const connectionResult = await provider.initiateConnection(apiKey, "platform-agent", args.app_slug, "", creds);
+        if (connectionResult.status === "active") {
+          return { content: [{ type: "text", text: `Successfully connected "${args.app_slug}". Connection ID: ${connectionResult.connectionId || "N/A"}` }] };
+        }
+        return { content: [{ type: "text", text: `Connection initiated but status is ${connectionResult.status}. This may require OAuth — direct the user to the Browse Toolkits UI.` }] };
+      }
+
+      case "list_integration_connections": {
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const provider = getProvider(providerId);
+        if (!provider) {
+          return { content: [{ type: "text", text: `Unknown integration provider: ${providerId}` }], isError: true };
+        }
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${provider.name} API key not configured` }], isError: true };
+        }
+        const accounts = await provider.listConnectedAccounts(apiKey, "platform-agent");
+        const result = accounts.map(a => ({
+          id: a.id,
+          appName: a.appName,
+          appId: a.appId,
+          status: a.status,
+          createdAt: a.createdAt,
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+
+      case "disconnect_integration_app": {
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const provider = getProvider(providerId);
+        if (!provider) {
+          return { content: [{ type: "text", text: `Unknown integration provider: ${providerId}` }], isError: true };
+        }
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${provider.name} API key not configured` }], isError: true };
+        }
+        const success = await provider.disconnect(apiKey, args.connection_id);
+        return { content: [{ type: "text", text: success ? `Disconnected successfully` : `Failed to disconnect` }], isError: !success };
+      }
+
+      case "list_integration_configs": {
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${providerId} API key not configured` }], isError: true };
+        }
+
+        if (providerId === "agentdojo") {
+          const servers = await listAgentDojoServers(apiKey, true);
+          const result = servers.map(s => ({
+            id: s.id,
+            name: s.name,
+            slug: s.slug,
+            url: s.url,
+            toolsCount: s.tools?.length || 0,
+          }));
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } else if (providerId === "composio") {
+          const servers = await listComposioServers(apiKey);
+          const result = servers.map(s => ({
+            id: s.id,
+            name: s.name,
+            url: s.mcpUrl,
+            toolkits: s.toolkits,
+          }));
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        return { content: [{ type: "text", text: `Config listing not supported for provider: ${providerId}` }], isError: true };
+      }
+
+      case "create_integration_config": {
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${providerId} API key not configured` }], isError: true };
+        }
+
+        if (providerId === "agentdojo") {
+          const server = await createAgentDojoServer(apiKey, args.name, [args.toolkit_slug]);
+          if (!server) {
+            return { content: [{ type: "text", text: "Failed to create MCP config on AgentDojo" }], isError: true };
+          }
+          return { content: [{ type: "text", text: `MCP config created on AgentDojo:\n${JSON.stringify({ id: server.id, name: server.name, slug: server.slug, url: server.url }, null, 2)}\n\nUse add_integration_config_locally to add it as a local MCP server.` }] };
+        } else if (providerId === "composio") {
+          // For Composio, we need the authConfigId for the toolkit
+          const authConfigId = await getComposioAuthConfig(apiKey, args.toolkit_slug);
+          if (!authConfigId) {
+            return { content: [{ type: "text", text: `No auth config found for toolkit "${args.toolkit_slug}". Make sure the app is connected first.` }], isError: true };
+          }
+          const server = await createComposioServer(apiKey, args.name, [authConfigId]);
+          if (!server) {
+            return { content: [{ type: "text", text: "Failed to create MCP config on Composio" }], isError: true };
+          }
+          // Create server instance for the user
+          const userId = await getComposioUserForAuth(apiKey, authConfigId);
+          if (userId) {
+            await createComposioInstance(apiKey, server.id, userId);
+          }
+          return { content: [{ type: "text", text: `MCP config created on Composio:\n${JSON.stringify({ id: server.id, name: server.name, url: server.mcpUrl }, null, 2)}\n\nUse add_integration_config_locally to add it as a local MCP server.` }] };
+        }
+        return { content: [{ type: "text", text: `Config creation not supported for provider: ${providerId}` }], isError: true };
+      }
+
+      case "add_integration_config_locally": {
+        const providerId = args.provider;
+        const projectId = args.project_id || null;
+        const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
+        if (!apiKey) {
+          return { content: [{ type: "text", text: `${providerId} API key not configured` }], isError: true };
+        }
+
+        const effectiveProjectId = projectId && projectId !== "unassigned" ? projectId : null;
+
+        if (providerId === "agentdojo") {
+          const server = await getAgentDojoServer(apiKey, args.config_id);
+          if (!server) {
+            return { content: [{ type: "text", text: `Config not found on AgentDojo: ${args.config_id}` }], isError: true };
+          }
+          // Check if already exists locally
+          const existing = McpServerDB.findAllLight().find(
+            s => s.source === "agentdojo" && s.project_id === effectiveProjectId && s.url?.endsWith(`/${server.slug}`)
+          );
+          if (existing) {
+            return { content: [{ type: "text", text: `Server "${server.name}" already exists locally (ID: ${existing.id})` }] };
+          }
+          const localServer = McpServerDB.create({
+            id: generateId(),
+            name: server.name,
+            type: "http",
+            package: null,
+            command: null,
+            args: null,
+            pip_module: null,
+            env: {},
+            url: server.url,
+            headers: { "X-API-Key": apiKey },
+            source: "agentdojo",
+            project_id: effectiveProjectId,
+          });
+          return { content: [{ type: "text", text: `Server "${server.name}" added locally (ID: ${localServer.id}). Use assign_mcp_server_to_agent to give agents access.` }] };
+        } else if (providerId === "composio") {
+          // Fetch config details from Composio
+          const res = await fetch(`https://backend.composio.dev/api/v3/mcp/${args.config_id}`, {
+            headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
+          });
+          if (!res.ok) {
+            return { content: [{ type: "text", text: `Config not found on Composio: ${args.config_id}` }], isError: true };
+          }
+          const data = await res.json();
+          const configName = data.name || `composio-${args.config_id.slice(0, 8)}`;
+          const mcpUrl = data.mcp_url;
+          if (!mcpUrl) {
+            return { content: [{ type: "text", text: "Config does not have an MCP URL" }], isError: true };
+          }
+          // Check if already exists locally
+          const existing = McpServerDB.findAllLight().find(
+            s => s.source === "composio" && s.url?.includes(args.config_id)
+          );
+          if (existing) {
+            return { content: [{ type: "text", text: `Server "${configName}" already exists locally (ID: ${existing.id})` }] };
+          }
+          // Get user_id for URL auth
+          const authConfigIds = data.auth_config_ids || [];
+          let userId: string | null = null;
+          if (authConfigIds.length > 0) {
+            userId = await getComposioUserForAuth(apiKey, authConfigIds[0]);
+          }
+          const mcpUrlWithUser = userId ? `${mcpUrl}?user_id=${encodeURIComponent(userId)}` : mcpUrl;
+          const localServer = McpServerDB.create({
+            id: generateId(),
+            name: configName,
+            type: "http",
+            package: null,
+            command: null,
+            args: null,
+            pip_module: null,
+            env: {},
+            url: mcpUrlWithUser,
+            headers: { "x-api-key": apiKey },
+            source: "composio",
+            project_id: effectiveProjectId,
+          });
+          return { content: [{ type: "text", text: `Server "${configName}" added locally (ID: ${localServer.id}). Use assign_mcp_server_to_agent to give agents access.` }] };
+        }
+        return { content: [{ type: "text", text: `Local add not supported for provider: ${providerId}` }], isError: true };
+      }
+
       default:
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
     }
@@ -1363,16 +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.
+- 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.
-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.`,
       };
@@ -1386,7 +2114,7 @@ Always use list_providers first to check which providers have API keys before cr
     }
 
     case "tools/list": {
-      result = { tools: PLATFORM_TOOLS };
+      result = { tools: getPlatformTools() };
       break;
     }