@hotmeshio/long-tail 0.1.0

package/build/system/seed/tool-manifests-escalation.d.ts

@@ -0,0 +1,173 @@
+export declare const HUMAN_QUEUE_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            role: {
+                type: string;
+                description: string;
+            };
+            message: {
+                type: string;
+                description: string;
+            };
+            data: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            subtype: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            priority: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            escalation_id?: undefined;
+            limit?: undefined;
+            resolver_id?: undefined;
+            payload?: undefined;
+            form_schema?: undefined;
+            assigned_to?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            escalation_id: {
+                type: string;
+                description: string;
+            };
+            role?: undefined;
+            message?: undefined;
+            data?: undefined;
+            type?: undefined;
+            subtype?: undefined;
+            priority?: undefined;
+            limit?: undefined;
+            resolver_id?: undefined;
+            payload?: undefined;
+            form_schema?: undefined;
+            assigned_to?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            role: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            message?: undefined;
+            data?: undefined;
+            type?: undefined;
+            subtype?: undefined;
+            priority?: undefined;
+            escalation_id?: undefined;
+            resolver_id?: undefined;
+            payload?: undefined;
+            form_schema?: undefined;
+            assigned_to?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            escalation_id: {
+                type: string;
+                description: string;
+            };
+            resolver_id: {
+                type: string;
+                description: string;
+            };
+            payload: {
+                type: string;
+                description: string;
+            };
+            role?: undefined;
+            message?: undefined;
+            data?: undefined;
+            type?: undefined;
+            subtype?: undefined;
+            priority?: undefined;
+            limit?: undefined;
+            form_schema?: undefined;
+            assigned_to?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            role: {
+                type: string;
+                description: string;
+            };
+            message: {
+                type: string;
+                description: string;
+            };
+            form_schema: {
+                type: string;
+                description: string;
+            };
+            data: {
+                type: string;
+                description: string;
+            };
+            assigned_to: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            subtype: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            priority: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            escalation_id?: undefined;
+            limit?: undefined;
+            resolver_id?: undefined;
+            payload?: undefined;
+        };
+        required: string[];
+    };
+})[];

package/build/system/seed/tool-manifests-escalation.js

@@ -0,0 +1,76 @@
+"use strict";
+// ── Escalation tool manifests ────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUMAN_QUEUE_TOOLS = void 0;
+exports.HUMAN_QUEUE_TOOLS = [
+    {
+        name: 'escalate_to_human',
+        description: 'Create a new escalation for human review. Returns the escalation ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', description: 'Target role for the escalation (e.g., "reviewer")' },
+                message: { type: 'string', description: 'Description of what needs human review' },
+                data: { type: 'object', description: 'Contextual data for the reviewer' },
+                type: { type: 'string', description: 'Escalation type classification', default: 'mcp' },
+                subtype: { type: 'string', description: 'Escalation subtype', default: 'tool_call' },
+                priority: { type: 'number', description: 'Priority: 1 (highest) to 4 (lowest)', default: 2 },
+            },
+            required: ['role', 'message'],
+        },
+    },
+    {
+        name: 'check_resolution',
+        description: 'Check the status of an escalation. Returns status and resolver payload if resolved.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                escalation_id: { type: 'string', description: 'The escalation ID to check' },
+            },
+            required: ['escalation_id'],
+        },
+    },
+    {
+        name: 'get_available_work',
+        description: 'List available escalations for a role. Returns pending, unassigned escalations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', description: 'Role to filter by' },
+                limit: { type: 'number', description: 'Max results to return', default: 10 },
+            },
+            required: ['role'],
+        },
+    },
+    {
+        name: 'claim_and_resolve',
+        description: 'Claim an escalation and immediately resolve it with a payload. Atomic operation.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                escalation_id: { type: 'string', description: 'The escalation ID to claim and resolve' },
+                resolver_id: { type: 'string', description: 'Identifier for who/what is resolving' },
+                payload: { type: 'object', description: 'Resolution payload data' },
+            },
+            required: ['escalation_id', 'resolver_id', 'payload'],
+        },
+    },
+    {
+        name: 'escalate_and_wait',
+        description: 'Create an escalation and pause the workflow until a human responds. Returns a signal ID that the workflow uses to wait durably. Preferred over escalate_to_human + check_resolution polling.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', description: 'Target role for the escalation (e.g., "reviewer")' },
+                message: { type: 'string', description: 'Description of what input is needed from the human' },
+                form_schema: { type: 'object', description: 'JSON Schema for the resolver form. Use format:"password" for sensitive fields.' },
+                data: { type: 'object', description: 'Contextual data for the reviewer' },
+                assigned_to: { type: 'string', description: 'Auto-assign to a specific user' },
+                type: { type: 'string', description: 'Escalation type classification', default: 'mcp' },
+                subtype: { type: 'string', description: 'Escalation subtype', default: 'wait_for_human' },
+                priority: { type: 'number', description: 'Priority: 1 (highest) to 4 (lowest)', default: 1 },
+            },
+            required: ['role', 'message'],
+        },
+    },
+];

