@exaudeus/workrail 2.1.0 → 3.0.0

package/dist/mcp/handlers/v2-checkpoint.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleV2CheckpointWorkflow = handleV2CheckpointWorkflow;
+exports.executeCheckpoint = executeCheckpoint;
 const neverthrow_1 = require("neverthrow");
 const types_js_1 = require("../types.js");
 const output_schemas_js_1 = require("../output-schemas.js");
@@ -13,19 +14,23 @@ const constants_js_1 = require("../../v2/durable-core/constants.js");
 function findNodeCreated(events, nodeId) {
     return events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.nodeId === String(nodeId));
 }
-function mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts) {
+function mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts, aliasStore, entropy) {
     const wfRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(originalNode.data.workflowHash);
     if (wfRefRes.isErr()) {
-        return { ok: false, error: { kind: 'precondition_failed', message: 'Cannot derive workflowHashRef for stateToken.' } };
+        return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'Cannot derive workflowHashRef for stateToken.' });
     }
-    const stateTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
-        payload: { tokenVersion: 1, tokenKind: 'state', sessionId, runId, nodeId, workflowHashRef: wfRefRes.value },
+    return (0, v2_token_ops_js_1.mintSingleShortToken)({
+        kind: 'state',
+        entry: {
+            sessionId: String(sessionId),
+            runId: String(runId),
+            nodeId: String(nodeId),
+            workflowHashRef: String(wfRefRes.value),
+        },
         ports: tokenCodecPorts,
-    });
-    if (stateTokenRes.isErr()) {
-        return { ok: false, error: { kind: 'token_signing_failed', cause: stateTokenRes.error } };
-    }
-    return { ok: true, value: stateTokenRes.value };
+        aliasStore,
+        entropy,
+    }).mapErr((failure) => ({ kind: 'token_signing_failed', cause: failure }));
 }
 function validateEvents(rawEvents) {
     const validated = [];
@@ -48,65 +53,68 @@ async function handleV2CheckpointWorkflow(input, ctx) {
     return executeCheckpoint(input, guard.ctx).match((payload) => (0, types_js_1.success)(payload), (e) => mapCheckpointErrorToToolError(e));
 }
 function executeCheckpoint(input, ctx) {
-    const { gate, sessionStore, tokenCodecPorts, idFactory } = ctx.v2;
-    const tokenRes = (0, v2_token_ops_js_1.parseCheckpointTokenOrFail)(input.checkpointToken, tokenCodecPorts);
-    if (!tokenRes.ok) {
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: tokenRes.failure });
-    }
-    const token = tokenRes.token;
-    const sessionId = (0, index_js_1.asSessionId)(String(token.payload.sessionId));
-    const runId = (0, index_js_1.asRunId)(String(token.payload.runId));
-    const nodeId = (0, index_js_1.asNodeId)(String(token.payload.nodeId));
-    const attemptId = (0, index_js_1.asAttemptId)(String(token.payload.attemptId));
-    const dedupeKey = `checkpoint:${String(sessionId)}:${String(runId)}:${String(nodeId)}:${String(attemptId)}`;
-    return sessionStore.load(sessionId)
-        .mapErr((cause) => ({ kind: 'store_failed', cause }))
-        .andThen((truth) => {
-        const originalNode = findNodeCreated(truth.events, nodeId);
-        if (!originalNode) {
-            return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
-        }
-        const alreadyRecorded = truth.events.some((e) => e.dedupeKey === dedupeKey);
-        if (alreadyRecorded) {
-            return replayCheckpoint(truth.events, dedupeKey, originalNode, sessionId, runId, nodeId, tokenCodecPorts);
-        }
-        return gate.withHealthySessionLock(sessionId, (lock) => {
-            return sessionStore.load(sessionId)
-                .mapErr((cause) => ({ kind: 'store_failed', cause }))
-                .andThen((truthLocked) => {
-                const originalNodeLocked = findNodeCreated(truthLocked.events, nodeId);
-                if (!originalNodeLocked) {
-                    return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
-                }
-                const alreadyRecordedLocked = truthLocked.events.some((e) => e.dedupeKey === dedupeKey);
-                if (alreadyRecordedLocked) {
-                    return replayCheckpoint(truthLocked.events, dedupeKey, originalNodeLocked, sessionId, runId, nodeId, tokenCodecPorts);
+    const { gate, sessionStore, tokenCodecPorts, idFactory, tokenAliasStore, entropy } = ctx.v2;
+    return (0, v2_token_ops_js_1.parseCheckpointTokenOrFail)(input.checkpointToken, tokenCodecPorts, tokenAliasStore)
+        .mapErr((failure) => ({ kind: 'validation_failed', failure }))
+        .andThen((token) => {
+        const sessionId = (0, index_js_1.asSessionId)(String(token.payload.sessionId));
+        const runId = (0, index_js_1.asRunId)(String(token.payload.runId));
+        const nodeId = (0, index_js_1.asNodeId)(String(token.payload.nodeId));
+        const attemptId = (0, index_js_1.asAttemptId)(String(token.payload.attemptId));
+        const dedupeKey = `checkpoint:${String(sessionId)}:${String(runId)}:${String(nodeId)}:${String(attemptId)}`;
+        return sessionStore.load(sessionId)
+            .mapErr((cause) => ({ kind: 'store_failed', cause }))
+            .andThen((truth) => {
+            const originalNode = findNodeCreated(truth.events, nodeId);
+            if (!originalNode) {
+                return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
+            }
+            const alreadyRecorded = truth.events.some((e) => e.dedupeKey === dedupeKey);
+            if (alreadyRecorded) {
+                return replayCheckpoint(truth.events, dedupeKey, originalNode, sessionId, runId, nodeId, attemptId, tokenCodecPorts, tokenAliasStore, entropy);
+            }
+            return gate.withHealthySessionLock(sessionId, (lock) => {
+                return sessionStore.load(sessionId)
+                    .mapErr((cause) => ({ kind: 'store_failed', cause }))
+                    .andThen((truthLocked) => {
+                    const originalNodeLocked = findNodeCreated(truthLocked.events, nodeId);
+                    if (!originalNodeLocked) {
+                        return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
+                    }
+                    const alreadyRecordedLocked = truthLocked.events.some((e) => e.dedupeKey === dedupeKey);
+                    if (alreadyRecordedLocked) {
+                        return replayCheckpoint(truthLocked.events, dedupeKey, originalNodeLocked, sessionId, runId, nodeId, attemptId, tokenCodecPorts, tokenAliasStore, entropy);
+                    }
+                    return writeCheckpoint(truthLocked, dedupeKey, originalNodeLocked, sessionId, runId, nodeId, attemptId, idFactory.mintNodeId(), () => idFactory.mintEventId(), lock, sessionStore, tokenCodecPorts, tokenAliasStore, entropy);
+                });
+            }).mapErr((gateErr) => {
+                if (isGateError(gateErr)) {
+                    return { kind: 'gate_failed', cause: gateErr };
                 }
-                return writeCheckpoint(truthLocked, dedupeKey, originalNodeLocked, sessionId, runId, nodeId, idFactory.mintNodeId(), () => idFactory.mintEventId(), lock, sessionStore, tokenCodecPorts);
+                return gateErr;
             });
-        }).mapErr((gateErr) => {
-            if (isGateError(gateErr)) {
-                return { kind: 'gate_failed', cause: gateErr };
-            }
-            return gateErr;
         });
     });
 }
-function replayCheckpoint(events, dedupeKey, originalNode, sessionId, runId, nodeId, tokenCodecPorts) {
+function replayCheckpoint(events, dedupeKey, originalNode, sessionId, runId, nodeId, attemptId, tokenCodecPorts, aliasStore, entropy) {
     const existingCheckpointNode = events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.dedupeKey === `checkpoint_node:${dedupeKey}`);
     const checkpointNodeId = existingCheckpointNode
         ? String(existingCheckpointNode.scope?.nodeId ?? 'unknown')
         : 'unknown';
-    const tokenResult = mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts);
-    if (!tokenResult.ok)
-        return (0, neverthrow_1.errAsync)(tokenResult.error);
-    return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
+    const workflowHashRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(originalNode.data.workflowHash);
+    const workflowHashRef = workflowHashRefRes.isOk() ? workflowHashRefRes.value : undefined;
+    return mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts, aliasStore, entropy)
+        .andThen((stateTokenValue) => (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({
+        entry: { sessionId: String(sessionId), runId: String(runId), nodeId: String(nodeId), attemptId: String(attemptId), workflowHashRef },
+        ports: tokenCodecPorts, aliasStore, entropy,
+    }).andThen(({ continueToken }) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
         checkpointNodeId,
-        stateToken: tokenResult.value,
-        nextCall: { tool: 'continue_workflow', params: { intent: 'rehydrate', stateToken: tokenResult.value } },
-    }));
+        stateToken: stateTokenValue,
+        nextCall: { tool: 'continue_workflow', params: { continueToken } },
+    }))))
+        .mapErr((e) => ({ kind: 'store_failed', cause: e }));
 }
