@hailer/mcp 0.1.15 → 0.1.16

package/dist/agents/shared/services/agent-registry.js

@@ -0,0 +1,629 @@
+"use strict";
+/**
+ * Agent Registry Service
+ *
+ * Handles registration of agents in Hailer workspace workflows:
+ * - Agent Directory: Main registry of all bots
+ * - Positions: Job descriptions/roles
+ * - Teams: Groups of agents
+ * - Tool Registry: MCP server configurations
+ * - MCP Config: Per-agent MCP configuration
+ *
+ * WORKSPACE ISOLATION: Uses WorkspaceSchemaCacheService for dynamic ID lookup.
+ * Never relies on hardcoded IDs - each workspace has its own workflow IDs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRegistryService = void 0;
+const config_1 = require("../../../config");
+class AgentRegistryService {
+    schemaCache;
+    logger;
+    callMcpTool;
+    getDefaultTeamId;
+    agentDirectoryId = null;
+    positionId = null;
+    teamId = null;
+    toolRegistryId = null;
+    mcpConfigId = null;
+    constructor(schemaCache, logger, callMcpTool, getDefaultTeamId) {
+        this.schemaCache = schemaCache;
+        this.logger = logger;
+        this.callMcpTool = callMcpTool;
+        this.getDefaultTeamId = getDefaultTeamId;
+    }
+    /**
+     * Load registration data - always returns false to force fresh Hailer lookup
+     * Kept for API compatibility with base.ts
+     */
+    async loadFromCache(_userId, _workspaceId) {
+        // Always return false - agent should query Hailer on every startup
+        // The findAgentByUserId() method in registerAllAgentData handles deduplication
+        return false;
+    }
+    /**
+     * Get agent directory ID
+     */
+    getAgentDirectoryId() {
+        return this.agentDirectoryId;
+    }
+    /**
+     * Get position ID
+     */
+    getPositionId() {
+        return this.positionId;
+    }
+    /**
+     * Get team ID
+     */
+    getTeamId() {
+        return this.teamId;
+    }
+    /**
+     * Register all agent data across all workflows
+     * Uses schemaCache for dynamic workflow ID lookup
+     */
+    async registerAllAgentData(agentInfo, positionDetails, mcpServerUrl, toolIndex, workspaceId) {
+        this.logger.info("Starting full agent registration", { workspaceId });
+        // Verify schema cache has required workflows
+        const agentDirSchema = this.schemaCache.getAgentDirectorySchema(workspaceId);
+        if (!agentDirSchema) {
+            this.logger.warn("Agent Directory workflow not found in workspace - skipping registration", { workspaceId });
+            return;
+        }
+        try {
+            // 1. Register in Agent Directory first (required for other links)
+            await this.registerAgentInDirectory(agentInfo, workspaceId);
+            // 2. Create/find shared Team for AI agents
+            await this.registerTeam(workspaceId);
+            // 3. Register MCP server in Tool Registry (per-agent)
+            const agentName = `${agentInfo.firstName} ${agentInfo.lastName}`;
+            await this.registerToolRegistry(mcpServerUrl, toolIndex, workspaceId, agentName);
+            // 4. Create Position for this agent
+            await this.registerPosition(positionDetails, workspaceId);
+            // 5. Create MCP Config for this agent
+            await this.registerMcpConfig(agentInfo, workspaceId);
+            // 6. Update Agent Directory with Position and Team links
+            await this.linkAgentToPositionAndTeam(workspaceId);
+            this.logger.info("Full agent registration completed", {
+                workspaceId,
+                agentDirectoryId: this.agentDirectoryId,
+                positionId: this.positionId,
+                teamId: this.teamId,
+                toolRegistryId: this.toolRegistryId,
+                mcpConfigId: this.mcpConfigId,
+            });
+        }
+        catch (error) {
+            this.logger.warn("Agent registration incomplete", {
+                error: error instanceof Error ? error.message : String(error),
+                workspaceId,
+                agentDirectoryId: this.agentDirectoryId,
+            });
+        }
+    }
+    /**
+     * Register this agent in the Agent Directory
+     * Uses dynamic schema lookup for workflow/field IDs
+     */
+    async registerAgentInDirectory(agentInfo, workspaceId) {
+        const schema = this.schemaCache.getAgentDirectorySchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Skipping agent directory registration - no schema");
+            return;
+        }
+        this.logger.info("Registering agent in directory", {
+            email: (0, config_1.maskEmail)(agentInfo.email),
+            userId: agentInfo.userId,
+            workflowId: schema.workflowId,
+        });
+        try {
+            // First, try to find existing agent by hailerProfile (userId) - most reliable
+            const existingAgent = await this.findAgentByUserId(agentInfo.userId, schema);
+            if (existingAgent) {
+                this.agentDirectoryId = existingAgent._id;
+                this.logger.info("Found existing agent in directory", {
+                    agentDirectoryId: this.agentDirectoryId,
+                    name: existingAgent.name,
+                });
+                return;
+            }
+            // Create new agent entry
+            const wsTeamId = this.getDefaultTeamId();
+            // Get phase ID - try "deployed agents" first, then partial match, then first available
+            const phaseId = this.findPhaseId(schema.phases, ["deployed agents", "deployed", "active"]);
+            this.logger.info("Creating new agent in directory", {
+                firstName: agentInfo.firstName,
+                lastName: agentInfo.lastName,
+                teamId: wsTeamId,
+                phaseId,
+            });
+            // Build fields using dynamic field IDs (support multiple key variants)
+            const fields = {};
+            // firstName field
+            const firstNameFieldId = schema.fields["firstName"] || schema.fields["Etunimi"];
+            if (firstNameFieldId)
+                fields[firstNameFieldId] = agentInfo.firstName;
+            // lastName field
+            const lastNameFieldId = schema.fields["lastName"] || schema.fields["Sukunimi"];
+            if (lastNameFieldId)
+                fields[lastNameFieldId] = agentInfo.lastName;
+            // description field
+            const descFieldId = schema.fields["description"] || schema.fields["agentmemoryThatAgentUsesToFindWhatToDo"] || schema.fields["Description"];
+            if (descFieldId)
+                fields[descFieldId] = agentInfo.description;
+            // email field (key varies by template)
+            const emailFieldId = schema.fields["agentEmailInHailer"] || schema.fields["email"] || schema.fields["Email of Hailer profile"];
+            if (emailFieldId)
+                fields[emailFieldId] = agentInfo.email;
+            // hailerProfile field (user ID link)
+            const profileFieldId = schema.fields["hailerProfile"] || schema.fields["Agent Hailer profile"];
+            if (profileFieldId)
+                fields[profileFieldId] = agentInfo.userId;
+            // startDate field
+            const startDateFieldId = schema.fields["startDate"] || schema.fields["Aloituspäivämäärä"];
+            if (startDateFieldId)
+                fields[startDateFieldId] = Date.now();
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: `${agentInfo.firstName} ${agentInfo.lastName}`,
+                phaseId,
+                fields,
+            };
+            if (wsTeamId) {
+                createParams.teamId = wsTeamId;
+            }
+            const result = await this.callMcpTool("create_activity", createParams);
+            // Parse result to get the created activity ID
+            const resultText = result?.content?.[0]?.text;
+            if (resultText) {
+                this.agentDirectoryId = this.extractActivityId(resultText);
+                if (this.agentDirectoryId) {
+                    this.logger.info("Agent registered in directory", {
+                        agentDirectoryId: this.agentDirectoryId,
+                        phaseId,
+                    });
+                }
+                else {
+                    this.logger.warn("Could not extract activity ID from create response", {
+                        responsePreview: resultText.substring(0, 200),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn("Failed to register agent in directory", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Find phase ID by trying multiple names (case insensitive, partial match)
+     */
+    findPhaseId(phases, preferredNames) {
+        // Normalize phase keys for lookup
+        const normalizedPhases = Object.entries(phases).map(([name, id]) => ({
+            name: name.toLowerCase(),
+            id,
+        }));
+        // Try each preferred name in order
+        for (const preferred of preferredNames) {
+            const match = normalizedPhases.find(p => p.name.includes(preferred.toLowerCase()));
+            if (match)
+                return match.id;
+        }
+        // Fallback to first phase
+        return Object.values(phases)[0];
+    }
+    /**
+     * Find existing agent entry by hailerProfile (userId) - most reliable method
+     */
+    async findAgentByUserId(userId, schema) {
+        const hailerProfileFieldId = schema.fields["hailerProfile"] || schema.fields["Agent Hailer profile"];
+        if (!hailerProfileFieldId) {
+            this.logger.debug("No hailerProfile field in Agent Directory schema");
+            return null;
+        }
+        // Search across all phases (agent might be in any phase)
+        const phasesToSearch = Object.values(schema.phases);
+        for (const phaseId of phasesToSearch) {
+            try {
+                const result = await this.callMcpTool("list_activities", {
+                    workflowId: schema.workflowId,
+                    phaseId,
+                    fields: [hailerProfileFieldId],
+                    filters: {
+                        [hailerProfileFieldId]: {
+                            operator: "equals",
+                            value: userId,
+                        },
+                    },
+                    limit: 1,
+                });
+                const resultText = result?.content?.[0]?.text;
+                if (resultText) {
+                    const activity = this.parseFirstActivity(resultText);
+                    if (activity) {
+                        this.logger.debug("Found agent by userId", { phaseId, activityId: activity._id });
+                        return activity;
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug("Error searching phase for agent", { phaseId, error });
+            }
+        }
+        return null;
+    }
+    /**
+     * Parse first activity from list_activities response
+     */
+    parseFirstActivity(text) {
+        try {
+            // Try JSON parse first
+            const jsonMatch = text.match(/```json\s*([\s\S]*?)\s*```/) ||
+                text.match(/\[[\s\S]*?\]/);
+            if (jsonMatch) {
+                const jsonStr = jsonMatch[1] || jsonMatch[0];
+                const activities = JSON.parse(jsonStr);
+                if (Array.isArray(activities) && activities.length > 0) {
+                    return activities[0];
+                }
+            }
+        }
+        catch {
+            // Regex fallback
+            const idMatch = text.match(/"_id":\s*"([a-f0-9]{24})"/i);
+            const nameMatch = text.match(/"name":\s*"([^"]+)"/i);
+            if (idMatch) {
+                return { _id: idMatch[1], name: nameMatch?.[1] || "Unknown" };
+            }
+        }
+        return null;
+    }
+    /**
+     * Register/find shared Team for AI agents
+     */
+    async registerTeam(workspaceId) {
+        const schema = this.schemaCache.getTeamsSchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Teams workflow not found - skipping team registration");
+            return;
+        }
+        const teamName = "AI Agents";
+        const phaseId = this.findPhaseId(schema.phases, ["tiimit", "teams", "active"]);
+        const infoFieldId = schema.fields["teamInfo"] || schema.fields["info"] || schema.fields["Tiimi-info"];
+        try {
+            // Search for existing team
+            const result = await this.callMcpTool("list_activities", {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: infoFieldId ? [infoFieldId] : [],
+                search: teamName,
+                limit: 1,
+            });
+            const resultText = result?.content?.[0]?.text;
+            const existingId = this.extractActivityId(resultText);
+            if (existingId) {
+                this.teamId = existingId;
+                this.logger.info("Found existing AI Agents team", { teamId: this.teamId });
+                return;
+            }
+            // Create new team
+            const wsTeamId = this.getDefaultTeamId();
+            const fields = {};
+            if (infoFieldId) {
+                fields[infoFieldId] = "Team of AI agent bots that assist with workspace operations.";
+            }
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: teamName,
+                phaseId,
+                fields,
+            };
+            if (wsTeamId)
+                createParams.teamId = wsTeamId;
+            const createResult = await this.callMcpTool("create_activity", createParams);
+            this.teamId = this.extractActivityId(createResult?.content?.[0]?.text);
+            this.logger.info("Created AI Agents team", { teamId: this.teamId });
+        }
+        catch (error) {
+            this.logger.warn("Failed to register team", { error });
+        }
+    }
+    /**
+     * Register MCP server in Tool Registry (per-agent)
+     */
+    async registerToolRegistry(mcpServerUrl, toolIndex, workspaceId, agentName) {
+        const schema = this.schemaCache.getToolRegistrySchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Tool Registry workflow not found - skipping");
+            return;
+        }
+        // Each agent gets its own Tool Registry entry
+        const serverName = `MCP Tools - ${agentName}`;
+        const phaseId = this.findPhaseId(schema.phases, ["active", "new phase"]);
+        try {
+            // Get field IDs with fallbacks
+            const baseUrlFieldId = schema.fields["mcpBaseUrl"] || schema.fields["baseUrl"] || schema.fields["mcp_base_url"];
+            const protocolFieldId = schema.fields["protocolVersion"] || schema.fields["protocol_version"];
+            const toolRegistryFieldId = schema.fields["toolRegistry"] || schema.fields["tool_registry"];
+            // Search for existing registry entry
+            const result = await this.callMcpTool("list_activities", {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: baseUrlFieldId ? [baseUrlFieldId] : [],
+                search: serverName,
+                limit: 1,
+            });
+            const resultText = result?.content?.[0]?.text;
+            const existingId = this.extractActivityId(resultText);
+            if (existingId) {
+                this.toolRegistryId = existingId;
+                this.logger.info("Found existing Tool Registry entry", { toolRegistryId: this.toolRegistryId });
+                return;
+            }
+            // Create new tool registry entry
+            const wsTeamId = this.getDefaultTeamId();
+            const toolNames = toolIndex.map((t) => t.name).join(", ");
+            const fields = {};
+            if (baseUrlFieldId)
+                fields[baseUrlFieldId] = mcpServerUrl;
+            if (protocolFieldId)
+                fields[protocolFieldId] = "2024-11-05";
+            if (toolRegistryFieldId)
+                fields[toolRegistryFieldId] = `Available tools (${toolIndex.length}):\n${toolNames}`;
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: serverName,
+                phaseId,
+                fields,
+            };
+            if (wsTeamId)
+                createParams.teamId = wsTeamId;
+            const createResult = await this.callMcpTool("create_activity", createParams);
+            this.toolRegistryId = this.extractActivityId(createResult?.content?.[0]?.text);
+            this.logger.info("Created Tool Registry entry", { toolRegistryId: this.toolRegistryId });
+        }
+        catch (error) {
+            this.logger.warn("Failed to register tool registry", { error });
+        }
+    }
+    /**
+     * Register Position for this agent
+     */
+    async registerPosition(details, workspaceId) {
+        const schema = this.schemaCache.getPositionsSchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("Positions workflow not found - skipping");
+            return;
+        }
+        const phaseId = this.findPhaseId(schema.phases, ["positiot", "positions", "active"]);
+        // Get field IDs with fallbacks
+        const purposeFieldId = schema.fields["purpose"] || schema.fields["Purpose"];
+        const personaFieldId = schema.fields["personaTone"] || schema.fields["Persona & Tone"];
+        const capabilitiesFieldId = schema.fields["coreCapabilities"] || schema.fields["Core Capabilities"];
+        const boundariesFieldId = schema.fields["boundaries"] || schema.fields["Boundaries & Restrictions"];
+        const multiAllowedFieldId = schema.fields["multipleAllowed"] || schema.fields[">1 allowed in role"];
+        const agentCountFieldId = schema.fields["numberOfAgents"] || schema.fields["Number of agents in position"];
+        try {
+            // Search for existing position by name
+            const result = await this.callMcpTool("list_activities", {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: purposeFieldId ? [purposeFieldId] : [],
+                search: details.name,
+                limit: 1,
+            });
+            const resultText = result?.content?.[0]?.text;
+            const existingId = this.extractActivityId(resultText);
+            if (existingId) {
+                this.positionId = existingId;
+                this.logger.info("Found existing Position", { positionId: this.positionId });
+                return;
+            }
+            // Create new position
+            const wsTeamId = this.getDefaultTeamId();
+            const fields = {};
+            if (purposeFieldId)
+                fields[purposeFieldId] = details.purpose;
+            if (personaFieldId)
+                fields[personaFieldId] = details.personaTone;
+            if (capabilitiesFieldId)
+                fields[capabilitiesFieldId] = details.coreCapabilities;
+            if (boundariesFieldId)
+                fields[boundariesFieldId] = details.boundaries;
+            if (multiAllowedFieldId)
+                fields[multiAllowedFieldId] = "Yes";
+            if (agentCountFieldId)
+                fields[agentCountFieldId] = 1;
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: details.name,
+                phaseId,
+                fields,
+            };
+            if (wsTeamId)
+                createParams.teamId = wsTeamId;
+            const createResult = await this.callMcpTool("create_activity", createParams);
+            this.positionId = this.extractActivityId(createResult?.content?.[0]?.text);
+            this.logger.info("Created Position", { positionId: this.positionId });
+        }
+        catch (error) {
+            this.logger.warn("Failed to register position", { error });
+        }
+    }
+    /**
+     * Register MCP Config for this agent
+     */
+    async registerMcpConfig(agentInfo, workspaceId) {
+        if (!this.agentDirectoryId) {
+            this.logger.debug("Skipping MCP config - no agent directory ID");
+            return;
+        }
+        const schema = this.schemaCache.getMcpConfigSchema(workspaceId);
+        if (!schema) {
+            this.logger.debug("MCP Config workflow not found - skipping");
+            return;
+        }
+        const configName = `${agentInfo.firstName} ${agentInfo.lastName} Config`;
+        const phaseId = this.findPhaseId(schema.phases, ["active", "new phase"]);
+        // Get field IDs with fallbacks
+        const agentNameFieldId = schema.fields["agentName"] || schema.fields["agent_name"];
+        const agentIdFieldId = schema.fields["agentId"] || schema.fields["Agent_ID"];
+        const workspaceIdFieldId = schema.fields["workspaceId"] || schema.fields["workspace_id"];
+        const permissionsFieldId = schema.fields["permissions"] || schema.fields["Permissions"];
+        const permCreateFieldId = schema.fields["permissionCreate"] || schema.fields["Create"];
+        const permReadFieldId = schema.fields["permissionRead"] || schema.fields["Read"];
+        const permUpdateFieldId = schema.fields["permissionUpdate"] || schema.fields["Update"];
+        const permDeleteFieldId = schema.fields["permissionDelete"] || schema.fields["Delete"];
+        const accessToFieldId = schema.fields["accessTo"] || schema.fields["Access to"];
+        try {
+            // Search for existing config
+            const result = await this.callMcpTool("list_activities", {
+                workflowId: schema.workflowId,
+                phaseId,
+                fields: agentIdFieldId ? [agentIdFieldId] : [],
+                search: configName,
+                limit: 1,
+            });
+            const resultText = result?.content?.[0]?.text;
+            const existingId = this.extractActivityId(resultText);
+            if (existingId) {
+                this.mcpConfigId = existingId;
+                this.logger.info("Found existing MCP Config", { mcpConfigId: this.mcpConfigId });
+                return;
+            }
+            // Create new MCP config
+            const wsTeamId = this.getDefaultTeamId();
+            const fields = {};
+            if (agentNameFieldId)
+                fields[agentNameFieldId] = this.agentDirectoryId;
+            if (agentIdFieldId)
+                fields[agentIdFieldId] = agentInfo.userId;
+            if (workspaceIdFieldId)
+                fields[workspaceIdFieldId] = workspaceId;
+            if (permissionsFieldId)
+                fields[permissionsFieldId] = "read, write";
+            if (permCreateFieldId)
+                fields[permCreateFieldId] = 1;
+            if (permReadFieldId)
+                fields[permReadFieldId] = 1;
+            if (permUpdateFieldId)
+                fields[permUpdateFieldId] = 1;
+            if (permDeleteFieldId)
+                fields[permDeleteFieldId] = 0;
+            // Link to Tool Registry if available
+            if (this.toolRegistryId && accessToFieldId) {
+                fields[accessToFieldId] = this.toolRegistryId;
+            }
+            const createParams = {
+                workflowId: schema.workflowId,
+                name: configName,
+                phaseId,
+                fields,
+            };
+            if (wsTeamId)
+                createParams.teamId = wsTeamId;
+            const createResult = await this.callMcpTool("create_activity", createParams);
+            this.mcpConfigId = this.extractActivityId(createResult?.content?.[0]?.text);
+            this.logger.info("Created MCP Config", { mcpConfigId: this.mcpConfigId });
+        }
+        catch (error) {
+            this.logger.warn("Failed to register MCP config", { error });
+        }
+    }
+    /**
+     * Link Agent Directory entry to Position and Team
+     */
+    async linkAgentToPositionAndTeam(workspaceId) {
+        if (!this.agentDirectoryId) {
+            this.logger.debug("Skipping agent linking - no agent directory ID");
+            return;
+        }
+        const schema = this.schemaCache.getAgentDirectorySchema(workspaceId);
+        if (!schema)
+            return;
+        // Get field IDs with fallbacks
+        const positionFieldId = schema.fields["position"] || schema.fields["Työpositio"];
+        const teamFieldId = schema.fields["team"] || schema.fields["Tiimi"];
+        const updates = {};
+        if (this.positionId && positionFieldId) {
+            updates[positionFieldId] = this.positionId;
+        }
+        if (this.teamId && teamFieldId) {
+            updates[teamFieldId] = this.teamId;
+        }
+        if (Object.keys(updates).length === 0) {
+            this.logger.debug("No links to update");
+            return;
+        }
+        try {
+            await this.callMcpTool("update_activity", {
+                activityId: this.agentDirectoryId,
+                fields: updates,
+            });
+            this.logger.info("Linked agent to Position and Team", {
+                agentDirectoryId: this.agentDirectoryId,
+                positionId: this.positionId,
+                teamId: this.teamId,
+            });
+        }
+        catch (error) {
+            this.logger.warn("Failed to link agent to Position/Team", { error });
+        }
+    }
+    /**
+     * Extract activity ID from MCP tool response text
+     * Specifically looks for created activity IDs, not workflow IDs
+     */
+    extractActivityId(text) {
+        if (!text)
+            return null;
+        // Priority 1: Look for "**ID**:" pattern from create_activity single response
+        // Format: "- **ID**: 69576c7cce2c07784299e5a3"
+        const boldIdMatch = text.match(/\*\*ID\*\*:\s*([a-f0-9]{24})/i);
+        if (boldIdMatch)
+            return boldIdMatch[1];
+        // Priority 2: Look for "(ID: xxx," pattern from create_activity bulk response
+        // Format: '1. "Name" (ID: 69576c7cce2c07784299e5a3, Phase: ...)'
+        const parenIdMatch = text.match(/\(ID:\s*([a-f0-9]{24})[,)]/i);
+        if (parenIdMatch)
+            return parenIdMatch[1];
+        // Priority 3: Look in JSON arrays (list_activities response format)
+        // Use proper JSON parsing like parseFirstActivity
+        try {
+            const jsonMatch = text.match(/```json\s*([\s\S]*?)\s*```/) || text.match(/(\[[\s\S]*?\])/);
+            if (jsonMatch) {
+                const jsonStr = jsonMatch[1] || jsonMatch[0];
+                const activities = JSON.parse(jsonStr);
+                if (Array.isArray(activities) && activities.length > 0 && activities[0]._id) {
+                    return activities[0]._id;
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors - try regex fallback
+            const idMatch = text.match(/"_id":\s*"([a-f0-9]{24})"/i);
+            if (idMatch)
+                return idMatch[1];
+        }
+        // Priority 4: Look for Activity ID label (from various tool responses)
+        const activityIdMatch = text.match(/Activity ID[:\s]+`?([a-f0-9]{24})`?/i);
+        if (activityIdMatch)
+            return activityIdMatch[1];
+        // Priority 5: Look for "created_ids" array (backup format)
+        const createdIdsMatch = text.match(/"created_ids":\s*\[\s*"([a-f0-9]{24})"/i);
+        if (createdIdsMatch)
+            return createdIdsMatch[1];
+        // Priority 6: Last resort - look for backtick-wrapped IDs (but NOT after "workflow")
+        const backtickIdMatch = text.match(/`([a-f0-9]{24})`/g);
+        if (backtickIdMatch && backtickIdMatch.length > 0) {
+            // Get the last backtick-wrapped ID (more likely to be the activity, not workflow)
+            const lastId = backtickIdMatch[backtickIdMatch.length - 1].replace(/`/g, '');
+            return lastId;
+        }
+        return null;
+    }
+}
+exports.AgentRegistryService = AgentRegistryService;
+//# sourceMappingURL=agent-registry.js.map

package/dist/agents/shared/services/conversation-manager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Conversation Manager Service
+ *
+ * Manages per-discussion conversation state:
+ * - LRU cache of conversation histories
+ * - Context size management with summarization
+ * - Conversation state access
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { Logger } from "../../../lib/logger";
+/** Conversation message using Anthropic's MessageParam type */
+export type ConversationMessage = Anthropic.MessageParam;
+export declare class ConversationManager {
+    private maxConversations;
+    private maxContextMessages;
+    private anthropicClient;
+    private logger;
+    private conversationsByDiscussion;
+    constructor(maxConversations: number, maxContextMessages: number, anthropicClient: Anthropic, logger: Logger);
+    /**
+     * Get or create conversation history for a specific discussion
+     * Each discussion has its own isolated context to prevent bloat
+     * Uses LRU eviction when map exceeds maxConversations
+     */
+    getConversation(discussionId: string): ConversationMessage[];
+    /**
+     * Add a message to a conversation
+     */
+    addMessage(discussionId: string, message: ConversationMessage): void;
+    /**
+     * Manage conversation context size - summarize if too large
+     */
+    manageContextSize(discussionId: string): Promise<void>;
+    /**
+     * Get conversation state for debugging
+     */
+    getState(currentDiscussionId?: string): {
+        discussionCount: number;
+        currentMessageCount: number;
+    };
+    /**
+     * Get full conversation for a discussion (for debugging)
+     */
+    getFullConversation(discussionId?: string): ConversationMessage[];
+    /**
+     * Clear all conversations
+     */
+    clear(): void;
+}
+//# sourceMappingURL=conversation-manager.d.ts.map