@hotmeshio/long-tail 0.1.0

package/build/system/workflows/mcp-deterministic/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpDeterministic = mcpDeterministic;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const activities = __importStar(require("./activities"));
+const { invokeCompiledWorkflow } = hotmesh_1.Durable.workflow.proxyActivities({
+    activities,
+    retryPolicy: {
+        maximumAttempts: 3,
+        backoffCoefficient: 2,
+        maximumInterval: '10 seconds',
+    },
+});
+/**
+ * MCP Deterministic workflow (leaf).
+ *
+ * Invokes a matched compiled YAML workflow with explicit inputs.
+ * Called by mcpQueryRouter when a compiled workflow matches
+ * the user's prompt with high confidence.
+ */
+async function mcpDeterministic(envelope) {
+    const { workflowName, inputs, confidence } = envelope.data;
+    const result = await invokeCompiledWorkflow(workflowName, inputs);
+    return {
+        type: 'return',
+        data: {
+            title: `Executed: ${workflowName}`,
+            summary: `Matched compiled workflow with ${(confidence * 100).toFixed(0)}% confidence. Deterministic execution completed.`,
+            result,
+            tool_calls_made: 1,
+            discovery: { method: 'compiled-workflow', confidence, workflowName },
+        },
+        milestones: [
+            { name: 'mcp_query', value: 'completed' },
+            { name: 'discovery', value: 'compiled_match' },
+            { name: 'confidence', value: String(confidence) },
+        ],
+    };
+}

package/build/system/workflows/mcp-query/activities/caches.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from '../../../../services/llm';
+/** Maps qualified tool name -> MCP server name for routing calls */
+export declare const toolServerMap: Map<string, string>;
+/** Tracks which qualified names are compiled YAML workflows (not raw MCP tools) */
+export declare const yamlWorkflowMap: Map<string, string>;
+/** Maps qualified tool name -> full tool definition */
+export declare const toolDefCache: Map<string, ToolDefinition>;

package/build/system/workflows/mcp-query/activities/caches.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolDefCache = exports.yamlWorkflowMap = exports.toolServerMap = void 0;
+// ── Tool caches (module-level, persist across proxy activity calls) ──
+/** Maps qualified tool name -> MCP server name for routing calls */
+exports.toolServerMap = new Map();
+/** Tracks which qualified names are compiled YAML workflows (not raw MCP tools) */
+exports.yamlWorkflowMap = new Map();
+/** Maps qualified tool name -> full tool definition */
+exports.toolDefCache = new Map();

package/build/system/workflows/mcp-query/activities/discovery.d.ts

@@ -0,0 +1,31 @@
+import type { WorkflowCandidate } from '../../../../types/discovery';
+/**
+ * Phase 1: Ranked discovery of compiled YAML workflows.
+ *
+ * Uses PostgreSQL full-text search (tsvector) + tag overlap for
+ * multi-signal ranked matching. Returns candidates for the LLM judge.
+ */
+export declare function findCompiledWorkflows(prompt: string): Promise<{
+    inventory: string;
+    toolIds: string[];
+    candidates: WorkflowCandidate[];
+}>;
+/**
+ * Phase 2: LLM-as-judge evaluates whether any discovered workflow
+ * matches the user's intent. One cheap call (mini model, ~200 tokens)
+ * to potentially skip the entire agentic loop.
+ */
+export declare function evaluateWorkflowMatch(prompt: string, candidates: WorkflowCandidate[]): Promise<{
+    matched: boolean;
+    workflowName: string | null;
+    confidence: number;
+}>;
+/**
+ * Phase 2b: Extract structured inputs from the user's prompt using the
+ * matched workflow's input_schema. Acts as a second confirmation gate —
+ * if the LLM can't map the prompt to the schema, the match is rejected.
+ */
+export declare function extractWorkflowInputs(prompt: string, inputSchema: Record<string, unknown>, workflowName: string): Promise<{
+    inputs: Record<string, any> | null;
+    extracted: boolean;
+}>;

