@agenticmail/enterprise 0.5.319 → 0.5.320

package/src/database-access/agent-tools.ts

@@ -3,34 +3,35 @@
  * 
  * Creates tools that agents can use to query databases they have access to.
  * Each agent only sees connections they've been granted access to.
+ * 
+ * IMPORTANT: execute() must match AgentTool signature: (toolCallId: string, params: any) => Promise<ToolResult>
+ * ToolResult = { content: [{ type: 'text', text: string }] }
  */
 
 import type { DatabaseConnectionManager } from './connection-manager.js';
 import { DATABASE_LABELS } from './types.js';
 
-interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: Record<string, any>;
-  execute: (input: any) => Promise<any>;
-  category?: string;
-  sideEffects?: string[];
+function jsonResult(data: any) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
 }
 
-export function createDatabaseTools(manager: DatabaseConnectionManager, agentId: string): ToolDefinition[] {
-  const accessList = manager.getAgentAccess(agentId);
-  if (accessList.length === 0) return [];
+function errorResult(msg: string) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify({ error: msg }) }] };
+}
 
-  const tools: ToolDefinition[] = [];
+export function createDatabaseTools(manager: DatabaseConnectionManager, agentId: string): any[] {
+  const tools: any[] = [];
 
   // Tool 1: List available databases
   tools.push({
     name: 'db_list_connections',
-    description: 'List database connections this agent has access to.',
+    description: 'List EXTERNAL database connections (Postgres, MySQL, Supabase, etc.) granted to you by your admin. Use this when asked about any named database like "DateGPT", "production", etc.',
     category: 'database',
+    risk: 'low',
     parameters: { type: 'object', properties: {}, required: [] },
-    async execute() {
-      const connections = accessList.map(a => {
+    async execute(_toolCallId: string, _params: any) {
+      const accessList = manager.getAgentAccess(agentId);
+      const connections = accessList.filter(a => a.enabled).map(a => {
         const conn = manager.getConnection(a.connectionId);
         if (!conn) return null;
         return {
@@ -42,58 +43,69 @@ export function createDatabaseTools(manager: DatabaseConnectionManager, agentId:
           host: conn.host,
           status: conn.status,
           permissions: a.permissions,
-          description: conn.description,
+          description: (conn as any).config?.description || conn.description,
         };
       }).filter(Boolean);
-      return { connections };
+
+      if (connections.length === 0) {
+        return jsonResult({ connections: [], message: 'No external database connections granted. Ask your admin to grant access from the Database Access page.' });
+      }
+      return jsonResult({ connections });
     },
   });
 
   // Tool 2: Execute SQL query
   tools.push({
     name: 'db_query',
-    description: 'Execute a SQL query on a connected database. Use db_list_connections first to see available databases.',
+    description: 'Execute a SQL query on an EXTERNAL database connection granted by your admin. Use db_list_connections first to see available databases and get the connectionId.',
     category: 'database',
+    risk: 'medium',
     sideEffects: ['database_write'],
     parameters: {
       type: 'object',
       properties: {
-        connectionId: { type: 'string', description: 'Database connection ID' },
+        connectionId: { type: 'string', description: 'Database connection ID (from db_list_connections)' },
         sql: { type: 'string', description: 'SQL query to execute' },
         params: { type: 'array', items: { type: 'string' }, description: 'Query parameters (for parameterized queries)' },
       },
       required: ['connectionId', 'sql'],
     },
-    async execute(input: { connectionId: string; sql: string; params?: any[] }) {
-      const result = await manager.executeQuery({
-        connectionId: input.connectionId,
-        agentId,
-        operation: 'read',
-        sql: input.sql,
-        params: input.params,
-      });
-
-      if (!result.success) {
-        return { error: result.error, queryId: result.queryId };
-      }
+    async execute(_toolCallId: string, input: { connectionId: string; sql: string; params?: any[] }) {
+      if (!input?.connectionId || !input?.sql) return errorResult('connectionId and sql are required');
+      
+      try {
+        const result = await manager.executeQuery({
+          connectionId: input.connectionId,
+          agentId,
+          operation: 'read',
+          sql: input.sql,
+          params: input.params,
+        });
+
+        if (!result.success) {
+          return errorResult(result.error || 'Query failed');
+        }
 
-      return {
-        rows: result.rows,
-        rowCount: result.rowCount,
-        affectedRows: result.affectedRows,
-        fields: result.fields,
-        executionTimeMs: result.executionTimeMs,
-        truncated: result.truncated,
-        queryId: result.queryId,
-      };
+        return jsonResult({
+          rows: result.rows,
+          rowCount: result.rowCount,
+          affectedRows: result.affectedRows,
+          fields: result.fields,
+          executionTimeMs: result.executionTimeMs,
+          truncated: result.truncated,
+        });
+      } catch (e: any) {
+        return errorResult(e.message || 'Query execution failed');
+      }
     },
   });
 
   // Tool 3: Describe table schema
   tools.push({
     name: 'db_describe_table',
-    description: 'Get the schema (columns, types, constraints) of a database table.',
+    description: 'Get the schema (columns, types, constraints) of a table in an external database.',
     category: 'database',
+    risk: 'low',
     parameters: {
       type: 'object',
       properties: {
@@ -102,11 +114,12 @@ export function createDatabaseTools(manager: DatabaseConnectionManager, agentId:
       },
       required: ['connectionId', 'table'],
     },
-    async execute(input: { connectionId: string; table: string }) {
+    async execute(_toolCallId: string, input: { connectionId: string; table: string }) {
+      if (!input?.connectionId || !input?.table) return errorResult('connectionId and table are required');
+
       const conn = manager.getConnection(input.connectionId);
-      if (!conn) return { error: 'Connection not found' };
+      if (!conn) return errorResult('Connection not found');
 
-      // Build describe query based on database type
       let sql: string;
       switch (conn.type) {
         case 'postgresql': case 'cockroachdb': case 'supabase': case 'neon':
@@ -119,23 +132,25 @@ export function createDatabaseTools(manager: DatabaseConnectionManager, agentId:
           sql = `PRAGMA table_info('${input.table.replace(/'/g, "''")}')`;
           break;
         default:
-          return { error: `Schema inspection not supported for ${conn.type}` };
+          return errorResult(`Schema inspection not supported for ${conn.type}`);
       }
 
-      return manager.executeQuery({
-        connectionId: input.connectionId,
-        agentId,
-        operation: 'read',
-        sql,
-      });
+      try {
+        const result = await manager.executeQuery({ connectionId: input.connectionId, agentId, operation: 'read', sql });
+        if (!result.success) return errorResult(result.error || 'Query failed');
+        return jsonResult({ columns: result.rows, table: input.table });
+      } catch (e: any) {
+        return errorResult(e.message);
+      }
     },
   });
 
   // Tool 4: List tables
   tools.push({
     name: 'db_list_tables',
-    description: 'List all tables in the connected database.',
+    description: 'List all tables in an external database connection.',
     category: 'database',
+    risk: 'low',
     parameters: {
       type: 'object',
       properties: {
@@ -143,9 +158,11 @@ export function createDatabaseTools(manager: DatabaseConnectionManager, agentId:
       },
       required: ['connectionId'],
     },
-    async execute(input: { connectionId: string }) {
+    async execute(_toolCallId: string, input: { connectionId: string }) {
+      if (!input?.connectionId) return errorResult('connectionId is required');
+
       const conn = manager.getConnection(input.connectionId);
-      if (!conn) return { error: 'Connection not found' };
+      if (!conn) return errorResult('Connection not found');
 
       let sql: string;
       switch (conn.type) {
@@ -158,19 +175,17 @@ export function createDatabaseTools(manager: DatabaseConnectionManager, agentId:
         case 'sqlite': case 'turso':
           sql = `SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name`;
           break;
-        case 'mongodb':
-          sql = JSON.stringify({ collection: 'system.namespaces', operation: 'find', filter: {} });
-          break;
         default:
-          return { error: `Table listing not supported for ${conn.type}` };
+          return errorResult(`Table listing not supported for ${conn.type}`);
       }
 
-      return manager.executeQuery({
-        connectionId: input.connectionId,
-        agentId,
-        operation: 'read',
-        sql,
-      });
+      try {
+        const result = await manager.executeQuery({ connectionId: input.connectionId, agentId, operation: 'read', sql });
+        if (!result.success) return errorResult(result.error || 'Query failed');
+        return jsonResult({ tables: result.rows });
+      } catch (e: any) {
+        return errorResult(e.message);
+      }
     },
   });
 

package/src/database-access/connection-manager.ts

@@ -115,8 +115,8 @@ export class DatabaseConnectionManager {
   private async dbAll(sql: string, params?: any[]): Promise<any[]> {
     if (!this.engineDb) return [];
     if (this.engineDb.all) return this.engineDb.all(sql, params) as Promise<any[]>;
-    if (this.engineDb.query) {
-      const result = await this.engineDb.query(sql, params);
+    if ((this.engineDb as any).query) {
+      const result = await (this.engineDb as any).query(sql, params);
       return Array.isArray(result) ? result : (result?.rows || []);
     }
     // Fallback: execute returns rows for some adapters
@@ -343,6 +343,17 @@ export class DatabaseConnectionManager {
     return this.configs.get(id);
   }
 
+  /** Get a human-readable summary of an agent's database connections for system prompts */
+  getAgentConnectionSummary(agentId: string): string[] {
+    const accesses = this.getAgentAccess(agentId).filter(a => a.enabled);
+    return accesses.map(a => {
+      const config = this.configs.get(a.connectionId);
+      if (!config) return '';
+      const perms = a.permissions?.join(', ') || 'read';
+      return `"${config.name}" (${config.type}) — permissions: ${perms}`;
+    }).filter(Boolean);
+  }
+
   listConnections(orgId: string): DatabaseConnectionConfig[] {
     return [...this.configs.values()].filter(c => c.orgId === orgId);
   }

package/src/database-access/routes.ts

@@ -9,6 +9,13 @@ import { Hono } from 'hono';
 import type { DatabaseConnectionManager } from './connection-manager.js';
 import type { DatabasePermission } from './types.js';
 
+async function notifyAgentReload(agentId: string) {
+  try {
+    const { notifyAgent } = await import('../engine/agent-notify.js');
+    await notifyAgent(agentId, 'db-access');
+  } catch { /* non-fatal */ }
+}
+
 export function createDatabaseAccessRoutes(manager: DatabaseConnectionManager) {
   const router = new Hono();
 
@@ -149,6 +156,9 @@ export function createDatabaseAccessRoutes(manager: DatabaseConnectionManager) {
       enabled: true,
     });
 
+    // Notify agent in real-time
+    notifyAgentReload(body.agentId).catch(() => {});
+
     return c.json(access, 201);
   });
 
@@ -162,7 +172,9 @@ export function createDatabaseAccessRoutes(manager: DatabaseConnectionManager) {
 
   /** Revoke agent access */
   router.delete('/connections/:connId/agents/:agentId', async (c) => {
-    await manager.revokeAccess(c.req.param('agentId'), c.req.param('connId'));
+    const agentId = c.req.param('agentId');
+    await manager.revokeAccess(agentId, c.req.param('connId'));
+    notifyAgentReload(agentId).catch(() => {});
     return c.json({ ok: true });
   });
 

package/src/db/adapter.ts

@@ -42,6 +42,7 @@ export interface Agent {
   status: 'active' | 'archived' | 'suspended';
   metadata: Record<string, unknown>;
   securityOverrides?: Partial<SecurityConfig>;
+  client_org_id?: string;
   createdAt: Date;
   updatedAt: Date;
   createdBy: string;

package/src/engine/agent-memory.ts

@@ -40,7 +40,8 @@ export type MemorySource =
   | 'correction'
   | 'system'
   | 'context_compaction'
-  | 'mcp_server_deletion';
+  | 'mcp_server_deletion'
+  | 'transfer';
 
 export const MEMORY_CATEGORIES: Record<MemoryCategory, { label: string; description: string }> = {
   org_knowledge: {

package/src/engine/agent-notify.ts

@@ -0,0 +1,50 @@
+/**
+ * Agent Notification — Push config changes to standalone agent processes in real-time.
+ * 
+ * When any config is changed from the dashboard, call notifyAgent() to tell
+ * the agent process to reload from DB immediately.
+ */
+
+import type { AgentLifecycleManager } from './lifecycle.js';
+
+type ReloadScope = 'all' | 'config' | 'permissions' | 'db-access' | 'budget' | 'guardrails';
+
+/**
+ * Notify a standalone agent process to reload its config.
+ * Non-blocking — failures are silently ignored (agent may be offline).
+ */
+export async function notifyAgent(agentId: string, scope: ReloadScope, lifecycle?: AgentLifecycleManager): Promise<boolean> {
+  const port = resolveAgentPort(agentId, lifecycle);
+  if (!port) return false;
+
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/reload?scope=${scope}`, {
+      method: 'POST',
+      signal: AbortSignal.timeout(3000),
+    });
+    if (resp.ok) {
+      const data = await resp.json() as any;
+      console.log(`[notify] Agent ${agentId} reloaded: ${data.reloaded?.join(', ') || scope}`);
+      return true;
+    }
+  } catch { /* agent offline or unreachable — that's fine */ }
+  return false;
+}
+
+/**
+ * Notify ALL running standalone agents to reload.
+ */
+export async function notifyAllAgents(scope: ReloadScope, lifecycle?: AgentLifecycleManager): Promise<void> {
+  if (!lifecycle) return;
+  const agents = lifecycle.getAllAgents().filter(a => a.state === 'running');
+  await Promise.allSettled(agents.map(a => notifyAgent(a.id, scope, lifecycle)));
+}
+
+function resolveAgentPort(agentId: string, lifecycle?: AgentLifecycleManager): number | null {
+  if (!lifecycle) return null;
+  const agent = lifecycle.getAgent(agentId);
+  if (!agent) return null;
+
+  const dep = agent.config?.deployment;
+  return dep?.port || dep?.config?.local?.port || null;
+}