-function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeId, checkpointNodeId, mintEventId, lock, sessionStore, tokenCodecPorts) {
+function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeId, attemptId, checkpointNodeId, mintEventId, lock, sessionStore, tokenCodecPorts, aliasStore, entropy) {
     const nodeCreatedEventId = mintEventId();
     const edgeCreatedEventId = mintEventId();
     const rawEvents = [
@@ -156,14 +164,18 @@ function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeI
     return sessionStore.append(lock, { events: validated, snapshotPins })
         .mapErr((cause) => ({ kind: 'store_failed', cause }))
         .andThen(() => {
-        const tokenResult = mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts);
-        if (!tokenResult.ok)
-            return (0, neverthrow_1.errAsync)(tokenResult.error);
-        return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
+        const workflowHashRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(originalNode.data.workflowHash);
+        const workflowHashRef = workflowHashRefRes.isOk() ? workflowHashRefRes.value : undefined;
+        return mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts, aliasStore, entropy)
+            .andThen((stateTokenValue) => (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({
+            entry: { sessionId: String(sessionId), runId: String(runId), nodeId: String(nodeId), attemptId: String(attemptId), workflowHashRef },
+            ports: tokenCodecPorts, aliasStore, entropy,
+        }).andThen(({ continueToken }) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
             checkpointNodeId: String(checkpointNodeId),
-            stateToken: tokenResult.value,
-            nextCall: { tool: 'continue_workflow', params: { intent: 'rehydrate', stateToken: tokenResult.value } },
-        }));
+            stateToken: stateTokenValue,
+            nextCall: { tool: 'continue_workflow', params: { continueToken } },
+        }))))
+            .mapErr((e) => ({ kind: 'store_failed', cause: e }));
     });
 }
 function mapCheckpointErrorToToolError(e) {

package/dist/mcp/handlers/v2-execution/continue-advance.d.ts

@@ -26,4 +26,6 @@ export declare function handleAdvanceIntent(args: {
         readonly mintEventId: () => string;
     };
     readonly sha256: Sha256PortV2;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;

package/dist/mcp/handlers/v2-execution/continue-advance.js

@@ -11,7 +11,7 @@ const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const replay_js_1 = require("./replay.js");
 const advance_js_1 = require("./advance.js");
 function handleAdvanceIntent(args) {
-    const { input, sessionId, runId, nodeId, attemptId, workflowHashRef, truth, gate, sessionStore, snapshotStore, pinnedStore, tokenCodecPorts, idFactory, sha256 } = args;
+    const { input, sessionId, runId, nodeId, attemptId, workflowHashRef, truth, gate, sessionStore, snapshotStore, pinnedStore, tokenCodecPorts, idFactory, sha256, aliasStore, entropy } = args;
     const dedupeKey = `advance_recorded:${sessionId}:${nodeId}:${attemptId}`;
     const runStarted = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.RUN_STARTED && e.scope.runId === String(runId));
     if (!runStarted) {
@@ -85,12 +85,12 @@ function handleAdvanceIntent(args) {
                 nodeId,
                 workflowHash,
                 attemptId,
-                inputStateToken: input.stateToken,
-                inputAckToken: input.ackToken,
                 pinnedWorkflow,
                 snapshotStore,
                 sha256,
                 tokenCodecPorts,
+                aliasStore,
+                entropy,
             });
         }
         return gate
@@ -162,12 +162,12 @@ function handleAdvanceIntent(args) {
                 nodeId,
                 workflowHash,
                 attemptId,
-                inputStateToken: input.stateToken,
-                inputAckToken: input.ackToken,
                 pinnedWorkflow,
                 snapshotStore,
                 sha256,
                 tokenCodecPorts,
+                aliasStore,
+                entropy,
             });
         });
     });

