apteva 0.4.32 → 0.4.41

package/src/providers.ts

@@ -12,7 +12,8 @@ export const PROVIDERS = {
     docsUrl: "https://console.anthropic.com/settings/keys",
     testEndpoint: "https://api.anthropic.com/v1/messages",
     models: [
-      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5", recommended: true },
+      { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", recommended: true },
+      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5" },
       { value: "claude-haiku-4-5", label: "Claude Haiku 4.5 (Fast)" },
     ],
   },
@@ -152,22 +153,21 @@ export const PROVIDERS = {
   browserengine: {
     id: "browserengine",
     name: "BrowserEngine",
-    displayName: "BrowserEngine (Self-hosted)",
+    displayName: "BrowserEngine",
     type: "browser" as const,
-    envVar: "BROWSER_ENGINE_URL",
-    docsUrl: "",
-    description: "Your own virtual browser service",
-    isLocal: true,
+    envVar: "BROWSERENGINE_API_KEY",
+    docsUrl: "https://browserengine.co",
+    description: "Cloud browser automation with stealth browsing and proxies",
     models: [],
   },
-  chrome: {
-    id: "chrome",
-    name: "Chrome",
-    displayName: "Chrome DevTools",
+  cdp: {
+    id: "cdp",
+    name: "CDP",
+    displayName: "Direct CDP",
     type: "browser" as const,
-    envVar: "CHROME_DEBUG_URL",
+    envVar: "CDP_URL",
     docsUrl: "",
-    description: "Direct CDP connection to Chrome",
+    description: "Connect directly to any browser via Chrome DevTools Protocol",
     isLocal: true,
     models: [],
   },

package/src/routes/api/agent-utils.ts

@@ -3,7 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { mkdirSync, existsSync, rmSync } from "fs";
 import { agentProcesses, agentsStarting, getBinaryPathForAgent, getBinaryStatus, BIN_DIR, telemetryBroadcaster, isShuttingDown, type TelemetryEvent } from "../../server";
-import { AgentDB, McpServerDB, SkillDB, TelemetryDB, generateId, getMultiAgentConfig, getOperatorConfig, type Agent, type Project } from "../../db";
+import { AgentDB, McpServerDB, SkillDB, SubscriptionDB, TelemetryDB, generateId, getMultiAgentConfig, getOperatorConfig, type Agent, type Project } from "../../db";
 import { ProviderKeys, PROVIDERS, type ProviderId } from "../../providers";
 import { binaryExists } from "../../binary";
 
@@ -93,32 +93,29 @@ function buildOperatorConfig(features: Agent["features"], projectId: string | nu
   if (!opConfig.enabled) {
     return {
       enabled: false,
-      virtual_browser: "http://localhost:8098",
       display_width: 1024,
       display_height: 768,
       max_actions_per_turn: 5,
     };
   }
 
-  const browserProvider = opConfig.browser_provider || "";
+  const browserProvider = opConfig.browser_provider || "browserengine";
   const displayWidth = opConfig.display_width || 1024;
   const displayHeight = opConfig.display_height || 768;
   const maxActions = opConfig.max_actions_per_turn || 5;
 
-  // Map browser provider IDs to agent binary config
   const operatorResult: Record<string, unknown> = {
     enabled: true,
+    browser_provider: browserProvider,
     display_width: displayWidth,
     display_height: displayHeight,
     max_actions_per_turn: maxActions,
   };
 
+  // Only include the active provider's config
   if (browserProvider === "browserbase") {
     const raw = ProviderKeys.getDecryptedForProject("browserbase", projectId);
-    operatorResult.browser_provider = "browserbase";
-    operatorResult.virtual_browser = "http://localhost:8098"; // fallback
     if (raw) {
-      // Parse JSON object {api_key, project_id} or plain string (backwards compat)
       try {
         const parsed = JSON.parse(raw);
         operatorResult.browserbase = { api_key: parsed.api_key || raw, project_id: parsed.project_id || "" };
@@ -128,26 +125,21 @@ function buildOperatorConfig(features: Agent["features"], projectId: string | nu
     }
   } else if (browserProvider === "steel") {
     const apiKey = ProviderKeys.getDecryptedForProject("steel", projectId);
-    operatorResult.browser_provider = "steel";
-    operatorResult.virtual_browser = "http://localhost:8098"; // fallback
     if (apiKey) {
       operatorResult.steel = { api_key: apiKey, base_url: "https://api.steel.dev" };
     }
-  } else if (browserProvider === "chrome") {
-    const debugUrl = ProviderKeys.getDecryptedForProject("chrome", projectId);
-    operatorResult.browser_provider = "chrome";
-    operatorResult.virtual_browser = "http://localhost:8098"; // fallback
-    if (debugUrl) {
-      operatorResult.chrome = { debug_url: debugUrl };
+  } else if (browserProvider === "cdp") {
+    // CDP uses a URL, not an API key — stored as the provider key value
+    const cdpUrl = ProviderKeys.getDecryptedForProject("cdp", projectId);
+    if (cdpUrl) {
+      operatorResult.cdp = { url: cdpUrl };
     }
-  } else if (browserProvider === "browserengine") {
-    const url = ProviderKeys.getDecryptedForProject("browserengine", projectId);
-    operatorResult.browser_provider = "self";
-    operatorResult.virtual_browser = url || "http://localhost:8098";
   } else {
-    // Default: auto-select first configured browser provider, or fall back to self
-    operatorResult.browser_provider = "self";
-    operatorResult.virtual_browser = ProviderKeys.getDecryptedForProject("browserengine", projectId) || "http://localhost:8098";
+    // Default: browserengine
+    const apiKey = ProviderKeys.getDecryptedForProject("browserengine", projectId);
+    if (apiKey) {
+      operatorResult.browserengine = { api_key: apiKey, base_url: "https://api.browserengine.co" };
+    }
   }
 
   return operatorResult;
@@ -173,8 +165,12 @@ export function buildAgentConfig(agent: Agent, providerKey: string) {
     enabled: boolean;
   }> = [];
 
+  // Batch load skills and MCP servers (2 queries instead of N+M)
+  const skillMap = SkillDB.findByIds(agent.skills || []);
+  const mcpMap = McpServerDB.findByIds(agent.mcp_servers || []);
+
   for (const skillId of agent.skills || []) {
-    const skill = SkillDB.findById(skillId);
+    const skill = skillMap.get(skillId);
     if (!skill || !skill.enabled) continue;
 
     skillDefinitions.push({
@@ -190,7 +186,7 @@ export function buildAgentConfig(agent: Agent, providerKey: string) {
   }
 
   for (const id of agent.mcp_servers || []) {
-    const server = McpServerDB.findById(id);
+    const server = mcpMap.get(id);
     if (!server) continue;
 
     if (server.type === "local" && server.status === "running") {
@@ -387,9 +383,8 @@ export async function pushSkillsToAgent(agentId: string, port: number, skills: A
   }
 
   try {
-    // Push each skill - try PUT first (update), then POST (create) if not found
-    for (const skill of skills) {
-      // First try PUT to update existing skill
+    // Push all skills in parallel - try PUT first (update), then POST (create) if not found
+    await Promise.allSettled(skills.map(async (skill) => {
       let res = await agentFetch(agentId, port, "/skills", {
         method: "PUT",
         headers: { "Content-Type": "application/json" },
@@ -397,7 +392,6 @@ export async function pushSkillsToAgent(agentId: string, port: number, skills: A
         signal: AbortSignal.timeout(5000),
       });
 
-      // If skill doesn't exist (404), create it with POST
       if (res.status === 404) {
         res = await agentFetch(agentId, port, "/skills", {
           method: "POST",
@@ -411,7 +405,7 @@ export async function pushSkillsToAgent(agentId: string, port: number, skills: A
         const data = await res.json().catch(() => ({}));
         console.error(`[pushSkillsToAgent] Failed to push skill ${skill.name}:`, data.error || res.status);
       }
-    }
+    }));
 
     // Enable skills globally via POST /skills/status
     const statusRes = await agentFetch(agentId, port, "/skills/status", {
@@ -611,6 +605,8 @@ export async function startAgentProcess(
       console.log(`  Pushing configuration...`);
     }
     const config = buildAgentConfig(agent, providerKey);
+    console.log(`[DEBUG] operator config being pushed:`, JSON.stringify(config.operator, null, 2));
+    console.log(`[DEBUG] builtin_tools:`, JSON.stringify(config.operator?.builtin_tools));
     const configResult = await pushConfigToAgent(agent.id, port, config);
     if (!configResult.success) {
       if (!silent) {
@@ -650,24 +646,27 @@ export async function startAgentProcess(
 }
 
 // Transform DB agent to API response format (camelCase for frontend compatibility)
+// Uses batch queries + light MCP loading (no decryption) for performance
 export function toApiAgent(agent: Agent) {
-  // Look up MCP server details
+  // Batch load MCP servers (light = no decryption) and skills in 2 queries
+  const mcpMap = McpServerDB.findByIdsLight(agent.mcp_servers || []);
+  const skillMap = SkillDB.findByIds(agent.skills || []);
+
   const mcpServerDetails = (agent.mcp_servers || [])
-    .map(id => McpServerDB.findById(id))
-    .filter((s): s is NonNullable<typeof s> => s !== null)
+    .map(id => mcpMap.get(id))
+    .filter((s): s is NonNullable<typeof s> => !!s)
     .map(s => ({
       id: s.id,
       name: s.name,
       type: s.type,
       status: s.status,
       port: s.port,
-      url: s.url, // Include URL for HTTP servers
+      url: s.url,
     }));
 
-  // Look up skill details
   const skillDetails = (agent.skills || [])
-    .map(id => SkillDB.findById(id))
-    .filter((s): s is NonNullable<typeof s> => s !== null)
+    .map(id => skillMap.get(id))
+    .filter((s): s is NonNullable<typeof s> => !!s)
     .map(s => ({
       id: s.id,
       name: s.name,
@@ -676,6 +675,11 @@ export function toApiAgent(agent: Agent) {
       enabled: s.enabled,
     }));
 
+  // Look up subscriptions
+  const subscriptions = SubscriptionDB.findByAgentId(agent.id).map(s => ({
+    id: s.id, trigger_slug: s.trigger_slug, enabled: s.enabled,
+  }));
+
   return {
     id: agent.id,
     name: agent.name,
@@ -685,29 +689,33 @@ export function toApiAgent(agent: Agent) {
     status: agent.status,
     port: agent.port,
     features: agent.features,
-    mcpServers: agent.mcp_servers, // Keep IDs for backwards compatibility
-    mcpServerDetails, // Include full details
-    skills: agent.skills, // Skill IDs
-    skillDetails, // Include full details
+    mcpServers: agent.mcp_servers,
+    mcpServerDetails,
+    skills: agent.skills,
+    skillDetails,
+    subscriptions,
     projectId: agent.project_id,
     createdAt: agent.created_at,
     updatedAt: agent.updated_at,
   };
 }
 
-// Batch transform: fetch all MCP servers + skills in 2 queries instead of N per agent
+// Batch transform: fetch all MCP servers + skills + subscriptions in 3 queries instead of N per agent
 export function toApiAgentsBatch(agents: Agent[]) {
   // Collect all unique IDs
   const allMcpIds = new Set<string>();
   const allSkillIds = new Set<string>();
+  const allAgentIds: string[] = [];
   for (const agent of agents) {
+    allAgentIds.push(agent.id);
     for (const id of agent.mcp_servers || []) allMcpIds.add(id);
     for (const id of agent.skills || []) allSkillIds.add(id);
   }
 
-  // Batch load in 2 queries
-  const mcpMap = McpServerDB.findByIds([...allMcpIds]);
+  // Batch load in 3 queries (Light = no decryption for MCP servers)
+  const mcpMap = McpServerDB.findByIdsLight([...allMcpIds]);
   const skillMap = SkillDB.findByIds([...allSkillIds]);
+  const subsMap = SubscriptionDB.findByAgentIds(allAgentIds);
 
   return agents.map(agent => {
     const mcpServerDetails = (agent.mcp_servers || [])
@@ -720,11 +728,15 @@ export function toApiAgentsBatch(agents: Agent[]) {
       .filter((s): s is NonNullable<typeof s> => !!s)
       .map(s => ({ id: s.id, name: s.name, description: s.description, version: s.version, enabled: s.enabled }));
 
+    const subscriptions = (subsMap.get(agent.id) || []).map(s => ({
+      id: s.id, trigger_slug: s.trigger_slug, enabled: s.enabled,
+    }));
+
     return {
       id: agent.id, name: agent.name, model: agent.model, provider: agent.provider,
       systemPrompt: agent.system_prompt, status: agent.status, port: agent.port,
       features: agent.features, mcpServers: agent.mcp_servers, mcpServerDetails,
-      skills: agent.skills, skillDetails, projectId: agent.project_id,
+      skills: agent.skills, skillDetails, subscriptions, projectId: agent.project_id,
       createdAt: agent.created_at, updatedAt: agent.updated_at,
     };
   });
@@ -742,11 +754,12 @@ export function toApiProject(project: Project) {
   };
 }
 
-// Helper to fetch from a running agent (with authentication)
-export async function fetchFromAgent(agentId: string, port: number, endpoint: string): Promise<any> {
+// Helper to fetch from a running agent (with authentication + timeout)
+export async function fetchFromAgent(agentId: string, port: number, endpoint: string, timeoutMs = 3000): Promise<any> {
   try {
     const response = await agentFetch(agentId, port, endpoint, {
       headers: { "Accept": "application/json" },
+      signal: AbortSignal.timeout(timeoutMs),
     });
     if (response.ok) {
       return await response.json();

package/src/routes/api/agents.ts

@@ -62,7 +62,7 @@ export async function handleAgentRoutes(
       const agent = AgentDB.create({
         id: generateId(),
         name,
-        model: model || "claude-sonnet-4-5",
+        model: model || "claude-sonnet-4-6",
         provider: provider || "anthropic",
         system_prompt: systemPrompt || "You are a helpful assistant.",
         features: features || DEFAULT_FEATURES,
@@ -358,6 +358,7 @@ export async function handleAgentRoutes(
     try {
       const body = await req.json();
 
+
       // Proxy to the agent's /chat endpoint with authentication
       const response = await agentFetch(agent.id, agent.port, "/chat", {
         method: "POST",
@@ -451,6 +452,56 @@ export async function handleAgentRoutes(
 
   // ==================== THREAD & MESSAGE PROXY ====================
 
+  // GET /api/threads - Consolidated threads from all running agents
+  if (path === "/api/threads" && method === "GET") {
+    const url = new URL(req.url);
+    const projectId = url.searchParams.get("project_id");
+
+    let agents;
+    if (projectId === "unassigned") {
+      agents = AgentDB.findByProject(null);
+    } else if (projectId) {
+      agents = AgentDB.findByProject(projectId);
+    } else {
+      agents = AgentDB.findAll();
+    }
+
+    // Only query running agents (excluding meta agent)
+    const runningAgents = agents.filter(a => a.id !== META_AGENT_ID && a.status === "running" && a.port);
+
+    const results = await Promise.allSettled(
+      runningAgents.map(async (agent) => {
+        const response = await agentFetch(agent.id, agent.port!, "/threads", {
+          method: "GET",
+          headers: { "Accept": "application/json" },
+          signal: AbortSignal.timeout(3000),
+        });
+        if (!response.ok) return [];
+        const data = await response.json() as any;
+        const threads = Array.isArray(data) ? data : (data.threads ?? []);
+        return threads.map((t: any) => ({
+          ...t,
+          agent_id: agent.id,
+          agent_name: agent.name,
+        }));
+      })
+    );
+
+    const allThreads = results
+      .filter((r): r is PromiseFulfilledResult<any[]> => r.status === "fulfilled")
+      .flatMap(r => r.value)
+      .filter((t: any) => !t.parent_id);
+
+    // Sort by most recent first
+    allThreads.sort((a, b) => {
+      const ta = a.updated_at || a.created_at || "";
+      const tb = b.updated_at || b.created_at || "";
+      return tb.localeCompare(ta);
+    });
+
+    return json({ threads: allThreads });
+  }
+
   // GET/POST /api/agents/:id/threads
   const threadsListMatch = path.match(/^\/api\/agents\/([^/]+)\/threads$/);
   if (threadsListMatch && method === "GET") {

package/src/routes/api/integrations.ts

@@ -111,8 +111,11 @@ export async function handleIntegrationRoutes(
 
     try {
       const body = await req.json();
-      const { appSlug, redirectUrl, credentials, project_id } = body;
-      const apiKey = ProviderKeys.getDecryptedForProject(providerId, project_id || null);
+      const { appSlug, redirectUrl, credentials } = body;
+      // Read project_id from query param (frontend sends it there), fall back to body
+      const url = new URL(req.url);
+      const projectId = url.searchParams.get("project_id") || body.project_id || null;
+      const apiKey = ProviderKeys.getDecryptedForProject(providerId, projectId);
       if (!apiKey) {
         return json({ error: `${provider.name} API key not configured` }, 401);
       }
@@ -127,7 +130,8 @@ export async function handleIntegrationRoutes(
       }
 
       // Default redirect URL back to our integrations page
-      const callbackUrl = redirectUrl || `http://localhost:${process.env.PORT || 4280}/mcp?tab=hosted&connected=${appSlug}`;
+      const origin = req.headers.get("origin") || process.env.INSTANCE_URL || `http://localhost:${process.env.PORT || 4280}`;
+      const callbackUrl = redirectUrl || `${origin}/mcp?tab=hosted&connected=${appSlug}`;
 
       const result = await provider.initiateConnection(apiKey, user.id, appSlug, callbackUrl, credentials);
       return json(result);
@@ -329,7 +333,8 @@ export async function handleIntegrationRoutes(
         : mcpUrl;
 
       // Check if already exists (match by config ID in URL)
-      const existing = McpServerDB.findAll().find(
+      // Use Light variant to skip expensive decryption of env/headers
+      const existing = McpServerDB.findAllLight().find(
         s => s.source === "composio" && s.url?.includes(configId)
       );
       if (existing) {
@@ -527,8 +532,9 @@ export async function handleIntegrationRoutes(
       console.log(`[agentdojo:add] fetched server: slug=${server.slug} name=${server.name} url=${server.url?.substring(0, 80)}`);
 
       // Check if already exists — match by slug in URL, scoped to same project
+      // Use Light variant to skip expensive decryption of env/headers
       const effectiveProjectId = projectId && projectId !== "unassigned" ? projectId : null;
-      const allServers = McpServerDB.findAll();
+      const allServers = McpServerDB.findAllLight();
       const agentdojoServers = allServers.filter(s => s.source === "agentdojo");
       console.log(`[agentdojo:add] total servers=${allServers.length} agentdojo servers=${agentdojoServers.length}`);
       const existing = agentdojoServers.find(

package/src/routes/api/mcp.ts

@@ -28,16 +28,17 @@ export async function handleMcpRoutes(
     let queryMode: string;
     if (forAgent !== null) {
       // Get servers available for an agent (global + agent's project)
-      servers = McpServerDB.findForAgent(forAgent || null);
+      // Use Light variant: skips expensive decryption of env/headers
+      servers = McpServerDB.findForAgentLight(forAgent || null);
       queryMode = `forAgent=${forAgent}`;
     } else if (projectFilter === "global") {
-      servers = McpServerDB.findGlobal();
+      servers = McpServerDB.findGlobalLight();
       queryMode = "global";
     } else if (projectFilter && projectFilter !== "all") {
-      servers = McpServerDB.findByProject(projectFilter);
+      servers = McpServerDB.findByProjectLight(projectFilter);
       queryMode = `project=${projectFilter}`;
     } else {
-      servers = McpServerDB.findAll();
+      servers = McpServerDB.findAllLight();
       queryMode = "all";
     }
     const agentdojoCount = servers.filter(s => s.source === "agentdojo").length;

package/src/routes/api/meta-agent.ts

@@ -56,6 +56,9 @@ WHAT YOU CAN DO:
 - **Skills**: List, enable/disable, and assign skills to agents
 - **Providers**: Check which LLM providers have API keys configured
 - **Communication**: Send messages to running agents
+- **Integrations**: Connect third-party apps (GitHub, Slack, etc.) via API key, create MCP servers from them, and add them locally
+- **Tests**: Create and run automated tests for agent workflows
+- **Triggers**: Subscribe agents to external events (webhooks)
 
 WORKFLOW FOR CREATING AGENTS:
 1. Use list_providers to check which providers have API keys
@@ -63,6 +66,14 @@ WORKFLOW FOR CREATING AGENTS:
 3. Optionally assign MCP servers (for tools) and skills (for behavior)
 4. Use start_agent to run it
 
+WORKFLOW FOR ADDING INTEGRATIONS:
+1. Use list_integration_providers to see available providers (agentdojo, composio)
+2. Use list_integration_apps to browse available apps/toolkits
+3. Use connect_integration_app to authenticate with an API key (for OAuth, direct user to Browse Toolkits UI)
+4. Use create_integration_config to create an MCP server from the connected app
+5. Use add_integration_config_locally to add it as a local MCP server
+6. Use assign_mcp_server_to_agent to give an agent access
+
 AGENT FEATURES (enable when creating/updating):
 - **memory**: Persistent memory across conversations (needs OpenAI key for embeddings)
 - **tasks**: Scheduling and task tracking
@@ -70,6 +81,9 @@ AGENT FEATURES (enable when creating/updating):
 - **mcp**: Required if assigning MCP servers — gives the agent tool-use capability
 - **files**: File read/write in agent workspace
 
+CRITICAL — PROJECT CONTEXT:
+Your chat context tells you the current project (name and id). **You MUST pass this project_id to EVERY tool call that accepts a project_id parameter.** API keys, integrations, MCP servers, and agents are scoped per project — calls without project_id will fail to find them. Extract the id from your context and always include it.
+
 ALWAYS use your tools proactively. When a user says "create an agent", don't explain how — just do it. Confirm what you did after.
 Be concise. Use markdown formatting.`,
         features: {
@@ -81,6 +95,10 @@ Be concise. Use markdown formatting.`,
           realtime: false,
           files: false,
           agents: false,
+          builtinTools: {
+            webSearch: providerId === "anthropic",
+            webFetch: providerId === "anthropic",
+          },
         },
         mcp_servers: [],
         skills: [],
@@ -118,8 +136,24 @@ Be concise. Use markdown formatting.`,
       return json({ agent: toApiAgent(metaAgent), message: "Already running" });
     }
 
+    // Ensure builtinTools are enabled for anthropic provider
+    if (metaAgent.provider === "anthropic" && !metaAgent.features?.builtinTools?.webSearch) {
+      const updatedFeatures = {
+        ...metaAgent.features,
+        builtinTools: { webSearch: true, webFetch: true },
+      };
+      AgentDB.update(META_AGENT_ID, { features: updatedFeatures });
+      console.log(`[meta-agent] Enabled builtinTools for anthropic provider`);
+    }
+    // Always re-read to get latest features
+    const freshAgent = AgentDB.findById(META_AGENT_ID);
+    if (!freshAgent) {
+      return json({ error: "Meta agent not found after update" }, 500);
+    }
+    console.log(`[meta-agent] Starting with builtinTools:`, JSON.stringify(freshAgent.features?.builtinTools));
+
     // Start the agent using existing startAgentProcess function
-    const result = await startAgentProcess(metaAgent, { silent: true });
+    const result = await startAgentProcess(freshAgent, { silent: true });
     if (!result.success) {
       return json({ error: result.error || "Failed to start meta agent" }, 500);
     }

package/src/routes/api/projects.ts

@@ -88,9 +88,9 @@ export async function handleProjectRoutes(
       return json({ error: "Project not found" }, 404);
     }
 
-    // Stop any running agents in this project first
+    // Stop any running agents in this project first - in parallel
     const projectAgents = AgentDB.findByProject(projectMatch[1]);
-    for (const agent of projectAgents) {
+    await Promise.allSettled(projectAgents.map(async (agent) => {
       if (agent.status === "running") {
         const entry = agentProcesses.get(agent.id);
         if (entry) {
@@ -102,7 +102,7 @@ export async function handleProjectRoutes(
         }
         setAgentStatus(agent.id, "stopped", "project_deleted");
       }
-    }
+    }));
 
     ProjectDB.delete(projectMatch[1]);
     return json({ success: true });