dexto 1.1.7 → 1.1.8

package/dist/api/server.js

@@ -6,7 +6,7 @@ import { WebhookEventSubscriber } from './webhook-subscriber.js';
 import { logger, redactSensitiveData } from '@dexto/core';
 import { setupA2ARoutes } from './a2a.js';
 import { createMcpTransport, initializeMcpServer, initializeMcpServerApiEndpoints, } from './mcp/mcp_handler.js';
-import { createAgentCard } from '@dexto/core';
+import { createAgentCard, DextoAgent } from '@dexto/core';
 import { stringify as yamlStringify } from 'yaml';
 import os from 'os';
 import { expressRedactionMiddleware } from './middleware/expressRedactionMiddleware.js';
@@ -19,7 +19,7 @@ import { getProviderKeyStatus, saveProviderApiKey } from '@dexto/core';
 import { errorHandler } from './middleware/errorHandler.js';
 import { McpServerConfigSchema } from '@dexto/core';
 import { sendWebSocketError, sendWebSocketValidationError } from './websocket-error-handler.js';
-import { DextoValidationError, ErrorScope, ErrorType, AgentErrorCode } from '@dexto/core';
+import { DextoValidationError, ErrorScope, ErrorType, AgentErrorCode, AgentError, } from '@dexto/core';
 /**
  * Helper function to send JSON response with optional pretty printing
  */
@@ -95,27 +95,125 @@ function parseQuery(schema, query) {
     return schema.parse(query); // ZodError handled by error middleware
 }
 // TODO: API endpoint names are work in progress and might be refactored/renamed in future versions
