@hotmeshio/long-tail 0.19.1 → 0.21.0

package/build/system/mcp-servers/admin/workflow-config.js

@@ -35,15 +35,25 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerWorkflowConfigTools = registerWorkflowConfigTools;
 const configService = __importStar(require("../../../services/config"));
+const lookup_cache_1 = require("../../../services/knowledge/lookup-cache");
+const lookup_refs_1 = require("../../../services/knowledge/lookup-refs");
 const ltconfig_1 = require("../../../modules/ltconfig");
 const cron_1 = require("../../../services/cron");
+const invocable_1 = require("../../../api/workflows/invocable");
+const workflow_icons_1 = require("../../../types/workflow-icons");
+const escalation_1 = require("../../../types/escalation");
 const schemas_1 = require("./schemas");
+const errorResult = (error) => ({
+    content: [{ type: 'text', text: JSON.stringify({ error }) }],
+    isError: true,
+});
 function registerWorkflowConfigTools(server) {
     // mirrors GET /api/workflows/config
     server.registerTool('list_workflow_configs', {
         title: 'List Workflow Configs',
         description: 'List all certified workflow configurations. Shows workflow type, ' +
-            'task queue, roles, invocable flag, and description.',
+            'task queue, roles, invocable flag, and description. Call ' +
+            'get_workflow_config for the full row including input_schema.',
         inputSchema: schemas_1.listWorkflowConfigsSchema,
     }, async (_args) => {
         const configs = await configService.listWorkflowConfigs();
@@ -64,15 +74,49 @@ function registerWorkflowConfigTools(server) {
                 }],
         };
     });
