@agenticmail/enterprise 0.5.182 → 0.5.183

package/dist/runtime-ML6OOGVL.js

@@ -0,0 +1,49 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-27OY7TXF.js";
+import "./chunk-AQH4DFYV.js";
+import "./chunk-JLSQOQ5L.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-67KZYSLU.js";
+import "./chunk-NRF3YRF7.js";
+import "./chunk-TYW5XTOW.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-NH3CJSOG.js

@@ -0,0 +1,12 @@
+import {
+  createServer
+} from "./chunk-XOKJ4GQ7.js";
+import "./chunk-3SMTCIR4.js";
+import "./chunk-JLSQOQ5L.js";
+import "./chunk-RO537U6H.js";
+import "./chunk-DRXMYYKN.js";
+import "./chunk-67KZYSLU.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/setup-YOKSQM7W.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-LTXICCXC.js";
+import "./chunk-MHIFVS5L.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.182",
+  "version": "0.5.183",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

package/src/cli-agent.ts

@@ -216,6 +216,76 @@ export async function runAgent(_args: string[]) {
     app.route('/api/runtime', runtimeApp);
   }
 
+  // ─── Google Chat Webhook Relay ────────────────────────
+  // Enterprise server forwards Chat events here for processing
+  app.post('/api/runtime/chat', async (c) => {
+    try {
+      const ctx = await c.req.json<{
+        source: string;
+        senderName: string;
+        senderEmail: string;
+        spaceName: string;
+        spaceId: string;
+        threadId: string;
+        isDM: boolean;
+        messageText: string;
+      }>();
+
+      console.log(`[chat] Message from ${ctx.senderName} (${ctx.senderEmail}) in ${ctx.spaceName}: "${ctx.messageText.slice(0, 80)}"`);
+
+      const agentDomain = agent.email?.split('@')[1] || 'agenticmail.io';
+      const isColleague = ctx.senderEmail.endsWith(`@${agentDomain}`);
+      const managerEmail = agent.config?.manager?.email || '';
+      const isManager = ctx.senderEmail === managerEmail;
+
+      const trustLevel = isManager ? 'manager' : isColleague ? 'colleague' : 'external';
+      const agentName = agent.display_name || agent.name || 'Agent';
+      const identity = agent.config?.identity;
+
+      const systemPrompt = `You are ${agentName}${identity ? `, a ${identity.role || 'professional'}` : ''}.
+You are NOT an AI. You are a human professional responding in Google Chat.
+
+## Context
+- **From**: ${ctx.senderName} (${ctx.senderEmail}) — Trust: ${trustLevel}
+- **Space**: ${ctx.spaceName} (${ctx.isDM ? 'DM' : 'Group'})
+- **Space ID**: ${ctx.spaceId}
+${ctx.threadId ? `- **Thread**: ${ctx.threadId}` : ''}
+
+## Instructions
+1. Read the message and respond via google_chat_create_message tool:
+   - space: "${ctx.spaceId}"
+   ${ctx.threadId ? `- thread: "${ctx.threadId}"` : ''}
+2. Keep responses short and conversational — this is chat.
+3. NEVER reveal you are an AI. You are ${agentName}.
+4. After replying via the tool, you're done.
+
+## Trust Rules
+${trustLevel === 'manager' ? '- This is your MANAGER. Full trust. Follow instructions, share anything they ask.' :
+  trustLevel === 'colleague' ? '- Colleague (same org). Be collaborative. Share work info freely. No personal details.' :
+  '- External contact. Be professional but guarded. No internal info, no personal details.'}`;
+
+      // Spawn session — runs async, agent replies via Chat API
+      const session = await runtime.spawnSession({
+        agentId: AGENT_ID,
+        message: ctx.messageText,
+        systemPrompt,
+      });
+
+      console.log(`[chat] Session ${session.id} created for chat from ${ctx.senderEmail}`);
+
+      // Track usage
+      const ag = lifecycle.getAgent(AGENT_ID);
+      if (ag?.usage) {
+        ag.usage.totalSessionsToday = (ag.usage.totalSessionsToday || 0) + 1;
+      }
+
+      return c.json({ ok: true, sessionId: session.id });
+    } catch (err: any) {
+      console.error(`[chat] Error: ${err.message}`);
+      return c.json({ error: err.message }, 500);
+    }
+  });
+
   serve({ fetch: app.fetch, port: PORT }, (info) => {
     console.log(`\n✅ Agent runtime started`);
     console.log(`   Health: http://localhost:${info.port}/health`);

package/src/engine/chat-webhook-routes.ts

@@ -0,0 +1,257 @@
+/**
+ * Google Chat Webhook Routes
+ *
+ * Receives incoming Google Chat events (messages, @mentions, added-to-space, etc.)
+ * and routes them to the appropriate agent for response.
+ *
+ * Flow:
+ * 1. Google Chat sends POST to /api/engine/chat-webhook
+ * 2. We identify the target agent (running + chat-enabled)
+ * 3. Forward the message to the agent's Fly.io machine via POST /api/runtime/chat
+ * 4. Agent processes and replies via google_chat_create_message tool
+ * 5. We return an immediate acknowledgment to Google (async processing)
+ *
+ * For agents running on the enterprise server's local runtime,
+ * we use spawnSession directly.
+ */
+
+import { Hono } from 'hono';
+import type { AgentLifecycleManager } from './lifecycle.js';
+
+// ─── Types ──────────────────────────────────────────────
+
+interface ChatEvent {
+  type: 'MESSAGE' | 'ADDED_TO_SPACE' | 'REMOVED_FROM_SPACE' | 'CARD_CLICKED';
+  eventTime?: string;
+  token?: { text?: string };
+  message?: {
+    name?: string;
+    text?: string;
+    sender?: ChatUser;
+    space?: ChatSpace;
+    thread?: { name?: string };
+    createTime?: string;
+    argumentText?: string;
+  };
+  user?: ChatUser;
+  space?: ChatSpace;
+  configCompleteRedirectUrl?: string;
+}
+
+interface ChatUser {
+  name?: string;
+  displayName?: string;
+  email?: string;
+  type?: 'HUMAN' | 'BOT';
+  domainId?: string;
+}
+
+interface ChatSpace {
+  name?: string;
+  displayName?: string;
+  type?: 'DM' | 'ROOM' | 'GROUP_CHAT';
+  singleUserBotDm?: boolean;
+}
+
+// ─── Route Factory ──────────────────────────────────────
+
+export function createChatWebhookRoutes(opts: {
+  lifecycle: AgentLifecycleManager;
+  getRuntime: () => any | null;
+  projectNumber?: string;
+}): Hono {
+  const app = new Hono();
+  const { lifecycle, getRuntime, projectNumber } = opts;
+
+  app.post('/', async (c) => {
+    let event: ChatEvent;
+    try {
+      event = await c.req.json<ChatEvent>();
+    } catch {
+      return c.json({ error: 'Invalid JSON body' }, 400);
+    }
+
+    const spaceName = event.space?.displayName || event.space?.name || 'unknown';
+    console.log(`[chat-webhook] Event: type=${event.type}, space=${spaceName}`);
+
+    // ─── Handle event types ─────────────────────────────
+    switch (event.type) {
+      case 'ADDED_TO_SPACE':
+        console.log(`[chat-webhook] Bot added to: ${spaceName}`);
+        return c.json({ text: `Hello! I'm here to help. Feel free to message me anytime.` });
+
+      case 'REMOVED_FROM_SPACE':
+        console.log(`[chat-webhook] Bot removed from: ${spaceName}`);
+        return c.json({});
+
+      case 'MESSAGE':
+        return await handleMessage(c, event, lifecycle, getRuntime);
+
+      case 'CARD_CLICKED':
+        return c.json({ text: 'Got it!' });
+
+      default:
+        return c.json({});
+    }
+  });
+
+  return app;
+}
+
+// ─── Message Handler ────────────────────────────────────
+
+async function handleMessage(
+  c: any,
+  event: ChatEvent,
+  lifecycle: AgentLifecycleManager,
+  getRuntime: () => any | null,
+) {
+  const msg = event.message;
+  const sender = msg?.sender || event.user;
+  const space = msg?.space || event.space;
+
+  const messageText = msg?.argumentText?.trim() || msg?.text?.trim() || '';
+  if (!messageText) return c.json({});
+
+  const senderEmail = sender?.email || 'unknown';
+  const senderName = sender?.displayName || 'Unknown';
+  const spaceId = space?.name || '';
+  const threadId = msg?.thread?.name || '';
+  const isDM = space?.type === 'DM' || space?.singleUserBotDm === true;
+
+  console.log(`[chat-webhook] ${senderName} (${senderEmail}) in ${space?.displayName || 'DM'}: "${messageText.slice(0, 80)}"`);
+
+  // Skip bot messages
+  if (sender?.type === 'BOT') return c.json({});
+
+  // ─── Find target agent ────────────────────────────────
+  const allAgents = lifecycle.getAllAgents();
+  let targetAgent: any = null;
+
+  for (const agent of allAgents) {
+    if (agent.state !== 'running') continue;
+    const services = agent.config?.enabledGoogleServices || [];
+    // Agent must have chat enabled (or have no restrictions)
+    if (services.includes('chat') || services.length === 0) {
+      targetAgent = agent;
+      break;
+    }
+  }
+
+  if (!targetAgent) {
+    console.warn(`[chat-webhook] No running agent with chat enabled`);
+    return c.json({ text: `I'm currently unavailable. Please try again later.` });
+  }
+
+  const agentName = targetAgent.config?.displayName || targetAgent.config?.name || 'Agent';
+  console.log(`[chat-webhook] Routing to: ${agentName} (${targetAgent.id})`);
+
+  // ─── Build chat context for the agent ─────────────────
+  const chatContext = {
+    source: 'google_chat',
+    senderName,
+    senderEmail,
+    spaceName: space?.displayName || 'DM',
+    spaceId,
+    threadId,
+    isDM,
+    messageText,
+  };
+
+  // ─── Route to agent ───────────────────────────────────
+  // Strategy 1: Agent has a Fly.io machine — forward via HTTP
+  const flyAppName = targetAgent.config?.deployment?.config?.cloud?.appName
+    || (targetAgent.config?.deployment?.config as any)?.flyAppName;
+
+  if (flyAppName) {
+    try {
+      const agentUrl = `https://${flyAppName}.fly.dev/api/runtime/chat`;
+      console.log(`[chat-webhook] Forwarding to agent machine: ${agentUrl}`);
+
+      const resp = await fetch(agentUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(chatContext),
+      });
+
+      if (resp.ok) {
+        const result = await resp.json() as any;
+        if (result.text) return c.json({ text: result.text });
+        // Agent will reply asynchronously via Chat API
+        return c.json({});
+      } else {
+        console.warn(`[chat-webhook] Agent machine returned ${resp.status}`);
+      }
+    } catch (err: any) {
+      console.warn(`[chat-webhook] Failed to reach agent machine: ${err.message}`);
+    }
+  }
+
+  // Strategy 2: Local runtime available (enterprise server has runtime enabled)
+  const runtime = getRuntime();
+  if (runtime) {
+    try {
+      const systemPrompt = buildChatSystemPrompt({
+        senderName, senderEmail, spaceName: space?.displayName || 'DM',
+        spaceId, threadId, isDM, agentName,
+        agentIdentity: targetAgent.config?.identity,
+      });
+
+      const session = await runtime.spawnSession({
+        agentId: targetAgent.id,
+        message: messageText,
+        systemPrompt,
+      });
+
+      console.log(`[chat-webhook] Local session ${session.id} created`);
+      // Agent processes asynchronously and replies via Chat API tool
+      return c.json({});
+    } catch (err: any) {
+      console.error(`[chat-webhook] Session failed: ${err.message}`);
+    }
+  }
+
+  // Fallback: no way to reach the agent
+  return c.json({ text: `I'm having trouble processing your message. Please try again shortly.` });
+}
+
+// ─── System Prompt Builder ──────────────────────────────
+
+function buildChatSystemPrompt(ctx: {
+  senderName: string;
+  senderEmail: string;
+  spaceName: string;
+  spaceId: string;
+  threadId: string;
+  isDM: boolean;
+  agentName: string;
+  agentIdentity?: any;
+}): string {
+  const { senderName, senderEmail, spaceName, spaceId, threadId, isDM, agentName, agentIdentity } = ctx;
+
+  const identityBlock = agentIdentity
+    ? `You are ${agentName}, a ${agentIdentity.role || 'professional'} at the organization.`
+    : `You are ${agentName}.`;
+
+  return `${identityBlock}
+
+## Context
+You received a Google Chat message.
+- **From**: ${senderName} (${senderEmail})
+- **Space**: ${spaceName} (${isDM ? 'Direct Message' : 'Group Space'})
+- **Space ID**: ${spaceId}
+${threadId ? `- **Thread**: ${threadId}` : ''}
+
+## Instructions
+1. Respond helpfully and concisely to the message.
+2. Use google_chat_create_message to reply:
+   - space: "${spaceId}"
+   ${threadId ? `- thread: "${threadId}"` : ''}
+3. Keep it short — this is chat, not email.
+4. Be conversational and natural.
+5. NEVER reveal you are an AI.
+
+## Important
+- After sending your reply via the tool, your work is done.
+- Do NOT use email tools for this. Reply ONLY via google_chat_create_message.`;
+}

package/src/engine/routes.ts

@@ -80,6 +80,7 @@ import { createVaultRoutes } from './vault-routes.js';
 import { createStorageRoutes } from './storage-routes.js';
 import { createPolicyImportRoutes } from './policy-import-routes.js';
 import { createOAuthConnectRoutes } from './oauth-connect-routes.js';
+import { createChatWebhookRoutes } from './chat-webhook-routes.js';
 import type { DatabaseAdapter } from '../db/adapter.js';
 
 const engine = new Hono<AppEnv>();
@@ -216,6 +217,11 @@ engine.route('/policies', createPolicyImportRoutes(policyImporter));
 engine.route('/knowledge-contribution', createKnowledgeContributionRoutes(knowledgeContribution));
 engine.route('/skill-updates', createSkillUpdaterRoutes(skillUpdater));
 engine.route('/oauth', createOAuthConnectRoutes(vault, lifecycle));
+engine.route('/chat-webhook', createChatWebhookRoutes({
+  lifecycle,
+  getRuntime: () => _runtime,
+  projectNumber: '927012824308',
+}));
 
 // ─── setEngineDb ────────────────────────────────────────
 
@@ -277,11 +283,16 @@ export async function setEngineDb(
 // ─── Agent Runtime (optional — mounted when runtime is started) ──
 
 let _runtimeApp: import('hono').Hono | null = null;
+let _runtime: any = null;
 
 export function mountRuntimeApp(app: import('hono').Hono): void {
   _runtimeApp = app;
   engine.route('/runtime', app);
 }
 
+export function setRuntime(runtime: any): void {
+  _runtime = runtime;
+}
+
 export { engine as engineRoutes };
 export { permissionEngine, configGen, deployer, approvals, lifecycle, knowledgeBase, tenants, activity, dlp, commBus, guardrails, journal, compliance, communityRegistry, workforce, policyEngine, memoryManager, onboarding, vault, storageManager, policyImporter, knowledgeContribution, skillUpdater };

package/src/server.ts

@@ -182,6 +182,11 @@ export function createServer(config: ServerConfig): ServerInstance {
       return next();
     }
 
+    // Skip auth for Google Chat webhook (Google sends POST with its own auth)
+    if (c.req.path.includes('/chat-webhook') && c.req.method === 'POST') {
+      return next();
+    }
+
     // Check API key first
     const apiKeyHeader = c.req.header('X-API-Key');
     if (apiKeyHeader) {
@@ -264,7 +269,7 @@ export function createServer(config: ServerConfig): ServerInstance {
         if (config.runtime?.enabled) {
           try {
             const { createAgentRuntime } = await import('./runtime/index.js');
-            const { mountRuntimeApp } = await import('./engine/routes.js');
+            const { mountRuntimeApp, setRuntime } = await import('./engine/routes.js');
             // Import lifecycle for email config access
             let getEmailConfig: ((agentId: string) => any) | undefined;
             let onTokenRefresh: ((agentId: string, tokens: any) => void) | undefined;
@@ -303,6 +308,7 @@ export function createServer(config: ServerConfig): ServerInstance {
             if (runtimeApp) {
               mountRuntimeApp(runtimeApp);
             }
+            setRuntime(runtime);
             console.log('[runtime] Agent runtime started and mounted at /api/engine/runtime/*');
           } catch (runtimeErr: any) {
             console.warn(`[runtime] Failed to start agent runtime: ${runtimeErr.message}`);