@hotmeshio/long-tail 0.1.0

package/build/system/activities/file-storage.js

@@ -0,0 +1,71 @@
+"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.writeFile = writeFile;
+exports.readFile = readFile;
+exports.listFiles = listFiles;
+exports.deleteFile = deleteFile;
+const path = __importStar(require("path"));
+const storage_1 = require("../../services/storage");
+const MIME_MAP = {
+    '.json': 'application/json', '.txt': 'text/plain', '.html': 'text/html',
+    '.csv': 'text/csv', '.xml': 'application/xml', '.png': 'image/png',
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.pdf': 'application/pdf', '.svg': 'image/svg+xml',
+};
+async function writeFile(args) {
+    const buffer = args.encoding === 'base64'
+        ? Buffer.from(args.content, 'base64')
+        : Buffer.from(args.content, 'utf-8');
+    return (0, storage_1.getStorageBackend)().write(args.path, buffer);
+}
+async function readFile(args) {
+    const { data, size } = await (0, storage_1.getStorageBackend)().read(args.path);
+    const ext = path.extname(args.path).toLowerCase();
+    const content = args.encoding === 'base64'
+        ? data.toString('base64')
+        : data.toString('utf-8');
+    return {
+        content,
+        size,
+        mime_type: MIME_MAP[ext] || 'application/octet-stream',
+    };
+}
+async function listFiles(args) {
+    return (0, storage_1.getStorageBackend)().list(args.directory, args.pattern);
+}
+async function deleteFile(args) {
+    return (0, storage_1.getStorageBackend)().delete(args.path);
+}

package/build/system/activities/http.d.ts

@@ -0,0 +1,27 @@
+export declare function httpRequest(args: {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeout_ms?: number;
+}): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+    elapsed_ms: number;
+}>;
+export declare function fetchJson(args: {
+    url: string;
+    headers?: Record<string, string>;
+}): Promise<{
+    data: any;
+    status: number;
+}>;
+export declare function fetchText(args: {
+    url: string;
+    headers?: Record<string, string>;
+}): Promise<{
+    text: string;
+    status: number;
+    content_type: string;
+}>;