package/build/system/workflows/mcp-query/activities/discovery.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCompiledWorkflows = findCompiledWorkflows;
+exports.evaluateWorkflowMatch = evaluateWorkflowMatch;
+exports.extractWorkflowInputs = extractWorkflowInputs;
+const llm_1 = require("../../../../services/llm");
+const defaults_1 = require("../../../../modules/defaults");
+const logger_1 = require("../../../../services/logger");
+const yamlDb = __importStar(require("../../../../services/yaml-workflow/db"));
+const prompts_1 = require("../prompts");
+const caches_1 = require("./caches");
+/**
+ * Phase 1: Ranked discovery of compiled YAML workflows.
+ *
+ * Uses PostgreSQL full-text search (tsvector) + tag overlap for
+ * multi-signal ranked matching. Returns candidates for the LLM judge.
+ */
+async function findCompiledWorkflows(prompt) {
+    // Extract keywords for tag-overlap signal
+    const keywords = prompt
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !defaults_1.STOP_WORDS.has(w));
+    // Ranked discovery: FTS + tag overlap
+    logger_1.loggerRegistry.debug(`[mcpQuery:findCompiledWorkflows] keywords: [${keywords.join(',')}]`);
+    const workflows = await yamlDb.discoverWorkflows(prompt, keywords, undefined, 5);
+    logger_1.loggerRegistry.info(`[mcpQuery:findCompiledWorkflows] ${workflows.length} candidate(s) found`);
+    if (workflows.length === 0) {
+        return { inventory: '', toolIds: [], candidates: [] };
+    }
+    const toolIds = [];
+    const inventoryLines = [];
+    const candidates = [];
+    for (const wf of workflows) {
+        const qualifiedName = `yaml__${wf.name.replace(/[^a-zA-Z0-9]/g, '_')}`;
+        caches_1.yamlWorkflowMap.set(qualifiedName, wf.name);
+        caches_1.toolDefCache.set(qualifiedName, {
+            type: 'function',
+            function: {
+                name: qualifiedName,
+                description: `[COMPILED WORKFLOW] ${wf.description || wf.name} — deterministic, no LLM needed. ` +
+                    `Tags: ${wf.tags.join(', ')}`,
+                parameters: (wf.input_schema || { type: 'object', properties: {} }),
+            },
+        });
+        toolIds.push(qualifiedName);
+        const activityCount = wf.activity_manifest.filter((a) => a.type === 'worker').length;
+        inventoryLines.push(`★ ${wf.name} [compiled, ${activityCount} steps, tags: ${wf.tags.join(', ')}]: ${wf.description || 'deterministic workflow'}`);
+        candidates.push({
+            name: wf.name,
+            description: wf.description,
+            original_prompt: wf.original_prompt,
+            category: wf.category,
+            tags: wf.tags,
+            input_schema: wf.input_schema,
+            tool_names: wf.activity_manifest
+                .filter((a) => a.type === 'worker' && a.mcp_tool_name)
+                .map((a) => a.mcp_tool_name),
+            fts_rank: wf.fts_rank || 0,
+        });
+    }
+    return { inventory: inventoryLines.join('\n'), toolIds, candidates };
+}
+/**
+ * Phase 2: LLM-as-judge evaluates whether any discovered workflow
+ * matches the user's intent. One cheap call (mini model, ~200 tokens)
+ * to potentially skip the entire agentic loop.
+ */
+async function evaluateWorkflowMatch(prompt, candidates) {
+    logger_1.loggerRegistry.debug(`[mcpQuery:evaluateWorkflowMatch] ${candidates.length} candidate(s)`);
+    if (candidates.length === 0) {
+        return { matched: false, workflowName: null, confidence: 0 };
+    }
+    const candidateText = candidates.map((c, i) => `${i + 1}. **${c.name}** (category: ${c.category || 'general'})\n` +
+        `   Description: ${c.description || 'N/A'}\n` +
+        `   Original prompt: "${c.original_prompt || 'N/A'}"\n` +
+        `   Tools: ${c.tool_names.join(', ')}\n` +
+        `   Input: ${JSON.stringify(c.input_schema).slice(0, 300)}`).join('\n\n');
+    try {
+        const response = await (0, llm_1.callLLM)({
+            model: defaults_1.LLM_MODEL_SECONDARY,
+            max_tokens: 200,
+            temperature: 0,
+            messages: [
+                { role: 'system', content: prompts_1.WORKFLOW_MATCH_PROMPT },
+                { role: 'user', content: `## User Request\n${prompt}\n\n## Candidate Workflows\n${candidateText}` },
+            ],
+        });
+        const raw = response.content || '{}';
+        const cleaned = raw.replace(/^```(?:json)?\s*/m, '').replace(/\s*```$/m, '').trim();
+        const result = JSON.parse(cleaned);
+        if (result.match && result.confidence >= 0.7) {
+            logger_1.loggerRegistry.info(`[mcpQuery:evaluateWorkflowMatch] MATCHED: ${result.workflow_name} (confidence: ${result.confidence})`);
+            return { matched: true, workflowName: result.workflow_name, confidence: result.confidence };
+        }
+        logger_1.loggerRegistry.info(`[mcpQuery:evaluateWorkflowMatch] no match (confidence: ${result.confidence || 0})`);
+        return { matched: false, workflowName: null, confidence: result.confidence || 0 };
+    }
+    catch (err) {
+        logger_1.loggerRegistry.warn(`[mcpQuery:evaluateWorkflowMatch] error: ${err.message}`);
+        return { matched: false, workflowName: null, confidence: 0 };
+    }
+}
+/**
+ * Phase 2b: Extract structured inputs from the user's prompt using the
+ * matched workflow's input_schema. Acts as a second confirmation gate —
+ * if the LLM can't map the prompt to the schema, the match is rejected.
+ */
+async function extractWorkflowInputs(prompt, inputSchema, workflowName) {
+    try {
+        const response = await (0, llm_1.callLLM)({
+            model: defaults_1.LLM_MODEL_SECONDARY,
+            max_tokens: 500,
+            temperature: 0,
+            messages: [
+                { role: 'system', content: prompts_1.EXTRACT_INPUTS_PROMPT },
+                {
+                    role: 'user',
+                    content: `## User Request\n${prompt}\n\n` +
+                        `## Workflow: ${workflowName}\n` +
+                        `## Input Schema\n${JSON.stringify(inputSchema, null, 2)}`,
+                },
+            ],
+        });
+        const raw = response.content || '{}';
+        const cleaned = raw.replace(/^```(?:json)?\s*/m, '').replace(/\s*```$/m, '').trim();
+        const result = JSON.parse(cleaned);
+        if (result._extraction_failed) {
+            return { inputs: null, extracted: false };
+        }
+        // Remove the meta field before passing to the workflow
+        delete result._extraction_failed;
+        return { inputs: result, extracted: true };
+    }
+    catch {
+        return { inputs: null, extracted: false };
+    }
+}