package/dist/mcp/handlers/v2-execution/continue-rehydrate.d.ts

@@ -19,4 +19,6 @@ export declare function handleRehydrateIntent(args: {
     readonly idFactory: {
         readonly mintAttemptId: () => import('../../../v2/durable-core/tokens/index.js').AttemptId;
     };
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;

package/dist/mcp/handlers/v2-execution/continue-rehydrate.js

@@ -16,7 +16,7 @@ const v2_state_conversion_js_1 = require("../v2-state-conversion.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const index_js_2 = require("./index.js");
 function handleRehydrateIntent(args) {
-    const { input, sessionId, runId, nodeId, workflowHashRef, truth, tokenCodecPorts, pinnedStore, snapshotStore, idFactory } = args;
+    const { input, sessionId, runId, nodeId, workflowHashRef, truth, tokenCodecPorts, pinnedStore, snapshotStore, idFactory, aliasStore, entropy } = args;
     const runStarted = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.RUN_STARTED && e.scope.runId === String(runId));
     const workflowId = runStarted?.data.workflowId;
     if (!runStarted || typeof workflowId !== 'string' || workflowId.trim() === '') {
@@ -75,28 +75,24 @@ function handleRehydrateIntent(args) {
             const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: true, isComplete, pending: null });
             return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                 kind: 'ok',
-                stateToken: input.stateToken,
                 isComplete,
                 pending: null,
                 preferences,
                 nextIntent,
-                nextCall: (0, index_js_2.buildNextCall)({ stateToken: input.stateToken, ackToken: undefined, isComplete, pending: null }),
+                nextCall: null,
             }));
         }
         const attemptId = (0, v2_token_ops_js_1.newAttemptId)(idFactory);
