@hotmeshio/long-tail 0.1.0

package/build/services/interceptor/activities/escalation.js

@@ -0,0 +1,110 @@
+"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.ltResolveEscalation = ltResolveEscalation;
+exports.ltClaimEscalation = ltClaimEscalation;
+exports.ltEnrichEscalationRouting = ltEnrichEscalationRouting;
+exports.ltCreateEscalation = ltCreateEscalation;
+const escalationService = __importStar(require("../../escalation"));
+const logger_1 = require("../../logger");
+/**
+ * Resolve an escalation record. Called by the interceptor after
+ * detecting a re-run (resolver data present in the envelope).
+ * This makes resolution durable: if the server crashes after
+ * signaling but before DB update, the workflow replays and
+ * retries this activity.
+ */
+async function ltResolveEscalation(input) {
+    const result = await escalationService.resolveEscalation(input.escalationId, input.resolverPayload);
+    if (!result) {
+        logger_1.loggerRegistry.warn(`[ltResolveEscalation] Escalation ${input.escalationId} already resolved or not found`);
+    }
+}
+/**
+ * Claim an escalation to a specific user. Used for auto-assignment
+ * when the system creates an advisory escalation (e.g., rounds exhausted).
+ */
+async function ltClaimEscalation(input) {
+    const result = await escalationService.claimEscalation(input.escalationId, input.userId, input.durationMinutes);
+    if (!result) {
+        logger_1.loggerRegistry.warn(`[ltClaimEscalation] Escalation ${input.escalationId} could not be claimed`);
+    }
+}
+/**
+ * Enrich an escalation record with signal routing metadata and workflow
+ * context so the resolution API can signal the paused workflow directly
+ * and the dashboard can display full context. Optionally auto-claims
+ * the escalation to the initiating user.
+ */
+async function ltEnrichEscalationRouting(input) {
+    const result = await escalationService.enrichEscalationRouting(input.escalationId, { signal_routing: { ...input.signalRouting, engine: 'durable' } }, {
+        workflowType: input.signalRouting.workflowType,
+        workflowId: input.signalRouting.workflowId,
+        taskQueue: input.signalRouting.taskQueue,
+        taskId: input.taskId,
+    });
+    if (!result) {
+        logger_1.loggerRegistry.warn(`[ltEnrichEscalationRouting] Escalation ${input.escalationId} not found`);
+        return;
+    }
+    // Auto-claim to the initiating user with a long window (4 hours)
+    if (input.claimForUserId) {
+        await escalationService.claimEscalation(input.escalationId, input.claimForUserId, 240);
+    }
+}
+/**
+ * Create an escalation record when a workflow needs human intervention.
+ */
+async function ltCreateEscalation(input) {
+    const escalation = await escalationService.createEscalation({
+        type: input.type,
+        subtype: input.subtype,
+        description: input.description,
+        priority: input.priority,
+        task_id: input.taskId,
+        origin_id: input.originId,
+        parent_id: input.parentId,
+        role: input.role,
+        envelope: input.envelope,
+        metadata: input.metadata,
+        escalation_payload: input.escalationPayload,
+        workflow_id: input.workflowId,
+        task_queue: input.taskQueue,
+        workflow_type: input.workflowType,
+        trace_id: input.traceId,
+        span_id: input.spanId,
+    });
+    return escalation.id;
+}

package/build/services/interceptor/activities/index.d.ts

@@ -0,0 +1,4 @@
+export { ltCreateTask, ltStartTask, ltCompleteTask, ltEscalateTask, ltFailTask, ltAppendMilestones, ltGetTask, ltGetTaskByWorkflowId, } from './task';
+export { ltClaimEscalation, ltCreateEscalation, ltEnrichEscalationRouting, ltResolveEscalation, } from './escalation';
+export { ltGetWorkflowConfig, ltGetProviderData, } from './config';
+export { ltSignalParent, ltStartWorkflow, } from './workflow';

