@agenticmail/enterprise 0.5.248 → 0.5.249

package/dist/runtime-M2GFJRL3.js

@@ -0,0 +1,45 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-RNREJCPG.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-UF3ZJMJO.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  PROVIDER_REGISTRY,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider,
+  runAgentLoop,
+  toolsToDefinitions
+};

package/dist/server-DT5K3D55.js

@@ -0,0 +1,15 @@
+import {
+  createServer
+} from "./chunk-XWVKQO6P.js";
+import "./chunk-OF4MUWWS.js";
+import "./chunk-UF3ZJMJO.js";
+import "./chunk-3OC6RH7W.js";
+import "./chunk-2DDKGTD6.js";
+import "./chunk-YVK6F5OD.js";
+import "./chunk-MKRNEM5A.js";
+import "./chunk-DRXMYYKN.js";
+import "./chunk-6WSX7QXF.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/setup-6EUJP3OZ.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-PNBWEEJZ.js";
+import "./chunk-ULRBF2T7.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/enterprise",
-  "version": "0.5.248",
+  "version": "0.5.249",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

package/src/agent-tools/index.ts

@@ -401,6 +401,25 @@ export async function createAllTools(options?: AllToolsOptions): Promise<AnyAgen
     }
   }
 
+  // ─── External MCP Server Tools ───
+  // Tools from MCP servers registered via Dashboard → Integrations & MCP
+  var mcpServerTools: AnyAgentTool[] = [];
+  if ((options as any)?.mcpProcessManager) {
+    try {
+      var { createMcpServerTools } = await import('./tools/mcp-server-tools.js');
+      mcpServerTools = createMcpServerTools({
+        mcpManager: (options as any).mcpProcessManager,
+        agentId: options?.agentId,
+        permissionEngine: (options as any)?.permissionEngine,
+      });
+      if (mcpServerTools.length > 0) {
+        console.log(`[tools] Loaded ${mcpServerTools.length} MCP server tools for agent ${options?.agentId || 'all'}`);
+      }
+    } catch (e: any) {
+      console.warn(`[tools] MCP server tools load failed: ${e.message}`);
+    }
+  }
+
   // ─── Messaging Tools (WhatsApp, Telegram) ───
   var messagingTools: AnyAgentTool[] = [];
   try {
@@ -461,6 +480,7 @@ export async function createAllTools(options?: AllToolsOptions): Promise<AnyAgen
     .concat(workspaceTools)
     .concat(enterpriseBrowserTools)
     .concat(integrationTools)
+    .concat(mcpServerTools)
     .concat(messagingTools)
     .concat(managementTools);
 

package/src/agent-tools/tools/mcp-server-tools.ts

@@ -0,0 +1,91 @@
+/**
+ * MCP Server Tools Bridge
+ *
+ * Converts tools from external MCP servers (registered via Dashboard → Integrations & MCP)
+ * into native AnyAgentTool[] that the agent loop can use directly.
+ *
+ * This bridges the McpProcessManager (which manages MCP server lifecycles)
+ * to the agent's tool system. Each discovered MCP tool becomes a callable agent tool.
+ *
+ * Flow:
+ *   McpProcessManager.getToolsForAgent(agentId)
+ *   → McpDiscoveredTool[] (name, description, inputSchema, serverId)
+ *   → createMcpServerTools() wraps each in AnyAgentTool with execute()
+ *   → execute() calls McpProcessManager.callTool(name, args)
+ *   → proxied to MCP server via stdio/HTTP → result returned to agent
+ */
+
+import type { AnyAgentTool } from '../types.js';
+import { jsonResult, errorResult } from '../common.js';
+import type { McpProcessManager } from '../../engine/mcp-process-manager.js';
+
+export interface McpServerToolsConfig {
+  mcpManager: McpProcessManager;
+  agentId?: string;
+  /** Optional permission engine for dynamic tool registration */
+  permissionEngine?: any;
+}
+
+/**
+ * Create agent tools from all connected MCP servers for a given agent.
+ * Returns empty array if no MCP servers are connected or none assigned to this agent.
+ */
+export function createMcpServerTools(config: McpServerToolsConfig): AnyAgentTool[] {
+  const { mcpManager, agentId } = config;
+  const discoveredTools = mcpManager.getToolsForAgent(agentId);
+
+  if (discoveredTools.length === 0) return [];
+
+  console.log(`[mcp-server-tools] Creating ${discoveredTools.length} tools from MCP servers for agent ${agentId || 'all'}`);
+
+  // Register with permission engine
+  if (config.permissionEngine && discoveredTools.length > 0) {
+    try {
+      const toolDefs = discoveredTools.map(t => ({
+        id: `mcp_${t.name}`,
+        name: `mcp_${t.name}`,
+        description: t.description || t.name,
+        category: 'utility' as any,
+        risk: 'medium' as any,
+        skillId: 'mcp-servers',
+        sideEffects: ['external_api'] as any[],
+      }));
+      config.permissionEngine.registerDynamicTools('mcp-servers', toolDefs);
+    } catch (e: any) {
+      console.warn(`[mcp-server-tools] Permission engine registration failed: ${e.message}`);
+    }
+  }
+
+  return discoveredTools.map(tool => {
+    // Prefix tool names with mcp_ to avoid collisions with built-in tools
+    const toolName = `mcp_${tool.name}`;
+
+    return {
+      name: toolName,
+      description: `[${tool.serverName}] ${tool.description || tool.name}`,
+      category: 'utility' as const,
+      parameters: {
+        type: 'object' as const,
+        properties: tool.inputSchema?.properties || {},
+        required: tool.inputSchema?.required || [],
+      },
+      async execute(_callId: string, params: any) {
+        try {
+          const result = await mcpManager.callTool(tool.name, params, agentId);
+          if (result.isError) {
+            return errorResult(result.content);
+          }
+          // Try to parse JSON for structured output
+          try {
+            const parsed = JSON.parse(result.content);
+            return jsonResult(parsed);
+          } catch {
+            return { content: [{ type: 'text' as const, text: result.content }] };
+          }
+        } catch (e: any) {
+          return errorResult(`MCP tool ${tool.name} error: ${e.message}`);
+        }
+      },
+    };
+  });
+}

package/src/cli-agent.ts

@@ -567,6 +567,25 @@ export async function runAgent(_args: string[]) {
     resumeOnStartup: false, // Disabled: zombie sessions exhaust Supabase pool on restart
   });
 