+    // mirrors GET /api/workflows/:type/config, plus the resolved lookup data the form reads
+    server.registerTool('get_workflow_config', {
+        title: 'Get Workflow Config',
+        description: 'The full configuration row for one workflow: input_schema (the x-lt-* form ' +
+            'an invoke payload must satisfy), envelope_schema (its metadata is the base ' +
+            'of every run), input_lookups, roles, and tier. input_lookup_data carries the ' +
+            'resolved knowledge editions keyed as the form reads them (lookup.<as ?? key>).',
+        inputSchema: schemas_1.getWorkflowConfigSchema,
+    }, async (args) => {
+        const config = await configService.getWorkflowConfig(args.workflow_type);
+        if (!config)
+            return errorResult('Workflow config not found');
+        const tier = config.certified ? invocable_1.WORKFLOW_TIERS.CERTIFIED : invocable_1.WORKFLOW_TIERS.REGISTERED;
+        const input_lookup_data = await (0, lookup_cache_1.resolveLookupContext)(config.input_lookups);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ ...config, tier, input_lookup_data }) }],
+        };
+    });
     // mirrors PUT /api/workflows/:type/config
     server.registerTool('upsert_workflow_config', {
         title: 'Upsert Workflow Config',
         description: 'Create or replace a workflow configuration (certify). Activates the ' +
             'interceptor for task tracking, escalation chains, and invocation controls. ' +
+            'Full replace, matching PUT /api/workflows/:type/config: omitted fields clear ' +
+            'to their defaults, so send the whole profile (start from get_workflow_config). ' +
             'Invalidates the config cache and restarts cron if schedule changes.',
         inputSchema: schemas_1.upsertWorkflowConfigSchema,
     }, async (args) => {
-        const config = await configService.upsertWorkflowConfig({
+        if (args.icon && !(0, workflow_icons_1.isWorkflowIcon)(args.icon)) {
+            return errorResult(`Unknown workflow icon "${args.icon}"; choose one of WORKFLOW_ICONS`);
+        }
+        if (args.input_lookups != null) {
+            try {
+                (0, escalation_1.assertLookupRefs)(args.input_lookups);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+            const missing = await (0, lookup_refs_1.describeMissingLookupRefs)(args.input_lookups);
+            if (missing.length)
+                return errorResult(missing.join('; '));
+        }
+        const declaration = {
             workflow_type: args.workflow_type,
             invocable: args.invocable,
             certified: args.certified,
@@ -85,9 +129,14 @@ function registerWorkflowConfigTools(server) {
             consumes: args.consumes,
             tool_tags: args.tool_tags,
             envelope_schema: args.envelope_schema,
+            input_schema: args.input_schema,
+            input_lookups: args.input_lookups,
+            icon: args.icon,
+            read_safe: args.read_safe,
             resolver_schema: args.resolver_schema,
             cron_schedule: args.cron_schedule,
-        });
+        };
+        const config = await configService.upsertWorkflowConfig(declaration);
         ltconfig_1.ltConfig.invalidate();
         await cron_1.cronRegistry.restartCron(config);
         return {
@@ -102,12 +151,8 @@ function registerWorkflowConfigTools(server) {
         inputSchema: schemas_1.deleteWorkflowConfigSchema,
     }, async (args) => {
         const deleted = await configService.deleteWorkflowConfig(args.workflow_type);
-        if (!deleted) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ error: 'Workflow config not found' }) }],
-                isError: true,
-            };
-        }
+        if (!deleted)
+            return errorResult('Workflow config not found');
         ltconfig_1.ltConfig.invalidate();
         return {
             content: [{

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

@@ -85,9 +85,8 @@ function registerWorkflowTools(server) {
         };
     });
     // The invoke input gate: data is validated against input_schema when declared.
-    const inputSchemaRejection = async (args) => {
-        const config = await configService.getWorkflowConfig(args.workflow_type);
-        const body = workflowApi.checkInvokeInput(config, args.data ?? {}, args.metadata);
+    const inputSchemaRejection = async (config, args) => {
+        const body = await workflowApi.checkInvokeInput(config, args.data ?? {}, args.metadata);
         return body ? { content: [{ type: 'text', text: JSON.stringify(body) }], isError: true } : null;
     };
     // mirrors POST /api/workflows/:type/invoke
@@ -95,11 +94,13 @@ function registerWorkflowTools(server) {
         title: 'Invoke Workflow',
         description: 'Start a certified workflow by type. The workflow must have invocable=true ' +
             'in its config. Data is validated against the config input_schema when one ' +
-            'is declared (422-shaped error). Returns the workflow ID immediately; the ' +
+            'is declared (422-shaped error). Call get_workflow_config for the input_schema ' +
+            'the payload must satisfy. Returns the workflow ID immediately; the ' +
             'workflow runs durably in the background.',
         inputSchema: schemas_1.invokeWorkflowSchema,
     }, async (args) => {
-        const rejected = await inputSchemaRejection(args);
+        const config = await configService.getWorkflowConfig(args.workflow_type);
+        const rejected = await inputSchemaRejection(config, args);
         if (rejected)
             return rejected;
         const result = await (0, workflow_invocation_1.invokeWorkflow)({
@@ -127,7 +128,8 @@ function registerWorkflowTools(server) {
         description: 'Start a workflow registered read-safe (side-effect-free). Same contract ' +
             'as invoke_workflow, gated to configs carrying read_safe=true — the ' +
             'variant exposed to read-scoped MCP callers. A workflow without the ' +
-            'flag fails with a clear error.',
+            'flag fails with a clear error. Call get_workflow_config for the ' +
+            'input_schema the payload must satisfy.',
         inputSchema: schemas_1.invokeWorkflowSchema,
     }, async (args) => {
         const config = await configService.getWorkflowConfig(args.workflow_type);
@@ -149,7 +151,7 @@ function registerWorkflowTools(server) {
                 isError: true,
             };
         }
-        const rejected = await inputSchemaRejection(args);
+        const rejected = await inputSchemaRejection(config, args);
         if (rejected)
             return rejected;
         const result = await (0, workflow_invocation_1.invokeWorkflow)({

package/build/system/mcp-servers/db-query/schemas.d.ts

@@ -7,12 +7,12 @@ export declare const findTasksSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     limit: number;
-    status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
+    status?: "completed" | "pending" | "in_progress" | "needs_intervention" | "failed" | undefined;
     workflow_type?: string | undefined;
     workflow_id?: string | undefined;
     origin_id?: string | undefined;
 }, {
-    status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
+    status?: "completed" | "pending" | "in_progress" | "needs_intervention" | "failed" | undefined;
     workflow_type?: string | undefined;
     workflow_id?: string | undefined;
     origin_id?: string | undefined;

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

@@ -52,12 +52,16 @@ function docsDir() {
     }
     return candidates[0];
 }
+/** Folders kept out of the published package; the served set matches it. */
+const UNPUBLISHED_DOC_DIRS = new Set(['donotcommit', 'donotpublish', 'img']);
 function listMarkdownFiles(dir, prefix = '') {
     if (!fs.existsSync(dir))
         return [];
     const results = [];
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory() && !prefix && UNPUBLISHED_DOC_DIRS.has(entry.name))
+            continue;
         if (entry.isDirectory()) {
             results.push(...listMarkdownFiles(path.join(dir, entry.name), rel));
         }

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

@@ -77,6 +77,91 @@ export declare const resolveBatchItemSchema: z.ZodObject<{
     payload: Record<string, any>;
     escalation_id: string;
 }>;
+export declare const accumulateItemSchema: z.ZodObject<{
+    escalation_id: z.ZodString;
+    item_key: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    reciprocal: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        signalKey: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+        payload?: Record<string, any> | undefined;
+    }, {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+        payload?: Record<string, any> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    item_key: string;
+    escalation_id: string;
+    payload?: Record<string, any> | undefined;
+    reciprocal?: {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+        payload?: Record<string, any> | undefined;
+    } | undefined;
+}, {
+    item_key: string;
+    escalation_id: string;
+    payload?: Record<string, any> | undefined;
+    reciprocal?: {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+        payload?: Record<string, any> | undefined;
+    } | undefined;
+}>;
+export declare const removeItemSchema: z.ZodObject<{
+    escalation_id: z.ZodString;
+    item_key: z.ZodString;
+    reciprocal: z.ZodOptional<z.ZodObject<Omit<{
+        id: z.ZodOptional<z.ZodString>;
+        signalKey: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "payload">, "strip", z.ZodTypeAny, {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+    }, {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    item_key: string;
+    escalation_id: string;
+    reciprocal?: {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+    } | undefined;
+}, {
+    item_key: string;
+    escalation_id: string;
+    reciprocal?: {
+        key?: string | undefined;
+        value?: string | undefined;
+        id?: string | undefined;
+        signalKey?: string | undefined;
+    } | undefined;
+}>;
 export declare const escalateAndWaitSchema: z.ZodObject<{
     role: z.ZodString;
     message: z.ZodString;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escalateAndWaitSchema = exports.resolveBatchItemSchema = exports.resolveEscalationSchema = exports.claimAndResolveSchema = exports.getAvailableWorkSchema = exports.checkResolutionSchema = exports.escalateSchema = void 0;
+exports.escalateAndWaitSchema = exports.removeItemSchema = exports.accumulateItemSchema = exports.resolveBatchItemSchema = 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({
@@ -42,6 +42,24 @@ exports.resolveBatchItemSchema = zod_1.z.object({
     item_key: zod_1.z.string().describe('The declared batch item key this submission fills'),
     payload: zod_1.z.record(zod_1.z.any()).describe(RESOLVER_PAYLOAD_DESC),
 });
+const reciprocalSchema = zod_1.z.object({
+    id: zod_1.z.string().optional().describe('Reciprocal escalation UUID'),
+    signalKey: zod_1.z.string().optional().describe('Reciprocal escalation signal_key'),
+    key: zod_1.z.string().optional().describe('Facet key selecting the reciprocal row'),
+    value: zod_1.z.string().optional().describe('Facet value selecting the reciprocal row'),
+    payload: zod_1.z.record(zod_1.z.any()).optional().describe('Stored as the reciprocal entry payload'),
+}).describe('A second accumulator row written in the same statement, both or neither. Exactly one of id, signalKey, or key/value.');
+exports.accumulateItemSchema = zod_1.z.object({
+    escalation_id: zod_1.z.string().describe('The accumulator escalation ID (the container)'),
+    item_key: zod_1.z.string().describe('The key this item is held under (an order id, a bag id)'),
+    payload: zod_1.z.record(zod_1.z.any()).optional().describe('Optional item payload, delivered inside $accumulated'),
+    reciprocal: reciprocalSchema.optional(),
+});
+exports.removeItemSchema = zod_1.z.object({
+    escalation_id: zod_1.z.string().describe('The accumulator escalation ID'),
+    item_key: zod_1.z.string().describe('The held item key to remove'),
+    reciprocal: reciprocalSchema.omit({ payload: true }).optional(),
+});
 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'),

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

@@ -9,6 +9,8 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
  * - claim_and_resolve — claim + resolve in one step
  * - resolve_escalation — resolve an already-claimed escalation
  * - resolve_batch_item — submit one declared item of a batch escalation
+ * - accumulate_item — add one item to an open accumulator escalation
+ * - remove_item — remove one held item from an open accumulator escalation
  * - escalate_and_wait — create escalation and return signal for durable wait
  *
  * The server is created with tools registered but no transport

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

@@ -80,6 +80,8 @@ async function checkResolveToolPayload(escalationId, payload) {
  * - claim_and_resolve — claim + resolve in one step
  * - resolve_escalation — resolve an already-claimed escalation
  * - resolve_batch_item — submit one declared item of a batch escalation
+ * - accumulate_item — add one item to an open accumulator escalation
+ * - remove_item — remove one held item from an open accumulator escalation
  * - escalate_and_wait — create escalation and return signal for durable wait
  *
  * The server is created with tools registered but no transport
@@ -299,6 +301,81 @@ async function createHumanQueueServer(options) {
                 }],
         };
     });
+    // ── accumulate_item ────────────────────────────────────────────────
+    server.registerTool('accumulate_item', {
+        title: 'Accumulate Item',
+        description: 'Add ONE item to an open accumulator escalation (a wait declared with accumulate). '
+            + 'Interim adds return outcome "accepted" with the count held and the remaining slots; the add that '
+            + 'reaches max completes the escalation and wakes the waiting workflow with the ordered collection. '
+            + 'A key already held is rejected. Name a reciprocal to write a second accumulator row (for example '
+            + 'the item\'s own escalation) in the same statement, both or neither.',
+        inputSchema: human_queue_schemas_1.accumulateItemSchema,
+    }, async (args) => {
+        if (args.payload) {
+            const rejected = await checkResolveToolPayload(args.escalation_id, args.payload);
+            if (rejected)
+                return rejected;
+        }
+        const result = await escalationService.accumulateItem(args.escalation_id, {
+            itemKey: args.item_key,
+            payload: args.payload,
+            metadata: { source: 'mcp_server' },
+            actor: 'mcp_server',
+            reciprocal: args.reciprocal,
+        });
+        if (result.outcome !== 'accepted' && result.outcome !== 'completed') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: `Item not accepted: ${result.outcome}`, outcome: result.outcome }),
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        escalation_id: args.escalation_id,
+                        outcome: result.outcome,
+                        count: result.count,
+                        remaining: result.remaining,
+                        status: result.escalation?.status,
+                        ...(result.reciprocal
+                            ? { reciprocal: { escalation_id: result.reciprocal.escalation.id, outcome: result.reciprocal.outcome, count: result.reciprocal.count } }
+                            : {}),
+                    }),
+                }],
+        };
+    });
+    // ── remove_item ────────────────────────────────────────────────────
+    server.registerTool('remove_item', {
+        title: 'Remove Item',
+        description: 'Remove ONE held item from a pending open accumulator escalation. The row stays pending and the '
+            + 'waiting workflow is never woken. Name a reciprocal to remove the container from that row in the same statement.',
+        inputSchema: human_queue_schemas_1.removeItemSchema,
+    }, async (args) => {
+        const result = await escalationService.removeAccumulatedItem(args.escalation_id, {
+            itemKey: args.item_key,
+            actor: 'mcp_server',
+            reciprocal: args.reciprocal,
+        });
+        if (result.outcome !== 'removed') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: `Item not removed: ${result.outcome}`, outcome: result.outcome }),
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ escalation_id: args.escalation_id, outcome: 'removed', count: result.count }),
+                }],
+        };
+    });
     // ── escalate_and_wait ──────────────────────────────────────────────
     server.registerTool('escalate_and_wait', {
         title: 'Escalate and Wait',