package/build/services/interceptor/activities/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ltStartWorkflow = exports.ltSignalParent = exports.ltGetProviderData = exports.ltGetWorkflowConfig = exports.ltResolveEscalation = exports.ltEnrichEscalationRouting = exports.ltCreateEscalation = exports.ltClaimEscalation = exports.ltGetTaskByWorkflowId = exports.ltGetTask = exports.ltAppendMilestones = exports.ltFailTask = exports.ltEscalateTask = exports.ltCompleteTask = exports.ltStartTask = exports.ltCreateTask = void 0;
+var task_1 = require("./task");
+Object.defineProperty(exports, "ltCreateTask", { enumerable: true, get: function () { return task_1.ltCreateTask; } });
+Object.defineProperty(exports, "ltStartTask", { enumerable: true, get: function () { return task_1.ltStartTask; } });
+Object.defineProperty(exports, "ltCompleteTask", { enumerable: true, get: function () { return task_1.ltCompleteTask; } });
+Object.defineProperty(exports, "ltEscalateTask", { enumerable: true, get: function () { return task_1.ltEscalateTask; } });
+Object.defineProperty(exports, "ltFailTask", { enumerable: true, get: function () { return task_1.ltFailTask; } });
+Object.defineProperty(exports, "ltAppendMilestones", { enumerable: true, get: function () { return task_1.ltAppendMilestones; } });
+Object.defineProperty(exports, "ltGetTask", { enumerable: true, get: function () { return task_1.ltGetTask; } });
+Object.defineProperty(exports, "ltGetTaskByWorkflowId", { enumerable: true, get: function () { return task_1.ltGetTaskByWorkflowId; } });
+var escalation_1 = require("./escalation");
+Object.defineProperty(exports, "ltClaimEscalation", { enumerable: true, get: function () { return escalation_1.ltClaimEscalation; } });
+Object.defineProperty(exports, "ltCreateEscalation", { enumerable: true, get: function () { return escalation_1.ltCreateEscalation; } });
+Object.defineProperty(exports, "ltEnrichEscalationRouting", { enumerable: true, get: function () { return escalation_1.ltEnrichEscalationRouting; } });
+Object.defineProperty(exports, "ltResolveEscalation", { enumerable: true, get: function () { return escalation_1.ltResolveEscalation; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "ltGetWorkflowConfig", { enumerable: true, get: function () { return config_1.ltGetWorkflowConfig; } });
+Object.defineProperty(exports, "ltGetProviderData", { enumerable: true, get: function () { return config_1.ltGetProviderData; } });
+var workflow_1 = require("./workflow");
+Object.defineProperty(exports, "ltSignalParent", { enumerable: true, get: function () { return workflow_1.ltSignalParent; } });
+Object.defineProperty(exports, "ltStartWorkflow", { enumerable: true, get: function () { return workflow_1.ltStartWorkflow; } });

package/build/services/interceptor/activities/task.d.ts

@@ -0,0 +1,65 @@
+import type { LTMilestone, LTTaskRecord } from '../../../types';
+/**
+ * Create a task record when a Long Tail workflow starts.
+ */
+export declare function ltCreateTask(input: {
+    workflowId: string;
+    workflowType: string;
+    ltType: string;
+    taskQueue?: string;
+    signalId: string;
+    parentWorkflowId: string;
+    originId?: string;
+    parentId?: string;
+    envelope: string;
+    metadata?: Record<string, any>;
+    traceId?: string;
+    spanId?: string;
+    initiatedBy?: string;
+    principalType?: string;
+    executingAs?: string;
+}): Promise<string>;
+/**
+ * Mark a task as in_progress.
+ */
+export declare function ltStartTask(taskId: string): Promise<void>;
+/**
+ * Mark a task as completed with result data and milestones.
+ */
+export declare function ltCompleteTask(input: {
+    taskId: string;
+    data?: string;
+    milestones?: LTMilestone[];
+    workflowId?: string;
+    workflowName?: string;
+    taskQueue?: string;
+}): Promise<void>;
+/**
+ * Mark a task as needing intervention (escalated).
+ */
+export declare function ltEscalateTask(taskId: string): Promise<void>;
+/**
+ * Mark a task as failed.
+ */
+export declare function ltFailTask(input: {
+    taskId: string;
+    error: string;
+}): Promise<void>;
+/**
+ * Append milestones to a task (used by activity interceptor).
+ */
+export declare function ltAppendMilestones(input: {
+    taskId: string;
+    milestones: LTMilestone[];
+}): Promise<void>;
+/**
+ * Look up a task by workflow ID. Used by the interceptor to detect
+ * whether a task was already created by executeLT (orchestrated mode)
+ * or needs to be created by the interceptor (standalone mode).
+ */
+export declare function ltGetTaskByWorkflowId(workflowId: string): Promise<LTTaskRecord | null>;
+/**
+ * Look up a task by its primary ID.
+ * Used by the interceptor on re-runs to find the original task.
+ */
+export declare function ltGetTask(taskId: string): Promise<LTTaskRecord | null>;

package/build/services/interceptor/activities/task.js

@@ -0,0 +1,168 @@
+"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.ltCreateTask = ltCreateTask;
+exports.ltStartTask = ltStartTask;
+exports.ltCompleteTask = ltCompleteTask;
+exports.ltEscalateTask = ltEscalateTask;
+exports.ltFailTask = ltFailTask;
+exports.ltAppendMilestones = ltAppendMilestones;
+exports.ltGetTaskByWorkflowId = ltGetTaskByWorkflowId;
+exports.ltGetTask = ltGetTask;
+const taskService = __importStar(require("../../task"));
+const publish_1 = require("../../events/publish");
+const db_1 = require("../../db");
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Resolve an external_id to a UUID. Returns null if not found or already a UUID. */
+async function resolveUserUuid(identifier) {
+    if (!identifier)
+        return undefined;
+    if (UUID_RE.test(identifier))
+        return identifier;
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query('SELECT id FROM lt_users WHERE external_id = $1 LIMIT 1', [identifier]);
+    return rows[0]?.id ?? undefined;
+}
+/**
+ * Create a task record when a Long Tail workflow starts.
+ */
+async function ltCreateTask(input) {
+    const initiatedByUuid = await resolveUserUuid(input.initiatedBy);
+    const task = await taskService.createTask({
+        workflow_id: input.workflowId,
+        workflow_type: input.workflowType,
+        lt_type: input.ltType,
+        task_queue: input.taskQueue,
+        signal_id: input.signalId,
+        parent_workflow_id: input.parentWorkflowId,
+        origin_id: input.originId,
+        parent_id: input.parentId,
+        envelope: input.envelope,
+        metadata: input.metadata,
+        trace_id: input.traceId,
+        span_id: input.spanId,
+        initiated_by: initiatedByUuid,
+        principal_type: input.principalType,
+        executing_as: input.executingAs,
+    });
+    (0, publish_1.publishTaskEvent)({
+        type: 'task.created',
+        source: 'interceptor',
+        workflowId: input.workflowId,
+        workflowName: input.workflowType,
+        taskQueue: input.taskQueue || 'unknown',
+        taskId: task.id,
+        originId: input.originId,
+        status: 'pending',
+    });
+    return task.id;
+}
+/**
+ * Mark a task as in_progress.
+ */
+async function ltStartTask(taskId) {
+    await taskService.updateTask(taskId, { status: 'in_progress' });
+}
+/**
+ * Mark a task as completed with result data and milestones.
+ */
+async function ltCompleteTask(input) {
+    await taskService.updateTask(input.taskId, {
+        status: 'completed',
+        completed_at: new Date(),
+        data: input.data,
+        milestones: input.milestones,
+    });
+    // Publish task.completed event
+    if (input.workflowId) {
+        (0, publish_1.publishTaskEvent)({
+            type: 'task.completed',
+            source: 'orchestrator',
+            workflowId: input.workflowId,
+            workflowName: input.workflowName || 'unknown',
+            taskQueue: input.taskQueue || 'unknown',
+            taskId: input.taskId,
+            status: 'completed',
+            milestones: input.milestones,
+        });
+    }
+    // Publish milestone event from orchestrator context
+    if (input.milestones?.length && input.workflowId) {
+        (0, publish_1.publishMilestoneEvent)({
+            source: 'orchestrator',
+            workflowId: input.workflowId,
+            workflowName: input.workflowName || 'unknown',
+            taskQueue: input.taskQueue || 'unknown',
+            taskId: input.taskId,
+            milestones: input.milestones,
+        });
+    }
+}
+/**
+ * Mark a task as needing intervention (escalated).
+ */
+async function ltEscalateTask(taskId) {
+    await taskService.updateTask(taskId, { status: 'needs_intervention' });
+}
+/**
+ * Mark a task as failed.
+ */
+async function ltFailTask(input) {
+    await taskService.updateTask(input.taskId, {
+        status: 'needs_intervention',
+        error: input.error,
+    });
+}
+/**
+ * Append milestones to a task (used by activity interceptor).
+ */
+async function ltAppendMilestones(input) {
+    await taskService.appendMilestones(input.taskId, input.milestones);
+}
+/**
+ * Look up a task by workflow ID. Used by the interceptor to detect
+ * whether a task was already created by executeLT (orchestrated mode)
+ * or needs to be created by the interceptor (standalone mode).
+ */
+async function ltGetTaskByWorkflowId(workflowId) {
+    return taskService.getTaskByWorkflowId(workflowId);
+}
+/**
+ * Look up a task by its primary ID.
+ * Used by the interceptor on re-runs to find the original task.
+ */
+async function ltGetTask(taskId) {
+    return taskService.getTask(taskId);
+}

package/build/services/interceptor/activities/workflow.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Signal an orchestrator workflow from within the interceptor.
+ * Used after a child workflow succeeds to send the result back
+ * to the awaiting orchestrator via its waitFor signal.
+ */
+export declare function ltSignalParent(input: {
+    parentTaskQueue: string;
+    parentWorkflowType: string;
+    parentWorkflowId: string;
+    signalId: string;
+    data: any;
+}): Promise<void>;
+/**
+ * Start a workflow from within an activity context.
+ * Used by the triage orchestrator to auto-resolve: directly re-run the
+ * original workflow with correctedData as the resolver, bypassing the
+ * "create escalation → human resolves → re-run" cycle for high-confidence
+ * pass-through cases.
+ */
+export declare function ltStartWorkflow(input: {
+    workflowName: string;
+    taskQueue: string;
+    workflowId: string;
+    args: any[];
+    expire?: number;
+}): Promise<void>;

package/build/services/interceptor/activities/workflow.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ltSignalParent = ltSignalParent;
+exports.ltStartWorkflow = ltStartWorkflow;
+const pg_1 = require("pg");
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const config_1 = require("../../../modules/config");
+const defaults_1 = require("../../../modules/defaults");
+const logger_1 = require("../../logger");
+/**
+ * Signal an orchestrator workflow from within the interceptor.
+ * Used after a child workflow succeeds to send the result back
+ * to the awaiting orchestrator via its waitFor signal.
+ */
+async function ltSignalParent(input) {
+    const client = new hotmesh_1.Durable.Client({
+        connection: { class: pg_1.Client, options: config_1.postgres_options },
+    });
+    const handle = await client.workflow.getHandle(input.parentTaskQueue, input.parentWorkflowType, input.parentWorkflowId);
+    await handle.signal(input.signalId, input.data);
+}
+/**
+ * Start a workflow from within an activity context.
+ * Used by the triage orchestrator to auto-resolve: directly re-run the
+ * original workflow with correctedData as the resolver, bypassing the
+ * "create escalation → human resolves → re-run" cycle for high-confidence
+ * pass-through cases.
+ */
+async function ltStartWorkflow(input) {
+    const client = new hotmesh_1.Durable.Client({
+        connection: { class: pg_1.Client, options: config_1.postgres_options },
+    });
+    await client.workflow.start({
+        workflowName: input.workflowName,
+        args: input.args,
+        taskQueue: input.taskQueue,
+        workflowId: input.workflowId,
+        expire: input.expire ?? defaults_1.JOB_EXPIRE_SECS,
+    });
+    logger_1.loggerRegistry.info(`[ltStartWorkflow] started ${input.workflowName} (${input.workflowId})`);
+}

package/build/services/interceptor/activity-interceptor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Create an LT Activity Interceptor.
+ *
+ * HotMesh activity interceptors support both **before** and **after**
+ * phases via the interruption/replay pattern:
+ *
+ * 1. First execution: before-phase runs → `next()` throws
+ *    `DurableProxyError` → workflow pauses
+ * 2. Second execution: before-phase replays → `next()` returns
+ *    the stored activity result → after-phase runs
+ *
+ * Before phase:
+ *   Injects the envelope's pre-resolved principal into argumentMetadata
+ *   so activities can read it via `Durable.activity.getContext()`.
+ *   Skipped for `lt*` interceptor activities (they don't need identity).
+ *
+ * After phase:
+ *   Inspects the activity result for a `milestones` field. If present,
+ *   milestone events are published to the event registry.
+ *
+ * @see {@link https://hotmeshio.github.io/hotmesh | HotMesh docs}
+ *      `services/durable/interceptor` — Activity Interceptor Replay Pattern
+ */
+export declare function createLTActivityInterceptor(_options?: {
+    activityTaskQueue?: string;
+}): {
+    execute(activityCtx: {
+        activityName: string;
+        args: any[];
+        options?: any;
+    }, workflowCtx: Map<string, any>, next: () => Promise<any>): Promise<any>;
+};

package/build/services/interceptor/activity-interceptor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLTActivityInterceptor = createLTActivityInterceptor;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const publish_1 = require("../events/publish");
+const state_1 = require("./state");
+/**
+ * Create an LT Activity Interceptor.
+ *
+ * HotMesh activity interceptors support both **before** and **after**
+ * phases via the interruption/replay pattern:
+ *
+ * 1. First execution: before-phase runs → `next()` throws
+ *    `DurableProxyError` → workflow pauses
+ * 2. Second execution: before-phase replays → `next()` returns
+ *    the stored activity result → after-phase runs
+ *
+ * Before phase:
+ *   Injects the envelope's pre-resolved principal into argumentMetadata
+ *   so activities can read it via `Durable.activity.getContext()`.
+ *   Skipped for `lt*` interceptor activities (they don't need identity).
+ *
+ * After phase:
+ *   Inspects the activity result for a `milestones` field. If present,
+ *   milestone events are published to the event registry.
+ *
+ * @see {@link https://hotmeshio.github.io/hotmesh | HotMesh docs}
+ *      `services/durable/interceptor` — Activity Interceptor Replay Pattern
+ */
+function createLTActivityInterceptor(_options) {
+    return {
+        async execute(activityCtx, workflowCtx, next) {
+            try {
+                // ── Before phase ─────────────────────────────────────────
+                // Inject principal into argumentMetadata for non-interceptor activities.
+                // The principal was resolved at the front door and travels in the envelope.
+                if (!activityCtx.activityName.startsWith('lt')) {
+                    const envelope = (0, state_1.extractEnvelope)(workflowCtx);
+                    const principal = envelope?.lt?.principal;
+                    if (principal) {
+                        activityCtx.options = {
+                            ...activityCtx.options,
+                            argumentMetadata: {
+                                ...(activityCtx.options?.argumentMetadata ?? {}),
+                                principal,
+                                scopes: envelope.lt?.scopes,
+                                ...(envelope.lt?.initiatingPrincipal
+                                    ? { initiatingPrincipal: envelope.lt.initiatingPrincipal }
+                                    : {}),
+                            },
+                        };
+                    }
+                }
+                // ── Execute the activity ─────────────────────────────────
+                const result = await next();
+                // ── After phase ──────────────────────────────────────────
+                // (runs on replay once the stored result is available)
+                // Check if the activity result includes milestones
+                if (result?.milestones?.length) {
+                    const workflowId = workflowCtx.get('workflowId');
+                    const workflowName = workflowCtx.get('workflowName');
+                    const workflowTopic = workflowCtx.get('workflowTopic');
+                    const taskQueue = workflowTopic
+                        ? workflowTopic.replace(new RegExp(`-${workflowName}$`), '')
+                        : 'long-tail-examples';
+                    await (0, publish_1.publishMilestoneEvent)({
+                        source: 'activity',
+                        workflowId,
+                        workflowName,
+                        taskQueue,
+                        activityName: activityCtx.activityName,
+                        milestones: result.milestones,
+                        data: result.data,
+                    });
+                }
+                return result;
+            }
+            catch (err) {
+                if (hotmesh_1.Durable.didInterrupt(err)) {
+                    throw err;
+                }
+                throw err;
+            }
+        },
+    };
+}

package/build/services/interceptor/completion.d.ts

@@ -0,0 +1,16 @@
+import type { LTReturn } from '../../types';
+import type { InterceptorState } from './types';
+/**
+ * Handle a workflow that returned { type: 'return' }.
+ *
+ * Augments milestones for re-runs, then signals the parent
+ * orchestrator with the result. The orchestrator is responsible
+ * for completing the task and persisting result data.
+ *
+ * If the result contains a `rounds_exhausted` milestone, an advisory
+ * escalation is also created and auto-assigned to the submitting user.
+ *
+ * Returns the (possibly augmented) result so the caller can
+ * return it to the workflow engine.
+ */
+export declare function handleCompletion(state: InterceptorState, result: LTReturn): Promise<LTReturn>;