package/build/system/workflows/mcp-query/activities/index.d.ts

@@ -0,0 +1,4 @@
+export { findCompiledWorkflows, evaluateWorkflowMatch, extractWorkflowInputs } from './discovery';
+export { loadTools } from './tool-loader';
+export { callMcpTool } from './tool-executor';
+export { callQueryLLM } from './llm';

package/build/system/workflows/mcp-query/activities/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callQueryLLM = exports.callMcpTool = exports.loadTools = exports.extractWorkflowInputs = exports.evaluateWorkflowMatch = exports.findCompiledWorkflows = void 0;
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "findCompiledWorkflows", { enumerable: true, get: function () { return discovery_1.findCompiledWorkflows; } });
+Object.defineProperty(exports, "evaluateWorkflowMatch", { enumerable: true, get: function () { return discovery_1.evaluateWorkflowMatch; } });
+Object.defineProperty(exports, "extractWorkflowInputs", { enumerable: true, get: function () { return discovery_1.extractWorkflowInputs; } });
+var tool_loader_1 = require("./tool-loader");
+Object.defineProperty(exports, "loadTools", { enumerable: true, get: function () { return tool_loader_1.loadTools; } });
+var tool_executor_1 = require("./tool-executor");
+Object.defineProperty(exports, "callMcpTool", { enumerable: true, get: function () { return tool_executor_1.callMcpTool; } });
+var llm_1 = require("./llm");
+Object.defineProperty(exports, "callQueryLLM", { enumerable: true, get: function () { return llm_1.callQueryLLM; } });

package/build/system/workflows/mcp-query/activities/llm.d.ts

@@ -0,0 +1,8 @@
+import { type LLMResponse } from '../../../../services/llm';
+/**
+ * Call the LLM with messages and optional tool IDs.
+ *
+ * Tool IDs are resolved from the module-level toolDefCache so that only
+ * lightweight string arrays flow through the durable pipe.
+ */
+export declare function callQueryLLM(messages: any[], toolIds?: string[]): Promise<LLMResponse>;

