@hotmeshio/long-tail 0.1.13 → 0.1.15

package/build/system/activities/schema-exchange.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Schema-driven data exchange with external service endpoints.
+ *
+ * Three pillars: endpoint + schema + identity.
+ * Transport (fetch, Playwright, gRPC) is an implementation detail.
+ * The value is schema enforcement and credential resolution —
+ * validating both sides of the exchange and resolving auth from
+ * the connection store at the last mile.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSchema = validateSchema;
+exports.exchange = exchange;
+const ajv_1 = __importDefault(require("ajv"));
+const context_1 = require("../../services/iam/context");
+const credentials_1 = require("../../services/iam/credentials");
+const DEFAULT_TIMEOUT = parseInt(process.env.LT_SCHEMA_EXCHANGE_TIMEOUT_MS || '30000', 10);
+const ajv = new ajv_1.default({ allErrors: true, strict: false });
+/**
+ * Normalize a JSON Schema object before validation.
+ *
+ * HotMesh YAML maps serialize JSON arrays as indexed objects
+ * (e.g. `required: {"0":"username","1":"password"}` instead of
+ * `required: ["username","password"]`). This recursively converts
+ * any indexed-object `required` fields back to arrays so Ajv
+ * validates correctly.
+ */
+function normalizeSchema(obj) {
+    if (obj === null || obj === undefined || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(normalizeSchema);
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (key === 'required' && value && typeof value === 'object' && !Array.isArray(value)) {
+            // Convert indexed object {"0":"a","1":"b"} to array ["a","b"]
+            const keys = Object.keys(value);
+            if (keys.every(k => /^\d+$/.test(k))) {
+                result[key] = keys.sort((a, b) => Number(a) - Number(b)).map(k => value[k]);
+                continue;
+            }
+        }
+        result[key] = normalizeSchema(value);
+    }
+    return result;
+}
+/**
+ * Validate data against a JSON Schema.
+ *
+ * Returns a list of human-readable error strings (empty when valid).
+ */
+function validateSchema(data, schema) {
+    const normalized = normalizeSchema(schema);
+    const validate = ajv.compile(normalized);
+    const valid = validate(data);
+    if (valid)
+        return { valid: true, errors: [] };
+    const errors = (validate.errors || []).map((e) => {
+        const path = e.instancePath || '(root)';
+        return `${path}: ${e.message}${e.params ? ` (${JSON.stringify(e.params)})` : ''}`;
+    });
+    return { valid: false, errors };
+}
+/**
+ * Exchange data with an external service endpoint under schema enforcement.
+ *
+ * 1. If request_schema provided, validate body before sending.
+ *    On failure: return immediately (never send the request).
+ * 2. Make the HTTP call (transport layer — currently Node.js fetch).
+ * 3. Parse response body (JSON auto-detect).
+ * 4. If response_schema provided, validate response after receiving.
+ * 5. Return result with validated flag and any validation_errors.
+ */
+async function exchange(args) {
+    // 1. Validate request body against schema (if provided)
+    if (args.request_schema && args.body !== undefined) {
+        const result = validateSchema(args.body, args.request_schema);
+        if (!result.valid) {
+            return {
+                status: 0,
+                data: null,
+                headers: {},
+                elapsed_ms: 0,
+                validated: false,
+                validation_errors: result.errors.map((e) => `request: ${e}`),
+            };
+        }
+    }
+    // 2. Resolve credential from connection store (if credential_provider set)
+    if (args.credential_provider) {
+        const ctx = (0, context_1.getToolContext)();
+        if (!ctx?.principal) {
+            return {
+                status: 0, data: null, headers: {}, elapsed_ms: 0,
+                validated: false,
+                validation_errors: ['credential: no identity context — cannot resolve credential_provider without a principal'],
+            };
+        }
+        const cred = await (0, credentials_1.resolveCredential)(ctx.principal, args.credential_provider, args.credential_label, ctx.initiatingPrincipal ? { fallbackPrincipal: ctx.initiatingPrincipal } : undefined);
+        if (!cred) {
+            return {
+                status: 0, data: null, headers: {}, elapsed_ms: 0,
+                validated: false,
+                validation_errors: [`credential: no credential found for provider "${args.credential_provider}" — register one at Settings > Connections`],
+            };
+        }
+        const scheme = args.auth_scheme || 'Bearer';
+        const headerName = args.auth_header || 'Authorization';
+        args.headers = { ...args.headers, [headerName]: `${scheme} ${cred.value}` };
+    }
+    // 3. Build URL with query parameters (accept endpoint or url)
+    let url = args.endpoint || args.url;
+    if (!url) {
+        return {
+            status: 0, data: null, headers: {}, elapsed_ms: 0,
+            validated: false, validation_errors: ['endpoint or url is required'],
+        };
+    }
+    if (args.query && Object.keys(args.query).length > 0) {
+        const params = new URLSearchParams(args.query);
+        url += (url.includes('?') ? '&' : '?') + params.toString();
+    }
+    // 3. Make the HTTP call
+    const start = performance.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), args.timeout_ms || DEFAULT_TIMEOUT);
+    let status;
+    let responseHeaders = {};
+    let rawBody;
+    try {
+        const fetchOpts = {
+            method: args.method,
+            headers: args.headers,
+            signal: controller.signal,
+        };
+        if (args.body !== undefined && args.method !== 'GET' && args.method !== 'HEAD') {
+            fetchOpts.body = typeof args.body === 'string' ? args.body : JSON.stringify(args.body);
+            if (!args.headers?.['Content-Type'] && !args.headers?.['content-type']) {
+                fetchOpts.headers = { ...fetchOpts.headers, 'Content-Type': 'application/json' };
+            }
+        }
+        const response = await fetch(url, fetchOpts);
+        status = response.status;
+        response.headers.forEach((value, key) => { responseHeaders[key] = value; });
+        rawBody = await response.text();
+    }
+    catch (err) {
+        const elapsed = performance.now() - start;
+        return {
+            status: 0,
+            data: null,
+            headers: {},
+            elapsed_ms: Math.round(elapsed),
+            validated: false,
+            validation_errors: [`transport: ${err.name === 'AbortError' ? 'request timed out' : err.message}`],
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    const elapsed = performance.now() - start;
+    // 3b. Fail fast on auth errors — don't silently return a 401 as a "result"
+    if (status === 401 || status === 403) {
+        return {
+            status,
+            data: null,
+            headers: responseHeaders,
+            elapsed_ms: Math.round(elapsed),
+            validated: false,
+            validation_errors: [
+                status === 401
+                    ? 'authentication: token expired or invalid — refresh credentials and retry'
+                    : 'authorization: insufficient permissions for this endpoint',
+            ],
+        };
+    }
+    // 4. Parse response body
+    let data;
+    const contentType = responseHeaders['content-type'] || '';
+    if (contentType.includes('json') || (rawBody.startsWith('{') || rawBody.startsWith('['))) {
+        try {
+            data = JSON.parse(rawBody);
+        }
+        catch {
+            data = rawBody;
+        }
+    }
+    else {
+        data = rawBody;
+    }
+    // 5. Validate response against schema (if provided)
+    let validated = true;
+    let validationErrors = [];
+    if (args.response_schema) {
+        const result = validateSchema(data, args.response_schema);
+        validated = result.valid;
+        validationErrors = result.errors.map((e) => `response: ${e}`);
+    }
+    return {
+        status,
+        data,
+        headers: responseHeaders,
+        elapsed_ms: Math.round(elapsed),
+        validated,
+        validation_errors: validationErrors,
+    };
+}

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

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

package/build/system/activities/sql.js

@@ -1,14 +1,34 @@
 "use strict";
 // ─── Knowledge CRUD ─────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APPEND_KNOWLEDGE = exports.LIST_DOMAINS = exports.DELETE_KNOWLEDGE = exports.COUNT_KNOWLEDGE_LIST = exports.LIST_KNOWLEDGE = exports.COUNT_KNOWLEDGE_SEARCH = exports.SEARCH_KNOWLEDGE = exports.GET_KNOWLEDGE = exports.UPSERT_KNOWLEDGE = void 0;
+exports.APPEND_KNOWLEDGE = exports.REMOVE_KNOWLEDGE_FIELD = exports.SET_KNOWLEDGE_FIELD = exports.LIST_DOMAINS = exports.DELETE_KNOWLEDGE = exports.COUNT_KNOWLEDGE_LIST = exports.LIST_KNOWLEDGE = exports.COUNT_KNOWLEDGE_SEARCH = exports.SEARCH_KNOWLEDGE = exports.GET_KNOWLEDGE = exports.REPLACE_KNOWLEDGE = exports.UPSERT_KNOWLEDGE = void 0;
+// Upsert knowledge entry. On conflict (domain+key), merges JSONB data at
+// the top level — new keys are added, existing keys are overwritten.
+//
+// Guard: if the existing `data` column is not a JSON object (e.g. it was
+// corrupted into an array by a prior string merge), replace it entirely
+// rather than appending to the array. The CASE expression ensures the
+// `||` operator always receives object || object, which produces a merge.
 exports.UPSERT_KNOWLEDGE = `
   INSERT INTO lt_knowledge (domain, key, data, tags)
   VALUES ($1, $2, $3, $4)
   ON CONFLICT (domain, key) DO UPDATE SET
-    data = lt_knowledge.data || EXCLUDED.data,
+    data = CASE
+      WHEN jsonb_typeof(lt_knowledge.data) = 'object'
+      THEN lt_knowledge.data || EXCLUDED.data
+      ELSE EXCLUDED.data
+    END,
     tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags))
   RETURNING id, domain, key, (xmax = 0) AS created, updated_at`;
+// Full replacement — overwrites data and tags entirely (no merge).
+// Used when removing fields or tags.
+exports.REPLACE_KNOWLEDGE = `
+  INSERT INTO lt_knowledge (domain, key, data, tags)
+  VALUES ($1, $2, $3, $4)
+  ON CONFLICT (domain, key) DO UPDATE SET
+    data = EXCLUDED.data,
+    tags = EXCLUDED.tags
+  RETURNING id, domain, key, (xmax = 0) AS created, updated_at`;
 exports.GET_KNOWLEDGE = `
   SELECT id, domain, key, data, tags, created_at, updated_at
   FROM lt_knowledge WHERE domain = $1 AND key = $2`;
@@ -29,6 +49,21 @@ exports.DELETE_KNOWLEDGE = `
 exports.LIST_DOMAINS = `
   SELECT domain, COUNT(*)::int AS count, MAX(updated_at) AS latest
   FROM lt_knowledge GROUP BY domain ORDER BY latest DESC`;
+// Set a value at a specific JSONB path without clobbering siblings.
+// Creates the entry if it doesn't exist. Uses jsonb_set for surgical updates.
+exports.SET_KNOWLEDGE_FIELD = `
+  INSERT INTO lt_knowledge (domain, key, data, tags)
+  VALUES ($1, $2, $3::jsonb, $4)
+  ON CONFLICT (domain, key) DO UPDATE SET
+    data = jsonb_set(lt_knowledge.data, $5::text[], $6::jsonb, true),
+    tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags))
+  RETURNING id, domain, key, (xmax = 0) AS created, updated_at`;
+// Remove a field at a specific JSONB path. Entry survives; only the targeted path is removed.
+exports.REMOVE_KNOWLEDGE_FIELD = `
+  UPDATE lt_knowledge
+  SET data = data #- $3::text[]
+  WHERE domain = $1 AND key = $2
+  RETURNING id, domain, key, updated_at`;
 exports.APPEND_KNOWLEDGE = `
   INSERT INTO lt_knowledge (domain, key, data)
   VALUES ($1, $2, $3::jsonb)