package/build/system/seed/tool-manifests-workflows.d.ts

@@ -0,0 +1,211 @@
+export declare const MCP_WORKFLOW_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                description: string;
+            };
+            workflow_name?: undefined;
+            input?: undefined;
+            async?: undefined;
+            timeout?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workflow_name: {
+                type: string;
+                description: string;
+            };
+            status?: undefined;
+            input?: undefined;
+            async?: undefined;
+            timeout?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workflow_name: {
+                type: string;
+                description: string;
+            };
+            input: {
+                type: string;
+                description: string;
+            };
+            async: {
+                type: string;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+            status?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare const WORKFLOW_COMPILER_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workflow_id: {
+                type: string;
+                description: string;
+            };
+            task_queue: {
+                type: string;
+                description: string;
+            };
+            workflow_name: {
+                type: string;
+                description: string;
+            };
+            yaml_name: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            yaml_workflow_id?: undefined;
+            activate?: undefined;
+            status?: undefined;
+            limit?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            yaml_workflow_id: {
+                type: string;
+                description: string;
+            };
+            activate: {
+                type: string;
+                description: string;
+            };
+            workflow_id?: undefined;
+            task_queue?: undefined;
+            workflow_name?: undefined;
+            yaml_name?: undefined;
+            description?: undefined;
+            status?: undefined;
+            limit?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            workflow_id?: undefined;
+            task_queue?: undefined;
+            workflow_name?: undefined;
+            yaml_name?: undefined;
+            description?: undefined;
+            yaml_workflow_id?: undefined;
+            activate?: undefined;
+        };
+        required?: undefined;
+    };
+})[];
+export declare const CLAUDE_CODE_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            prompt: {
+                type: string;
+                description: string;
+            };
+            working_directory: {
+                type: string;
+                description: string;
+            };
+            allowed_tools: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            max_turns: {
+                type: string;
+                description: string;
+            };
+            model: {
+                type: string;
+                description: string;
+            };
+            system_prompt: {
+                type: string;
+                description: string;
+            };
+            timeout_ms: {
+                type: string;
+                description: string;
+            };
+            credential_label: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            prompt?: undefined;
+            working_directory?: undefined;
+            allowed_tools?: undefined;
+            max_turns?: undefined;
+            model?: undefined;
+            system_prompt?: undefined;
+            timeout_ms?: undefined;
+            credential_label?: undefined;
+        };
+        required?: undefined;
+    };
+})[];

package/build/system/seed/tool-manifests-workflows.js