+  // ─── MCP Process Manager ───────────────────────────
+  // Manages external MCP servers registered via Dashboard → Integrations & MCP
+  try {
+    const { McpProcessManager } = await import('./engine/mcp-process-manager.js');
+    const mcpManager = new McpProcessManager({ engineDb, orgId: 'default' });
+    await mcpManager.start();
+    (runtime as any).config.mcpProcessManager = mcpManager;
+    console.log(`[agent] MCP Process Manager started`);
+
+    // Graceful shutdown
+    const origStop = runtime.stop?.bind(runtime);
+    (runtime as any).stop = async () => {
+      await mcpManager.stop();
+      if (origStop) await origStop();
+    };
+  } catch (e: any) {
+    console.warn(`[agent] MCP Process Manager init failed (non-fatal): ${e.message}`);
+  }
+
   await runtime.start();
   const runtimeApp = runtime.getApp();
 

package/src/dashboard/pages/skill-connections.js

@@ -1,4 +1,4 @@
-import { h, useState, useEffect, useCallback, Fragment, useApp, engineCall } from '../components/utils.js';
+import { h, useState, useEffect, useCallback, Fragment, useApp, engineCall, adminCall } from '../components/utils.js';
 import { I } from '../components/icons.js';
 import { Modal } from '../components/modal.js';
 import { HelpButton } from '../components/help-button.js';