-        const ackTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
-            payload: { tokenVersion: 1, tokenKind: 'ack', sessionId, runId, nodeId, attemptId },
-            ports: tokenCodecPorts,
-        });
-        if (ackTokenRes.isErr())
-            return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: ackTokenRes.error });
-        const checkpointTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
-            payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
-            ports: tokenCodecPorts,
-        });
-        if (checkpointTokenRes.isErr())
-            return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointTokenRes.error });
-        return pinnedStore.get(workflowHash)
+        const entryBase = {
+            sessionId: String(sessionId),
+            runId: String(runId),
+            nodeId: String(nodeId),
+            attemptId: String(attemptId),
+            workflowHashRef: String(workflowHashRef),
+        };
+        return (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({ entry: entryBase, ports: tokenCodecPorts, aliasStore, entropy })
+            .mapErr((failure) => ({ kind: 'token_signing_failed', cause: failure }))
+            .andThen(({ continueToken: continueTokenValue, checkpointToken: checkpointTokenValue }) => pinnedStore.get(workflowHash)
             .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
             .andThen((pinned) => {
             if (!pinned)
@@ -131,15 +127,14 @@ function handleRehydrateIntent(args) {
             const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: true, isComplete, pending: meta });
             return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                 kind: 'ok',
-                stateToken: input.stateToken,
-                ackToken: ackTokenRes.value,
-                checkpointToken: checkpointTokenRes.value,
+                continueToken: continueTokenValue,
+                checkpointToken: checkpointTokenValue,
                 isComplete,
-                pending: { stepId: meta.stepId, title: meta.title, prompt: meta.prompt },
+                pending: (0, output_schemas_js_1.toPendingStep)(meta),
                 preferences,
                 nextIntent,
-                nextCall: (0, index_js_2.buildNextCall)({ stateToken: input.stateToken, ackToken: ackTokenRes.value, isComplete, pending: meta }),
+                nextCall: (0, index_js_2.buildNextCall)({ continueToken: continueTokenValue, isComplete, pending: meta }),
             }));
-        });
+        }));
     });
 }

package/dist/mcp/handlers/v2-execution/index.d.ts

@@ -1,31 +1,24 @@
-import type { ToolContext, ToolResult } from '../../types.js';
+import type { ToolContext, ToolResult, V2ToolContext } from '../../types.js';
 import type { V2ContinueWorkflowInput, V2StartWorkflowInput } from '../../v2/tools.js';