@@ -0,0 +1,136 @@
+"use strict";
+// ── Workflow and compiler tool manifests ─────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_CODE_TOOLS = exports.WORKFLOW_COMPILER_TOOLS = exports.MCP_WORKFLOW_TOOLS = void 0;
+exports.MCP_WORKFLOW_TOOLS = [
+    {
+        name: 'list_workflows',
+        description: 'List available compiled YAML workflows. These are deterministic pipelines converted from successful MCP triage executions. Each workflow represents a proven solution to a specific edge case. Defaults to listing active (invocable) workflows.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', description: 'Filter by lifecycle status (default: "active")' },
+            },
+        },
+    },
+    {
+        name: 'get_workflow',
+        description: 'Inspect a compiled workflow by name. Returns the activity manifest, input/output schemas, and provenance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflow_name: { type: 'string', description: 'Name of the workflow to inspect' },
+            },
+            required: ['workflow_name'],
+        },
+    },
+    {
+        name: 'invoke_workflow',
+        description: 'Run a compiled YAML workflow by name. Deterministic — no LLM reasoning, just direct tool-to-tool data piping. Use list_workflows to discover available workflows and their input schemas. Set async=true for fire-and-forget.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflow_name: { type: 'string', description: 'Name of the compiled workflow to invoke' },
+                input: { type: 'object', description: 'Input data matching the workflow input schema' },
+                async: { type: 'boolean', description: 'If true, fire-and-forget (returns job ID)' },
+                timeout: { type: 'number', description: 'Max ms to wait for result (sync mode only)' },
+            },
+            required: ['workflow_name'],
+        },
+    },
+];
+exports.WORKFLOW_COMPILER_TOOLS = [
+    {
+        name: 'convert_execution_to_yaml',
+        description: 'Analyze a completed workflow execution and convert its tool call sequence into a deterministic HotMesh YAML workflow. Extracts tool call pairs and replaces LLM reasoning with direct tool-to-tool data piping. The generated YAML is stored as a draft that can be deployed and activated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workflow_id: { type: 'string', description: 'The workflow execution ID to analyze' },
+                task_queue: { type: 'string', description: 'HotMesh task queue' },
+                workflow_name: { type: 'string', description: 'Workflow name' },
+                yaml_name: { type: 'string', description: 'Name for the generated YAML workflow' },
+                description: { type: 'string', description: 'Optional description' },
+            },
+            required: ['workflow_id', 'task_queue', 'workflow_name', 'yaml_name'],
+        },
+    },
+    {
+        name: 'deploy_yaml_workflow',
+        description: 'Deploy a stored YAML workflow to HotMesh. Optionally activate it immediately and register workers so it can receive invocations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                yaml_workflow_id: { type: 'string', description: 'UUID of the stored YAML workflow' },
+                activate: { type: 'boolean', description: 'Whether to activate immediately after deployment' },
+            },
+            required: ['yaml_workflow_id'],
+        },
+    },
+    {
+        name: 'list_yaml_workflows',
+        description: 'List stored YAML workflows with optional status filter.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', description: 'Filter by status (draft, deployed, active, archived)' },
+                limit: { type: 'integer', description: 'Maximum results (default: 25)' },
+                offset: { type: 'integer', description: 'Pagination offset' },
+            },
+        },
+    },
+];
+exports.CLAUDE_CODE_TOOLS = [
+    {
+        name: 'execute_task',
+        description: 'Run a task using Claude Code CLI. Claude Code is an agentic coding assistant with terminal access, ' +
+            'file I/O, code search, and editing. Returns structured output with result text, cost, and duration.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                prompt: {
+                    type: 'string',
+                    description: 'The task prompt. Be specific and actionable.',
+                },
+                working_directory: {
+                    type: 'string',
+                    description: 'Working directory for the task. Defaults to server cwd.',
+                },
+                allowed_tools: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Restrict which tools Claude Code can use (e.g., ["Read", "Grep"]).',
+                },
+                max_turns: {
+                    type: 'number',
+                    description: 'Maximum agentic turns before stopping.',
+                },
+                model: {
+                    type: 'string',
+                    description: 'Override the Claude model (e.g., "claude-sonnet-4-6").',
+                },
+                system_prompt: {
+                    type: 'string',
+                    description: 'Additional system prompt to append.',
+                },
+                timeout_ms: {
+                    type: 'number',
+                    description: 'Execution timeout in ms. Default: 120000, max: 300000.',
+                },
+                credential_label: {
+                    type: 'string',
+                    description: 'Label of the stored Anthropic credential to use (e.g., "subscription", "api-batch"). Default: "default".',
+                },
+            },
+            required: ['prompt'],
+        },
+    },
+    {
+        name: 'check_availability',
+        description: 'Check if Claude Code CLI is installed and an API key is available. Returns version and readiness status.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+];

package/build/system/workflows/mcp-deterministic/activities.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Invoke a compiled YAML workflow by name with explicit inputs.
+ * The YAML workflow's stored tool_arguments provide defaults;
+ * the provided inputs override them.
+ */
+export declare function invokeCompiledWorkflow(workflowName: string, inputs: Record<string, any>): Promise<any>;

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

@@ -0,0 +1,56 @@
+"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.invokeCompiledWorkflow = invokeCompiledWorkflow;
+const yamlDb = __importStar(require("../../../services/yaml-workflow/db"));
+const yamlDeployer = __importStar(require("../../../services/yaml-workflow/deployer"));
+/**
+ * Invoke a compiled YAML workflow by name with explicit inputs.
+ * The YAML workflow's stored tool_arguments provide defaults;
+ * the provided inputs override them.
+ */
+async function invokeCompiledWorkflow(workflowName, inputs) {
+    const wf = await yamlDb.getYamlWorkflowByName(workflowName);
+    if (!wf || wf.status !== 'active') {
+        return { error: `Compiled workflow "${workflowName}" is not active` };
+    }
+    try {
+        const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, inputs, undefined, wf.graph_topic);
+        return { job_id, workflow: workflowName, status: 'completed', result };
+    }
+    catch (err) {
+        return { error: err.message, workflow: workflowName, args: inputs };
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { LTEnvelope, LTReturn } from '../../../types';
+/**
+ * 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.
+ */
+export declare function mcpDeterministic(envelope: LTEnvelope): Promise<LTReturn>;