-export async function initializeApi(agent, agentCardOverride, listenPort) {
+export async function initializeApi(agent, agentCardOverride, listenPort, agentName) {
     const app = express();
-    registerGracefulShutdown(agent);
+    // Declare before registering shutdown hook to avoid TDZ on signals
+    let activeAgent = agent;
+    let activeAgentName = agentName || 'default';
+    let isSwitchingAgent = false;
+    registerGracefulShutdown(() => activeAgent);
     // this will apply middleware to all /api/llm/* routes
     app.use('/api/llm', expressRedactionMiddleware);
     app.use('/api/config.yaml', expressRedactionMiddleware);
     const server = http.createServer(app);
     const wss = new WebSocketServer({ server });
-    // set up event broadcasting over WebSocket
+    logger.info(`Initializing API server with agent: ${activeAgentName}`);
+    // Ensure the initial agent is started
+    if (!activeAgent.isStarted() && !activeAgent.isStopped()) {
+        logger.info('Starting initial agent...');
+        await activeAgent.start();
+    }
+    else if (activeAgent.isStopped()) {
+        logger.warn('Initial agent is stopped, this may cause issues');
+    }
     const webSubscriber = new WebSocketEventSubscriber(wss);
     logger.info('Setting up API event subscriptions...');
-    webSubscriber.subscribe(agent.agentEventBus);
+    webSubscriber.subscribe(activeAgent.agentEventBus);
+    // Initialize webhook subscriber
+    const webhookSubscriber = new WebhookEventSubscriber();
+    logger.info('Setting up webhook event subscriptions...');
+    webhookSubscriber.subscribe(activeAgent.agentEventBus);
     // Tool confirmation responses are handled by the main WebSocket handler below
+    function ensureAgentAvailable() {
+        // Gate requests during agent switching
+        if (isSwitchingAgent) {
+            throw AgentError.apiValidationError('Agent switch already in progress');
+        }
+        // Fast path: most common case is agent is started and running
+        if (activeAgent.isStarted() && !activeAgent.isStopped()) {
+            return;
+        }
+        // Provide specific error messages for better debugging
+        if (activeAgent.isStopped()) {
+            throw AgentError.stopped();
+        }
+        if (!activeAgent.isStarted()) {
+            throw AgentError.notStarted();
+        }
+    }
+    async function switchAgentByName(name) {
+        if (isSwitchingAgent) {
+            throw AgentError.apiValidationError('Agent switch already in progress');
+        }
+        isSwitchingAgent = true;
+        let newAgent;
+        try {
+            // Use domain layer method to create new agent
+            newAgent = await DextoAgent.createAgent(name);
+            logger.info(`Starting new agent: ${name}`);
+            await newAgent.start();
+            // Rewire event/webhook subscribers to new agent bus
+            logger.info('Rewiring event subscribers...');
+            try {
+                webSubscriber.unsubscribe();
+            }
+            catch (_err) {
+                logger.debug(`Failed to unsubscribe webSubscriber: ${_err instanceof Error ? _err.message : String(_err)}`);
+            }
+            webSubscriber.subscribe(newAgent.agentEventBus);
+            try {
+                webhookSubscriber.unsubscribe();
+            }
+            catch (_err) {
+                logger.debug(`Failed to unsubscribe webhookSubscriber: ${_err instanceof Error ? _err.message : String(_err)}`);
+            }
+            webhookSubscriber.subscribe(newAgent.agentEventBus);
+            // Stop previous agent last (only after new one is fully operational)
+            const previousAgent = activeAgent;
+            activeAgent = newAgent;
+            activeAgentName = name;
+            logger.info(`Successfully switched to agent: ${name}`);
+            // Now safely stop the previous agent
+            try {
+                if (previousAgent && previousAgent !== newAgent) {
+                    logger.info('Stopping previous agent...');
+                    await previousAgent.stop();
+                }
+            }
+            catch (err) {
+                logger.warn(`Stopping previous agent failed: ${err}`);
+                // Don't throw here as the switch was successful
+            }
+            return { name };
+        }
+        catch (error) {
+            logger.error(`Failed to switch to agent '${name}': ${error instanceof Error ? error.message : String(error)}`, { error });
+            // Clean up the failed new agent if it was created
+            if (newAgent) {
+                try {
+                    await newAgent.stop();
+                }
+                catch (cleanupErr) {
+                    logger.warn(`Failed to cleanup new agent: ${cleanupErr}`);
+                }
+            }
+            throw error;
+        }
+        finally {
+            isSwitchingAgent = false;
+        }
+    }
     // HTTP endpoints
     // Health check endpoint
     app.get('/health', (req, res) => {
         res.status(200).send('OK');
     });
-    app.post('/api/message', express.json(), async (req, res, next) => {
+    // JSON body size limit for message endpoints supporting base64 image/file payloads
+    // Both /api/message and /api/message-sync accept base64 attachments; increased limit to avoid 413s.
+    app.post('/api/message', express.json({ limit: process.env.MESSAGE_JSON_LIMIT || '10mb' }), async (req, res, next) => {
         logger.info('Received message via POST /api/message');
         try {
+            ensureAgentAvailable();
             const { message, sessionId, stream, imageData, fileData } = parseBody(MessageRequestSchema, req.body);
             const imageDataInput = imageData
                 ? { image: imageData.base64, mimeType: imageData.mimeType }
@@ -134,7 +232,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
                 logger.info('File data included in message.');
             if (sessionId)
                 logger.info(`Message for session: ${sessionId}`);
-            const response = await agent.run(message || '', imageDataInput, fileDataInput, sessionId, stream || false);
+            const response = await activeAgent.run(message || '', imageDataInput, fileDataInput, sessionId, stream || false);
             return res.status(202).send({ response, sessionId });
         }
         catch (error) {
@@ -145,7 +243,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.post('/api/sessions/:sessionId/cancel', async (req, res, next) => {
         try {
             const { sessionId } = parseQuery(CancelRequestSchema, req.params);
-            const cancelled = await agent.cancel(sessionId);
+            const cancelled = await activeAgent.cancel(sessionId);
             if (!cancelled) {
                 logger.debug(`No in-flight run to cancel for session: ${sessionId}`);
             }
@@ -156,9 +254,11 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
         }
     });
     // Synchronous endpoint: await the full AI response and return it in one go
-    app.post('/api/message-sync', express.json(), async (req, res, next) => {
+    // JSON body size limit increased for image/file uploads
+    app.post('/api/message-sync', express.json({ limit: process.env.MESSAGE_JSON_LIMIT || '10mb' }), async (req, res, next) => {
         logger.info('Received message via POST /api/message-sync');
         try {
+            ensureAgentAvailable();
             const { message, sessionId, imageData, fileData } = parseBody(MessageRequestSchema, req.body);
             // Extract optional image and file data
             const imageDataInput = imageData
@@ -178,7 +278,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
                 logger.info('File data included in message.');
             if (sessionId)
                 logger.info(`Message for session: ${sessionId}`);
-            const response = await agent.run(message || '', imageDataInput, fileDataInput, sessionId, false // Force non-streaming for sync endpoint
+            const response = await activeAgent.run(message || '', imageDataInput, fileDataInput, sessionId, false // Force non-streaming for sync endpoint
             );
             return res.status(200).json({ response, sessionId });
         }
@@ -189,8 +289,9 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.post('/api/reset', express.json(), async (req, res, next) => {
         logger.info('Received request via POST /api/reset');
         try {
+            ensureAgentAvailable();
             const { sessionId } = parseBody(z.object({ sessionId: z.string().optional() }), req.body);
-            await agent.resetConversation(sessionId);
+            await activeAgent.resetConversation(sessionId);
             return res.status(200).send({ status: 'reset initiated', sessionId });
         }
         catch (error) {
@@ -200,8 +301,9 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     // Dynamic MCP server connection endpoint (legacy)
     app.post('/api/connect-server', express.json(), async (req, res, next) => {
         try {
+            ensureAgentAvailable();
             const { name, config } = parseBody(McpServerRequestSchema, req.body);
-            await agent.connectMcpServer(name, config);
+            await activeAgent.connectMcpServer(name, config);
             logger.info(`Successfully connected to new server '${name}' via API request.`);
             return res.status(200).send({ status: 'connected', name });
         }
@@ -212,8 +314,9 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     // Add a new MCP server
     app.post('/api/mcp/servers', express.json(), async (req, res, next) => {
         try {
+            ensureAgentAvailable();
             const { name, config } = parseBody(McpServerRequestSchema, req.body);
-            await agent.connectMcpServer(name, config);
+            await activeAgent.connectMcpServer(name, config);
             return res.status(201).json({ status: 'connected', name });
         }
         catch (error) {
@@ -223,8 +326,9 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     // Add MCP servers listing endpoint
     app.get('/api/mcp/servers', async (req, res, next) => {
         try {
-            const clientsMap = agent.getMcpClients();
-            const failedConnections = agent.getMcpFailedConnections();
+            ensureAgentAvailable();
+            const clientsMap = activeAgent.getMcpClients();
+            const failedConnections = activeAgent.getMcpFailedConnections();
             const servers = [];
             for (const name of clientsMap.keys()) {
                 servers.push({ id: name, name, status: 'connected' });
@@ -240,12 +344,13 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     });
     // Add MCP server tools listing endpoint
     app.get('/api/mcp/servers/:serverId/tools', async (req, res, next) => {
-        const serverId = req.params.serverId;
-        const client = agent.getMcpClients().get(serverId);
-        if (!client) {
-            return res.status(404).json({ error: `Server '${serverId}' not found` });
-        }
         try {
+            ensureAgentAvailable();
+            const serverId = req.params.serverId;
+            const client = activeAgent.getMcpClients().get(serverId);
+            if (!client) {
+                return res.status(404).json({ error: `Server '${serverId}' not found` });
+            }
             const toolsMap = await client.getTools();
             const tools = Object.entries(toolsMap).map(([toolName, toolDef]) => ({
                 id: toolName,
@@ -265,12 +370,13 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
         logger.info(`Received request to DELETE /api/mcp/servers/${serverId}`);
         try {
             // Check if server exists before attempting to disconnect
-            const clientExists = agent.getMcpClients().has(serverId) || agent.getMcpFailedConnections()[serverId];
+            const clientExists = activeAgent.getMcpClients().has(serverId) ||
+                activeAgent.getMcpFailedConnections()[serverId];
             if (!clientExists) {
                 logger.warn(`Attempted to delete non-existent server: ${serverId}`);
                 return res.status(404).json({ error: `Server '${serverId}' not found.` });
             }
-            await agent.removeMcpServer(serverId);
+            await activeAgent.removeMcpServer(serverId);
             return res.status(200).json({ status: 'disconnected', id: serverId });
         }
         catch (error) {
@@ -281,7 +387,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.post('/api/mcp/servers/:serverId/tools/:toolName/execute', express.json(), async (req, res, next) => {
         const { serverId, toolName } = req.params;
         // Verify server exists
-        const client = agent.getMcpClients().get(serverId);
+        const client = activeAgent.getMcpClients().get(serverId);
         if (!client) {
             return res
                 .status(404)
@@ -289,7 +395,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
         }
         try {
             // Execute tool through the agent's unified wrapper method
-            const rawResult = await agent.executeTool(toolName, req.body);
+            const rawResult = await activeAgent.executeTool(toolName, req.body);
             // Return standardized result shape
             return res.json({ success: true, data: rawResult });
         }
@@ -320,7 +426,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
                 const data = JSON.parse(messageString);
                 if (data.type === 'toolConfirmationResponse' && data.data) {
                     // Route confirmation back via AgentEventBus and do not broadcast an error
-                    agent.agentEventBus.emit('dexto:toolConfirmationResponse', data.data);
+                    activeAgent.agentEventBus.emit('dexto:toolConfirmationResponse', data.data);
                     return;
                 }
                 else if (data.type === 'message' &&
@@ -349,8 +455,17 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
                         logger.info('File data included in message.');
                     if (sessionId)
                         logger.info(`Message for session: ${sessionId}`);
+                    // Check if agent is available before processing
+                    try {
+                        ensureAgentAvailable();
+                    }
+                    catch (error) {
+                        logger.error(`Agent not available for WebSocket message: ${error}`);
+                        sendWebSocketError(ws, error instanceof Error ? error.message : 'Agent not available', sessionId);
+                        return;
+                    }
                     // Comprehensive input validation
-                    const currentConfig = agent.getEffectiveConfig(sessionId);
+                    const currentConfig = activeAgent.getEffectiveConfig(sessionId);
                     const validation = validateInputForLLM({
                         text: data.content,
                         ...(imageDataInput && { imageData: imageDataInput }),
@@ -386,17 +501,35 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
                         sendWebSocketError(ws, hierarchicalError, sessionId);
                         return;
                     }
-                    await agent.run(data.content, imageDataInput, fileDataInput, sessionId, stream);
+                    await activeAgent.run(data.content, imageDataInput, fileDataInput, sessionId, stream);
                 }
                 else if (data.type === 'reset') {
                     const sessionId = data.sessionId;
                     logger.info(`Processing reset command from WebSocket${sessionId ? ` for session: ${sessionId}` : ''}.`);
-                    await agent.resetConversation(sessionId);
+                    // Check if agent is available before processing
+                    try {
+                        ensureAgentAvailable();
+                    }
+                    catch (error) {
+                        logger.error(`Agent not available for WebSocket reset: ${error}`);
+                        sendWebSocketError(ws, error instanceof Error ? error.message : 'Agent not available', sessionId || 'unknown');
+                        return;
+                    }
+                    await activeAgent.resetConversation(sessionId);
                 }
                 else if (data.type === 'cancel') {
                     const sessionId = data.sessionId;
                     logger.info(`Processing cancel command from WebSocket${sessionId ? ` for session: ${sessionId}` : ''}.`);
-                    const cancelled = await agent.cancel(sessionId);
+                    // Check if agent is available before processing
+                    try {
+                        ensureAgentAvailable();
+                    }
+                    catch (error) {
+                        logger.error(`Agent not available for WebSocket cancel: ${error}`);
+                        sendWebSocketError(ws, error instanceof Error ? error.message : 'Agent not available', sessionId || 'unknown');
+                        return;
+                    }
+                    const cancelled = await activeAgent.cancel(sessionId);
                     if (!cancelled) {
                         logger.debug('No in-flight run to cancel');
                     }
@@ -459,7 +592,9 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     try {
         const transportType = process.env.DEXTO_MCP_TRANSPORT_TYPE || 'http';
         const mcpTransport = await createMcpTransport(transportType);
-        // TODO: Think of a better way to handle the MCP implementation
+        // TODO: MCP server is bound to the initial agent; breaks after agent switch
+        // initializeMcpServer receives the original agent, so MCP endpoints keep talking to the stale instance post-switch.
+        // Make MCP consume the current agent via a getter to stay in sync.
         await initializeMcpServer(agent, agentCardData, // Pass the agent card data for the MCP resource
         mcpTransport);
         await initializeMcpServerApiEndpoints(app, mcpTransport);
@@ -471,6 +606,57 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
             res.status(500).json({ error: 'MCP server initialization failed' });
         });
     }
+    // ===== Agents API =====
+    app.get('/api/agents', async (_req, res, next) => {
+        try {
+            ensureAgentAvailable();
+            const agents = await activeAgent.listAgents();
+            return sendJsonResponse(res, {
+                installed: agents.installed,
+                available: agents.available,
+                current: { name: activeAgentName ?? 'default' },
+            });
+        }
+        catch (error) {
+            return next(error);
+        }
+    });
+    app.get('/api/agents/current', async (_req, res, next) => {
+        try {
+            // TODO: Consider exposing agent.getName() method or config.name for more accurate tracking
+            return sendJsonResponse(res, { name: activeAgentName ?? 'default' });
+        }
+        catch (error) {
+            return next(error);
+        }
+    });
+    const AgentNameSchema = z.object({ name: z.string().min(1) }).strict();
+    app.post('/api/agents/install', express.json(), async (req, res, next) => {
+        try {
+            ensureAgentAvailable();
+            const { name } = AgentNameSchema.parse(req.body);
+            await activeAgent.installAgent(name);
+            return sendJsonResponse(res, { installed: true, name }, 201);
+        }
+        catch (error) {
+            return next(error);
+        }
+    });
+    app.post('/api/agents/switch', express.json(), async (req, res, next) => {
+        try {
+            const { name } = AgentNameSchema.parse(req.body);
+            const result = await switchAgentByName(name);
+            return sendJsonResponse(res, { switched: true, ...result });
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message &&
+                error.message.includes('already in progress')) {
+                return res.status(409).json({ error: error.message });
+            }
+            return next(error);
+        }
+    });
     // Configuration export endpoint
     /**
      * Helper function to redact sensitive environment variables
@@ -513,7 +699,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.get('/api/config.yaml', async (req, res, next) => {
         try {
             const sessionId = req.query.sessionId;
-            const config = agent.getEffectiveConfig(sessionId);
+            const config = activeAgent.getEffectiveConfig(sessionId);
             // Export config as YAML, masking sensitive data
             const maskedConfig = {
                 ...config,
@@ -535,7 +721,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.get('/api/greeting', async (req, res, next) => {
         try {
             const sessionId = req.query.sessionId;
-            const config = agent.getEffectiveConfig(sessionId);
+            const config = activeAgent.getEffectiveConfig(sessionId);
             res.json({ greeting: config.greeting });
         }
         catch (error) {
@@ -548,8 +734,8 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
             const { sessionId } = req.query;
             // Use session-specific config if sessionId is provided, otherwise use default
             const currentConfig = sessionId
-                ? agent.getEffectiveConfig(sessionId).llm
-                : agent.getCurrentLLMConfig();
+                ? activeAgent.getEffectiveConfig(sessionId).llm
+                : activeAgent.getCurrentLLMConfig();
             // Attach displayName for the current model if available in registry
             let displayName;
             try {
@@ -711,7 +897,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
             const sessionId = typeof body.sessionId === 'string' ? body.sessionId : undefined;
             const { sessionId: _omit, ...llmCandidate } = body;
             const llmConfig = LLMUpdatesSchema.parse(llmCandidate);
-            const config = await agent.switchLLM(llmConfig, sessionId);
+            const config = await activeAgent.switchLLM(llmConfig, sessionId);
             return res.status(200).json({ config, sessionId });
         }
         catch (error) {
@@ -722,10 +908,10 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     // List all active sessions
     app.get('/api/sessions', async (req, res, next) => {
         try {
-            const sessionIds = await agent.listSessions();
+            const sessionIds = await activeAgent.listSessions();
             const sessions = await Promise.all(sessionIds.map(async (id) => {
                 try {
-                    const metadata = await agent.getSessionMetadata(id);
+                    const metadata = await activeAgent.getSessionMetadata(id);
                     return {
                         id,
                         createdAt: metadata?.createdAt || null,
@@ -753,8 +939,8 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.post('/api/sessions', express.json(), async (req, res, next) => {
         try {
             const { sessionId } = req.body;
-            const session = await agent.createSession(sessionId);
-            const metadata = await agent.getSessionMetadata(session.id);
+            const session = await activeAgent.createSession(sessionId);
+            const metadata = await activeAgent.getSessionMetadata(session.id);
             return res.status(201).json({
                 session: {
                     id: session.id,
@@ -771,7 +957,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     // Get current working session (must come before parameterized route)
     app.get('/api/sessions/current', async (req, res, next) => {
         try {
-            const currentSessionId = agent.getCurrentSessionId();
+            const currentSessionId = activeAgent.getCurrentSessionId();
             return res.json({ currentSessionId });
         }
         catch (error) {
@@ -782,8 +968,8 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.get('/api/sessions/:sessionId', async (req, res, next) => {
         try {
             const { sessionId } = req.params;
-            const metadata = await agent.getSessionMetadata(sessionId);
-            const history = await agent.getSessionHistory(sessionId);
+            const metadata = await activeAgent.getSessionMetadata(sessionId);
+            const history = await activeAgent.getSessionHistory(sessionId);
             return res.json({
                 session: {
                     id: sessionId,
@@ -803,7 +989,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
         try {
             const { sessionId } = req.params;
             // getSessionHistory already checks existence via getSession
-            const history = await agent.getSessionHistory(sessionId);
+            const history = await activeAgent.getSessionHistory(sessionId);
             return res.json({ history });
         }
         catch (error) {
@@ -820,7 +1006,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
                 ...(sessionId && { sessionId }),
                 ...(role && { role }),
             };
-            const searchResults = await agent.searchMessages(query, options);
+            const searchResults = await activeAgent.searchMessages(query, options);
             return sendJsonResponse(res, searchResults);
         }
         catch (error) {
@@ -831,7 +1017,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.get('/api/search/sessions', async (req, res, next) => {
         try {
             const { q: query } = parseQuery(z.object({ q: z.string().min(1, 'Search query is required') }), req.query);
-            const searchResults = await agent.searchSessions(query);
+            const searchResults = await activeAgent.searchSessions(query);
             return sendJsonResponse(res, searchResults);
         }
         catch (error) {
@@ -843,7 +1029,7 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
         try {
             const { sessionId } = req.params;
             // deleteSession already checks existence internally
-            await agent.deleteSession(sessionId);
+            await activeAgent.deleteSession(sessionId);
             return res.json({ status: 'deleted', sessionId });
         }
         catch (error) {
@@ -856,20 +1042,20 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
             const { sessionId } = req.params;
             // Handle null/reset case
             if (sessionId === 'null' || sessionId === 'undefined') {
-                await agent.loadSessionAsDefault(null);
+                await activeAgent.loadSessionAsDefault(null);
                 res.json({
                     status: 'reset',
                     sessionId: null,
-                    currentSession: agent.getCurrentSessionId(),
+                    currentSession: activeAgent.getCurrentSessionId(),
                 });
                 return;
             }
             // loadSession already checks session existence
-            await agent.loadSessionAsDefault(sessionId);
+            await activeAgent.loadSessionAsDefault(sessionId);
             return res.json({
                 status: 'loaded',
                 sessionId,
-                currentSession: agent.getCurrentSessionId(),
+                currentSession: activeAgent.getCurrentSessionId(),
             });
         }
         catch (error) {
@@ -877,10 +1063,6 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
         }
     });
     // Webhook Management APIs
-    // Initialize webhook subscriber
-    const webhookSubscriber = new WebhookEventSubscriber();
-    logger.info('Setting up webhook event subscriptions...');
-    webhookSubscriber.subscribe(agent.agentEventBus);
     // Register a new webhook endpoint
     app.post('/api/webhooks', express.json(), async (req, res, next) => {
         try {
@@ -988,8 +1170,8 @@ export async function initializeApi(agent, agentCardOverride, listenPort) {
     app.use(errorHandler);
     return { app, server, wss, webSubscriber, webhookSubscriber };
 }
-export async function startApiServer(agent, port = 3000, agentCardOverride) {
-    const { server, wss, webSubscriber, webhookSubscriber } = await initializeApi(agent, agentCardOverride, port);
+export async function startApiServer(agent, port = 3000, agentCardOverride, agentName) {
+    const { server, wss, webSubscriber, webhookSubscriber } = await initializeApi(agent, agentCardOverride, port, agentName);
     // API server for REST endpoints and WebSocket connections
     server.listen(port, '0.0.0.0', () => {
         const networkInterfaces = os.networkInterfaces();

package/dist/api/webhook-subscriber.d.ts

@@ -41,6 +41,10 @@ export declare class WebhookEventSubscriber implements EventSubscriber {
      * Clean up event listeners and resources
      */
     cleanup(): void;
+    /**
+     * Unsubscribe from current event bus without clearing registered webhooks
+     */
+    unsubscribe(): void;
     /**
      * Deliver an event to all registered webhooks
      */

package/dist/api/webhook-subscriber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhook-subscriber.d.ts","sourceRoot":"","sources":["../../src/api/webhook-subscriber.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAmD,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EACH,KAAK,aAAa,EAElB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC9B,MAAM,oBAAoB,CAAC;AAW5B;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAC1D,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,OAAO,CAA0B;gBAE7B,EACR,OAAO,EACP,GAAG,eAAe,EACrB,GAAE,sBAAsB,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;KAAO;IAOtE;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IA0CxC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAKxC;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAUzC;;OAEG;IACH,WAAW,IAAI,aAAa,EAAE;IAI9B;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIxD;;OAEG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAoBpE;;OAEG;IACH,OAAO,IAAI,IAAI;IAUf;;OAEG;YACW,YAAY;IA+C1B;;OAEG;YACW,gBAAgB;IAoD9B;;OAEG;YACW,kBAAkB;IA+DhC;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAK5B"}
+{"version":3,"file":"webhook-subscriber.d.ts","sourceRoot":"","sources":["../../src/api/webhook-subscriber.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAmD,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EACH,KAAK,aAAa,EAElB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC9B,MAAM,oBAAoB,CAAC;AAW5B;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAC1D,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,OAAO,CAA0B;gBAE7B,EACR,OAAO,EACP,GAAG,eAAe,EACrB,GAAE,sBAAsB,GAAG;QAAE,OAAO,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;KAAO;IAOtE;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IA0CxC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAKxC;;OAEG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAUzC;;OAEG;IACH,WAAW,IAAI,aAAa,EAAE;IAI9B;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIxD;;OAEG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAoBpE;;OAEG;IACH,OAAO,IAAI,IAAI;IAUf;;OAEG;IACH,WAAW,IAAI,IAAI;IAYnB;;OAEG;YACW,YAAY;IA+C1B;;OAEG;YACW,gBAAgB;IAoD9B;;OAEG;YACW,kBAAkB;IA+DhC;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAK5B"}

package/dist/api/webhook-subscriber.js

@@ -122,6 +122,21 @@ export class WebhookEventSubscriber {
         this.webhooks.clear();
         logger.debug('Webhook event subscriber cleaned up');
     }
+    /**
+     * Unsubscribe from current event bus without clearing registered webhooks
+     */
+    unsubscribe() {
+        if (this.abortController) {
+            const controller = this.abortController;
+            delete this.abortController;
+            try {
+                controller.abort();
+            }
+            catch (error) {
+                logger.debug('Error aborting controller during unsubscribe:', error);
+            }
+        }
+    }
     /**
      * Deliver an event to all registered webhooks
      */

package/dist/api/websocket-subscriber.d.ts

@@ -17,6 +17,11 @@ export declare class WebSocketEventSubscriber implements EventSubscriber {
      * Clean up event listeners and resources
      */
     cleanup(): void;
+    /**
+     * Unsubscribe from current event bus without closing WebSocket clients.
+     * Useful when switching the active agent and re-subscribing to a new bus.
+     */
+    unsubscribe(): void;
     private broadcast;
 }
 //# sourceMappingURL=websocket-subscriber.d.ts.map

package/dist/api/websocket-subscriber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-subscriber.d.ts","sourceRoot":"","sources":["../../src/api/websocket-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAa,MAAM,IAAI,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C;;GAEG;AACH,qBAAa,wBAAyB,YAAW,eAAe;IAIhD,OAAO,CAAC,GAAG;IAHvB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,eAAe,CAAC,CAAkB;gBAEtB,GAAG,EAAE,eAAe;IAmBxC;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAyKxC;;OAEG;IACH,OAAO,IAAI,IAAI;IAiBf,OAAO,CAAC,SAAS;CAUpB"}
+{"version":3,"file":"websocket-subscriber.d.ts","sourceRoot":"","sources":["../../src/api/websocket-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAa,MAAM,IAAI,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C;;GAEG;AACH,qBAAa,wBAAyB,YAAW,eAAe;IAIhD,OAAO,CAAC,GAAG;IAHvB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,eAAe,CAAC,CAAkB;gBAEtB,GAAG,EAAE,eAAe;IAmBxC;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAyKxC;;OAEG;IACH,OAAO,IAAI,IAAI;IAiBf;;;OAGG;IACH,WAAW,IAAI,IAAI;IAYnB,OAAO,CAAC,SAAS;CAUpB"}

package/dist/api/websocket-subscriber.js

@@ -159,6 +159,22 @@ export class WebSocketEventSubscriber {
         this.connections.clear();
         logger.debug('WebSocket event subscriber cleaned up');
     }
+    /**
+     * Unsubscribe from current event bus without closing WebSocket clients.
+     * Useful when switching the active agent and re-subscribing to a new bus.
+     */
+    unsubscribe() {
+        if (this.abortController) {
+            const controller = this.abortController;
+            delete this.abortController;
+            try {
+                controller.abort();
+            }
+            catch (error) {
+                logger.debug('Error aborting controller during unsubscribe:', error);
+            }
+        }
+    }
     broadcast(message) {
         const messageString = JSON.stringify(message);
         for (const client of this.connections) {