package/build/system/activities/http.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequest = httpRequest;
+exports.fetchJson = fetchJson;
+exports.fetchText = fetchText;
+const DEFAULT_TIMEOUT = parseInt(process.env.LT_HTTP_FETCH_TIMEOUT_MS || '30000', 10);
+async function httpRequest(args) {
+    const start = Date.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), args.timeout_ms || DEFAULT_TIMEOUT);
+    try {
+        const response = await fetch(args.url, {
+            method: args.method || 'GET',
+            headers: args.headers,
+            body: args.body,
+            signal: controller.signal,
+        });
+        const body = await response.text();
+        const headers = {};
+        response.headers.forEach((value, key) => { headers[key] = value; });
+        return {
+            status: response.status,
+            headers,
+            body,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function fetchJson(args) {
+    const result = await httpRequest({
+        url: args.url,
+        method: 'GET',
+        headers: { Accept: 'application/json', ...args.headers },
+    });
+    try {
+        return { data: JSON.parse(result.body), status: result.status };
+    }
+    catch {
+        return { data: result.body, status: result.status };
+    }
+}
+async function fetchText(args) {
+    const result = await httpRequest({
+        url: args.url,
+        method: 'GET',
+        headers: args.headers,
+    });
+    return {
+        text: result.body,
+        status: result.status,
+        content_type: result.headers['content-type'] || 'text/plain',
+    };
+}

package/build/system/activities/oauth.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Get a fresh OAuth access token for an external service.
+ * Automatically refreshes expired tokens.
+ */
+export declare function getAccessToken(args: {
+    provider: string;
+    user_id: string;
+    label?: string;
+}): Promise<{
+    access_token: string;
+    expires_at: string | null;
+    scopes: string[];
+    label: string;
+}>;
+/**
+ * List a user's connected OAuth providers.
+ */
+export declare function listConnections(args: {
+    user_id: string;
+}): Promise<{
+    connections: Array<{
+        provider: string;
+        label: string;
+        email: string | null;
+        scopes: string[];
+        expires_at: string | null;
+        credential_type: string | null;
+    }>;
+}>;
+/**
+ * Revoke an OAuth connection for a user.
+ */
+export declare function revokeConnection(args: {
+    provider: string;
+    user_id: string;
+    label?: string;
+}): Promise<{
+    success: boolean;
+}>;

package/build/system/activities/oauth.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccessToken = getAccessToken;
+exports.listConnections = listConnections;
+exports.revokeConnection = revokeConnection;
+const oauth_1 = require("../../services/oauth");
+/**
+ * Get a fresh OAuth access token for an external service.
+ * Automatically refreshes expired tokens.
+ */
+async function getAccessToken(args) {
+    const token = await (0, oauth_1.getFreshAccessToken)(args.user_id, args.provider, args.label);
+    return {
+        access_token: token.accessToken,
+        expires_at: token.expiresAt?.toISOString() ?? null,
+        scopes: token.scopes,
+        label: token.label,
+    };
+}
+/**
+ * List a user's connected OAuth providers.
+ */
+async function listConnections(args) {
+    const connections = await (0, oauth_1.listOAuthConnections)(args.user_id);
+    return { connections };
+}
+/**
+ * Revoke an OAuth connection for a user.
+ */
+async function revokeConnection(args) {
+    const deleted = await (0, oauth_1.deleteOAuthConnection)(args.user_id, args.provider, args.label);
+    return { success: deleted };
+}

package/build/system/activities/triage/cache.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 */
+export declare const yamlWorkflowMap: Map<string, string>;
+/** Maps qualified tool name → full ChatCompletionTool definition */
+export declare const toolDefCache: Map<string, ToolDefinition>;

package/build/system/activities/triage/cache.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 */
+exports.yamlWorkflowMap = new Map();
+/** Maps qualified tool name → full ChatCompletionTool definition */
+exports.toolDefCache = new Map();

package/build/system/activities/triage/context.d.ts

@@ -0,0 +1,21 @@
+import type { LTTaskRecord, LTEscalationRecord } from '../../../types';
+/**
+ * Query all tasks sharing an originId.
+ * Gives the triage workflow full context of upstream work.
+ */
+export declare function getUpstreamTasks(originId: string): Promise<LTTaskRecord[]>;
+/**
+ * Query all escalations sharing an originId.
+ * Gives the triage workflow the full conversation history.
+ */
+export declare function getEscalationHistory(originId: string): Promise<LTEscalationRecord[]>;
+/**
+ * Create an escalation to the engineering team with a recommendation.
+ * Used by the triage workflow to surface long-term fixes (non-blocking).
+ */
+export declare function notifyEngineering(originId: string, description: string, metadata?: Record<string, any>): Promise<void>;
+/**
+ * Look up tool_tags for a workflow type from lt_config_workflows (cached).
+ * Returns empty array if the workflow type has no tags configured.
+ */
+export declare function getToolTags(workflowType: string): Promise<string[]>;

package/build/system/activities/triage/context.js

@@ -0,0 +1,92 @@
+"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.getUpstreamTasks = getUpstreamTasks;
+exports.getEscalationHistory = getEscalationHistory;
+exports.notifyEngineering = notifyEngineering;
+exports.getToolTags = getToolTags;
+const logger_1 = require("../../../services/logger");
+const ltconfig_1 = require("../../../modules/ltconfig");
+const taskService = __importStar(require("../../../services/task"));
+const escalationService = __importStar(require("../../../services/escalation"));
+// ── Context activities ────────────────────────────────────────
+/**
+ * Query all tasks sharing an originId.
+ * Gives the triage workflow full context of upstream work.
+ */
+async function getUpstreamTasks(originId) {
+    const { tasks } = await taskService.listTasks({
+        origin_id: originId,
+        limit: 100,
+    });
+    return tasks;
+}
+/**
+ * Query all escalations sharing an originId.
+ * Gives the triage workflow the full conversation history.
+ */
+async function getEscalationHistory(originId) {
+    return escalationService.getEscalationsByOriginId(originId);
+}
+/**
+ * Create an escalation to the engineering team with a recommendation.
+ * Used by the triage workflow to surface long-term fixes (non-blocking).
+ */
+async function notifyEngineering(originId, description, metadata) {
+    await escalationService.createEscalation({
+        type: 'triage_recommendation',
+        subtype: 'pipeline_fix',
+        description,
+        priority: 3,
+        origin_id: originId,
+        role: 'engineer',
+        envelope: JSON.stringify({}),
+        metadata: {
+            ...metadata,
+            source: 'mcp_triage',
+            auto_generated: true,
+        },
+    });
+}
+// ── Tool scoping ─────────────────────────────────────────────
+/**
+ * Look up tool_tags for a workflow type from lt_config_workflows (cached).
+ * Returns empty array if the workflow type has no tags configured.
+ */
+async function getToolTags(workflowType) {
+    const tags = await ltconfig_1.ltConfig.getToolTags(workflowType);
+    logger_1.loggerRegistry.debug(`[mcpTriage:getToolTags] ${workflowType} → [${tags.join(',')}]`);
+    return tags;
+}

package/build/system/activities/triage/discovery.d.ts

@@ -0,0 +1,25 @@
+import type { WorkflowCandidate } from '../../../types/discovery';
+/**
+ * Search for active compiled YAML workflows matching a text query.
+ * Uses PostgreSQL FTS + tag overlap for ranked matching.
+ */
+export declare function findTriageWorkflows(prompt: string): Promise<{
+    inventory: string;
+    toolIds: string[];
+    candidates: WorkflowCandidate[];
+}>;
+/**
+ * LLM-as-judge: does a compiled workflow match the triage context?
+ */
+export declare function evaluateTriageMatch(prompt: string, candidates: WorkflowCandidate[]): Promise<{
+    matched: boolean;
+    workflowName: string | null;
+    confidence: number;
+}>;
+/**
+ * Extract structured inputs from the triage context using a workflow's input schema.
+ */
+export declare function extractTriageInputs(prompt: string, inputSchema: Record<string, unknown>, workflowName: string): Promise<{
+    inputs: Record<string, any> | null;
+    extracted: boolean;
+}>;

package/build/system/activities/triage/discovery.js

@@ -0,0 +1,170 @@
+"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.findTriageWorkflows = findTriageWorkflows;
+exports.evaluateTriageMatch = evaluateTriageMatch;
+exports.extractTriageInputs = extractTriageInputs;
+const llm_1 = require("../../../services/llm");
+const defaults_1 = require("../../../modules/defaults");
+const prompts_1 = require("../../workflows/mcp-query/prompts");
+const logger_1 = require("../../../services/logger");
+const yamlDb = __importStar(require("../../../services/yaml-workflow/db"));
+const cache_1 = require("./cache");
+/**
+ * Search for active compiled YAML workflows matching a text query.
+ * Uses PostgreSQL FTS + tag overlap for ranked matching.
+ */
+async function findTriageWorkflows(prompt) {
+    logger_1.loggerRegistry.debug(`[mcpTriage:findTriageWorkflows] searching: ${prompt.slice(0, 60)}`);
+    const keywords = prompt
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !defaults_1.STOP_WORDS.has(w));
+    logger_1.loggerRegistry.debug(`[mcpTriage:findTriageWorkflows] keywords: [${keywords.join(',')}]`);
+    let workflows;
+    try {
+        workflows = await yamlDb.discoverWorkflows(prompt, keywords, undefined, 5);
+        logger_1.loggerRegistry.info(`[mcpTriage:findTriageWorkflows] ${workflows.length} candidate(s) found`);
+    }
+    catch (err) {
+        logger_1.loggerRegistry.warn(`[mcpTriage:findTriageWorkflows] discovery failed: ${err.message}`);
+        return { inventory: '', toolIds: [], candidates: [] };
+    }
+    if (workflows.length === 0) {
+        logger_1.loggerRegistry.debug(`[mcpTriage:findTriageWorkflows] no candidates found`);
+        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, '_')}`;
+        cache_1.yamlWorkflowMap.set(qualifiedName, wf.name);
+        cache_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 };
+}
+// ── Compiled workflow matching (reused by mcpTriageRouter) ────
+/**
+ * LLM-as-judge: does a compiled workflow match the triage context?
+ */
+async function evaluateTriageMatch(prompt, candidates) {
+    logger_1.loggerRegistry.debug(`[mcpTriage:evaluateTriageMatch] ${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) {
+            return { matched: true, workflowName: result.workflow_name, confidence: result.confidence };
+        }
+        return { matched: false, workflowName: null, confidence: result.confidence || 0 };
+    }
+    catch {
+        return { matched: false, workflowName: null, confidence: 0 };
+    }
+}
+/**
+ * Extract structured inputs from the triage context using a workflow's input schema.
+ */
+async function extractTriageInputs(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 };
+        }
+        delete result._extraction_failed;
+        return { inputs: result, extracted: true };
+    }
+    catch {
+        return { inputs: null, extracted: false };
+    }
+}