package/build/system/index.js

@@ -110,4 +110,5 @@ exports.builtinMcpServerFactories = {
     'long-tail-claude-code': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/claude-code'))).then((m) => m.createClaudeCodeServer()),
     'long-tail-admin': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/admin'))).then((m) => m.createAdminServer()),
     'long-tail-knowledge': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/knowledge'))).then((m) => m.createKnowledgeServer()),
+    'long-tail-schema-exchange': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/schema-exchange'))).then((m) => m.createSchemaExchangeServer()),
 };

package/build/system/mcp-servers/file-storage.js

@@ -52,6 +52,8 @@ const readFileSchema = zod_1.z.object({
 const listFilesSchema = zod_1.z.object({
     directory: zod_1.z.string().optional().describe('Subdirectory to list (default: root)'),
     pattern: zod_1.z.string().optional().describe('Glob-like filter pattern (e.g., "*.json")'),
+    page_size: zod_1.z.number().optional().describe('Max results per page (default 100)'),
+    continuation_token: zod_1.z.string().optional().describe('Pagination token from a previous response'),
 });
 const deleteFileSchema = zod_1.z.object({
     path: zod_1.z.string().describe('File path relative to storage root'),
@@ -82,7 +84,7 @@ async function createFileStorageServer(options) {
     });
     instance.registerTool('list_files', {
         title: 'List Files',
-        description: 'List files in a storage directory. Returns file paths, sizes, and modification timestamps.',
+        description: 'List files and directories at a storage prefix. Supports cursor-based pagination via continuation tokens. Returns file paths, sizes, timestamps, subdirectories, and a nextToken for the next page.',
         inputSchema: listFilesSchema,
     }, async (args) => {
         const result = await fileStorage.listFiles(args);

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();