eve 0.47.7 → 0.48.0

package/dist/src/execution/wire/session-inbox-wire.v3.d.ts

@@ -0,0 +1,480 @@
+import { z } from "#compiled/zod/index.js";
+import type { DeliverHookPayload, SessionCommand, SessionTimeoutHookPayload } from "#channel/types.js";
+/** Version 3 adds the trusted deployment that accepted each channel delivery. */
+export declare const sessionInboxWireV3Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    auth: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        attributes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        authenticator: z.ZodString;
+        issuer: z.ZodOptional<z.ZodString>;
+        principalId: z.ZodString;
+        principalType: z.ZodString;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    kind: z.ZodLiteral<"deliver">;
+    payloads: z.ZodArray<z.ZodObject<{
+        context: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inputResponses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            optionId: z.ZodOptional<z.ZodString>;
+            requestId: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>>;
+            text: z.ZodString;
+            type: z.ZodLiteral<"text">;
+        }, z.core.$strict>, z.ZodObject<{
+            image: z.ZodCustom<URL | import("ai").DataContent, URL | import("ai").DataContent>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>>;
+            type: z.ZodLiteral<"image">;
+        }, z.core.$strict>, z.ZodObject<{
+            data: z.ZodCustom<URL | import("ai").DataContent, URL | import("ai").DataContent>;
+            filename: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodString;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>>;
+            type: z.ZodLiteral<"file">;
+        }, z.core.$strict>], "type">>]>>;
+        outputSchema: z.ZodOptional<z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>;
+        task: z.ZodOptional<z.ZodObject<{
+            authorizationEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                hookPayload: z.ZodObject<{
+                    callId: z.ZodString;
+                    childSessionId: z.ZodString;
+                    event: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+                    kind: z.ZodLiteral<"subagent-authorization-event">;
+                    subagentName: z.ZodString;
+                }, z.core.$strict>;
+                taskId: z.ZodString;
+            }, z.core.$strict>>>;
+            inputRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                hookPayload: z.ZodObject<{
+                    callId: z.ZodString;
+                    childContinuationToken: z.ZodString;
+                    childSessionId: z.ZodString;
+                    event: z.ZodObject<{
+                        requests: z.ZodArray<z.ZodObject<{
+                            action: z.ZodObject<{
+                                callId: z.ZodString;
+                                input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
+                                kind: z.ZodLiteral<"tool-call">;
+                                toolName: z.ZodString;
+                            }, z.core.$strict>;
+                            allowFreeform: z.ZodOptional<z.ZodBoolean>;
+                            display: z.ZodOptional<z.ZodEnum<{
+                                confirmation: "confirmation";
+                                select: "select";
+                                text: "text";
+                            }>>;
+                            kind: z.ZodEnum<{
+                                question: "question";
+                                "session-limit": "session-limit";
+                                "tool-approval": "tool-approval";
+                            }>;
+                            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                                description: z.ZodOptional<z.ZodString>;
+                                id: z.ZodString;
+                                label: z.ZodString;
+                                style: z.ZodOptional<z.ZodEnum<{
+                                    danger: "danger";
+                                    default: "default";
+                                    primary: "primary";
+                                }>>;
+                            }, z.core.$strict>>>;
+                            prompt: z.ZodString;
+                            requestId: z.ZodString;
+                        }, z.core.$strict>>;
+                        sequence: z.ZodNumber;
+                        stepIndex: z.ZodNumber;
+                        turnId: z.ZodString;
+                    }, z.core.$strict>;
+                    kind: z.ZodLiteral<"subagent-input-request">;
+                    subagentName: z.ZodString;
+                }, z.core.$strict>;
+                taskId: z.ZodString;
+            }, z.core.$strict>>>;
+            views: z.ZodOptional<z.ZodArray<z.ZodType<import("../../tasks/types.ts").TaskView, unknown, z.core.$ZodTypeInternals<import("../../tasks/types.ts").TaskView, unknown>>>>;
+        }, z.core.$strict>>;
+    }, z.core.$loose>>;
+    requestId: z.ZodOptional<z.ZodString>;
+    taskDeliveryId: z.ZodOptional<z.ZodString>;
+    turnPolicy: z.ZodOptional<z.ZodEnum<{
+        queue: "queue";
+        steer: "steer";
+    }>>;
+    caller: z.ZodOptional<z.ZodObject<{
+        callId: z.ZodString;
+        replyTo: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"hook">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"callback">;
+            token: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        subagentName: z.ZodString;
+        taskId: z.ZodOptional<z.ZodString>;
+        activityObserver: z.ZodOptional<z.ZodObject<{
+            sink: z.ZodObject<{
+                url: z.ZodString;
+                version: z.ZodLiteral<1>;
+            }, z.core.$strict>;
+            workIdentity: z.ZodOptional<z.ZodObject<{
+                callId: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    "remote-agent": "remote-agent";
+                    "root-turn": "root-turn";
+                    subagent: "subagent";
+                    task: "task";
+                }>;
+                name: z.ZodOptional<z.ZodString>;
+                parentId: z.ZodOptional<z.ZodString>;
+                rootSessionId: z.ZodString;
+                rootTurnId: z.ZodString;
+                sessionId: z.ZodOptional<z.ZodString>;
+                turnId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    payload: z.ZodObject<{
+        context: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inputResponses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            optionId: z.ZodOptional<z.ZodString>;
+            requestId: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>>;
+            text: z.ZodString;
+            type: z.ZodLiteral<"text">;
+        }, z.core.$strict>, z.ZodObject<{
+            image: z.ZodCustom<URL | import("ai").DataContent, URL | import("ai").DataContent>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>>;
+            type: z.ZodLiteral<"image">;
+        }, z.core.$strict>, z.ZodObject<{
+            data: z.ZodCustom<URL | import("ai").DataContent, URL | import("ai").DataContent>;
+            filename: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodString;
+            providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>>;
+            type: z.ZodLiteral<"file">;
+        }, z.core.$strict>], "type">>]>>;
+        outputSchema: z.ZodOptional<z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>>;
+        task: z.ZodOptional<z.ZodObject<{
+            authorizationEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                hookPayload: z.ZodObject<{
+                    callId: z.ZodString;
+                    childSessionId: z.ZodString;
+                    event: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+                    kind: z.ZodLiteral<"subagent-authorization-event">;
+                    subagentName: z.ZodString;
+                }, z.core.$strict>;
+                taskId: z.ZodString;
+            }, z.core.$strict>>>;
+            inputRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                hookPayload: z.ZodObject<{
+                    callId: z.ZodString;
+                    childContinuationToken: z.ZodString;
+                    childSessionId: z.ZodString;
+                    event: z.ZodObject<{
+                        requests: z.ZodArray<z.ZodObject<{
+                            action: z.ZodObject<{
+                                callId: z.ZodString;
+                                input: z.ZodType<import("../../shared/json.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonObject, unknown>>;
+                                kind: z.ZodLiteral<"tool-call">;
+                                toolName: z.ZodString;
+                            }, z.core.$strict>;
+                            allowFreeform: z.ZodOptional<z.ZodBoolean>;
+                            display: z.ZodOptional<z.ZodEnum<{
+                                confirmation: "confirmation";
+                                select: "select";
+                                text: "text";
+                            }>>;
+                            kind: z.ZodEnum<{
+                                question: "question";
+                                "session-limit": "session-limit";
+                                "tool-approval": "tool-approval";
+                            }>;
+                            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                                description: z.ZodOptional<z.ZodString>;
+                                id: z.ZodString;
+                                label: z.ZodString;
+                                style: z.ZodOptional<z.ZodEnum<{
+                                    danger: "danger";
+                                    default: "default";
+                                    primary: "primary";
+                                }>>;
+                            }, z.core.$strict>>>;
+                            prompt: z.ZodString;
+                            requestId: z.ZodString;
+                        }, z.core.$strict>>;
+                        sequence: z.ZodNumber;
+                        stepIndex: z.ZodNumber;
+                        turnId: z.ZodString;
+                    }, z.core.$strict>;
+                    kind: z.ZodLiteral<"subagent-input-request">;
+                    subagentName: z.ZodString;
+                }, z.core.$strict>;
+                taskId: z.ZodString;
+            }, z.core.$strict>>>;
+            views: z.ZodOptional<z.ZodArray<z.ZodType<import("../../tasks/types.ts").TaskView, unknown, z.core.$ZodTypeInternals<import("../../tasks/types.ts").TaskView, unknown>>>>;
+        }, z.core.$strict>>;
+    }, z.core.$loose>;
+    deliveryMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        channelKind: z.ZodString;
+        channelName: z.ZodString;
+        deliveryId: z.ZodString;
+        payloadIndex: z.ZodNumber;
+        requestId: z.ZodOptional<z.ZodString>;
+        requestTraceContext: z.ZodOptional<z.ZodObject<{
+            spanId: z.ZodString;
+            traceFlags: z.ZodNumber;
+            traceId: z.ZodString;
+        }, z.core.$strict>>;
+        acceptedDeploymentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    version: z.ZodLiteral<3>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"session-timeout">;
+    version: z.ZodLiteral<3>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clear">;
+    version: z.ZodLiteral<3>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"compact">;
+    version: z.ZodLiteral<3>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reset">;
+    reason: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<3>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"cancel">;
+    taskId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<3>;
+}, z.core.$strict>], "kind">;
+export type SessionInboxWireV3 = z.infer<typeof sessionInboxWireV3Schema>;
+export declare function parseSessionInboxWireV3(value: unknown): z.ZodSafeParseResult<{
+    auth?: {
+        attributes: Record<string, string | string[]>;
+        authenticator: string;
+        issuer?: string | undefined;
+        principalId: string;
+        principalType: string;
+        subject?: string | undefined;
+    } | null | undefined;
+    kind: "deliver";
+    payloads: {
+        [x: string]: unknown;
+        context?: string[] | undefined;
+        inputResponses?: {
+            optionId?: string | undefined;
+            requestId: string;
+            text?: string | undefined;
+        }[] | undefined;
+        message?: string | ({
+            providerOptions?: Record<string, import("../../shared/json.ts").JsonObject> | undefined;
+            text: string;
+            type: "text";
+        } | {
+            image: URL | import("ai").DataContent;
+            mediaType?: string | undefined;
+            providerOptions?: Record<string, import("../../shared/json.ts").JsonObject> | undefined;
+            type: "image";
+        } | {
+            data: URL | import("ai").DataContent;
+            filename?: string | undefined;
+            mediaType: string;
+            providerOptions?: Record<string, import("../../shared/json.ts").JsonObject> | undefined;
+            type: "file";
+        })[] | undefined;
+        outputSchema?: import("../../shared/json.ts").JsonObject | undefined;
+        task?: {
+            authorizationEvents?: {
+                hookPayload: {
+                    callId: string;
+                    childSessionId: string;
+                    event: Record<string, unknown>;
+                    kind: "subagent-authorization-event";
+                    subagentName: string;
+                };
+                taskId: string;
+            }[] | undefined;
+            inputRequests?: {
+                hookPayload: {
+                    callId: string;
+                    childContinuationToken: string;
+                    childSessionId: string;
+                    event: {
+                        requests: {
+                            action: {
+                                callId: string;
+                                input: import("../../shared/json.ts").JsonObject;
+                                kind: "tool-call";
+                                toolName: string;
+                            };
+                            allowFreeform?: boolean | undefined;
+                            display?: "confirmation" | "select" | "text" | undefined;
+                            kind: "question" | "session-limit" | "tool-approval";
+                            options?: {
+                                description?: string | undefined;
+                                id: string;
+                                label: string;
+                                style?: "danger" | "default" | "primary" | undefined;
+                            }[] | undefined;
+                            prompt: string;
+                            requestId: string;
+                        }[];
+                        sequence: number;
+                        stepIndex: number;
+                        turnId: string;
+                    };
+                    kind: "subagent-input-request";
+                    subagentName: string;
+                };
+                taskId: string;
+            }[] | undefined;
+            views?: import("../../tasks/types.ts").TaskView[] | undefined;
+        } | undefined;
+    }[];
+    requestId?: string | undefined;
+    taskDeliveryId?: string | undefined;
+    turnPolicy?: "queue" | "steer" | undefined;
+    caller?: {
+        callId: string;
+        replyTo: {
+            kind: "hook";
+            token: string;
+        } | {
+            kind: "callback";
+            token: string;
+            url: string;
+        };
+        subagentName: string;
+        taskId?: string | undefined;
+        activityObserver?: {
+            sink: {
+                url: string;
+                version: 1;
+            };
+            workIdentity?: {
+                callId?: string | undefined;
+                id: string;
+                kind: "remote-agent" | "root-turn" | "subagent" | "task";
+                name?: string | undefined;
+                parentId?: string | undefined;
+                rootSessionId: string;
+                rootTurnId: string;
+                sessionId?: string | undefined;
+                turnId?: string | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    payload: {
+        [x: string]: unknown;
+        context?: string[] | undefined;
+        inputResponses?: {
+            optionId?: string | undefined;
+            requestId: string;
+            text?: string | undefined;
+        }[] | undefined;
+        message?: string | ({
+            providerOptions?: Record<string, import("../../shared/json.ts").JsonObject> | undefined;
+            text: string;
+            type: "text";
+        } | {
+            image: URL | import("ai").DataContent;
+            mediaType?: string | undefined;
+            providerOptions?: Record<string, import("../../shared/json.ts").JsonObject> | undefined;
+            type: "image";
+        } | {
+            data: URL | import("ai").DataContent;
+            filename?: string | undefined;
+            mediaType: string;
+            providerOptions?: Record<string, import("../../shared/json.ts").JsonObject> | undefined;
+            type: "file";
+        })[] | undefined;
+        outputSchema?: import("../../shared/json.ts").JsonObject | undefined;
+        task?: {
+            authorizationEvents?: {
+                hookPayload: {
+                    callId: string;
+                    childSessionId: string;
+                    event: Record<string, unknown>;
+                    kind: "subagent-authorization-event";
+                    subagentName: string;
+                };
+                taskId: string;
+            }[] | undefined;
+            inputRequests?: {
+                hookPayload: {
+                    callId: string;
+                    childContinuationToken: string;
+                    childSessionId: string;
+                    event: {
+                        requests: {
+                            action: {
+                                callId: string;
+                                input: import("../../shared/json.ts").JsonObject;
+                                kind: "tool-call";
+                                toolName: string;
+                            };
+                            allowFreeform?: boolean | undefined;
+                            display?: "confirmation" | "select" | "text" | undefined;
+                            kind: "question" | "session-limit" | "tool-approval";
+                            options?: {
+                                description?: string | undefined;
+                                id: string;
+                                label: string;
+                                style?: "danger" | "default" | "primary" | undefined;
+                            }[] | undefined;
+                            prompt: string;
+                            requestId: string;
+                        }[];
+                        sequence: number;
+                        stepIndex: number;
+                        turnId: string;
+                    };
+                    kind: "subagent-input-request";
+                    subagentName: string;
+                };
+                taskId: string;
+            }[] | undefined;
+            views?: import("../../tasks/types.ts").TaskView[] | undefined;
+        } | undefined;
+    };
+    deliveryMetadata?: {
+        channelKind: string;
+        channelName: string;
+        deliveryId: string;
+        payloadIndex: number;
+        requestId?: string | undefined;
+        requestTraceContext?: {
+            spanId: string;
+            traceFlags: number;
+            traceId: string;
+        } | undefined;
+        acceptedDeploymentId?: string | undefined;
+    }[] | undefined;
+    version: 3;
+} | {
+    kind: "session-timeout";
+    version: 3;
+} | {
+    kind: "clear";
+    version: 3;
+} | {
+    kind: "compact";
+    version: 3;
+} | {
+    kind: "reset";
+    reason?: string | undefined;
+    version: 3;
+} | {
+    kind: "cancel";
+    taskId?: string | undefined;
+    turnId?: string | undefined;
+    version: 3;
+}>;
+/** Builds and validates one complete version-3 wire value. */
+export declare function encodeSessionCommandV3(command: DeliverHookPayload | SessionCommand | SessionTimeoutHookPayload): SessionInboxWireV3;

package/dist/src/execution/wire/session-inbox-wire.v3.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{formatValidationError}from"#runtime/validation.js";import{coalesceDeliverPayloads}from"#execution/deliver-payloads.js";import{SessionInboxWireError}from"#execution/wire/session-inbox-contract.js";import{sessionInboxWireV2Schema}from"#execution/wire/session-inbox-wire.v2.js";import{normalizeSessionInboxWireV2}from"#execution/wire/session-inbox-wire.v2-migration.js";const v2=sessionInboxWireV2Schema.options,v2Deliver=v2[0],v2DeliveryMetadata=v2Deliver.shape.deliveryMetadata.unwrap().element,version=z.literal(3),sessionInboxWireV3Schema=z.discriminatedUnion(`kind`,[v2Deliver.extend({deliveryMetadata:z.array(v2DeliveryMetadata.extend({acceptedDeploymentId:z.string().optional()})).optional(),version}),v2[1].extend({version}),v2[2].extend({version}),v2[3].extend({version}),v2[4].extend({version}),v2[5].extend({version})]);function parseSessionInboxWireV3(e){return sessionInboxWireV3Schema.safeParse(normalizeSessionInboxWireV2(e))}function encodeSessionCommandV3(e){let t=parseSessionInboxWireV3(e.kind===`send`?{auth:e.auth,caller:e.caller,deliveryMetadata:e.delivery===void 0?void 0:[{...e.delivery,payloadIndex:0}],kind:`deliver`,payload:e.payload,payloads:[e.payload],requestId:e.requestId,taskDeliveryId:e.taskDeliveryId,turnPolicy:e.turnPolicy,version:3}:e.kind===`deliver`?{...e,payload:coalesceDeliverPayloads(e.payloads),version:3}:{...e,version:3});if(!t.success)throw new SessionInboxWireError(`Produced a session inbox payload that does not match wire version 3: ${formatValidationError(t.error)}`);return t.data}export{encodeSessionCommandV3,parseSessionInboxWireV3,sessionInboxWireV3Schema};

package/dist/src/execution/wire/session-inbox-wire.v3.migration.d.ts

@@ -0,0 +1,3 @@
+import type { VersionMigration } from "#execution/durable-session-migrations/chain.js";
+/** Pure shape migration from the immutable v2 wire contract to v3. */
+export declare const sessionInboxWireV2Migration: VersionMigration;

package/dist/src/execution/wire/session-inbox-wire.v3.migration.js

@@ -0,0 +1 @@
+const sessionInboxWireV2Migration={from:2,migrate(e){return{...e,version:3}},to:3};export{sessionInboxWireV2Migration};

package/dist/src/execution/workflow-entry-finalization.js

@@ -1 +1 @@
-import{fireSessionCallbackStep}from"#execution/session-callback-step.js";import{notifyDelegatedParentStep,notifyTurnCallerStep}from"#execution/delegated-parent-notification.js";import{createDelegatedSubagentErrorResult,createDelegatedSubagentSuccessResult}from"#execution/delegated-parent-result.js";import{emitTerminalSessionCompletionStep}from"#execution/terminal-session-completion-step.js";import{terminateChildSessionsStep}from"#execution/terminate-child-sessions-step.js";async function finalizeExpiredSession(t){return await terminateChildSessionsStep({serializedContext:t.serializedContext,sessionState:t.sessionState}),await emitTerminalSessionCompletionStep({parentWritable:t.driverWritable,serializedContext:t.serializedContext}),t.mode===`task`?(await fireSessionCallbackStep({output:``,serializedContext:t.serializedContext,status:`completed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentSuccessResult(t.serializedContext,``),serializedContext:t.serializedContext})):t.caller!==void 0&&await notifyTurnCallerStep({caller:t.caller,lifecycle:`terminal`,sessionId:t.sessionState.sessionId,settled:{output:``}}),{output:``}}async function finalizeDone(n){let{output:r,serializedContext:i}=n.action,a=n.action.isError===!0;if(await terminateChildSessionsStep({serializedContext:i,sessionState:n.action.sessionState}),n.mode===`task`)await fireSessionCallbackStep({error:a?r:void 0,output:a?void 0:r,serializedContext:i,status:a?`failed`:`completed`,usage:n.action.usage}),await notifyDelegatedParentStep({result:a?createDelegatedSubagentErrorResult(i,r):createDelegatedSubagentSuccessResult(i,r),serializedContext:i,usage:n.action.usage});else{let e={output:r,usage:n.action.usageDelta};a&&(e.isError=!0),n.caller!==void 0&&await notifyTurnCallerStep({caller:n.caller,lifecycle:`terminal`,sessionId:n.action.sessionState.sessionId,settled:e})}return{output:r}}export{finalizeDone,finalizeExpiredSession};
+import{notifyDelegatedParentStep,notifyTurnCallerStep}from"#execution/delegated-parent-notification.js";import{createDelegatedSubagentErrorResult,createDelegatedSubagentSuccessResult}from"#execution/delegated-parent-result.js";import{fireSessionCallbackStep}from"#execution/session-callback-step.js";import{emitTerminalSessionCompletionStep}from"#execution/terminal-session-completion-step.js";import{terminateChildSessionsStep}from"#execution/terminate-child-sessions-step.js";async function finalizeExpiredSession(t){return await terminateChildSessionsStep({serializedContext:t.serializedContext,sessionState:t.sessionState}),await emitTerminalSessionCompletionStep({parentWritable:t.driverWritable,serializedContext:t.serializedContext}),t.mode===`task`?(await fireSessionCallbackStep({output:``,serializedContext:t.serializedContext,status:`completed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentSuccessResult(t.serializedContext,``),serializedContext:t.serializedContext})):t.caller!==void 0&&await notifyTurnCallerStep({caller:t.caller,lifecycle:`terminal`,sessionId:t.sessionState.sessionId,settled:{output:``}}),{output:``}}async function finalizeDone(n){let{output:r,serializedContext:i}=n.action,a=n.action.isError===!0;if(await terminateChildSessionsStep({serializedContext:i,sessionState:n.action.sessionState}),n.mode===`task`)await fireSessionCallbackStep({error:a?r:void 0,output:a?void 0:r,serializedContext:i,status:a?`failed`:`completed`,usage:n.action.usage}),await notifyDelegatedParentStep({result:a?createDelegatedSubagentErrorResult(i,r):createDelegatedSubagentSuccessResult(i,r),serializedContext:i,usage:n.action.usage});else{let e={output:r,usage:n.action.usageDelta};a&&(e.isError=!0),n.caller!==void 0&&await notifyTurnCallerStep({caller:n.caller,lifecycle:`terminal`,sessionId:n.action.sessionState.sessionId,settled:e})}return{output:r}}export{finalizeDone,finalizeExpiredSession};

package/dist/src/execution/workflow-entry.js

@@ -1 +1 @@
-import{attachClientContext,readClientContext}from"#internal/client-context.js";import{sessionCommandHookToken}from"#execution/session-command-token.js";import{CHANNEL_CONTEXT_KEY_NAME,SESSION_CALLBACK_CONTEXT_KEY_NAME}from"#context/key-names.js";import{getWorkflowMetadata,getWritable}from"#compiled/@workflow/core/index.js";import{isHookConflictError}from"#execution/hook-ownership.js";import{isTaskOwnedSerializedContext}from"#execution/tasks/child/instructions.js";import{SUBAGENT_ADAPTER_KIND}from"#execution/subagent-adapter-state.js";import{readSerializedSubagentDepth}from"#harness/subagent-depth.js";import{readChannelRequestId,readRootSessionId}from"#execution/eve-workflow-attributes.js";import{activeTurnId}from"#harness/active-turn-id.js";import{fireSessionCallbackStep}from"#execution/session-callback-step.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{SessionStateCursor}from"#execution/session-state-cursor.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{bindTurnCallerContextStep,notifyCancelledTaskCallerStep,notifyDelegatedParentStep,notifyTaskTurnStartedStep,notifyTurnCallerStep,resolveInitialTurnCallerStep}from"#execution/delegated-parent-notification.js";import{createDelegatedSubagentErrorResult}from"#execution/delegated-parent-result.js";import{terminateChildSessionsStep}from"#execution/terminate-child-sessions-step.js";import{nextTurnDelivery}from"#execution/parked-delivery-wait.js";import{dispatchAndAwaitTurn}from"#execution/turn-dispatch.js";import{finalizeDone,finalizeExpiredSession}from"#execution/workflow-entry-finalization.js";import{createSessionStep}from"#execution/create-session-step.js";import{settleCancelledTurnStep}from"#execution/settle-cancelled-turn-step.js";import{emitTerminalSessionFailureStep}from"#execution/terminal-session-failure-step.js";import{createSessionCommandInbox}from"#execution/session-command-inbox.js";import{DEFAULT_SESSION_TIMEOUT_MS}from"#execution/session-timeout.js";import{createSessionTimeoutControl}from"#execution/session-timeout-control.js";async function workflowEntry(n){"use workflow";let{workflowRunId:r,workflowStartedAt:i}=getWorkflowMetadata(),s=n.serializedContext[`eve.continuationToken`]||``,l=n.serializedContext[`eve.mode`],p=n.serializedContext[`eve.capabilities`],g=n.serializedContext[`eve.bundle`];n.serializedContext[`eve.sessionId`]=r;let _=getWritable(),v={caller:void 0,callerResolved:!1,lastSessionState:void 0};try{let a=readRootSessionId(n.serializedContext),o=readSerializedSubagentDepth(n.serializedContext),m=n.serializedContext[`eve.dynamicSubagentAgentConfig`],{state:h}=await createSessionStep({compiledArtifactsSource:g.source,continuationToken:s,dynamicSubagentAgentConfig:m,inheritedLimits:n.limits,nodeId:g.nodeId,outputSchema:n.input.outputSchema,rootSessionId:a,sessionId:r,subagentDepth:o,taskOwned:isTaskOwnedSerializedContext(n.serializedContext)});v.lastSessionState=h,hasGuaranteedRootLineage(n.serializedContext)||(v.caller=await resolveInitialTurnCallerStep({serializedContext:n.serializedContext})),v.callerResolved=!0;let y=await runDriverLoop({capabilities:p,driverWritable:_,initialInput:{deliveryMetadata:n.serializedContext[`eve.channelDelivery`]===void 0?void 0:[{...n.serializedContext[`eve.channelDelivery`],payloadIndex:0}],kind:`deliver`,payloads:[attachClientContext({message:n.input.message,context:n.input.context,outputSchema:n.input.outputSchema},readClientContext(n.input))],requestId:readChannelRequestId(n.serializedContext)},crashCleanupState:v,mode:l,serializedContext:n.serializedContext,sessionState:h,sessionTimeoutDeadline:n.sessionTimeoutMs===!1?void 0:new Date(i.getTime()+(n.sessionTimeoutMs??DEFAULT_SESSION_TIMEOUT_MS))});return y.kind===`result`?y.result:await finalizeExpiredSession({caller:v.caller,driverWritable:_,mode:l,serializedContext:y.serializedContext,sessionState:y.sessionState})}catch(e){if(v.lastSessionState!==void 0&&await terminateChildSessionsStep({serializedContext:n.serializedContext,sessionState:v.lastSessionState}),await emitTerminalSessionFailureStep({error:normalizeSerializableError(e),parentWritable:_,serializedContext:n.serializedContext}),l===`task`)await fireSessionCallbackStep({error:normalizeSerializableError(e),serializedContext:n.serializedContext,status:`failed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentErrorResult(n.serializedContext,e),serializedContext:n.serializedContext});else{let t=await resolveCallerForCrash(v,n.serializedContext);t!==void 0&&await notifyTurnCallerStep({caller:t,lifecycle:`terminal`,sessionId:r,settled:{isError:!0,output:e}})}throw createSafeOuterWorkflowError()}}async function resolveCallerForCrash(e,t){if(e.callerResolved)return e.caller;try{return await resolveInitialTurnCallerStep({serializedContext:t})}catch{return}}function createSafeOuterWorkflowError(){let e=Error(`Agent workflow failed. Inspect the private session trace for details.`);return e.name=`EveWorkflowFailure`,e}function hasGuaranteedRootLineage(e){if(e[SESSION_CALLBACK_CONTEXT_KEY_NAME]!==void 0||e[`eve.parentSession`]!==void 0||e[`eve.subagentDepth`]!==void 0)return!1;let t=e[CHANNEL_CONTEXT_KEY_NAME];if(typeof t!=`object`||!t)return!1;let n=Reflect.get(t,`kind`);return typeof n==`string`&&n!==SUBAGENT_ADAPTER_KIND}async function runDriverLoop(e){let t=new Map,nextParkedActivity=async n=>{let r=new Set(n.expectedAttemptIds);for(let e of t.keys())r.has(e)||t.delete(e);for(;;){if(r.size>0&&[...r].every(e=>t.has(e))){let e=[...r].map(e=>t.get(e));return t.clear(),{kind:`authorization-resume`,payloads:e}}let n=await nextTurnDelivery({awaitAuthorizationCallbacks:r.size>0,bufferedDeliveries:i,bufferedSessionControls:a,cancelledTaskIds:o,commandInbox:l,deferDeliveries:e.mode===`task`&&r.size>0,driverWritable:e.driverWritable,seenTaskDeliveries:c,stateCursor:f});if(n.kind!==`authorization`)return n;for(let e of n.payloads){let n=e.authorizationCallback;typeof n?.attemptId==`string`&&r.has(n.attemptId)&&!t.has(n.attemptId)&&t.set(n.attemptId,e)}if(n.closed){let e=[...t.values()];return t.clear(),{kind:`authorization-resume`,payloads:e}}}},r=0,nextTurnControlToken=()=>`${e.sessionState.sessionId}:turn-control:${String(r++)}`,i=[],a=[],o=new Set,c=new Set,l=createSessionCommandInbox(),u=sessionCommandHookToken(e.sessionState.sessionId);await l.claimStable(u),await l.claimAuthorization(`${e.sessionState.sessionId}:auth`);let d=e.sessionTimeoutDeadline===void 0?void 0:createSessionTimeoutControl({deadline:e.sessionTimeoutDeadline,token:u}),f=new SessionStateCursor({serializedContext:e.serializedContext,sessionState:e.sessionState}),m,runTurn=async t=>{let n=e.crashCleanupState.caller;n?.taskId!==void 0&&(c.add(n.taskId),await notifyTaskTurnStartedStep({caller:n,childSessionId:f.sessionState.sessionId,childTurnId:activeTurnId(f.sessionState.emissionState)}));let r=n===void 0?f.serializedContext:await bindTurnCallerContextStep({caller:n,serializedContext:f.serializedContext}),s=await dispatchAndAwaitTurn({bufferedDeliveries:i,bufferedSessionControls:a,cancelledTaskIds:o,capabilities:e.capabilities,commandInbox:l,controlToken:nextTurnControlToken(),delivery:t,mode:e.mode,parentWritable:e.driverWritable,serializedContext:r,seenTaskDeliveries:c,sessionState:f.sessionState});return await m?.(),m=s.dispose,f.adoptState(s.action),e.crashCleanupState.lastSessionState=f.sessionState,s.action};try{if(e.sessionState.continuationToken)try{await l.rekeyContinuation(e.sessionState.continuationToken)}catch(e){if(!isHookConflictError(e))throw e;return{kind:`result`,result:{output:``}}}await d?.start();let t=await runTurn(e.initialInput);for(;;){if(t.kind===`done`)return{kind:`result`,result:await finalizeDone({action:t,caller:e.crashCleanupState.caller,mode:e.mode})};if(t.kind!==`park`)throw Error(`Driver received unexpected turn action "${t.kind}".`);if(t.cancelled===!0){let t=await settleCancelledTurnStep({parentWritable:e.driverWritable,serializedContext:f.serializedContext,sessionState:f.sessionState});f.adoptState(t);let n={caller:e.crashCleanupState.caller,sessionId:f.sessionState.sessionId};await notifyCancelledTaskCallerStep(t.usage===void 0?n:{...n,usage:t.usage}),e.crashCleanupState.lastSessionState=f.sessionState}f.sessionState.continuationToken&&await l.rekeyContinuation(f.sessionState.continuationToken);let n=t.settled;t.cancelled!==!0&&n!==void 0?(e.crashCleanupState.caller!==void 0&&await notifyTurnCallerStep({caller:e.crashCleanupState.caller,lifecycle:`parked`,sessionId:f.sessionState.sessionId,settled:n}),e.crashCleanupState.caller=void 0):t.cancelled===!0&&(e.crashCleanupState.caller=void 0);let r=await nextParkedActivity({expectedAttemptIds:t.authorizationAttemptIds??[]});if(e.crashCleanupState.lastSessionState=f.sessionState,r.kind===`authorization-resume`){t=await runTurn({kind:`deliver`,payloads:r.payloads});continue}if(r.kind===`expired`)return{kind:`expired`,serializedContext:f.serializedContext,sessionState:f.sessionState};if(r.kind===`reset`)return await terminateChildSessionsStep({serializedContext:f.serializedContext,sessionState:f.sessionState}),{kind:`result`,result:{output:``}};if(r.kind===`clear`||r.kind===`compact`){t=await runTurn({kind:r.kind});continue}if(r.kind===`closed`)return await terminateChildSessionsStep({serializedContext:f.serializedContext,sessionState:f.sessionState}),{kind:`result`,result:{output:``}};if(r.kind===`cancel-turn`){await cancelDescendantTurnsStep({serializedContext:f.serializedContext,sessionState:f.sessionState});let n=await settleCancelledTurnStep({parentWritable:e.driverWritable,serializedContext:f.serializedContext,sessionState:f.sessionState});f.adoptState(n),t={...t,settled:void 0},e.crashCleanupState.caller=void 0,e.crashCleanupState.lastSessionState=f.sessionState;continue}r.delivery.caller!==void 0&&(e.crashCleanupState.caller=r.delivery.caller),t=await runTurn(r.delivery)}}finally{await m?.(),await d?.dispose(),await l.dispose()}}export{workflowEntry};
+import{attachClientContext,readClientContext}from"#internal/client-context.js";import{sessionCommandHookToken}from"#execution/session-command-token.js";import{CHANNEL_CONTEXT_KEY_NAME,SESSION_CALLBACK_CONTEXT_KEY_NAME}from"#context/key-names.js";import{getWorkflowMetadata,getWritable}from"#compiled/@workflow/core/index.js";import{isHookConflictError}from"#execution/hook-ownership.js";import{isTaskOwnedSerializedContext}from"#execution/tasks/child/instructions.js";import{SUBAGENT_ADAPTER_KIND}from"#execution/subagent-adapter-state.js";import{readSerializedSubagentDepth}from"#harness/subagent-depth.js";import{readChannelRequestId,readRootSessionId}from"#execution/eve-workflow-attributes.js";import{activeTurnId}from"#harness/active-turn-id.js";import{bindTurnCallerContextStep,notifyCancelledTaskCallerStep,notifyDelegatedParentStep,notifyTaskTurnStartedStep,notifyTurnCallerStep,resolveInitialTurnCallerStep}from"#execution/delegated-parent-notification.js";import{createDelegatedSubagentErrorResult}from"#execution/delegated-parent-result.js";import{fireSessionCallbackStep}from"#execution/session-callback-step.js";import{terminateChildSessionsStep}from"#execution/terminate-child-sessions-step.js";import{SessionStateCursor}from"#execution/session-state-cursor.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{nextTurnDelivery}from"#execution/parked-delivery-wait.js";import{dispatchAndAwaitTurn}from"#execution/turn-dispatch.js";import{finalizeDone}from"#execution/workflow-entry-finalization.js";import{createSessionStep}from"#execution/create-session-step.js";import{settleCancelledTurnStep}from"#execution/settle-cancelled-turn-step.js";import{emitTerminalSessionFailureStep}from"#execution/terminal-session-failure-step.js";import{finalizeTerminalSession}from"#execution/finalize-terminal-session.js";import{createSessionCommandInbox}from"#execution/session-command-inbox.js";import{DEFAULT_SESSION_TIMEOUT_MS}from"#execution/session-timeout.js";import{createSessionTimeoutControl}from"#execution/session-timeout-control.js";async function workflowEntry(r){"use workflow";let{workflowRunId:i,workflowStartedAt:l}=getWorkflowMetadata(),p=r.serializedContext[`eve.continuationToken`]||``,m=r.serializedContext[`eve.mode`],h=r.serializedContext[`eve.capabilities`],_=r.serializedContext[`eve.bundle`];r.serializedContext[`eve.sessionId`]=i;let S=getWritable(),w={activeTurnId:void 0,caller:void 0,callerResolved:!1,lastSessionState:void 0,serializedContext:r.serializedContext,terminalEmitted:!1};try{let a=readRootSessionId(r.serializedContext),o=readSerializedSubagentDepth(r.serializedContext),g=r.serializedContext[`eve.dynamicSubagentAgentConfig`],v=createSessionCommandInbox(),y=sessionCommandHookToken(i),b=`${i}:auth`,x,C;try{let[n,u,f,T]=await Promise.allSettled([createSessionStep({compiledArtifactsSource:_.source,continuationToken:p,dynamicSubagentAgentConfig:g,inheritedLimits:r.limits,nodeId:_.nodeId,outputSchema:r.input.outputSchema,rootSessionId:a,sessionId:i,subagentDepth:o,taskOwned:isTaskOwnedSerializedContext(r.serializedContext)}),v.claimStable(y),v.claimAuthorization(b),v.rekeyContinuation(p)]);if(n.status===`rejected`)throw n.reason;if(u.status===`rejected`)throw u.reason;if(f.status===`rejected`)throw f.reason;if(T.status===`rejected`){if(isHookConflictError(T.reason))return{output:``};throw T.reason}x=n.value.state,w.lastSessionState=x,hasGuaranteedRootLineage(r.serializedContext)||(w.caller=await resolveInitialTurnCallerStep({serializedContext:r.serializedContext})),w.callerResolved=!0,C=await runDriverLoop({capabilities:h,commandInbox:v,driverWritable:S,initialInput:{deliveryMetadata:r.serializedContext[`eve.channelDelivery`]===void 0?void 0:[{...r.serializedContext[`eve.channelDelivery`],payloadIndex:0}],kind:`deliver`,payloads:[attachClientContext({message:r.input.message,context:r.input.context,outputSchema:r.input.outputSchema},readClientContext(r.input))],requestId:readChannelRequestId(r.serializedContext)},crashCleanupState:w,mode:m,serializedContext:r.serializedContext,sessionState:x,sessionTimeoutDeadline:r.sessionTimeoutMs===!1?void 0:new Date(l.getTime()+(r.sessionTimeoutMs??DEFAULT_SESSION_TIMEOUT_MS)),stableCommandToken:y})}finally{await v.dispose()}return C.kind===`result`?C.result:await finalizeTerminalSession({caller:w.caller,driverWritable:S,mode:m,notifyCaller:C.notifyCaller,serializedContext:C.serializedContext,sessionState:C.sessionState,terminalState:w})}catch(e){if(w.lastSessionState!==void 0&&await terminateChildSessionsStep({serializedContext:w.serializedContext,sessionState:w.lastSessionState}),!w.terminalEmitted)if(await emitTerminalSessionFailureStep({error:normalizeSerializableError(e),parentWritable:S,serializedContext:w.serializedContext,turnId:w.activeTurnId}),m===`task`)await fireSessionCallbackStep({error:normalizeSerializableError(e),serializedContext:r.serializedContext,status:`failed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentErrorResult(r.serializedContext,e),serializedContext:r.serializedContext});else{let t=await resolveCallerForCrash(w,r.serializedContext);t!==void 0&&await notifyTurnCallerStep({caller:t,lifecycle:`terminal`,sessionId:i,settled:{isError:!0,output:e}})}throw createSafeOuterWorkflowError()}}async function resolveCallerForCrash(e,t){if(e.callerResolved)return e.caller;try{return await resolveInitialTurnCallerStep({serializedContext:t})}catch{return}}function createSafeOuterWorkflowError(){let e=Error(`Agent workflow failed. Inspect the private session trace for details.`);return e.name=`EveWorkflowFailure`,e}function hasGuaranteedRootLineage(e){if(e[SESSION_CALLBACK_CONTEXT_KEY_NAME]!==void 0||e[`eve.parentSession`]!==void 0||e[`eve.subagentDepth`]!==void 0)return!1;let t=e[CHANNEL_CONTEXT_KEY_NAME];if(typeof t!=`object`||!t)return!1;let n=Reflect.get(t,`kind`);return typeof n==`string`&&n!==SUBAGENT_ADAPTER_KIND}async function runDriverLoop(e){let t=e.commandInbox,n=new Map,nextParkedActivity=async r=>{let c=new Set(r.expectedAttemptIds);for(let e of n.keys())c.has(e)||n.delete(e);for(;;){if(c.size>0&&[...c].every(e=>n.has(e))){let e=[...c].map(e=>n.get(e));return n.clear(),{kind:`authorization-resume`,payloads:e}}let r=await nextTurnDelivery({awaitAuthorizationCallbacks:c.size>0,bufferedDeliveries:i,bufferedSessionControls:a,cancelledTaskIds:o,commandInbox:t,deferDeliveries:e.mode===`task`&&c.size>0,driverWritable:e.driverWritable,seenTaskDeliveries:s,stateCursor:l});if(r.kind!==`authorization`)return r;for(let e of r.payloads){let t=e.authorizationCallback;typeof t?.attemptId==`string`&&c.has(t.attemptId)&&!n.has(t.attemptId)&&n.set(t.attemptId,e)}if(r.closed){let e=[...n.values()];return n.clear(),{kind:`authorization-resume`,payloads:e}}}},r=0,nextTurnControlToken=()=>`${e.sessionState.sessionId}:turn-control:${String(r++)}`,i=[],a=[],o=new Set,s=new Set,c=e.sessionTimeoutDeadline===void 0?void 0:createSessionTimeoutControl({deadline:e.sessionTimeoutDeadline,token:e.stableCommandToken}),l=new SessionStateCursor({serializedContext:e.serializedContext,sessionState:e.sessionState}),u,runTurn=async n=>{let r=e.crashCleanupState.caller;r?.taskId!==void 0&&(s.add(r.taskId),await notifyTaskTurnStartedStep({caller:r,childSessionId:l.sessionState.sessionId,childTurnId:activeTurnId(l.sessionState.emissionState)}));let c=r===void 0?l.serializedContext:await bindTurnCallerContextStep({caller:r,serializedContext:l.serializedContext}),d=activeTurnId(l.sessionState.emissionState);e.crashCleanupState.activeTurnId=d;let f=await dispatchAndAwaitTurn({bufferedDeliveries:i,bufferedSessionControls:a,cancelledTaskIds:o,capabilities:e.capabilities,commandInbox:t,controlToken:nextTurnControlToken(),delivery:n,mode:e.mode,parentWritable:e.driverWritable,serializedContext:c,seenTaskDeliveries:s,sessionState:l.sessionState});return e.crashCleanupState.activeTurnId=f.action.kind===`park`&&f.action.cancelled===!0?d:void 0,e.crashCleanupState.lastSessionState=f.action.sessionState,e.crashCleanupState.serializedContext=f.action.serializedContext,f.action.kind===`done`&&(e.crashCleanupState.terminalEmitted=!0),await u?.(),u=f.dispose,l.adoptState(f.action),f.action};try{await c?.start();let n=await runTurn(e.initialInput);for(;;){if(n.kind===`done`)return{kind:`result`,result:await finalizeDone({action:n,caller:e.crashCleanupState.caller,mode:e.mode})};if(n.kind!==`park`)throw Error(`Driver received unexpected turn action "${n.kind}".`);if(n.cancelled===!0){let t=await settleCancelledTurnStep({parentWritable:e.driverWritable,serializedContext:l.serializedContext,sessionState:l.sessionState});l.adoptState(t),e.crashCleanupState.activeTurnId=void 0,e.crashCleanupState.lastSessionState=l.sessionState,e.crashCleanupState.serializedContext=l.serializedContext;let n={caller:e.crashCleanupState.caller,sessionId:l.sessionState.sessionId};await notifyCancelledTaskCallerStep(t.usage===void 0?n:{...n,usage:t.usage})}l.sessionState.continuationToken&&await t.rekeyContinuation(l.sessionState.continuationToken);let r=n.settled;n.cancelled!==!0&&r!==void 0?(e.crashCleanupState.caller!==void 0&&await notifyTurnCallerStep({caller:e.crashCleanupState.caller,lifecycle:`parked`,sessionId:l.sessionState.sessionId,settled:r}),e.crashCleanupState.caller=void 0):n.cancelled===!0&&(e.crashCleanupState.caller=void 0);let i=await nextParkedActivity({expectedAttemptIds:n.authorizationAttemptIds??[]});if(e.crashCleanupState.lastSessionState=l.sessionState,e.crashCleanupState.serializedContext=l.serializedContext,i.kind===`authorization-resume`){n=await runTurn({kind:`deliver`,payloads:i.payloads});continue}if(i.kind===`expired`)return{kind:`terminal`,notifyCaller:!0,serializedContext:l.serializedContext,sessionState:l.sessionState};if(i.kind===`reset`)return{kind:`terminal`,notifyCaller:!1,serializedContext:l.serializedContext,sessionState:l.sessionState};if(i.kind===`clear`||i.kind===`compact`){n=await runTurn({kind:i.kind});continue}if(i.kind===`closed`)return{kind:`terminal`,notifyCaller:!1,serializedContext:l.serializedContext,sessionState:l.sessionState};if(i.kind===`cancel-turn`){await cancelDescendantTurnsStep({serializedContext:l.serializedContext,sessionState:l.sessionState});let t=await settleCancelledTurnStep({parentWritable:e.driverWritable,serializedContext:l.serializedContext,sessionState:l.sessionState});l.adoptState(t),n={...n,settled:void 0},e.crashCleanupState.caller=void 0,e.crashCleanupState.lastSessionState=l.sessionState,e.crashCleanupState.serializedContext=l.serializedContext;continue}i.delivery.caller!==void 0&&(e.crashCleanupState.caller=i.delivery.caller),n=await runTurn(i.delivery)}}finally{await u?.(),await c?.dispose()}}export{workflowEntry};

package/dist/src/execution/workflow-registry.d.ts

@@ -0,0 +1,5 @@
+declare global {
+    var __private_workflows: Map<string, unknown> | undefined;
+}
+export declare const WORKFLOW_REGISTRY_GLOBAL = "__private_workflows";
+export declare function readRegisteredWorkflow(workflowId: string): unknown;

package/dist/src/execution/workflow-registry.js

@@ -0,0 +1 @@
+const WORKFLOW_REGISTRY_GLOBAL=`__private_workflows`;function readRegisteredWorkflow(e){return globalThis[WORKFLOW_REGISTRY_GLOBAL]?.get(e)}export{WORKFLOW_REGISTRY_GLOBAL,readRegisteredWorkflow};

package/dist/src/execution/workflow-runtime.d.ts

@@ -3,17 +3,6 @@ import { type Run, type StartOptionsWithoutDeploymentId, type WorkflowFunction,
 import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
 import type { DynamicSubagentAgentConfig } from "#runtime/subagents/dynamic-agent-config.js";
 export declare const LATEST_DEPLOYMENT_UNSUPPORTED_MESSAGE = "deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()";
-/**
- * Workflow function names whose bundled id is stable across deployments
- * (no `@<pkg.version>` stamp). The bundler reads this set when emitting
- * the workflow id so cross-deployment routing — `start(ref, args, {
- * deploymentId: "latest" })` — finds the same workflow on a newer
- * deployment even when the eve version differs.
- *
- * Both halves of the contract (bundler output and runtime reference
- * template) read this single set so they cannot drift.
- */
-export declare const STABLE_WORKFLOW_NAMES: ReadonlySet<string>;
 interface WorkflowHookRecord {
     readonly runId: string;
 }
@@ -48,6 +37,10 @@ export declare const taskRunWorkflowReference: {
 export declare const activityCollectorWorkflowReference: {
     workflowId: string;
 };
+/** Stable workflow reference for authored workflow tool runs. */
+export declare const toolRunWorkflowReference: {
+    workflowId: string;
+};
 /**
  * Creates a workflow-backed runtime whose long-lived driver owns the
  * event stream and dispatches each turn as a child workflow run.
@@ -65,4 +58,9 @@ export declare function waitForCommandHookOwner(token: string): Promise<Workflow
  * while preserving local/dev worlds that do not implement latest routing.
  */
 export declare function startWorkflowPreferLatest<TArgs extends unknown[], TResult>(workflow: WorkflowFunction<TArgs, TResult> | WorkflowMetadata, args: TArgs, options?: StartOptionsWithoutDeploymentId): Promise<Run<unknown> | Run<TResult>>;
+/**
+ * Starts on the deployment that accepted a delivery when this step is running
+ * there, otherwise preserves latest-deployment routing.
+ */
+export declare function startWorkflowPreferAcceptedDeployment<TArgs extends unknown[], TResult>(workflow: WorkflowFunction<TArgs, TResult> | WorkflowMetadata, args: TArgs, acceptedDeploymentId: string | undefined, options?: StartOptionsWithoutDeploymentId): Promise<Run<unknown> | Run<TResult>>;
 export {};