-type NextCallAdvance = {
+import { V2ContinueWorkflowOutputSchema } from '../../output-schemas.js';
+import { ResultAsync as RA } from 'neverthrow';
+import { type ContinueWorkflowError } from '../v2-execution-helpers.js';
+import * as z from 'zod';
+type NextCallTemplate = {
     readonly tool: 'continue_workflow';
     readonly params: {
-        readonly intent: 'advance';
-        readonly stateToken: string;
-        readonly ackToken: string;
+        readonly continueToken: string;
     };
 };
-type NextCallRehydrate = {
-    readonly tool: 'continue_workflow';
-    readonly params: {
-        readonly intent: 'rehydrate';
-        readonly stateToken: string;
-    };
-};
-type NextCallTemplate = NextCallAdvance | NextCallRehydrate;
 export declare function buildNextCall(args: {
-    readonly stateToken: string;
-    readonly ackToken: string | undefined;
+    readonly continueToken?: string;
     readonly isComplete: boolean;
     readonly pending: {
         readonly stepId: string;
     } | null;
-    readonly retryable?: boolean;
-    readonly retryAckToken?: string;
+    readonly retryContinueToken?: string;
 }): NextCallTemplate | null;
 export declare function handleV2StartWorkflow(input: V2StartWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
 export declare function handleV2ContinueWorkflow(input: V2ContinueWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
+export declare function executeContinueWorkflow(input: V2ContinueWorkflowInput, ctx: V2ToolContext): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;
 export {};

package/dist/mcp/handlers/v2-execution/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildNextCall = buildNextCall;
 exports.handleV2StartWorkflow = handleV2StartWorkflow;
 exports.handleV2ContinueWorkflow = handleV2ContinueWorkflow;
+exports.executeContinueWorkflow = executeContinueWorkflow;
 const types_js_1 = require("../../types.js");
 const index_js_1 = require("../../../v2/durable-core/tokens/index.js");
 const index_js_2 = require("../../../v2/durable-core/ids/index.js");
@@ -16,18 +17,13 @@ const continue_advance_js_1 = require("./continue-advance.js");
 function buildNextCall(args) {
     if (args.isComplete && !args.pending)
         return null;
-    if (args.retryable && args.retryAckToken) {
-        return {
-            tool: 'continue_workflow',
-            params: { intent: 'advance', stateToken: args.stateToken, ackToken: args.retryAckToken },
-        };
+    if (args.retryContinueToken) {
+        return { tool: 'continue_workflow', params: { continueToken: args.retryContinueToken } };
     }
-    if (!args.ackToken)
-        return null;
-    return {
-        tool: 'continue_workflow',
-        params: { intent: 'advance', stateToken: args.stateToken, ackToken: args.ackToken },
-    };
+    if (args.continueToken) {
+        return { tool: 'continue_workflow', params: { continueToken: args.continueToken } };
+    }
+    return null;
 }
 async function handleV2StartWorkflow(input, ctx) {
     const guard = (0, types_js_1.requireV2Context)(ctx);
@@ -42,61 +38,55 @@ async function handleV2ContinueWorkflow(input, ctx) {
     return executeContinueWorkflow(input, guard.ctx).match((payload) => (0, types_js_1.success)(payload), (e) => (0, v2_execution_helpers_js_1.mapContinueWorkflowErrorToToolError)(e));
 }
 function executeContinueWorkflow(input, ctx) {
-    const { gate, sessionStore, snapshotStore, pinnedStore, sha256, tokenCodecPorts, idFactory } = ctx.v2;
-    const stateRes = (0, v2_token_ops_js_1.parseStateTokenOrFail)(input.stateToken, tokenCodecPorts);
-    if (!stateRes.ok)
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: stateRes.failure });
-    const state = stateRes.token;
+    const { gate, sessionStore, snapshotStore, pinnedStore, sha256, tokenCodecPorts, idFactory, tokenAliasStore, entropy } = ctx.v2;
     const ctxCheck = (0, v2_context_budget_js_1.checkContextBudget)({ tool: 'continue_workflow', context: input.context });
     if (!ctxCheck.ok)
         return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: ctxCheck.error });
-    const sessionId = (0, index_js_2.asSessionId)(state.payload.sessionId);
-    const runId = (0, index_js_2.asRunId)(state.payload.runId);
-    const nodeId = (0, index_js_2.asNodeId)(state.payload.nodeId);
-    const workflowHashRef = state.payload.workflowHashRef;
-    if (input.intent === 'rehydrate') {
+    return (0, v2_token_ops_js_1.parseContinueTokenOrFail)(input.continueToken, tokenCodecPorts, tokenAliasStore)
+        .mapErr((failure) => ({ kind: 'validation_failed', failure }))
+        .andThen((resolved) => {
+        const sessionId = (0, index_js_2.asSessionId)(resolved.sessionId);
+        const runId = (0, index_js_2.asRunId)(resolved.runId);
+        const nodeId = (0, index_js_2.asNodeId)(resolved.nodeId);
+        const workflowHashRef = resolved.workflowHashRef;
+        if (input.intent === 'rehydrate') {
+            return sessionStore.load(sessionId)
+                .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
+                .andThen((truth) => (0, continue_rehydrate_js_1.handleRehydrateIntent)({
+                input,
+                sessionId,
+                runId,
+                nodeId,
+                workflowHashRef,
+                truth,
+                tokenCodecPorts,
+                pinnedStore,
+                snapshotStore,
+                idFactory,
+                aliasStore: tokenAliasStore,
+                entropy,
+            }));
+        }
+        const attemptId = (0, index_js_1.asAttemptId)(resolved.attemptId);
         return sessionStore.load(sessionId)
             .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
-            .andThen((truth) => (0, continue_rehydrate_js_1.handleRehydrateIntent)({
+            .andThen((truth) => (0, continue_advance_js_1.handleAdvanceIntent)({
             input,
             sessionId,
             runId,
             nodeId,
+            attemptId,
             workflowHashRef,
             truth,
-            tokenCodecPorts,
-            pinnedStore,
+            gate,
+            sessionStore,
             snapshotStore,
+            pinnedStore,
+            tokenCodecPorts,
             idFactory,
+            sha256,
+            aliasStore: tokenAliasStore,
+            entropy,
         }));
-    }
-    if (!input.ackToken) {
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: (0, types_js_1.error)('VALIDATION_ERROR', 'ackToken is required for advance intent') });
-    }
-    const ackRes = (0, v2_token_ops_js_1.parseAckTokenOrFail)(input.ackToken, tokenCodecPorts);
-    if (!ackRes.ok)
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: ackRes.failure });
-    const ack = ackRes.token;
-    const scopeRes = (0, index_js_1.assertTokenScopeMatchesStateBinary)(state, ack);
-    if (scopeRes.isErr())
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: (0, v2_execution_helpers_js_1.mapTokenDecodeErrorToToolError)(scopeRes.error) });
-    const attemptId = (0, index_js_1.asAttemptId)(ack.payload.attemptId);
-    return sessionStore.load(sessionId)
-        .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
-        .andThen((truth) => (0, continue_advance_js_1.handleAdvanceIntent)({
-        input,
-        sessionId,
-        runId,
-        nodeId,
-        attemptId,
-        workflowHashRef,
-        truth,
-        gate,
-        sessionStore,
-        snapshotStore,
-        pinnedStore,
-        tokenCodecPorts,
-        idFactory,
-        sha256,
-    }));
+    });
 }

