@hailer/mcp 0.1.17 → 0.2.2

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

@@ -1,629 +0,0 @@
-"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

@@ -1,50 +0,0 @@
-/**
- * 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