@@ -44,9 +44,10 @@ function McpServersSection() {
   var _showAdd = useState(false); var showAdd = _showAdd[0]; var setShowAdd = _showAdd[1];
   var _editServer = useState(null); var editServer = _editServer[0]; var setEditServer = _editServer[1];
   var _testing = useState(null); var testing = _testing[0]; var setTesting = _testing[1];
+  var _agents = useState([]); var agents = _agents[0]; var setAgents = _agents[1];
 
   // Add/edit form
-  var _form = useState({ name: '', type: 'stdio', command: '', args: '', url: '', apiKey: '', headers: '{}', env: '{}', enabled: true, description: '', autoRestart: true, timeout: 30 });
+  var _form = useState({ name: '', type: 'stdio', command: '', args: '', url: '', apiKey: '', headers: '{}', env: '{}', enabled: true, description: '', autoRestart: true, timeout: 30, assignedAgents: [] });
   var form = _form[0]; var setForm = _form[1];
 
   var load = useCallback(function() {
@@ -58,9 +59,12 @@ function McpServersSection() {
   }, []);
 
   useEffect(function() { load(); }, [load]);
+  useEffect(function() {
+    adminCall('/agents').then(function(d) { setAgents((d.agents || d || []).filter(function(a) { return a.status !== 'archived'; })); }).catch(function() {});
+  }, []);
 
   var resetForm = function() {
-    setForm({ name: '', type: 'stdio', command: '', args: '', url: '', apiKey: '', headers: '{}', env: '{}', enabled: true, description: '', autoRestart: true, timeout: 30 });
+    setForm({ name: '', type: 'stdio', command: '', args: '', url: '', apiKey: '', headers: '{}', env: '{}', enabled: true, description: '', autoRestart: true, timeout: 30, assignedAgents: [] });
   };
 
   var openAdd = function() { resetForm(); setEditServer(null); setShowAdd(true); };
@@ -79,6 +83,7 @@ function McpServersSection() {
       description: server.description || '',
       autoRestart: server.autoRestart !== false,
       timeout: server.timeout || 30,
+      assignedAgents: server.assignedAgents || [],
     });
     setEditServer(server);
     setShowAdd(true);
@@ -92,6 +97,7 @@ function McpServersSection() {
       description: form.description.trim(),
       autoRestart: form.autoRestart,
       timeout: parseInt(form.timeout) || 30,
+      assignedAgents: form.assignedAgents || [],
     };
     if (form.type === 'stdio') {
       payload.command = form.command.trim();
@@ -210,7 +216,13 @@ function McpServersSection() {
                     ? (server.command + ' ' + (server.args || []).join(' ')).trim()
                     : server.url || ''
                 ),
-                server.description && h('div', { style: { fontSize: 11, color: 'var(--text-secondary)', marginTop: 2 } }, server.description)
+                server.description && h('div', { style: { fontSize: 11, color: 'var(--text-secondary)', marginTop: 2 } }, server.description),
+                server.assignedAgents && server.assignedAgents.length > 0 && h('div', { style: { fontSize: 10, color: 'var(--text-muted)', marginTop: 3 } },
+                  'Agents: ' + server.assignedAgents.map(function(aid) {
+                    var a = agents.find(function(x) { return x.id === aid; });
+                    return a ? (a.display_name || a.name) : aid.slice(0, 8);
+                  }).join(', ')
+                )
               ),
               h('div', { style: { display: 'flex', gap: 4, flexShrink: 0 } },
                 h('button', { className: 'btn btn-ghost btn-sm', title: 'Test connection', disabled: isTesting, onClick: function() { testServer(server); } },
@@ -400,6 +412,38 @@ function McpServersSection() {
                 h('p', { style: { marginTop: 8 } }, 'Keep this on unless you have a reason to disable it.')
               )
             )
+          ),
+          // Agent assignment
+          agents.length > 0 && h('div', { className: 'form-group', style: { marginTop: 16 } },
+            h('label', { className: 'form-label', style: { display: 'flex', alignItems: 'center' } }, 'Agent Access', h(HelpButton, { label: 'Agent Access' },
+              h('p', null, 'Choose which agents can use this MCP server\'s tools. If none are selected, ALL agents can use it.'),
+              h('p', { style: { marginTop: 8 } }, 'Use this to restrict sensitive tools (like database access) to specific agents only.')
+            )),
+            h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: 6 } },
+              agents.map(function(a) {
+                var isSelected = (form.assignedAgents || []).includes(a.id);
+                return h('button', {
+                  key: a.id,
+                  type: 'button',
+                  style: {
+                    padding: '4px 10px', borderRadius: 6, fontSize: 12, cursor: 'pointer',
+                    border: '1px solid ' + (isSelected ? 'var(--primary)' : 'var(--border)'),
+                    background: isSelected ? 'var(--primary)' : 'var(--bg-secondary)',
+                    color: isSelected ? '#fff' : 'var(--text-primary)',
+                  },
+                  onClick: function() {
+                    var current = form.assignedAgents || [];
+                    var next = isSelected ? current.filter(function(x) { return x !== a.id; }) : current.concat(a.id);
+                    setForm(Object.assign({}, form, { assignedAgents: next }));
+                  }
+                }, a.display_name || a.name);
+              })
+            ),
+            h('div', { style: { fontSize: 11, color: 'var(--text-muted)', marginTop: 4 } },
+              form.assignedAgents && form.assignedAgents.length > 0
+                ? form.assignedAgents.length + ' agent(s) selected — only they can use this server'
+                : 'No agents selected — all agents can use this server'
+            )
           )
         ),
         // Preset templates