@exaudeus/workrail 0.11.0 → 0.12.0

package/dist/mcp/server.js

@@ -38,6 +38,7 @@ exports.startServer = startServer;
 const zod_to_json_schema_js_1 = require("./zod-to-json-schema.js");
 const container_js_1 = require("../di/container.js");
 const tokens_js_1 = require("../di/tokens.js");
+const types_js_1 = require("./types.js");
 const tool_factory_js_1 = require("./tool-factory.js");
 const workflow_next_prevalidate_js_1 = require("./validation/workflow-next-prevalidate.js");
 const bounded_json_js_1 = require("./validation/bounded-json.js");
@@ -56,16 +57,17 @@ function toMcpResult(result) {
                 content: [{
                         type: 'text',
                         text: JSON.stringify({
-                            error: result.message,
                             code: result.code,
-                            ...(result.suggestion && { suggestion: result.suggestion }),
+                            message: result.message,
+                            retry: result.retry,
+                            ...(result.details !== undefined ? { details: result.details } : {}),
                         }, null, 2),
                     }],
                 isError: true,
             };
     }
 }
-function createToolContext() {
+async function createToolContext() {
     const workflowService = container_js_1.container.resolve(tokens_js_1.DI.Services.Workflow);
     const featureFlags = container_js_1.container.resolve(tokens_js_1.DI.Infra.FeatureFlags);
     let sessionManager = null;
@@ -78,11 +80,40 @@ function createToolContext() {
     else {
         console.error('[FeatureFlags] Session tools disabled (enable with WORKRAIL_ENABLE_SESSION_TOOLS=true)');
     }
+    let v2 = null;
+    if (featureFlags.isEnabled('v2Tools')) {
+        const gate = container_js_1.container.resolve(tokens_js_1.DI.V2.ExecutionGate);
+        const sessionStore = container_js_1.container.resolve(tokens_js_1.DI.V2.SessionStore);
+        const snapshotStore = container_js_1.container.resolve(tokens_js_1.DI.V2.SnapshotStore);
+        const pinnedStore = container_js_1.container.resolve(tokens_js_1.DI.V2.PinnedWorkflowStore);
+        const keyringPort = container_js_1.container.resolve(tokens_js_1.DI.V2.Keyring);
+        const keyringResult = await keyringPort.loadOrCreate();
+        if (keyringResult.isErr()) {
+            console.error(`[FeatureFlags] v2 tools enabled but keyring load failed: ${keyringResult.error.code}`);
+            throw new Error(`Failed to initialize v2 keyring: ${keyringResult.error.message}`);
+        }
+        const crypto = container_js_1.container.resolve(tokens_js_1.DI.V2.Crypto);
+        const hmac = container_js_1.container.resolve(tokens_js_1.DI.V2.HmacSha256);
+        v2 = {
+            gate,
+            sessionStore,
+            snapshotStore,
+            pinnedStore,
+            keyring: keyringResult.value,
+            crypto,
+            hmac,
+        };
+        console.error('[FeatureFlags] v2 tools enabled');
+    }
+    else {
+        console.error('[FeatureFlags] v2 tools disabled (enable with WORKRAIL_ENABLE_V2_TOOLS=true)');
+    }
     return {
         workflowService,
         featureFlags,
         sessionManager,
         httpServer,
+        v2,
     };
 }
 function toMcpTool(tool) {
@@ -97,20 +128,12 @@ function createHandler(schema, handler) {
     return async (args, ctx) => {
         const parseResult = schema.safeParse(args);
         if (!parseResult.success) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            error: 'Invalid input',
-                            code: 'VALIDATION_ERROR',
-                            details: parseResult.error.errors.map(e => ({
-                                path: e.path.join('.'),
-                                message: e.message,
-                            })),
-                        }, null, 2),
-                    }],
-                isError: true,
-            };
+            return toMcpResult((0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Invalid input', {
+                validationErrors: parseResult.error.errors.map(e => ({
+                    path: e.path.join('.'),
+                    message: e.message,
+                })),
+            }));
         }
         return toMcpResult(await handler(parseResult.data, ctx));
     };