package/build/system/activities/triage/index.d.ts

@@ -0,0 +1,5 @@
+export { toolServerMap, yamlWorkflowMap, toolDefCache } from './cache';
+export { getUpstreamTasks, getEscalationHistory, notifyEngineering, getToolTags } from './context';
+export { findTriageWorkflows, evaluateTriageMatch, extractTriageInputs } from './discovery';
+export { BASE_TAGS, loadTriageTools, callTriageTool } from './tools';
+export { callTriageLLM } from './llm';

package/build/system/activities/triage/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callTriageLLM = exports.callTriageTool = exports.loadTriageTools = exports.BASE_TAGS = exports.extractTriageInputs = exports.evaluateTriageMatch = exports.findTriageWorkflows = exports.getToolTags = exports.notifyEngineering = exports.getEscalationHistory = exports.getUpstreamTasks = exports.toolDefCache = exports.yamlWorkflowMap = exports.toolServerMap = void 0;
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "toolServerMap", { enumerable: true, get: function () { return cache_1.toolServerMap; } });
+Object.defineProperty(exports, "yamlWorkflowMap", { enumerable: true, get: function () { return cache_1.yamlWorkflowMap; } });
+Object.defineProperty(exports, "toolDefCache", { enumerable: true, get: function () { return cache_1.toolDefCache; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "getUpstreamTasks", { enumerable: true, get: function () { return context_1.getUpstreamTasks; } });
+Object.defineProperty(exports, "getEscalationHistory", { enumerable: true, get: function () { return context_1.getEscalationHistory; } });
+Object.defineProperty(exports, "notifyEngineering", { enumerable: true, get: function () { return context_1.notifyEngineering; } });
+Object.defineProperty(exports, "getToolTags", { enumerable: true, get: function () { return context_1.getToolTags; } });
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "findTriageWorkflows", { enumerable: true, get: function () { return discovery_1.findTriageWorkflows; } });
+Object.defineProperty(exports, "evaluateTriageMatch", { enumerable: true, get: function () { return discovery_1.evaluateTriageMatch; } });
+Object.defineProperty(exports, "extractTriageInputs", { enumerable: true, get: function () { return discovery_1.extractTriageInputs; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "BASE_TAGS", { enumerable: true, get: function () { return tools_1.BASE_TAGS; } });
+Object.defineProperty(exports, "loadTriageTools", { enumerable: true, get: function () { return tools_1.loadTriageTools; } });
+Object.defineProperty(exports, "callTriageTool", { enumerable: true, get: function () { return tools_1.callTriageTool; } });
+var llm_1 = require("./llm");
+Object.defineProperty(exports, "callTriageLLM", { enumerable: true, get: function () { return llm_1.callTriageLLM; } });

package/build/system/activities/triage/llm.d.ts

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

package/build/system/activities/triage/llm.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callTriageLLM = callTriageLLM;
+const llm_1 = require("../../../services/llm");
+const defaults_1 = require("../../../modules/defaults");
+const logger_1 = require("../../../services/logger");
+const cache_1 = require("./cache");
+/**
+ * Call the LLM with messages and optional tool IDs.
+ *
+ * Uses the primary model for better tool-calling reliability.
+ * Tool IDs are resolved from the module-level toolDefCache so that only
+ * lightweight string arrays flow through the durable pipe.
+ */
+async function callTriageLLM(messages, toolIds) {
+    let tools;
+    if (toolIds?.length) {
+        tools = toolIds
+            .map((id) => cache_1.toolDefCache.get(id))
+            .filter((t) => !!t);
+    }
+    const t0 = Date.now();
+    logger_1.loggerRegistry.debug(`[mcpTriage:callLLM] ${tools?.length || 0} tools, ${messages.length} messages`);
+    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(`[mcpTriage:callLLM] ${Date.now() - t0}ms | in=${usage?.prompt_tokens} out=${usage?.completion_tokens} total=${usage?.total_tokens} | tool_calls=${response.tool_calls?.length || 0}`);
+    return response;
+}

package/build/system/activities/triage/tools.d.ts

@@ -0,0 +1,24 @@
+/** Base tags always included — triage always needs DB for investigation + compiled workflows */
+export declare const BASE_TAGS: string[];
+/**
+ * Single activity that discovers, caches, and returns a lightweight summary.
+ *
+ * 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.
+ *
+ * Includes strategy advisor section for overlapping server categories.
+ *
+ * @param tags - MCP server tags to scope by (merged with BASE_TAGS).
+ *               Pass undefined/empty to load all servers.
+ */
+export declare function loadTriageTools(tags?: string[]): Promise<{
+    toolIds: string[];
+    inventory: string;
+    strategy: string;
+}>;
+/**
+ * Call any tool by its qualified name — handles both YAML workflows
+ * (yaml__* prefix) and raw MCP tools (server_slug__tool_name).
+ */
+export declare function callTriageTool(qualifiedName: string, args: Record<string, any>): Promise<any>;