package/build/system/workflows/mcp-query/activities/llm.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callQueryLLM = callQueryLLM;
+const llm_1 = require("../../../../services/llm");
+const defaults_1 = require("../../../../modules/defaults");
+const logger_1 = require("../../../../services/logger");
+const caches_1 = require("./caches");
+/**
+ * Call the LLM with messages and optional tool IDs.
+ *
+ * Tool IDs are resolved from the module-level toolDefCache so that only
+ * lightweight string arrays flow through the durable pipe.
+ */
+async function callQueryLLM(messages, toolIds) {
+    // Resolve full tool definitions from module-level cache
+    let tools;
+    if (toolIds?.length) {
+        tools = toolIds
+            .map((id) => caches_1.toolDefCache.get(id))
+            .filter((t) => !!t);
+    }
+    const t0 = Date.now();
+    const response = await (0, llm_1.callLLM)({
+        model: defaults_1.LLM_MODEL_PRIMARY,
+        messages,
+        temperature: 0,
+        ...(tools?.length ? { tools } : {}),
+        ...(!tools?.length ? { max_tokens: defaults_1.LLM_MAX_TOKENS_DEFAULT } : {}),
+    });
+    const usage = response.usage;
+    logger_1.loggerRegistry.info(`[mcpQuery:callLLM] ${Date.now() - t0}ms | in=${usage?.prompt_tokens} out=${usage?.completion_tokens} total=${usage?.total_tokens}`);
+    return response;
+}

package/build/system/workflows/mcp-query/activities/tool-executor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Call any tool by its qualified name — handles both YAML workflows
+ * (yaml__* prefix) and raw MCP tools (server_slug__tool_name).
+ */
+export declare function callMcpTool(qualifiedName: string, args: Record<string, any>): Promise<any>;

package/build/system/workflows/mcp-query/activities/tool-executor.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callMcpTool = callMcpTool;
+const context_1 = require("../../../../services/iam/context");
+const ephemeral_1 = require("../../../../services/iam/ephemeral");
+const mcpClient = __importStar(require("../../../../services/mcp/client"));
+const mcpDbService = __importStar(require("../../../../services/mcp/db"));
+const yamlDb = __importStar(require("../../../../services/yaml-workflow/db"));
+const yamlDeployer = __importStar(require("../../../../services/yaml-workflow/deployer"));
+const caches_1 = require("./caches");
+/**
+ * Call any tool by its qualified name — handles both YAML workflows
+ * (yaml__* prefix) and raw MCP tools (server_slug__tool_name).
+ */
+async function callMcpTool(qualifiedName, args) {
+    // Check if this is a compiled YAML workflow
+    const yamlWorkflowName = caches_1.yamlWorkflowMap.get(qualifiedName);
+    if (yamlWorkflowName) {
+        try {
+            const wf = await yamlDb.getYamlWorkflowByName(yamlWorkflowName);
+            if (!wf || wf.status !== 'active') {
+                return { error: `Compiled workflow "${yamlWorkflowName}" is not active` };
+            }
+            // Inject _scope from the current ToolContext so YAML workers get IAM
+            const toolCtx = (0, context_1.getToolContext)();
+            const scopedArgs = toolCtx?.principal.id
+                ? {
+                    ...args,
+                    _scope: {
+                        principal: toolCtx.principal,
+                        ...(toolCtx.initiatingPrincipal ? { initiatingPrincipal: toolCtx.initiatingPrincipal } : {}),
+                        scopes: toolCtx.credentials.scopes,
+                    },
+                }
+                : args;
+            const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, scopedArgs, undefined, wf.graph_topic);
+            return { job_id, workflow: yamlWorkflowName, status: 'completed', result };
+        }
+        catch (err) {
+            return { error: err.message, tool: qualifiedName, args };
+        }
+    }
+    // Exchange ephemeral credential tokens (eph:v1:...) right before the MCP call.
+    // This is the latest possible moment — the LLM only ever sees opaque tokens.
+    args = await (0, ephemeral_1.exchangeTokensInArgs)(args);
+    // Standard MCP tool routing
+    const serverName = caches_1.toolServerMap.get(qualifiedName);
+    const separatorIdx = qualifiedName.indexOf('__');
+    const toolName = separatorIdx >= 0
+        ? qualifiedName.slice(separatorIdx + 2)
+        : qualifiedName;
+    // Build auth context from ToolContext (set by interceptor via IAM service)
+    const toolCtx = (0, context_1.getToolContext)();
+    const authContext = toolCtx?.principal.id
+        ? { userId: toolCtx.principal.id, delegationToken: toolCtx.credentials.delegationToken }
+        : undefined;
+    if (serverName) {
+        try {
+            return await mcpClient.callServerTool(serverName, toolName, args, authContext);
+        }
+        catch (err) {
+            return { error: err.message, tool: qualifiedName, args };
+        }
+    }
+    // Fallback: try the tool name directly against all connected servers
+    const { servers } = await mcpDbService.listMcpServers({ limit: 100 });
+    for (const server of servers) {
+        const manifest = server.tool_manifest || [];
+        if (manifest.some((t) => t.name === toolName)) {
+            try {
+                return await mcpClient.callServerTool(server.name, toolName, args, authContext);
+            }
+            catch (err) {
+                return { error: err.message, tool: qualifiedName, args };
+            }
+        }
+    }
+    return { error: `Unknown tool: ${qualifiedName} (no server found)`, tool: qualifiedName };
+}