@@ -118,26 +141,29 @@ function createHandler(schema, handler) {
 function createValidatingHandler(schema, preValidate, handler) {
     return async (args, ctx) => {
         const pre = preValidate(args);
-        if (!pre.ok) {
-            const bounded = pre.correctTemplate ? (0, bounded_json_js_1.toBoundedJsonValue)(pre.correctTemplate, 512) : undefined;
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            error: pre.message,
-                            code: pre.code,
-                            ...(bounded ? { correctTemplate: bounded } : {}),
-                        }, null, 2),
-                    }],
-                isError: true,
-            };
+        if ('error' in pre && !pre.ok) {
+            const error = pre.error;
+            const details = error.details && typeof error.details === 'object' ? error.details : {};
+            const correctTemplate = details.correctTemplate;
+            if (correctTemplate !== undefined) {
+                const boundedTemplate = (0, bounded_json_js_1.toBoundedJsonValue)(correctTemplate, 512);
+                const boundedError = {
+                    ...error,
+                    details: {
+                        ...details,
+                        correctTemplate: boundedTemplate,
+                    },
+                };
+                return toMcpResult(boundedError);
+            }
+            return toMcpResult(error);
         }
         return createHandler(schema, handler)(args, ctx);
     };
 }
 async function startServer() {
     await (0, container_js_1.bootstrap)({ runtimeMode: { kind: 'production' } });
-    const ctx = createToolContext();
+    const ctx = await createToolContext();
     const descriptionProvider = container_js_1.container.resolve(tokens_js_1.DI.Mcp.DescriptionProvider);
     const buildTool = (0, tool_factory_js_1.createToolFactory)(descriptionProvider);
     const workflowListTool = buildTool({

package/dist/mcp/tool-descriptions.js

@@ -45,6 +45,15 @@ This tool provides:
 - Schema version and metadata information`,
         list_workflows: `Lists available workflows using the WorkRail v2 read-only surface (feature-flagged). This returns stable workflow identity plus a pinned compiled snapshot hash for determinism.`,
         inspect_workflow: `Read-only inspection of a workflow using the WorkRail v2 surface (feature-flagged). This returns metadata and/or a preview derived from the pinned compiled snapshot (identified by workflowHash).`,
+        start_workflow: `Start a WorkRail v2 workflow run (feature-flagged). Returns an initial pending step plus opaque execution tokens.
+
+Notes:
+- Tokens are opaque: round-trip them unchanged.
+- This tool may create durable session/run state. Keep inputs small and deterministic.`,
+        continue_workflow: `Continue a WorkRail v2 workflow run (feature-flagged).
+
+- If you provide \`ackToken\`: acknowledge completion of the pending step for the given snapshot (idempotent).
+- If you omit \`ackToken\`: rehydrate the pending step for the given snapshot (MUST be side-effect-free).`,
     },
     authoritative: {
         workflow_list: `Check for workflows that apply to the user's request. Workflows are the user's pre-defined instructions that you MUST follow when they exist.
@@ -105,5 +114,13 @@ This tool is read-only and is intended to validate the v2 determinism substrate
         inspect_workflow: `Inspect a workflow via the WorkRail v2 tool surface (feature-flagged).
 
 This tool is read-only. It MUST reflect the pinned compiled snapshot identified by workflowHash (not mutable on-disk source).`,
+        start_workflow: `Start a workflow run via the WorkRail v2 token-based execution surface (feature-flagged).
+
+You MUST treat returned tokens as opaque and round-trip them unchanged.`,
+        continue_workflow: `Continue a workflow run via the WorkRail v2 token-based execution surface (feature-flagged).
+
+REQUIRED BEHAVIOR:
+- If \`ackToken\` is omitted: rehydrate-only MUST be side-effect-free (no durable writes).
+- If \`ackToken\` is provided: advancement MUST be idempotent and replay-safe for the given tokens.`,
     },
 };

package/dist/mcp/tools.js

@@ -72,6 +72,16 @@ exports.WORKFLOW_TOOL_ANNOTATIONS = {
         destructiveHint: false,
         idempotentHint: true,
     },
+    start_workflow: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+    },
+    continue_workflow: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
 };
 exports.WORKFLOW_TOOL_TITLES = {
     workflow_list: 'List Available Workflows',
@@ -81,6 +91,8 @@ exports.WORKFLOW_TOOL_TITLES = {
     workflow_get_schema: 'Get Workflow Schema',
     list_workflows: 'List Workflows (v2)',
     inspect_workflow: 'Inspect Workflow (v2)',
+    start_workflow: 'Start Workflow (v2)',
+    continue_workflow: 'Continue Workflow (v2)',
 };
 exports.CreateSessionInput = zod_1.z.object({
     workflowId: zod_1.z

package/dist/mcp/types/tool-description-types.d.ts

@@ -1,6 +1,6 @@
 export declare const DESCRIPTION_MODES: readonly ["standard", "authoritative"];
 export type DescriptionMode = typeof DESCRIPTION_MODES[number];
-export declare const WORKFLOW_TOOL_NAMES: readonly ["workflow_list", "workflow_get", "workflow_next", "workflow_validate_json", "workflow_get_schema", "list_workflows", "inspect_workflow"];
+export declare const WORKFLOW_TOOL_NAMES: readonly ["workflow_list", "workflow_get", "workflow_next", "workflow_validate_json", "workflow_get_schema", "list_workflows", "inspect_workflow", "start_workflow", "continue_workflow"];
 export type WorkflowToolName = typeof WORKFLOW_TOOL_NAMES[number];
 export type ToolDescriptionMap = Readonly<Record<WorkflowToolName, string>>;
 export type DescriptionsByMode = Readonly<Record<DescriptionMode, ToolDescriptionMap>>;

package/dist/mcp/types/tool-description-types.js

@@ -15,6 +15,8 @@ exports.WORKFLOW_TOOL_NAMES = [
     'workflow_get_schema',
     'list_workflows',
     'inspect_workflow',
+    'start_workflow',
+    'continue_workflow',
 ];
 function isDescriptionMode(value) {
     return exports.DESCRIPTION_MODES.includes(value);

package/dist/mcp/types.d.ts

@@ -2,7 +2,27 @@ import type { WorkflowService } from '../application/services/workflow-service.j
 import type { IFeatureFlagProvider } from '../config/feature-flags.js';
 import type { SessionManager } from '../infrastructure/session/SessionManager.js';
 import type { HttpServer } from '../infrastructure/session/HttpServer.js';
-export type ErrorCode = 'VALIDATION_ERROR' | 'NOT_FOUND' | 'PRECONDITION_FAILED' | 'TIMEOUT' | 'INTERNAL_ERROR';
+import type { SessionHealthV2 } from '../v2/durable-core/schemas/session/session-health.js';
+import type { ExecutionSessionGateV2 } from '../v2/usecases/execution-session-gate.js';
+import type { SessionEventLogAppendStorePortV2, SessionEventLogReadonlyStorePortV2 } from '../v2/ports/session-event-log-store.port.js';
+import type { SnapshotStorePortV2 } from '../v2/ports/snapshot-store.port.js';
+import type { PinnedWorkflowStorePortV2 } from '../v2/ports/pinned-workflow-store.port.js';
+import type { KeyringV1 } from '../v2/ports/keyring.port.js';
+import type { CryptoPortV2 } from '../v2/durable-core/canonical/hashing.js';
+import type { HmacSha256PortV2 } from '../v2/ports/hmac-sha256.port.js';
+import type { JsonValue } from './output-schemas.js';
+export interface SessionHealthDetails {
+    readonly health: SessionHealthV2;
+}
+export type ErrorCode = 'VALIDATION_ERROR' | 'NOT_FOUND' | 'PRECONDITION_FAILED' | 'TIMEOUT' | 'INTERNAL_ERROR' | 'TOKEN_INVALID_FORMAT' | 'TOKEN_UNSUPPORTED_VERSION' | 'TOKEN_BAD_SIGNATURE' | 'TOKEN_SCOPE_MISMATCH' | 'TOKEN_UNKNOWN_NODE' | 'TOKEN_WORKFLOW_HASH_MISMATCH' | 'TOKEN_SESSION_LOCKED' | 'SESSION_NOT_HEALTHY';
+export type ToolRetry = {
+    readonly kind: 'not_retryable';
+} | {
+    readonly kind: 'retryable_immediate';
+} | {
+    readonly kind: 'retryable_after_ms';
+    readonly afterMs: number;
+};
 export interface ToolSuccess<T> {
     readonly type: 'success';
     readonly data: T;
@@ -11,15 +31,30 @@ export interface ToolError {
     readonly type: 'error';
     readonly code: ErrorCode;
     readonly message: string;
-    readonly suggestion?: string;
+    readonly retry: ToolRetry;
+    readonly details?: JsonValue;
 }
 export type ToolResult<T> = ToolSuccess<T> | ToolError;
 export declare const success: <T>(data: T) => ToolResult<T>;
-export declare const error: (code: ErrorCode, message: string, suggestion?: string) => ToolResult<never>;
+export declare const errNotRetryable: (code: ErrorCode, message: string, details?: JsonValue) => ToolError;
+export declare const errRetryAfterMs: (code: ErrorCode, message: string, afterMs: number, details?: JsonValue) => ToolError;
+export declare const errRetryImmediate: (code: ErrorCode, message: string, details?: JsonValue) => ToolError;
+export declare const error: (code: ErrorCode, message: string, suggestion?: string, retry?: ToolRetry) => ToolError;
+export declare function detailsSessionHealth(health: SessionHealthV2): SessionHealthDetails;
+export interface V2Dependencies {
+    readonly gate: ExecutionSessionGateV2;
+    readonly sessionStore: SessionEventLogAppendStorePortV2 & SessionEventLogReadonlyStorePortV2;
+    readonly snapshotStore: SnapshotStorePortV2;
+    readonly pinnedStore: PinnedWorkflowStorePortV2;
+    readonly keyring: KeyringV1;
+    readonly crypto: CryptoPortV2;
+    readonly hmac: HmacSha256PortV2;
+}
 export interface ToolContext {
     readonly workflowService: WorkflowService;
     readonly featureFlags: IFeatureFlagProvider;
     readonly sessionManager: SessionManager | null;
     readonly httpServer: HttpServer | null;
+    readonly v2: V2Dependencies | null;
 }
 export type ToolHandler<TInput, TOutput> = (input: TInput, ctx: ToolContext) => Promise<ToolResult<TOutput>>;

package/dist/mcp/types.js

@@ -1,15 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.error = exports.success = void 0;
+exports.error = exports.errRetryImmediate = exports.errRetryAfterMs = exports.errNotRetryable = exports.success = void 0;
+exports.detailsSessionHealth = detailsSessionHealth;
 const success = (data) => ({
     type: 'success',
     data,
 });
 exports.success = success;
-const error = (code, message, suggestion) => ({
+const errNotRetryable = (code, message, details) => ({
     type: 'error',
     code,
     message,
-    suggestion,
+    retry: { kind: 'not_retryable' },
+    details,
+});
+exports.errNotRetryable = errNotRetryable;
+const errRetryAfterMs = (code, message, afterMs, details) => ({
+    type: 'error',
+    code,
+    message,
+    retry: { kind: 'retryable_after_ms', afterMs },
+    details,
+});
+exports.errRetryAfterMs = errRetryAfterMs;
+const errRetryImmediate = (code, message, details) => ({
+    type: 'error',
+    code,
+    message,
+    retry: { kind: 'retryable_immediate' },
+    details,
+});
+exports.errRetryImmediate = errRetryImmediate;
+const error = (code, message, suggestion, retry) => ({
+    type: 'error',
+    code,
+    message,
+    retry: retry ?? { kind: 'not_retryable' },
+    details: suggestion ? { suggestion } : undefined,
 });
 exports.error = error;
+function detailsSessionHealth(health) {
+    return { health };
+}

package/dist/mcp/v2/tool-registry.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildV2ToolRegistry = buildV2ToolRegistry;
 const tools_js_1 = require("./tools.js");
+const v2_execution_js_1 = require("../handlers/v2-execution.js");
 const v2_workflow_js_1 = require("../handlers/v2-workflow.js");
 function buildV2ToolRegistry(buildTool) {
     const listTool = buildTool({
@@ -16,11 +17,25 @@ function buildV2ToolRegistry(buildTool) {
         inputSchema: tools_js_1.V2InspectWorkflowInput,
         annotations: tools_js_1.V2_TOOL_ANNOTATIONS.inspect_workflow,
     });
+    const startTool = buildTool({
+        name: 'start_workflow',
+        title: tools_js_1.V2_TOOL_TITLES.start_workflow,
+        inputSchema: tools_js_1.V2StartWorkflowInput,
+        annotations: tools_js_1.V2_TOOL_ANNOTATIONS.start_workflow,
+    });
+    const continueTool = buildTool({
+        name: 'continue_workflow',
+        title: tools_js_1.V2_TOOL_TITLES.continue_workflow,
+        inputSchema: tools_js_1.V2ContinueWorkflowInput,
+        annotations: tools_js_1.V2_TOOL_ANNOTATIONS.continue_workflow,
+    });
     return {
-        tools: [listTool, inspectTool],
+        tools: [listTool, inspectTool, startTool, continueTool],
         handlers: {
             list_workflows: { schema: tools_js_1.V2ListWorkflowsInput, handler: v2_workflow_js_1.handleV2ListWorkflows },
             inspect_workflow: { schema: tools_js_1.V2InspectWorkflowInput, handler: v2_workflow_js_1.handleV2InspectWorkflow },
+            start_workflow: { schema: tools_js_1.V2StartWorkflowInput, handler: v2_execution_js_1.handleV2StartWorkflow },
+            continue_workflow: { schema: tools_js_1.V2ContinueWorkflowInput, handler: v2_execution_js_1.handleV2ContinueWorkflow },
         },
     };
 }

package/dist/mcp/v2/tools.d.ts

@@ -13,8 +13,53 @@ export declare const V2InspectWorkflowInput: z.ZodObject<{
     mode?: "metadata" | "preview" | undefined;
 }>;
 export type V2InspectWorkflowInput = z.infer<typeof V2InspectWorkflowInput>;
+export declare const V2StartWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    context?: Record<string, unknown> | undefined;
+}, {
+    workflowId: string;
+    context?: Record<string, unknown> | undefined;
+}>;
+export type V2StartWorkflowInput = z.infer<typeof V2StartWorkflowInput>;
+export declare const V2ContinueWorkflowInput: z.ZodObject<{
+    stateToken: z.ZodString;
+    ackToken: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodOptional<z.ZodObject<{
+        notesMarkdown: z.ZodOptional<z.ZodString>;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        notesMarkdown?: string | undefined;
+        artifacts?: unknown[] | undefined;
+    }, {
+        notesMarkdown?: string | undefined;
+        artifacts?: unknown[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    stateToken: string;
+    context?: Record<string, unknown> | undefined;
+    output?: {
+        notesMarkdown?: string | undefined;
+        artifacts?: unknown[] | undefined;
+    } | undefined;
+    ackToken?: string | undefined;
+}, {
+    stateToken: string;
+    context?: Record<string, unknown> | undefined;
+    output?: {
+        notesMarkdown?: string | undefined;
+        artifacts?: unknown[] | undefined;
+    } | undefined;
+    ackToken?: string | undefined;
+}>;
+export type V2ContinueWorkflowInput = z.infer<typeof V2ContinueWorkflowInput>;
 export declare const V2_TOOL_TITLES: {
     readonly list_workflows: "List Workflows (v2)";
     readonly inspect_workflow: "Inspect Workflow (v2)";
+    readonly start_workflow: "Start Workflow (v2)";
+    readonly continue_workflow: "Continue Workflow (v2)";
 };
 export declare const V2_TOOL_ANNOTATIONS: Readonly<Record<keyof typeof V2_TOOL_TITLES, ToolAnnotations>>;

package/dist/mcp/v2/tools.js

@@ -1,17 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.V2_TOOL_ANNOTATIONS = exports.V2_TOOL_TITLES = exports.V2InspectWorkflowInput = exports.V2ListWorkflowsInput = void 0;
+exports.V2_TOOL_ANNOTATIONS = exports.V2_TOOL_TITLES = exports.V2ContinueWorkflowInput = exports.V2StartWorkflowInput = exports.V2InspectWorkflowInput = exports.V2ListWorkflowsInput = void 0;
 const zod_1 = require("zod");
 exports.V2ListWorkflowsInput = zod_1.z.object({});
 exports.V2InspectWorkflowInput = zod_1.z.object({
     workflowId: zod_1.z.string().min(1).describe('The workflow ID to inspect'),
     mode: zod_1.z.enum(['metadata', 'preview']).default('preview').describe('Detail level'),
 });
+exports.V2StartWorkflowInput = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1).describe('The workflow ID to start'),
+    context: zod_1.z.record(zod_1.z.unknown()).optional().describe('External context inputs (conditions, parameters). Do not include workflow progress state.'),
+});
+exports.V2ContinueWorkflowInput = zod_1.z.object({
+    stateToken: zod_1.z.string().min(1).describe('Opaque WorkRail-minted state token'),
+    ackToken: zod_1.z.string().min(1).optional().describe('Opaque WorkRail-minted ack token (omit for rehydrate-only)'),
+    context: zod_1.z.record(zod_1.z.unknown()).optional().describe('External context inputs (conditions, parameters). Do not include workflow progress state.'),
+    output: zod_1.z
+        .object({
+        notesMarkdown: zod_1.z.string().min(1).optional().describe('Durable recap notes (short; WorkRail may truncate deterministically)'),
+        artifacts: zod_1.z.array(zod_1.z.unknown()).optional().describe('Optional structured artifacts (schema is workflow/contract-defined)'),
+    })
+        .optional()
+        .describe('Optional durable output to attach to the current node'),
+});
 exports.V2_TOOL_TITLES = {
     list_workflows: 'List Workflows (v2)',
     inspect_workflow: 'Inspect Workflow (v2)',
+    start_workflow: 'Start Workflow (v2)',
+    continue_workflow: 'Continue Workflow (v2)',
 };
 exports.V2_TOOL_ANNOTATIONS = {
     list_workflows: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
     inspect_workflow: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    start_workflow: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    continue_workflow: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
 };

package/dist/mcp/validation/workflow-next-prevalidate.d.ts

@@ -1,9 +1,8 @@
+import type { ToolError } from '../types.js';
 export type PreValidateResult = {
     readonly ok: true;
 } | {
     readonly ok: false;
-    readonly code: 'VALIDATION_ERROR' | 'PRECONDITION_FAILED';
-    readonly message: string;
-    readonly correctTemplate?: unknown;
+    readonly error: ToolError;
 };
 export declare function preValidateWorkflowNextArgs(args: unknown): PreValidateResult;

package/dist/mcp/validation/workflow-next-prevalidate.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preValidateWorkflowNextArgs = preValidateWorkflowNextArgs;
+const types_js_1 = require("../types.js");
 function normalizeWorkflowIdForTemplate(value) {
     if (typeof value !== 'string')
         return '<workflowId>';
@@ -13,45 +14,52 @@ function normalizeWorkflowIdForTemplate(value) {
 function variablesToContextTemplate(value) {
     if (value == null || typeof value !== 'object' || Array.isArray(value))
         return {};
-    return value;
+    const obj = value;
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (v !== undefined) {
+            result[k] = v;
+        }
+    }
+    return result;
 }
 function preValidateWorkflowNextArgs(args) {
     if (args == null || typeof args !== 'object' || Array.isArray(args)) {
-        return { ok: false, code: 'VALIDATION_ERROR', message: 'Invalid input: expected a JSON object.' };
+        return { ok: false, error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Invalid input: expected a JSON object.') };
     }
     const a = args;
     const suggestedContext = variablesToContextTemplate(a.variables);
     if (!('workflowId' in a)) {
-        return { ok: false, code: 'VALIDATION_ERROR', message: 'Missing required field: workflowId.' };
+        return { ok: false, error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Missing required field: workflowId.') };
     }
     if (!('state' in a)) {
         return {
             ok: false,
-            code: 'VALIDATION_ERROR',
-            message: 'Missing required field: state. For the first call, use { kind: "init" }.',
-            correctTemplate: {
-                workflowId: normalizeWorkflowIdForTemplate(a.workflowId),
-                state: { kind: 'init' },
-                context: suggestedContext,
-            },
+            error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Missing required field: state. For the first call, use { kind: "init" }.', {
+                correctTemplate: {
+                    workflowId: normalizeWorkflowIdForTemplate(a.workflowId),
+                    state: { kind: 'init' },
+                    context: suggestedContext,
+                },
+            }),
         };
     }
     const state = a.state;
     if (state == null || typeof state !== 'object' || Array.isArray(state)) {
         return {
             ok: false,
-            code: 'VALIDATION_ERROR',
-            message: 'Invalid state: expected an object with discriminator field "kind".',
-            correctTemplate: { kind: 'init' },
+            error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Invalid state: expected an object with discriminator field "kind".', {
+                correctTemplate: { kind: 'init' },
+            }),
         };
     }
     const kind = state.kind;
     if (typeof kind !== 'string') {
         return {
             ok: false,
-            code: 'VALIDATION_ERROR',
-            message: 'Invalid state: missing state.kind. Valid values: "init" | "running" | "complete".',
-            correctTemplate: { kind: 'init' },
+            error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Invalid state: missing state.kind. Valid values: "init" | "running" | "complete".', {
+                correctTemplate: { kind: 'init' },
+            }),
         };
     }
     if (kind === 'running') {
@@ -60,23 +68,26 @@ function preValidateWorkflowNextArgs(args) {
         if (!Array.isArray(completed) || !Array.isArray(loopStack)) {
             return {
                 ok: false,
-                code: 'VALIDATION_ERROR',
-                message: 'Invalid state: state.kind="running" requires completed: string[] and loopStack: LoopFrame[].',
-                correctTemplate: { kind: 'running', completed: [], loopStack: [] },
+                error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Invalid state: state.kind="running" requires completed: string[] and loopStack: LoopFrame[].', {
+                    correctTemplate: { kind: 'running', completed: [], loopStack: [] },
+                }),
             };
         }
     }
     if ('variables' in a && !('context' in a)) {
+        const correctTemplate = {
+            workflowId: normalizeWorkflowIdForTemplate(a.workflowId),
+            state: a.state,
+            context: suggestedContext,
+        };
+        if (a.event && typeof a.event === 'object') {
+            correctTemplate.event = a.event;
+        }
         return {
             ok: false,
-            code: 'VALIDATION_ERROR',
-            message: 'Unexpected top-level key: variables. Use context (object) for condition evaluation and loop inputs.',
-            correctTemplate: {
-                workflowId: normalizeWorkflowIdForTemplate(a.workflowId),
-                state: a.state,
-                ...(a.event ? { event: a.event } : {}),
-                context: suggestedContext,
-            },
+            error: (0, types_js_1.errNotRetryable)('VALIDATION_ERROR', 'Unexpected top-level key: variables. Use context (object) for condition evaluation and loop inputs.', {
+                correctTemplate,
+            }),
         };
     }
     return { ok: true };

package/dist/v2/durable-core/ids/index.d.ts

@@ -11,6 +11,7 @@ export type EventIndex = Brand<number, 'v2.EventIndex'>;
 export type ManifestIndex = Brand<number, 'v2.ManifestIndex'>;
 export type SnapshotRef = Brand<Sha256Digest, 'v2.SnapshotRef'>;
 export type AttemptId = Brand<string, 'v2.AttemptId'>;
+export type OutputId = Brand<string, 'v2.OutputId'>;
 export type TokenStringV1 = Brand<string, 'v2.TokenStringV1'>;
 export declare function asWorkflowId(value: string): WorkflowId;
 export declare function asSha256Digest(value: string): Sha256Digest;
@@ -24,4 +25,5 @@ export declare function asEventIndex(value: number): EventIndex;
 export declare function asManifestIndex(value: number): ManifestIndex;
 export declare function asSnapshotRef(value: Sha256Digest): SnapshotRef;
 export declare function asAttemptId(value: string): AttemptId;
+export declare function asOutputId(value: string): OutputId;
 export declare function asTokenStringV1(value: string): TokenStringV1;

package/dist/v2/durable-core/ids/index.js

@@ -12,6 +12,7 @@ exports.asEventIndex = asEventIndex;
 exports.asManifestIndex = asManifestIndex;
 exports.asSnapshotRef = asSnapshotRef;
 exports.asAttemptId = asAttemptId;
+exports.asOutputId = asOutputId;
 exports.asTokenStringV1 = asTokenStringV1;
 function asWorkflowId(value) {
     return value;
@@ -49,6 +50,9 @@ function asSnapshotRef(value) {
 function asAttemptId(value) {
     return value;
 }
+function asOutputId(value) {
+    return value;
+}
 function asTokenStringV1(value) {
     return value;
 }