@hotmeshio/long-tail 0.4.18 → 0.4.20

package/build/system/mcp-servers/admin/agent-subscriptions.js

@@ -0,0 +1,78 @@
+"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.registerAgentSubscriptionTools = registerAgentSubscriptionTools;
+const api = __importStar(require("../../../api/agent-subscriptions"));
+const schemas_1 = require("./schemas");
+function registerAgentSubscriptionTools(server) {
+    // mirrors GET /api/agents/:agentId/subscriptions
+    server.registerTool('list_agent_subscriptions', {
+        title: 'List Agent Subscriptions',
+        description: 'List all event subscriptions for an agent automation.',
+        inputSchema: schemas_1.listAgentSubscriptionsSchema,
+    }, async (args) => {
+        const result = await api.listSubscriptions({ agentId: args.agent_id });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/agents/:agentId/subscriptions
+    server.registerTool('create_agent_subscription', {
+        title: 'Create Agent Subscription',
+        description: 'Create an event subscription for an agent. When events match the ' +
+            'topic pattern, the configured reaction is triggered.',
+        inputSchema: schemas_1.createAgentSubscriptionSchema,
+    }, async (args) => {
+        const { agent_id, ...body } = args;
+        const result = await api.createSubscription({ agentId: agent_id, ...body });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors DELETE /api/agents/:agentId/subscriptions/:subId
+    server.registerTool('delete_agent_subscription', {
+        title: 'Delete Agent Subscription',
+        description: 'Delete an event subscription by ID.',
+        inputSchema: schemas_1.deleteAgentSubscriptionSchema,
+    }, async (args) => {
+        const result = await api.deleteSubscription({ id: args.id });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+}

package/build/system/mcp-servers/admin/agents.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Agent automation tools — mirrors routes/agents.ts
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAgentTools(server: McpServer): void;

package/build/system/mcp-servers/admin/agents.js

@@ -0,0 +1,103 @@
+"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.registerAgentTools = registerAgentTools;
+const api = __importStar(require("../../../api/agents"));
+const schemas_1 = require("./schemas");
+function registerAgentTools(server) {
+    // mirrors GET /api/agents
+    server.registerTool('list_agents', {
+        title: 'List Agents',
+        description: 'List agent automations with optional status and knowledge domain filters. ' +
+            'Returns agents with subscription counts and topic lists.',
+        inputSchema: schemas_1.listAgentsSchema,
+    }, async (args) => {
+        const result = await api.listAgents(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/agents/:id
+    server.registerTool('get_agent', {
+        title: 'Get Agent',
+        description: 'Get a single agent automation by ID, including aggregated stats ' +
+            '(knowledge entry count, escalation count).',
+        inputSchema: schemas_1.getAgentSchema,
+    }, async (args) => {
+        const result = await api.getAgent(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/agents
+    server.registerTool('create_agent', {
+        title: 'Create Agent',
+        description: 'Create a new agent automation with identity, goals, rules, ' +
+            'optional schedules, and event subscriptions.',
+        inputSchema: schemas_1.createAgentSchema,
+    }, async (args) => {
+        const result = await api.createAgent(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors PUT /api/agents/:id
+    server.registerTool('update_agent', {
+        title: 'Update Agent',
+        description: 'Update an existing agent automation.',
+        inputSchema: schemas_1.updateAgentSchema,
+    }, async (args) => {
+        const result = await api.updateAgent(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors DELETE /api/agents/:id
+    server.registerTool('delete_agent', {
+        title: 'Delete Agent',
+        description: 'Delete an agent automation and all its subscriptions.',
+        inputSchema: schemas_1.deleteAgentSchema,
+    }, async (args) => {
+        const result = await api.deleteAgent(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+}

package/build/system/mcp-servers/admin/bot-accounts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Bot account tools — mirrors routes/bot-accounts.ts
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerBotAccountTools(server: McpServer): void;

package/build/system/mcp-servers/admin/bot-accounts.js

@@ -0,0 +1,126 @@
+"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.registerBotAccountTools = registerBotAccountTools;
+const api = __importStar(require("../../../api/bot-accounts"));
+const schemas_1 = require("./schemas");
+function registerBotAccountTools(server) {
+    // mirrors GET /api/bot-accounts
+    server.registerTool('list_bot_accounts', {
+        title: 'List Bot Accounts',
+        description: 'List all bot (service) accounts with pagination.',
+        inputSchema: schemas_1.listBotsSchema,
+    }, async (args) => {
+        const result = await api.listBots(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/bot-accounts/:id
+    server.registerTool('get_bot_account', {
+        title: 'Get Bot Account',
+        description: 'Get a single bot account by ID.',
+        inputSchema: schemas_1.getBotSchema,
+    }, async (args) => {
+        const result = await api.getBot(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/bot-accounts
+    server.registerTool('create_bot_account', {
+        title: 'Create Bot Account',
+        description: 'Create a new bot (service) account with optional roles. ' +
+            'Bot accounts can run workflows and hold API keys.',
+        inputSchema: schemas_1.createBotSchema,
+    }, async (args) => {
+        const result = await api.createBot(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors PUT /api/bot-accounts/:id
+    server.registerTool('update_bot_account', {
+        title: 'Update Bot Account',
+        description: 'Update a bot account (display name, description, status).',
+        inputSchema: schemas_1.updateBotSchema,
+    }, async (args) => {
+        const result = await api.updateBot(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors DELETE /api/bot-accounts/:id
+    server.registerTool('delete_bot_account', {
+        title: 'Delete Bot Account',
+        description: 'Delete a bot account and all its API keys.',
+        inputSchema: schemas_1.deleteBotSchema,
+    }, async (args) => {
+        const result = await api.deleteBot(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/bot-accounts/:id/api-keys
+    server.registerTool('create_bot_api_key', {
+        title: 'Create Bot API Key',
+        description: 'Generate a new API key for a bot account. Returns the raw key ' +
+            'ONCE — it cannot be retrieved again.',
+        inputSchema: schemas_1.createBotApiKeySchema,
+    }, async (args) => {
+        const result = await api.createBotKey(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors DELETE /api/bot-accounts/:id/api-keys/:keyId
+    server.registerTool('revoke_bot_api_key', {
+        title: 'Revoke Bot API Key',
+        description: 'Revoke (delete) an API key for a bot account.',
+        inputSchema: schemas_1.revokeBotKeySchema,
+    }, async (args) => {
+        const result = await api.revokeBotKey({ keyId: args.key_id });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+}

package/build/system/mcp-servers/admin/controlplane.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Control plane tools — mirrors routes/controlplane.ts
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerControlPlaneTools(server: McpServer): void;

package/build/system/mcp-servers/admin/controlplane.js

@@ -0,0 +1,107 @@
+"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.registerControlPlaneTools = registerControlPlaneTools;
+const api = __importStar(require("../../../api/controlplane"));
+const schemas_1 = require("./schemas");
+function registerControlPlaneTools(server) {
+    // mirrors GET /api/controlplane/apps
+    server.registerTool('list_apps', {
+        title: 'List Apps',
+        description: 'List available HotMesh application namespaces.',
+        inputSchema: schemas_1.listAppsSchema,
+    }, async (_args) => {
+        const result = await api.listApps();
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/controlplane/rollcall
+    server.registerTool('rollcall', {
+        title: 'Roll Call',
+        description: 'Execute a roll call — discovers all engines and workers in the mesh. ' +
+            'Returns topology of active participants.',
+        inputSchema: schemas_1.rollCallSchema,
+    }, async (args) => {
+        const result = await api.rollCall({
+            appId: args.app_id || 'durable',
+            delay: args.delay,
+        });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/controlplane/throttle
+    server.registerTool('apply_throttle', {
+        title: 'Apply Throttle',
+        description: 'Apply a throttle to the mesh. Values: -1 = pause, 0 = resume, ' +
+            '>0 = delay in ms per message.',
+        inputSchema: schemas_1.applyThrottleSchema,
+    }, async (args) => {
+        const result = await api.applyThrottle(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/controlplane/streams
+    server.registerTool('get_stream_stats', {
+        title: 'Get Stream Stats',
+        description: 'Stream processing statistics — pending count and processed volume ' +
+            'by time range.',
+        inputSchema: schemas_1.getStreamStatsSchema,
+    }, async (args) => {
+        const result = await api.getStreamStats(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/controlplane/stream-messages
+    server.registerTool('list_stream_messages', {
+        title: 'List Stream Messages',
+        description: 'Browse stream messages with pagination, filtering, and sorting. ' +
+            'Both namespace and source are required.',
+        inputSchema: schemas_1.listStreamMessagesSchema,
+    }, async (args) => {
+        const result = await api.listStreamMessages(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+}

package/build/system/mcp-servers/admin/escalations.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerEscalationTools = registerEscalationTools;
 const escalationService = __importStar(require("../../../services/escalation"));
+const escalationMetaApi = __importStar(require("../../../api/escalations/metadata"));
+const escalationBulkApi = __importStar(require("../../../api/escalations/bulk"));
 const schemas_1 = require("./schemas");
 function registerEscalationTools(server) {
     // mirrors GET /api/escalations
@@ -146,4 +148,90 @@ function registerEscalationTools(server) {
                 }],
         };
     });
+    // ── Metadata-based operations ───────────────────────────────────────────────
+    // mirrors GET /api/escalations/by-metadata
+    server.registerTool('find_by_metadata', {
+        title: 'Find by Metadata',
+        description: 'Find escalations by a metadata key-value pair.',
+        inputSchema: schemas_1.findByMetadataSchema,
+    }, async (args) => {
+        const result = await escalationMetaApi.findByMetadata(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/escalations/claim-by-metadata
+    server.registerTool('claim_by_metadata', {
+        title: 'Claim by Metadata',
+        description: 'Find and claim an escalation by metadata key-value pair.',
+        inputSchema: schemas_1.claimByMetadataSchema,
+    }, async (args) => {
+        const result = await escalationMetaApi.claimByMetadata(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/escalations/resolve-by-metadata
+    server.registerTool('resolve_by_metadata', {
+        title: 'Resolve by Metadata',
+        description: 'Find and resolve an escalation by metadata key-value pair.',
+        inputSchema: schemas_1.resolveByMetadataSchema,
+    }, async (args) => {
+        const result = await escalationMetaApi.resolveByMetadata(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // ── Bulk operations ─────────────────────────────────────────────────────────
+    // mirrors POST /api/escalations/bulk-claim
+    server.registerTool('bulk_claim', {
+        title: 'Bulk Claim',
+        description: 'Claim multiple escalations in a single operation.',
+        inputSchema: schemas_1.bulkClaimSchema,
+    }, async (args) => {
+        const result = await escalationBulkApi.bulkClaim(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors POST /api/escalations/bulk-assign
+    server.registerTool('bulk_assign', {
+        title: 'Bulk Assign',
+        description: 'Assign multiple escalations to a specific user.',
+        inputSchema: schemas_1.bulkAssignSchema,
+    }, async (args) => {
+        const result = await escalationBulkApi.bulkAssign(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors PATCH /api/escalations/bulk-escalate
+    server.registerTool('bulk_escalate', {
+        title: 'Bulk Escalate',
+        description: 'Escalate multiple escalations to a different role.',
+        inputSchema: schemas_1.bulkEscalateSchema,
+    }, async (args) => {
+        const result = await escalationBulkApi.bulkEscalate(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors PATCH /api/escalations/priority
+    server.registerTool('update_priority', {
+        title: 'Update Priority',
+        description: 'Update the priority of multiple escalations.',
+        inputSchema: schemas_1.updatePrioritySchema,
+    }, async (args) => {
+        const result = await escalationBulkApi.updatePriority(args, { userId: 'lt-system' });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
 }

package/build/system/mcp-servers/admin/exports.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Export tools — mirrors routes/exports.ts
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerExportTools(server: McpServer): void;

package/build/system/mcp-servers/admin/exports.js

@@ -0,0 +1,101 @@
+"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.registerExportTools = registerExportTools;
+const api = __importStar(require("../../../api/exports"));
+const schemas_1 = require("./schemas");
+function registerExportTools(server) {
+    // mirrors GET /api/workflow-states/jobs
+    server.registerTool('list_export_jobs', {
+        title: 'List Export Jobs',
+        description: 'List workflow jobs with optional filtering and pagination.',
+        inputSchema: schemas_1.listExportJobsSchema,
+    }, async (args) => {
+        const result = await api.listJobs(args);
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/workflow-states/:workflowId
+    server.registerTool('export_workflow_state', {
+        title: 'Export Workflow State',
+        description: 'Export the full workflow state using HotMesh durable export. ' +
+            'Optionally allow/block specific fields.',
+        inputSchema: schemas_1.exportWorkflowStateSchema,
+    }, async (args) => {
+        const result = await api.exportWorkflowState({
+            workflowId: args.workflow_id,
+            allow: args.allow,
+            block: args.block,
+            values: args.values,
+        });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/workflow-states/:workflowId/execution
+    server.registerTool('export_workflow_execution', {
+        title: 'Export Workflow Execution',
+        description: 'Export workflow state as a structured execution event history. ' +
+            'Useful for debugging and workflow compilation.',
+        inputSchema: schemas_1.exportWorkflowExecutionSchema,
+    }, async (args) => {
+        const result = await api.exportWorkflowExecution({
+            workflowId: args.workflow_id,
+            excludeSystem: args.excludeSystem,
+            omitResults: args.omitResults,
+            mode: args.mode,
+            maxDepth: args.maxDepth,
+        });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+    // mirrors GET /api/workflow-states/:workflowId/status
+    server.registerTool('get_export_status', {
+        title: 'Get Workflow Status',
+        description: 'Return the numeric status semaphore for a workflow.',
+        inputSchema: schemas_1.getExportStatusSchema,
+    }, async (args) => {
+        const result = await api.getWorkflowStatus({ workflowId: args.workflow_id });
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
+}