package/build/system/workflows/mcp-query/activities/tool-loader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Single activity that discovers, caches, and returns lightweight tool data.
+ *
+ * Full ChatCompletionTool definitions are cached in module-level toolDefCache
+ * so they never flow through the durable pipe. Only tool IDs (qualified name
+ * strings) and a compact inventory string are returned.
+ *
+ * @param tags - MCP server tags to scope by. Pass undefined to load all servers.
+ */
+export declare function loadTools(tags?: string[]): Promise<{
+    toolIds: string[];
+    inventory: string;
+    strategy: string;
+}>;

package/build/system/workflows/mcp-query/activities/tool-loader.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTools = loadTools;
+const mcpDbService = __importStar(require("../../../../services/mcp/db"));
+const strategy_advisors_1 = require("../strategy-advisors");
+const caches_1 = require("./caches");
+/**
+ * Single activity that discovers, caches, and returns lightweight tool data.
+ *
+ * Full ChatCompletionTool definitions are cached in module-level toolDefCache
+ * so they never flow through the durable pipe. Only tool IDs (qualified name
+ * strings) and a compact inventory string are returned.
+ *
+ * @param tags - MCP server tags to scope by. Pass undefined to load all servers.
+ */
+async function loadTools(tags) {
+    let servers;
+    if (tags?.length) {
+        servers = await mcpDbService.findServersByTags(tags, 'any');
+    }
+    else {
+        const result = await mcpDbService.listMcpServers({ limit: 100 });
+        servers = result.servers;
+    }
+    const toolIds = [];
+    const inventoryLines = [];
+    const serverInfos = [];
+    for (const server of servers) {
+        const manifest = server.tool_manifest || [];
+        const slug = server.name.replace(/[^a-zA-Z0-9]/g, '_');
+        const serverTags = server.tags?.length ? server.tags.join(', ') : 'general';
+        const toolNames = [];
+        for (const t of manifest) {
+            const qualifiedName = `${slug}__${t.name}`;
+            caches_1.toolServerMap.set(qualifiedName, server.name);
+            caches_1.toolDefCache.set(qualifiedName, {
+                type: 'function',
+                function: {
+                    name: qualifiedName,
+                    description: `[${server.name}] ${t.description || ''}`,
+                    parameters: (t.inputSchema || { type: 'object', properties: {} }),
+                },
+            });
+            toolIds.push(qualifiedName);
+            toolNames.push(t.name);
+        }
+        inventoryLines.push(`• ${server.name} [${serverTags}] (${manifest.length} tools): ${toolNames.join(', ')}`);
+        serverInfos.push({
+            name: server.name,
+            description: server.description || null,
+            tags: server.tags || [],
+            metadata: server.metadata || null,
+            toolNames,
+            toolCount: manifest.length,
+            slug,
+        });
+    }
+    const strategy = (0, strategy_advisors_1.generateStrategySection)(serverInfos);
+    return { toolIds, inventory: inventoryLines.join('\n'), strategy };
+}

package/build/system/workflows/mcp-query/index.d.ts

@@ -0,0 +1,14 @@
+import type { LTEnvelope, LTReturn, LTEscalation } from '../../../types';
+/**
+ * MCP Query workflow (leaf).
+ *
+ * Dynamic MCP tool orchestration via LLM agentic loop.
+ * Discovers available MCP tools by tag and uses an LLM to
+ * fulfill arbitrary requests. This workflow ONLY handles
+ * dynamic execution — compiled workflow matching is done
+ * by the mcpQueryRouter parent.
+ *
+ * Clean execution traces from this workflow are what get
+ * compiled into deterministic YAML workflows.
+ */
+export declare function mcpQuery(envelope: LTEnvelope): Promise<LTReturn | LTEscalation>;