package/dist/mcp/handlers/v2-execution/replay.d.ts

@@ -10,19 +10,6 @@ import type { TokenCodecPorts } from '../../../v2/durable-core/tokens/token-code
 import { ResultAsync as RA } from 'neverthrow';
 import { type ContinueWorkflowError } from '../v2-execution-helpers.js';
 import * as z from 'zod';
-export declare function buildBlockedReplayResponse(args: {
-    readonly sessionId: SessionId;
-    readonly runId: RunId;
-    readonly nodeId: NodeId;
-    readonly attemptId: AttemptId;
-    readonly blockers: import('../../../v2/durable-core/schemas/session/blockers.js').BlockerReportV1;
-    readonly snapshot: ExecutionSnapshotFileV1 | null;
-    readonly truth: LoadedSessionTruthV2;
-    readonly workflow: ReturnType<typeof createWorkflow>;
-    readonly inputStateToken: string;
-    readonly inputAckToken: string;
-    readonly ports: TokenCodecPorts;
-}): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;
 export declare function buildAdvancedReplayResponse(args: {
     readonly sessionId: SessionId;
     readonly runId: RunId;
@@ -35,6 +22,8 @@ export declare function buildAdvancedReplayResponse(args: {
     readonly workflowHash: WorkflowHash;
     readonly ports: TokenCodecPorts;
     readonly sha256: Sha256PortV2;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;
 export declare function replayFromRecordedAdvance(args: {
     readonly recordedEvent: Extract<DomainEventV1, {
@@ -46,10 +35,10 @@ export declare function replayFromRecordedAdvance(args: {
     readonly nodeId: NodeId;
     readonly workflowHash: WorkflowHash;
     readonly attemptId: AttemptId;
-    readonly inputStateToken: string;
-    readonly inputAckToken: string;
     readonly pinnedWorkflow: ReturnType<typeof createWorkflow>;
     readonly snapshotStore: import('../../../v2/ports/snapshot-store.port.js').SnapshotStorePortV2;
     readonly sha256: Sha256PortV2;
     readonly tokenCodecPorts: TokenCodecPorts;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;