@hotmeshio/long-tail 0.1.4 → 0.1.5

package/build/start/workers.d.ts

@@ -1,4 +1,3 @@
-import { Client as Postgres } from 'pg';
 import type { LTStartConfig } from '../types/startup';
 type WorkerEntry = {
     taskQueue: string;
@@ -8,7 +7,7 @@ type WorkerEntry = {
  * Build the connection descriptor used by HotMesh / Durable.
  */
 export declare function buildConnection(): {
-    class: typeof Postgres;
+    class: typeof import("pg").Client;
     options: {
         host: string;
         port: number;

package/build/start/workers.js

@@ -36,24 +36,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildConnection = buildConnection;
 exports.collectWorkers = collectWorkers;
 exports.startWorkers = startWorkers;
-const pg_1 = require("pg");
 const hotmesh_1 = require("@hotmeshio/hotmesh");
-const config_1 = require("../modules/config");
+const db_1 = require("../lib/db");
 const interceptor_1 = require("../services/interceptor");
 const registry_1 = require("../services/workers/registry");
-const logger_1 = require("../services/logger");
-const telemetry_1 = require("../services/telemetry");
-const events_1 = require("../services/events");
+const logger_1 = require("../lib/logger");
+const telemetry_1 = require("../lib/telemetry");
+const events_1 = require("../lib/events");
 const maintenance_1 = require("../services/maintenance");
 const cron_1 = require("../services/cron");
 const mcp_1 = require("../services/mcp");
 const yamlWorkflowWorkers = __importStar(require("../services/yaml-workflow/workers"));
-const migrate_1 = require("../services/db/migrate");
+const migrate_1 = require("../lib/db/migrate");
 /**
  * Build the connection descriptor used by HotMesh / Durable.
  */
 function buildConnection() {
-    return { class: pg_1.Client, options: config_1.postgres_options };
+    return (0, db_1.getConnection)();
 }
 /**
  * Collect all workers: system, optional examples, and user-provided.
@@ -92,10 +91,12 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
         });
         // Start each worker
         for (const w of workers) {
+            const label = `${w.taskQueue}::${w.workflow.name}`;
             const worker = await hotmesh_1.Durable.Worker.create({
                 connection,
                 taskQueue: w.taskQueue,
                 workflow: w.workflow,
+                guid: `${label}-${hotmesh_1.Durable.guid()}`,
             });
             await worker.run();
             (0, registry_1.registerWorker)(w.workflow.name, w.taskQueue);

package/build/system/activities/claude-code.js

@@ -37,7 +37,7 @@ exports.executeTask = executeTask;
 exports.checkAvailability = checkAvailability;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /** Maximum execution time for a Claude Code task (5 minutes) */
 const MAX_TIMEOUT_MS = 300_000;

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

@@ -38,7 +38,7 @@ exports.readFile = readFile;
 exports.listFiles = listFiles;
 exports.deleteFile = deleteFile;
 const path = __importStar(require("path"));
-const storage_1 = require("../../services/storage");
+const storage_1 = require("../../lib/storage");
 const MIME_MAP = {
     '.json': 'application/json', '.txt': 'text/plain', '.html': 'text/html',
     '.csv': 'text/csv', '.xml': 'application/xml', '.png': 'image/png',

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

@@ -0,0 +1,58 @@
+export declare function storeKnowledge(args: {
+    domain: string;
+    key: string;
+    data: Record<string, any>;
+    tags?: string[];
+}): Promise<{
+    id: string;
+    domain: string;
+    key: string;
+    created: boolean;
+    updated_at: string;
+}>;
+export declare function getKnowledge(args: {
+    domain: string;
+    key: string;
+}): Promise<Record<string, any>>;
+export declare function searchKnowledge(args: {
+    domain: string;
+    query: Record<string, any>;
+    tags?: string[];
+    limit?: number;
+}): Promise<{
+    entries: Record<string, any>[];
+    total: number;
+}>;
+export declare function listKnowledge(args: {
+    domain: string;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    entries: Record<string, any>[];
+    total: number;
+}>;
+export declare function deleteKnowledge(args: {
+    domain: string;
+    key: string;
+}): Promise<{
+    deleted: boolean;
+}>;
+export declare function listDomains(): Promise<{
+    domains: Array<{
+        domain: string;
+        count: number;
+        latest: string;
+    }>;
+}>;
+export declare function appendKnowledge(args: {
+    domain: string;
+    key: string;
+    path: string;
+    value: any;
+}): Promise<{
+    id: string;
+    domain: string;
+    key: string;
+    updated_at: string;
+}>;

package/build/system/activities/knowledge.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeKnowledge = storeKnowledge;
+exports.getKnowledge = getKnowledge;
+exports.searchKnowledge = searchKnowledge;
+exports.listKnowledge = listKnowledge;
+exports.deleteKnowledge = deleteKnowledge;
+exports.listDomains = listDomains;
+exports.appendKnowledge = appendKnowledge;
+const db_1 = require("../../lib/db");
+const sql_1 = require("./sql");
+async function withClient(fn) {
+    const { class: PgClient, options } = (0, db_1.getConnection)();
+    const client = new PgClient(options);
+    await client.connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        await client.end();
+    }
+}
+async function storeKnowledge(args) {
+    return withClient(async (client) => {
+        const { rows } = await client.query(sql_1.UPSERT_KNOWLEDGE, [args.domain, args.key, JSON.stringify(args.data), args.tags || []]);
+        return { ...rows[0], updated_at: rows[0].updated_at.toISOString() };
+    });
+}
+async function getKnowledge(args) {
+    return withClient(async (client) => {
+        const { rows } = await client.query(sql_1.GET_KNOWLEDGE, [args.domain, args.key]);
+        if (!rows.length)
+            return { found: false, domain: args.domain, key: args.key };
+        const row = rows[0];
+        return {
+            id: row.id,
+            domain: row.domain,
+            key: row.key,
+            data: row.data,
+            tags: row.tags,
+            created_at: row.created_at.toISOString(),
+            updated_at: row.updated_at.toISOString(),
+        };
+    });
+}
+async function searchKnowledge(args) {
+    return withClient(async (client) => {
+        const limit = Math.min(args.limit || 50, 200);
+        const params = [args.domain, JSON.stringify(args.query), limit];
+        let tagClause = '';
+        if (args.tags?.length) {
+            tagClause = ' AND tags && $4';
+            params.push(args.tags);
+        }
+        const countResult = await client.query(`SELECT COUNT(*)::int AS total FROM lt_knowledge
+       WHERE domain = $1 AND data @> $2::jsonb${tagClause}`, tagClause ? [args.domain, JSON.stringify(args.query), ...(args.tags ? [args.tags] : [])]
+            : [args.domain, JSON.stringify(args.query)]);
+        const { rows } = await client.query(`SELECT id, domain, key, data, tags, created_at, updated_at
+       FROM lt_knowledge
+       WHERE domain = $1 AND data @> $2::jsonb${tagClause}
+       ORDER BY updated_at DESC LIMIT $3`, params);
+        return {
+            entries: rows.map((r) => ({
+                id: r.id, domain: r.domain, key: r.key, data: r.data, tags: r.tags,
+                created_at: r.created_at.toISOString(), updated_at: r.updated_at.toISOString(),
+            })),
+            total: countResult.rows[0].total,
+        };
+    });
+}
+async function listKnowledge(args) {
+    return withClient(async (client) => {
+        const limit = Math.min(args.limit || 50, 200);
+        const offset = args.offset || 0;
+        const params = [args.domain];
+        let tagClause = '';
+        if (args.tags?.length) {
+            tagClause = ' AND tags && $2';
+            params.push(args.tags);
+        }
+        const countResult = await client.query(`SELECT COUNT(*)::int AS total FROM lt_knowledge WHERE domain = $1${tagClause}`, params);
+        const queryParams = [...params, limit, offset];
+        const limitIdx = params.length + 1;
+        const offsetIdx = params.length + 2;
+        const { rows } = await client.query(`SELECT id, domain, key, data, tags, created_at, updated_at
+       FROM lt_knowledge WHERE domain = $1${tagClause}
+       ORDER BY updated_at DESC LIMIT $${limitIdx} OFFSET $${offsetIdx}`, queryParams);
+        return {
+            entries: rows.map((r) => ({
+                id: r.id, domain: r.domain, key: r.key, data: r.data, tags: r.tags,
+                created_at: r.created_at.toISOString(), updated_at: r.updated_at.toISOString(),
+            })),
+            total: countResult.rows[0].total,
+        };
+    });
+}
+async function deleteKnowledge(args) {
+    return withClient(async (client) => {
+        const { rowCount } = await client.query(sql_1.DELETE_KNOWLEDGE, [args.domain, args.key]);
+        return { deleted: (rowCount ?? 0) > 0 };
+    });
+}
+async function listDomains() {
+    return withClient(async (client) => {
+        const { rows } = await client.query(sql_1.LIST_DOMAINS);
+        return {
+            domains: rows.map((r) => ({
+                domain: r.domain,
+                count: r.count,
+                latest: r.latest.toISOString(),
+            })),
+        };
+    });
+}
+async function appendKnowledge(args) {
+    return withClient(async (client) => {
+        const pathParts = args.path.split('.');
+        const pathArray = pathParts;
+        const valueJson = JSON.stringify(args.value);
+        // Build the initial data object for INSERT (nested path support)
+        let initData = { [pathParts[pathParts.length - 1]]: [args.value] };
+        for (let i = pathParts.length - 2; i >= 0; i--) {
+            initData = { [pathParts[i]]: initData };
+        }
+        const { rows } = await client.query(sql_1.APPEND_KNOWLEDGE, [args.domain, args.key, JSON.stringify(initData), pathArray, valueJson]);
+        return { ...rows[0], updated_at: rows[0].updated_at.toISOString() };
+    });
+}

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

@@ -0,0 +1,9 @@
+export declare const UPSERT_KNOWLEDGE = "\n  INSERT INTO lt_knowledge (domain, key, data, tags)\n  VALUES ($1, $2, $3, $4)\n  ON CONFLICT (domain, key) DO UPDATE SET\n    data = lt_knowledge.data || EXCLUDED.data,\n    tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags))\n  RETURNING id, domain, key, (xmax = 0) AS created, updated_at";
+export declare const GET_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, created_at, updated_at\n  FROM lt_knowledge WHERE domain = $1 AND key = $2";
+export declare const SEARCH_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, created_at, updated_at\n  FROM lt_knowledge\n  WHERE domain = $1 AND data @> $2::jsonb";
+export declare const COUNT_KNOWLEDGE_SEARCH = "\n  SELECT COUNT(*)::int AS total FROM lt_knowledge\n  WHERE domain = $1 AND data @> $2::jsonb";
+export declare const LIST_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, created_at, updated_at\n  FROM lt_knowledge WHERE domain = $1";
+export declare const COUNT_KNOWLEDGE_LIST = "\n  SELECT COUNT(*)::int AS total FROM lt_knowledge WHERE domain = $1";
+export declare const DELETE_KNOWLEDGE = "\n  DELETE FROM lt_knowledge WHERE domain = $1 AND key = $2";
+export declare const LIST_DOMAINS = "\n  SELECT domain, COUNT(*)::int AS count, MAX(updated_at) AS latest\n  FROM lt_knowledge GROUP BY domain ORDER BY latest DESC";
+export declare const APPEND_KNOWLEDGE = "\n  INSERT INTO lt_knowledge (domain, key, data)\n  VALUES ($1, $2, $3::jsonb)\n  ON CONFLICT (domain, key) DO UPDATE SET\n    data = CASE\n      WHEN lt_knowledge.data #> $4::text[] IS NULL\n      THEN jsonb_set(lt_knowledge.data, $4::text[], jsonb_build_array($5::jsonb))\n      ELSE jsonb_set(lt_knowledge.data, $4::text[], (lt_knowledge.data #> $4::text[]) || jsonb_build_array($5::jsonb))\n    END\n  RETURNING id, domain, key, updated_at";

package/build/system/activities/sql.js

@@ -0,0 +1,41 @@
+"use strict";
+// ─── Knowledge CRUD ─────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APPEND_KNOWLEDGE = exports.LIST_DOMAINS = exports.DELETE_KNOWLEDGE = exports.COUNT_KNOWLEDGE_LIST = exports.LIST_KNOWLEDGE = exports.COUNT_KNOWLEDGE_SEARCH = exports.SEARCH_KNOWLEDGE = exports.GET_KNOWLEDGE = exports.UPSERT_KNOWLEDGE = void 0;
+exports.UPSERT_KNOWLEDGE = `
+  INSERT INTO lt_knowledge (domain, key, data, tags)
+  VALUES ($1, $2, $3, $4)
+  ON CONFLICT (domain, key) DO UPDATE SET
+    data = lt_knowledge.data || EXCLUDED.data,
+    tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags))
+  RETURNING id, domain, key, (xmax = 0) AS created, updated_at`;
+exports.GET_KNOWLEDGE = `
+  SELECT id, domain, key, data, tags, created_at, updated_at
+  FROM lt_knowledge WHERE domain = $1 AND key = $2`;
+exports.SEARCH_KNOWLEDGE = `
+  SELECT id, domain, key, data, tags, created_at, updated_at
+  FROM lt_knowledge
+  WHERE domain = $1 AND data @> $2::jsonb`;
+exports.COUNT_KNOWLEDGE_SEARCH = `
+  SELECT COUNT(*)::int AS total FROM lt_knowledge
+  WHERE domain = $1 AND data @> $2::jsonb`;
+exports.LIST_KNOWLEDGE = `
+  SELECT id, domain, key, data, tags, created_at, updated_at
+  FROM lt_knowledge WHERE domain = $1`;
+exports.COUNT_KNOWLEDGE_LIST = `
+  SELECT COUNT(*)::int AS total FROM lt_knowledge WHERE domain = $1`;
+exports.DELETE_KNOWLEDGE = `
+  DELETE FROM lt_knowledge WHERE domain = $1 AND key = $2`;
+exports.LIST_DOMAINS = `
+  SELECT domain, COUNT(*)::int AS count, MAX(updated_at) AS latest
+  FROM lt_knowledge GROUP BY domain ORDER BY latest DESC`;
+exports.APPEND_KNOWLEDGE = `
+  INSERT INTO lt_knowledge (domain, key, data)
+  VALUES ($1, $2, $3::jsonb)
+  ON CONFLICT (domain, key) DO UPDATE SET
+    data = CASE
+      WHEN lt_knowledge.data #> $4::text[] IS NULL
+      THEN jsonb_set(lt_knowledge.data, $4::text[], jsonb_build_array($5::jsonb))
+      ELSE jsonb_set(lt_knowledge.data, $4::text[], (lt_knowledge.data #> $4::text[]) || jsonb_build_array($5::jsonb))
+    END
+  RETURNING id, domain, key, updated_at`;

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

@@ -37,7 +37,7 @@ exports.getUpstreamTasks = getUpstreamTasks;
 exports.getEscalationHistory = getEscalationHistory;
 exports.notifyEngineering = notifyEngineering;
 exports.getToolTags = getToolTags;
-const logger_1 = require("../../../services/logger");
+const logger_1 = require("../../../lib/logger");
 const ltconfig_1 = require("../../../modules/ltconfig");
 const taskService = __importStar(require("../../../services/task"));
 const escalationService = __importStar(require("../../../services/escalation"));

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

@@ -1,25 +1,13 @@
+import { extractWorkflowInputs } from '../../workflows/shared/discovery';
 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;
-}>;
+export { extractWorkflowInputs as extractTriageInputs };

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

@@ -1,170 +1,14 @@
 "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.extractTriageInputs = void 0;
 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 discovery_1 = require("../../workflows/shared/discovery");
+Object.defineProperty(exports, "extractTriageInputs", { enumerable: true, get: function () { return discovery_1.extractWorkflowInputs; } });
 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 };
+    return (0, discovery_1.findCompiledWorkflows)(prompt, { yamlWorkflowMap: cache_1.yamlWorkflowMap, toolDefCache: cache_1.toolDefCache }, 'mcpTriage');
 }
-// ── 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 };
-    }
+    return (0, discovery_1.evaluateWorkflowMatch)(prompt, candidates, 'mcpTriage');
 }

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

@@ -1,9 +1,2 @@
-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.
- */
+import type { LLMResponse } from '../../../services/llm';
 export declare function callTriageLLM(messages: any[], toolIds?: string[]): Promise<LLMResponse>;

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

@@ -1,34 +1,8 @@
 "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 llm_caller_1 = require("../../workflows/shared/llm-caller");
 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;
+    return (0, llm_caller_1.callWorkflowLLM)(messages, toolIds, cache_1.toolDefCache, 'mcpTriage');
 }

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

@@ -1,24 +1,8 @@
-/** Base tags always included — triage always needs DB for investigation + compiled workflows */
+/** Base tags always included — triage always needs DB + 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>;