@hotmeshio/long-tail 0.1.14 → 0.1.15

package/build/system/mcp-servers/human-queue-schemas.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const escalateSchema: z.ZodObject<{
+    role: z.ZodString;
+    message: z.ZodString;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    subtype: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    type: string;
+    message: string;
+    priority: number;
+    subtype: string;
+    data?: Record<string, any> | undefined;
+}, {
+    role: string;
+    message: string;
+    data?: Record<string, any> | undefined;
+    type?: string | undefined;
+    priority?: number | undefined;
+    subtype?: string | undefined;
+}>;
+export declare const checkResolutionSchema: z.ZodObject<{
+    escalation_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    escalation_id: string;
+}, {
+    escalation_id: string;
+}>;
+export declare const getAvailableWorkSchema: z.ZodObject<{
+    role: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    limit: number;
+}, {
+    role: string;
+    limit?: number | undefined;
+}>;
+export declare const claimAndResolveSchema: z.ZodObject<{
+    escalation_id: z.ZodString;
+    resolver_id: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    escalation_id: string;
+    resolver_id: string;
+    payload: Record<string, any>;
+}, {
+    escalation_id: string;
+    resolver_id: string;
+    payload: Record<string, any>;
+}>;
+export declare const resolveEscalationSchema: z.ZodObject<{
+    escalation_id: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    escalation_id: string;
+    payload: Record<string, any>;
+}, {
+    escalation_id: string;
+    payload: Record<string, any>;
+}>;
+export declare const escalateAndWaitSchema: z.ZodObject<{
+    role: z.ZodString;
+    message: z.ZodString;
+    form_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    assigned_to: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    subtype: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    role: z.ZodString;
+    message: z.ZodString;
+    form_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    assigned_to: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    subtype: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    role: z.ZodString;
+    message: z.ZodString;
+    form_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    assigned_to: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    subtype: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.ZodTypeAny, "passthrough">>;

package/build/system/mcp-servers/human-queue-schemas.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escalateAndWaitSchema = exports.resolveEscalationSchema = exports.claimAndResolveSchema = exports.getAvailableWorkSchema = exports.checkResolutionSchema = exports.escalateSchema = void 0;
+const zod_1 = require("zod");
+// ── Schemas (extracted to break TS2589 deep-instantiation in registerTool generics) ──
+exports.escalateSchema = zod_1.z.object({
+    role: zod_1.z.string().describe('Target role for the escalation (e.g., "reviewer")'),
+    message: zod_1.z.string().describe('Description of what needs human review'),
+    data: zod_1.z.record(zod_1.z.any()).optional().describe('Contextual data for the reviewer'),
+    type: zod_1.z.string().optional().default('mcp').describe('Escalation type classification'),
+    subtype: zod_1.z.string().optional().default('tool_call').describe('Escalation subtype'),
+    priority: zod_1.z.number().min(1).max(4).optional().default(2)
+        .describe('Priority: 1 (highest) to 4 (lowest)'),
+});
+exports.checkResolutionSchema = zod_1.z.object({
+    escalation_id: zod_1.z.string().describe('The escalation ID to check'),
+});
+exports.getAvailableWorkSchema = zod_1.z.object({
+    role: zod_1.z.string().describe('Role to filter by'),
+    limit: zod_1.z.number().optional().default(10).describe('Max results to return'),
+});
+exports.claimAndResolveSchema = zod_1.z.object({
+    escalation_id: zod_1.z.string().describe('The escalation ID to claim and resolve'),
+    resolver_id: zod_1.z.string().describe('Identifier for who/what is resolving'),
+    payload: zod_1.z.record(zod_1.z.any()).describe('Resolution payload data'),
+});
+exports.resolveEscalationSchema = zod_1.z.object({
+    escalation_id: zod_1.z.string().describe('The escalation ID to resolve'),
+    payload: zod_1.z.record(zod_1.z.any()).describe('Resolution payload data'),
+});
+exports.escalateAndWaitSchema = zod_1.z.object({
+    role: zod_1.z.string().describe('Target role for the escalation (e.g., "reviewer")'),
+    message: zod_1.z.string().describe('Description of what input is needed from the human'),
+    form_schema: zod_1.z.record(zod_1.z.any()).optional()
+        .describe('JSON Schema for the resolver form. Use format:"password" for sensitive fields.'),
+    data: zod_1.z.record(zod_1.z.any()).optional().describe('Contextual data for the reviewer'),
+    assigned_to: zod_1.z.string().optional().describe('Auto-assign to a specific user'),
+    type: zod_1.z.string().optional().default('mcp').describe('Escalation type classification'),
+    subtype: zod_1.z.string().optional().default('wait_for_human').describe('Escalation subtype'),
+    priority: zod_1.z.number().min(1).max(4).optional().default(1)
+        .describe('Priority: 1 (highest) to 4 (lowest)'),
+}).passthrough();

package/build/system/mcp-servers/human-queue.d.ts

@@ -16,11 +16,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function createHumanQueueServer(options?: {
     name?: string;
 }): Promise<McpServer>;
-/**
- * Get the current MCP server instance.
- */
+/** Get the current MCP server instance. */
 export declare function getServer(): McpServer | null;
-/**
- * Stop the MCP server and release resources.
- */
+/** Stop the MCP server and release resources. */
 export declare function stopServer(): Promise<void>;

package/build/system/mcp-servers/human-queue.js

@@ -38,48 +38,10 @@ exports.getServer = getServer;
 exports.stopServer = stopServer;
 const crypto = __importStar(require("crypto"));
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const zod_1 = require("zod");
 const logger_1 = require("../../lib/logger");
 const escalationService = __importStar(require("../../services/escalation"));
+const human_queue_schemas_1 = require("./human-queue-schemas");
 let server = null;
-// ── Schemas (extracted to break TS2589 deep-instantiation in registerTool generics) ──
-const escalateSchema = zod_1.z.object({
-    role: zod_1.z.string().describe('Target role for the escalation (e.g., "reviewer")'),
-    message: zod_1.z.string().describe('Description of what needs human review'),
-    data: zod_1.z.record(zod_1.z.any()).optional().describe('Contextual data for the reviewer'),
-    type: zod_1.z.string().optional().default('mcp').describe('Escalation type classification'),
-    subtype: zod_1.z.string().optional().default('tool_call').describe('Escalation subtype'),
-    priority: zod_1.z.number().min(1).max(4).optional().default(2)
-        .describe('Priority: 1 (highest) to 4 (lowest)'),
-});
-const checkResolutionSchema = zod_1.z.object({
-    escalation_id: zod_1.z.string().describe('The escalation ID to check'),
-});
-const getAvailableWorkSchema = zod_1.z.object({
-    role: zod_1.z.string().describe('Role to filter by'),
-    limit: zod_1.z.number().optional().default(10).describe('Max results to return'),
-});
-const claimAndResolveSchema = zod_1.z.object({
-    escalation_id: zod_1.z.string().describe('The escalation ID to claim and resolve'),
-    resolver_id: zod_1.z.string().describe('Identifier for who/what is resolving'),
-    payload: zod_1.z.record(zod_1.z.any()).describe('Resolution payload data'),
-});
-const resolveEscalationSchema = zod_1.z.object({
-    escalation_id: zod_1.z.string().describe('The escalation ID to resolve'),
-    payload: zod_1.z.record(zod_1.z.any()).describe('Resolution payload data'),
-});
-const escalateAndWaitSchema = zod_1.z.object({
-    role: zod_1.z.string().describe('Target role for the escalation (e.g., "reviewer")'),
-    message: zod_1.z.string().describe('Description of what input is needed from the human'),
-    form_schema: zod_1.z.record(zod_1.z.any()).optional()
-        .describe('JSON Schema for the resolver form. Use format:"password" for sensitive fields.'),
-    data: zod_1.z.record(zod_1.z.any()).optional().describe('Contextual data for the reviewer'),
-    assigned_to: zod_1.z.string().optional().describe('Auto-assign to a specific user'),
-    type: zod_1.z.string().optional().default('mcp').describe('Escalation type classification'),
-    subtype: zod_1.z.string().optional().default('wait_for_human').describe('Escalation subtype'),
-    priority: zod_1.z.number().min(1).max(4).optional().default(1)
-        .describe('Priority: 1 (highest) to 4 (lowest)'),
-}).passthrough();
 /**
  * Create the Long Tail Human Queue MCP server.
  *
@@ -103,7 +65,7 @@ async function createHumanQueueServer(options) {
     server.registerTool('escalate_to_human', {
         title: 'Escalate to Human',
         description: 'Create a new escalation for human review. Returns the escalation ID.',
-        inputSchema: escalateSchema,
+        inputSchema: human_queue_schemas_1.escalateSchema,
     }, async (args) => {
         const escalation = await escalationService.createEscalation({
             type: args.type || 'mcp',
@@ -130,7 +92,7 @@ async function createHumanQueueServer(options) {
     server.registerTool('check_resolution', {
         title: 'Check Escalation Resolution',
         description: 'Check the status of an escalation. Returns status and resolver payload if resolved.',
-        inputSchema: checkResolutionSchema,
+        inputSchema: human_queue_schemas_1.checkResolutionSchema,
     }, async (args) => {
         const escalation = await escalationService.getEscalation(args.escalation_id);
         if (!escalation) {
@@ -163,7 +125,7 @@ async function createHumanQueueServer(options) {
     server.registerTool('get_available_work', {
         title: 'Get Available Work',
         description: 'List available escalations for a role. Returns pending, unassigned escalations.',
-        inputSchema: getAvailableWorkSchema,
+        inputSchema: human_queue_schemas_1.getAvailableWorkSchema,
     }, async (args) => {
         const { escalations } = await escalationService.listAvailableEscalations({
             role: args.role,
@@ -189,7 +151,7 @@ async function createHumanQueueServer(options) {
     server.registerTool('claim_and_resolve', {
         title: 'Claim and Resolve',
         description: 'Claim an escalation and immediately resolve it with a payload. Atomic operation.',
-        inputSchema: claimAndResolveSchema,
+        inputSchema: human_queue_schemas_1.claimAndResolveSchema,
     }, async (args) => {
         const claimed = await escalationService.claimEscalation(args.escalation_id, args.resolver_id, 5);
         if (!claimed) {
@@ -226,7 +188,7 @@ async function createHumanQueueServer(options) {
     server.registerTool('resolve_escalation', {
         title: 'Resolve Escalation',
         description: 'Resolve an already-claimed escalation with a payload. Use when the claim happened externally (e.g. via API).',
-        inputSchema: resolveEscalationSchema,
+        inputSchema: human_queue_schemas_1.resolveEscalationSchema,
     }, async (args) => {
         const resolved = await escalationService.resolveEscalation(args.escalation_id, args.payload);
         if (!resolved) {
@@ -255,7 +217,7 @@ async function createHumanQueueServer(options) {
         description: 'Create an escalation and pause the workflow until a human responds. ' +
             'Returns a signal ID that the workflow uses to wait. ' +
             'Preferred over escalate_to_human + check_resolution polling.',
-        inputSchema: escalateAndWaitSchema,
+        inputSchema: human_queue_schemas_1.escalateAndWaitSchema,
     }, async (args) => {
         const signalId = `wait-for-human-${crypto.randomUUID()}`;
         // YAML workflows inject _yaml_signal_routing to override Durable's signalId-based routing
@@ -300,15 +262,11 @@ async function createHumanQueueServer(options) {
     logger_1.loggerRegistry.info(`[lt-mcp:server] ${name} ready (5 tools registered)`);
     return server;
 }
-/**
- * Get the current MCP server instance.
- */
+/** Get the current MCP server instance. */
 function getServer() {
     return server;
 }
-/**
- * Stop the MCP server and release resources.
- */
+/** Stop the MCP server and release resources. */
 async function stopServer() {
     if (server) {
         await server.close();

package/build/system/mcp-servers/knowledge.js

@@ -39,10 +39,10 @@ const zod_1 = require("zod");
 const logger_1 = require("../../lib/logger");
 const knowledge = __importStar(require("../activities/knowledge"));
 const storeSchema = zod_1.z.object({
-    domain: zod_1.z.string().describe('Top level of a 3-level hierarchy (domain > key > field). Groups related entries by namespace (e.g. "screenshots", "config", "analysis").'),
-    key: zod_1.z.string().describe('Second level. Unique identifier within a domain (e.g. "homepage", "user_profile"). Multiple fields accumulate under the same domain+key.'),
-    field: zod_1.z.string().optional().describe('Third level (leaf). Names a specific field within the domain+key entry (e.g. "url", "analysis", "score"). When provided, data is stored as { [field]: data } and merged into the existing entry. Calls with the same domain+key+field overwrite that field; different fields accumulate additively. Omit to pass data as a full object.'),
-    data: zod_1.z.any().describe('The value to store. When field is provided, this can be any type (string, number, boolean, object, array). When field is omitted, this must be a JSON object whose keys become the fields.'),
+    domain: zod_1.z.string().describe('Namespace grouping related entries (e.g. "screenshots", "config", "analysis").'),
+    key: zod_1.z.string().describe('Unique identifier within the domain (e.g. "google", "user_profile").'),
+    field: zod_1.z.string().optional().describe('RECOMMENDED. Names a specific field to set within the entry (e.g. "2026-05-09", "url", "score"). Using field is additive — it merges into existing data without clobbering other fields. Without field, the entire data object is merged at the top level, which can overwrite existing fields with the same keys. Always use field when adding to an entry that may already have data.'),
+    data: zod_1.z.any().describe('The value to store. When field is provided, this can be any type (string, number, boolean, object, array) and is stored as { [field]: data }. When field is omitted, data must be a JSON object whose keys merge into existing data.'),
     tags: zod_1.z.array(zod_1.z.string()).optional().describe('Categorization tags (unioned on upsert)'),
 });
 const getSchema = zod_1.z.object({
@@ -54,9 +54,11 @@ const searchSchema = zod_1.z.object({
     query: zod_1.z.record(zod_1.z.any()).describe('JSONB containment query (e.g. {"type":"screenshot"})'),
     tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (any match)'),
     limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
+    offset: zod_1.z.number().optional().describe('Pagination offset'),
 });
 const listSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
+    search: zod_1.z.string().optional().describe('Search by key name or tag (partial match)'),
     tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (any match)'),
     limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
     offset: zod_1.z.number().optional().describe('Pagination offset'),
@@ -65,6 +67,18 @@ const deleteSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
     key: zod_1.z.string().describe('Document key to delete'),
 });
+const setFieldSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key'),
+    path: zod_1.z.string().describe('Dot-notation path to the field (e.g. "google.holiday", "config.retries"). Sets the value at this exact path without overwriting sibling fields.'),
+    value: zod_1.z.any().refine((v) => v !== undefined, 'value is required').describe('Value to set — any JSON type (string, number, boolean, object, array)'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Tags to union with existing tags'),
+});
+const removeFieldSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key'),
+    path: zod_1.z.string().describe('Dot-notation path to remove (e.g. "google.legacy_data", "temp.cache")'),
+});
 const appendSchema = zod_1.z.object({
     domain: zod_1.z.string().describe('Knowledge domain'),
     key: zod_1.z.string().describe('Document key'),
@@ -74,11 +88,11 @@ const appendSchema = zod_1.z.object({
 function registerTools(server) {
     server.registerTool('store_knowledge', {
         title: 'Store Knowledge',
-        description: 'Store a value in a 3-level additive hierarchy: domain > key > field. ' +
-            'Upserts by domain+key — fields accumulate across calls. ' +
-            'If all three (domain+key+field) match, that field is overwritten. ' +
-            'When field is provided, data can be any type (string, number, etc.). ' +
-            'When field is omitted, data must be an object whose keys become the fields.',
+        description: 'Store a value in the knowledge base using a 3-level hierarchy: domain > key > field. ' +
+            'IMPORTANT: Always use the field parameter when adding data to an existing entry — ' +
+            'it merges additively without clobbering other fields. Without field, top-level keys ' +
+            'in data overwrite existing keys with the same name. ' +
+            'Example: domain="screenshots", key="google", field="2026-05-10", data="description text".',
         inputSchema: storeSchema,
     }, async (args) => {
         // When field is provided, wrap the data value as { [field]: data }
@@ -156,6 +170,26 @@ function registerTools(server) {
         const result = await knowledge.appendKnowledge(args);
         return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     });
+    server.registerTool('set_knowledge_field', {
+        title: 'Set Knowledge Field',
+        description: 'RECOMMENDED for updating existing entries. Set a value at a specific path within a knowledge entry ' +
+            'without overwriting sibling fields. Use dot-notation for nested paths (e.g. "google.holiday" sets ' +
+            'data.google.holiday while preserving data.google.description). Creates the entry if it does not exist. ' +
+            'Use this instead of store_knowledge when the entry may already have data you want to preserve.',
+        inputSchema: setFieldSchema,
+    }, async (args) => {
+        const result = await knowledge.setKnowledgeField(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('remove_knowledge_field', {
+        title: 'Remove Knowledge Field',
+        description: 'Remove a specific field from a knowledge entry by dot-path. The entry survives — only the targeted ' +
+            'path is deleted. Use this for intentional cleanup of obsolete or incorrect fields.',
+        inputSchema: removeFieldSchema,
+    }, async (args) => {
+        const result = await knowledge.removeKnowledgeField(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
 }
 async function createKnowledgeServer(options) {
     const name = options?.name || 'long-tail-knowledge';

package/build/system/mcp-servers/workflow-compiler.js

@@ -40,6 +40,7 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
 const logger_1 = require("../../lib/logger");
 const yamlGenerator = __importStar(require("../../services/yaml-workflow/generator"));
+const durable_compiler_1 = require("../../services/yaml-workflow/durable-compiler");
 const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
 const yamlDeployer = __importStar(require("../../services/yaml-workflow/deployer"));
 const yamlWorkers = __importStar(require("../../services/yaml-workflow/workers"));
@@ -65,6 +66,13 @@ const listSchema = zod_1.z.object({
     offset: zod_1.z.number().int().min(0).optional().default(0)
         .describe('Pagination offset'),
 });
+const compileDurableSchema = zod_1.z.object({
+    source: zod_1.z.string().describe('TypeScript source code of the durable workflow function (inline source, not a file path)'),
+    workflow_name: zod_1.z.string().describe('Name of the exported workflow function to compile (e.g., "assemblyLine", "basicSignal")'),
+    yaml_name: zod_1.z.string().describe('Name for the generated YAML workflow (becomes graph topic)'),
+    description: zod_1.z.string().optional().describe('Optional description of what the workflow does'),
+    app_id: zod_1.z.string().optional().describe('Target namespace (defaults to "longtail")'),
+});
 /**
  * Create the Workflow Compiler MCP server.
  *
@@ -216,6 +224,52 @@ async function createWorkflowCompilerServer(options) {
                 }],
         };
     });
+    // ── compile_durable_to_yaml ────────────────────────────────────────
+    server.registerTool('compile_durable_to_yaml', {
+        title: 'Compile Durable Workflow to YAML',
+        description: 'Convert a procedural durable TypeScript workflow (Temporal-like API) into an equivalent ' +
+            'HotMesh YAML DAG. The generated YAML runs without replay overhead and achieves the same ' +
+            'orchestration behavior. Handles proxyActivities, sleep, condition/signal, escalation, ' +
+            'startChild composition, parallel execution, and loop patterns.',
+        inputSchema: compileDurableSchema,
+    }, async (args) => {
+        const result = await (0, durable_compiler_1.compileDurableToYaml)({
+            source: args.source,
+            isFilePath: false,
+            workflowName: args.workflow_name,
+            name: args.yaml_name,
+            description: args.description,
+            appId: args.app_id,
+        });
+        const record = await yamlDb.createYamlWorkflow({
+            name: args.yaml_name,
+            description: args.description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: result.tags,
+            source_workflow_type: 'durable',
+            original_prompt: args.description,
+            category: result.category,
+            metadata: { durable_source: args.source },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        yaml_workflow_id: record.id,
+                        app_id: record.app_id,
+                        graph_topic: result.graphTopic,
+                        activity_count: result.activityManifest.filter((a) => a.type === 'worker').length,
+                        input_schema: result.inputSchema,
+                        yaml_preview: result.yaml.slice(0, 500),
+                    }),
+                }],
+        };
+    });
     logger_1.loggerRegistry.info(`[lt-mcp] workflow compiler server created: ${name}`);
     return server;
 }

package/build/system/workflows/mcp-triage/activities-proxy.d.ts

@@ -0,0 +1,21 @@
+import type { TriageResponseDeps } from './types';
+declare const getUpstreamTasks: (originId: string) => Promise<import("../../..").LTTaskRecord[]>, getEscalationHistory: (originId: string) => Promise<import("../../..").LTEscalationRecord[]>, getToolTags: (workflowType: string) => Promise<string[]>, loadTriageTools: (tags?: string[] | undefined) => Promise<{
+    toolIds: string[];
+    inventory: string;
+    strategy: string;
+}>, callTriageTool: (qualifiedName: string, args: Record<string, any>) => Promise<any>, callTriageLLM: (messages: any[], toolIds?: string[] | undefined) => Promise<import("../../../services/llm").LLMResponse>;
+declare const ltEnrichEscalationRouting: (input: {
+    escalationId: string;
+    signalRouting: {
+        taskQueue: string;
+        workflowType: string;
+        workflowId: string;
+        signalId: string;
+    };
+    taskId?: string;
+    claimForUserId?: string;
+}) => Promise<void>;
+export declare const MAX_TOOL_ROUNDS: number;
+/** Proxied activity refs passed to response handlers */
+export declare const responseDeps: TriageResponseDeps;
+export { getUpstreamTasks, getEscalationHistory, getToolTags, loadTriageTools, callTriageTool, callTriageLLM, ltEnrichEscalationRouting, };

package/build/system/workflows/mcp-triage/activities-proxy.js

@@ -0,0 +1,70 @@
+"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.ltEnrichEscalationRouting = exports.callTriageLLM = exports.callTriageTool = exports.loadTriageTools = exports.getToolTags = exports.getEscalationHistory = exports.getUpstreamTasks = exports.responseDeps = exports.MAX_TOOL_ROUNDS = void 0;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const defaults_1 = require("../../../modules/defaults");
+const activities = __importStar(require("../../activities/triage"));
+const interceptorActivities = __importStar(require("../../../services/interceptor/activities"));
+const { getUpstreamTasks, getEscalationHistory, getToolTags, loadTriageTools, callTriageTool, callTriageLLM, notifyEngineering, } = hotmesh_1.Durable.workflow.proxyActivities({
+    activities,
+    retry: {
+        maximumAttempts: 3,
+        backoffCoefficient: 2,
+        maximumInterval: '10 seconds',
+    },
+});
+exports.getUpstreamTasks = getUpstreamTasks;
+exports.getEscalationHistory = getEscalationHistory;
+exports.getToolTags = getToolTags;
+exports.loadTriageTools = loadTriageTools;
+exports.callTriageTool = callTriageTool;
+exports.callTriageLLM = callTriageLLM;
+const { ltCreateEscalation, ltCreateTask, ltGetTask, ltGetWorkflowConfig, ltStartWorkflow, ltEnrichEscalationRouting, } = hotmesh_1.Durable.workflow.proxyActivities({
+    activities: interceptorActivities,
+    taskQueue: 'lt-interceptor',
+    retry: { maximumAttempts: 3 },
+});
+exports.ltEnrichEscalationRouting = ltEnrichEscalationRouting;
+exports.MAX_TOOL_ROUNDS = defaults_1.TOOL_ROUNDS_TRIAGE;
+/** Proxied activity refs passed to response handlers */
+exports.responseDeps = {
+    ltCreateEscalation,
+    ltCreateTask,
+    ltGetTask,
+    ltGetWorkflowConfig,
+    ltStartWorkflow,
+    notifyEngineering,
+};