eve 0.55.0 → 0.57.0

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

@@ -1,342 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { DeliverHookPayload, SessionCommand, SessionTimeoutHookPayload } from "#channel/types.js";
-/** Version 7 adds optional presentation labels to delegated activity work. */
-export declare const sessionInboxWireV7Schema: 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">;
-    requestId: z.ZodOptional<z.ZodString>;
-    taskDeliveryId: z.ZodOptional<z.ZodString>;
-    turnPolicy: z.ZodOptional<z.ZodEnum<{
-        queue: "queue";
-        steer: "steer";
-    }>>;
-    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>>>;
-    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<{
-            agentRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                replyTo: z.ZodString;
-                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    input: z.ZodObject<{
-                        agentId: z.ZodOptional<z.ZodString>;
-                        message: z.ZodString;
-                        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>>;
-                        target: z.ZodString;
-                    }, z.core.$strict>;
-                    invocationId: z.ZodString;
-                    kind: z.ZodLiteral<"agent-invoke">;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"agent-settled">;
-                    result: z.ZodObject<{
-                        backgroundTask: z.ZodOptional<z.ZodObject<{
-                            status: z.ZodLiteral<"working">;
-                            taskId: z.ZodString;
-                        }, z.core.$strict>>;
-                        callId: z.ZodString;
-                        isError: z.ZodOptional<z.ZodBoolean>;
-                        kind: z.ZodLiteral<"subagent-result">;
-                        origin: z.ZodLiteral<"child">;
-                        outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                            kind: z.ZodLiteral<"parked">;
-                            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                                kind: z.ZodLiteral<"succeeded">;
-                                output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                            }, z.core.$strict>, z.ZodObject<{
-                                error: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                                kind: z.ZodLiteral<"failed">;
-                            }, z.core.$strict>, z.ZodObject<{
-                                kind: z.ZodLiteral<"cancelled">;
-                            }, z.core.$strict>], "kind">;
-                            usageDelta: z.ZodObject<{
-                                cacheReadTokens: z.ZodNumber;
-                                cacheWriteTokens: z.ZodNumber;
-                                inputTokens: z.ZodNumber;
-                                outputTokens: z.ZodNumber;
-                                costUsd: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>;
-                        }, z.core.$strict>, z.ZodObject<{
-                            kind: z.ZodLiteral<"terminal">;
-                            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                                kind: z.ZodLiteral<"succeeded">;
-                                output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                            }, z.core.$strict>, z.ZodObject<{
-                                error: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                                kind: z.ZodLiteral<"failed">;
-                            }, z.core.$strict>, z.ZodObject<{
-                                kind: z.ZodLiteral<"cancelled">;
-                            }, z.core.$strict>], "kind">;
-                            usageDelta: z.ZodObject<{
-                                cacheReadTokens: z.ZodNumber;
-                                cacheWriteTokens: z.ZodNumber;
-                                inputTokens: z.ZodNumber;
-                                outputTokens: z.ZodNumber;
-                                costUsd: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>;
-                        }, z.core.$strict>], "kind">;
-                        output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                        subagentName: z.ZodString;
-                        usage: z.ZodOptional<z.ZodObject<{
-                            cacheReadTokens: z.ZodNumber;
-                            cacheWriteTokens: z.ZodNumber;
-                            inputTokens: z.ZodNumber;
-                            outputTokens: z.ZodNumber;
-                            costUsd: z.ZodOptional<z.ZodNumber>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strict>;
-                }, z.core.$strict>], "kind">;
-                taskId: z.ZodString;
-            }, z.core.$strict>>>;
-            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.ZodUnion<readonly [z.ZodObject<{
-                replyTo: z.ZodString;
-                sequence: z.ZodNumber;
-                stepIndex: z.ZodNumber;
-                taskId: z.ZodString;
-                turnId: z.ZodString;
-                request: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-            }, z.core.$loose>, z.ZodObject<{
-                replyTo: z.ZodString;
-                sequence: z.ZodNumber;
-                stepIndex: z.ZodNumber;
-                taskId: z.ZodString;
-                turnId: z.ZodString;
-                requests: z.ZodArray<z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>;
-            }, z.core.$loose>]>>>;
-            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>;
-    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<{
-            agentRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                replyTo: z.ZodString;
-                request: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    input: z.ZodObject<{
-                        agentId: z.ZodOptional<z.ZodString>;
-                        message: z.ZodString;
-                        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>>;
-                        target: z.ZodString;
-                    }, z.core.$strict>;
-                    invocationId: z.ZodString;
-                    kind: z.ZodLiteral<"agent-invoke">;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"agent-settled">;
-                    result: z.ZodObject<{
-                        backgroundTask: z.ZodOptional<z.ZodObject<{
-                            status: z.ZodLiteral<"working">;
-                            taskId: z.ZodString;
-                        }, z.core.$strict>>;
-                        callId: z.ZodString;
-                        isError: z.ZodOptional<z.ZodBoolean>;
-                        kind: z.ZodLiteral<"subagent-result">;
-                        origin: z.ZodLiteral<"child">;
-                        outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                            kind: z.ZodLiteral<"parked">;
-                            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                                kind: z.ZodLiteral<"succeeded">;
-                                output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                            }, z.core.$strict>, z.ZodObject<{
-                                error: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                                kind: z.ZodLiteral<"failed">;
-                            }, z.core.$strict>, z.ZodObject<{
-                                kind: z.ZodLiteral<"cancelled">;
-                            }, z.core.$strict>], "kind">;
-                            usageDelta: z.ZodObject<{
-                                cacheReadTokens: z.ZodNumber;
-                                cacheWriteTokens: z.ZodNumber;
-                                inputTokens: z.ZodNumber;
-                                outputTokens: z.ZodNumber;
-                                costUsd: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>;
-                        }, z.core.$strict>, z.ZodObject<{
-                            kind: z.ZodLiteral<"terminal">;
-                            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                                kind: z.ZodLiteral<"succeeded">;
-                                output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                            }, z.core.$strict>, z.ZodObject<{
-                                error: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                                kind: z.ZodLiteral<"failed">;
-                            }, z.core.$strict>, z.ZodObject<{
-                                kind: z.ZodLiteral<"cancelled">;
-                            }, z.core.$strict>], "kind">;
-                            usageDelta: z.ZodObject<{
-                                cacheReadTokens: z.ZodNumber;
-                                cacheWriteTokens: z.ZodNumber;
-                                inputTokens: z.ZodNumber;
-                                outputTokens: z.ZodNumber;
-                                costUsd: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>;
-                        }, z.core.$strict>], "kind">;
-                        output: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-                        subagentName: z.ZodString;
-                        usage: z.ZodOptional<z.ZodObject<{
-                            cacheReadTokens: z.ZodNumber;
-                            cacheWriteTokens: z.ZodNumber;
-                            inputTokens: z.ZodNumber;
-                            outputTokens: z.ZodNumber;
-                            costUsd: z.ZodOptional<z.ZodNumber>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strict>;
-                }, z.core.$strict>], "kind">;
-                taskId: z.ZodString;
-            }, z.core.$strict>>>;
-            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.ZodUnion<readonly [z.ZodObject<{
-                replyTo: z.ZodString;
-                sequence: z.ZodNumber;
-                stepIndex: z.ZodNumber;
-                taskId: z.ZodString;
-                turnId: z.ZodString;
-                request: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
-            }, z.core.$loose>, z.ZodObject<{
-                replyTo: z.ZodString;
-                sequence: z.ZodNumber;
-                stepIndex: z.ZodNumber;
-                taskId: z.ZodString;
-                turnId: z.ZodString;
-                requests: z.ZodArray<z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>;
-            }, z.core.$loose>]>>>;
-            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>>;
-    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>;
-                label: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    version: z.ZodLiteral<7>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"session-timeout">;
-    version: z.ZodLiteral<7>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"clear">;
-    version: z.ZodLiteral<7>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"compact">;
-    version: z.ZodLiteral<7>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"reset">;
-    reason: z.ZodOptional<z.ZodString>;
-    version: z.ZodLiteral<7>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"cancel">;
-    taskId: z.ZodOptional<z.ZodString>;
-    turnId: z.ZodOptional<z.ZodString>;
-    tasks: z.ZodOptional<z.ZodBoolean>;
-    version: z.ZodLiteral<7>;
-}, z.core.$strict>], "kind">;
-export type SessionInboxWireV7 = z.infer<typeof sessionInboxWireV7Schema>;
-/** Builds and validates one complete version-7 wire value. */
-export declare function encodeSessionCommandV7(command: DeliverHookPayload | SessionCommand | SessionTimeoutHookPayload): SessionInboxWireV7;

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

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{formatValidationError}from"#runtime/validation.js";import{SessionInboxWireError}from"#execution/wire/session-inbox-contract.js";import{encodeSessionCommandV6,sessionInboxWireV6Schema}from"#execution/wire/session-inbox-wire.v6.js";const v6=sessionInboxWireV6Schema.options,v6Deliver=v6[0],v6Caller=v6Deliver.shape.caller.unwrap(),v6ActivityObserver=v6Caller.shape.activityObserver.unwrap(),v6WorkIdentity=v6ActivityObserver.shape.workIdentity.unwrap(),version=z.literal(7),sessionInboxWireV7Schema=z.discriminatedUnion(`kind`,[v6Deliver.extend({caller:v6Caller.extend({activityObserver:v6ActivityObserver.extend({workIdentity:v6WorkIdentity.extend({label:z.string().optional()}).optional()}).optional()}).optional(),version}),v6[1].extend({version}),v6[2].extend({version}),v6[3].extend({version}),v6[4].extend({version}),v6[5].extend({version})]);function encodeSessionCommandV7(e){let t=readActivityLabel(e),n=encodeSessionCommandV6(withoutActivityLabel(e)),r=t===void 0||n.kind!==`deliver`||n.caller===void 0?{...n,version:7}:{...n,caller:{...n.caller,activityObserver:{...n.caller.activityObserver,workIdentity:{...n.caller.activityObserver.workIdentity,label:t}}},version:7},i=sessionInboxWireV7Schema.safeParse(r);if(!i.success)throw new SessionInboxWireError(`Produced a session inbox payload that does not match wire version 7: ${formatValidationError(i.error)}`);return i.data}function readActivityLabel(e){return e.kind===`send`||e.kind===`deliver`?e.caller?.activityObserver?.workIdentity?.label:void 0}function withoutActivityLabel(e){if(e.kind!==`send`&&e.kind!==`deliver`||e.caller?.activityObserver?.workIdentity?.label===void 0)return e;let{label:t,...n}=e.caller.activityObserver.workIdentity;return{...e,caller:{...e.caller,activityObserver:{...e.caller.activityObserver,workIdentity:n}}}}export{encodeSessionCommandV7,sessionInboxWireV7Schema};

package/dist/src/execution/workflow-entry-crash.d.ts

@@ -1,39 +0,0 @@
-import type { TurnCaller } from "#channel/types.js";
-import type { DurableSessionState } from "#execution/durable-session-store.js";
-/**
- * Write-through cell owned by `workflowEntry`: written
- * unconditionally by the driver loop as turns advance, read only by the
- * outer catch. When the loop throws, its locals are unreachable, so this
- * cell is the crash path's only view of values that changed after turn 1.
- *
- * Reach for this cell only when all three hold for a value:
- * 1. it is produced or replaced inside the driver loop, so the entry
- *    function's own locals go stale;
- * 2. it travels by value inside Workflow step results — there is no
- *    store the catch could re-read it from at crash time;
- * 3. the crash path needs its latest value to discharge a cleanup
- *    obligation.
- * If any of the three fails, read the value from where it already lives
- * instead of mirroring it here.
- */
-export interface CrashCleanupState {
-    caller: TurnCaller | undefined;
-    callerResolved: boolean;
-    lastSessionState: DurableSessionState | undefined;
-    serializedContext: Record<string, unknown>;
-    terminalEmitted: boolean;
-    turnId?: string;
-}
-export declare function hasDelegatedCallerContext(serializedContext: Record<string, unknown>): boolean;
-/**
- * Caller to reject from the crash path. Normally the resolved cell value —
- * including `undefined` after a settled reply cleared it, when there is
- * nothing left to notify. When the crash happened before
- * `resolveInitialTurnCallerStep` ever ran (e.g. `createSessionStep` threw),
- * the cell is empty even though a delegated caller may be parked on this
- * session's reply, so the caller is re-resolved from the serialized context
- * — which needs nothing from the failed steps. Best-effort: when resolution
- * fails again there is no reachable caller to notify.
- */
-export declare function resolveCallerForCrash(state: CrashCleanupState, serializedContext: Record<string, unknown>): Promise<TurnCaller | undefined>;
-export declare function createSafeOuterWorkflowError(): Error;

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

@@ -1 +0,0 @@
-import{resolveInitialTurnCallerStep}from"#subagents/parent-notification.js";function hasDelegatedCallerContext(e){if(e[`eve.sessionCallback`]!==void 0)return!0;let t=e[`eve.channel`];return typeof t==`object`&&!!t&&Reflect.get(t,`kind`)===`subagent`}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}export{createSafeOuterWorkflowError,hasDelegatedCallerContext,resolveCallerForCrash};

package/dist/src/execution/workflow-entry-finalization.d.ts

@@ -1,28 +0,0 @@
-import type { TurnCaller } from "#channel/types.js";
-import type { DurableSessionState } from "#execution/durable-session-store.js";
-import type { NextDriverAction } from "#execution/next-driver-action.js";
-import type { RunMode } from "#shared/run-mode.js";
-export declare function finalizeExpiredSession(input: {
-    readonly caller: TurnCaller | undefined;
-    readonly driverWritable: WritableStream<Uint8Array>;
-    readonly mode: RunMode;
-    readonly serializedContext: Record<string, unknown>;
-    readonly sessionState: DurableSessionState;
-    readonly terminalState?: {
-        terminalEmitted: boolean;
-    };
-}): Promise<{
-    readonly output: unknown;
-}>;
-export declare function finalizeDone(input: {
-    readonly action: NextDriverAction & {
-        readonly kind: "done";
-    };
-    readonly caller: TurnCaller | undefined;
-    readonly mode: RunMode;
-    readonly terminalState?: {
-        terminalEmitted: boolean;
-    };
-}): Promise<{
-    readonly output: unknown;
-}>;

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

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

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

@@ -1,37 +0,0 @@
-import type { RunInput, SessionCommand } from "#channel/types.js";
-import type { AgentWorkflowRetentionDefinition } from "#shared/agent-definition.js";
-/**
- * Serializable workflow-entry input. All runtime state travels via
- * `serializedContext`, which is produced by `serializeContext(ctx)`
- * and deserialized at each `"use step"` boundary.
- */
-export interface WorkflowEntryInput {
-    readonly activityCollectorRunId?: string;
-    readonly continuationConflictCommand?: Extract<SessionCommand, {
-        readonly kind: "send";
-    }>;
-    readonly input: RunInput["input"];
-    readonly limits?: RunInput["limits"];
-    readonly retention?: AgentWorkflowRetentionDefinition;
-    readonly sessionTimeoutMs?: number | false;
-    readonly serializedContext: Record<string, unknown>;
-    readonly taskId?: string;
-}
-export interface WorkflowEntryResult {
-    readonly output: unknown;
-}
-/**
- * Long-lived workflow entrypoint. Handles both root sessions and
- * delegated child sessions: root sessions expose only parent
- * control-plane events; delegated children publish their full progress
- * on a child stream and resume the parked parent with a
- * `subagent-result` on completion.
- *
- * Owns the stable command inbox, its channel alias, and the session lifecycle; each turn-owned
- * turn resolves its own runtime actions in-line and reports back only
- * `done`/`park` via the closed-contract {@link NextDriverAction}. The
- * only session-shape flag the driver reads (besides identity) is
- * `hasProxyInputRequests`, the documented short-circuit for hook-payload
- * routing to any descendant still active when the parent parks.
- */
-export declare function workflowEntry(input: WorkflowEntryInput): Promise<WorkflowEntryResult>;

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

@@ -1 +0,0 @@
-import{attachClientContext,readClientContext}from"#internal/client-context.js";import{sessionCommandHookToken}from"#execution/session-command-token.js";import{SESSION_INBOX_CONTEXT_KEY,SESSION_INBOX_WIRE_VERSION}from"#execution/wire/session-inbox-contract.js";import{getWorkflowMetadata,getWritable}from"#compiled/@workflow/core/index.js";import{isHookConflictError}from"#execution/hook-ownership.js";import{readChannelRequestId,readRootSessionId}from"#execution/eve-workflow-attributes.js";import{SessionStateCursor}from"#execution/session-state-cursor.js";import{fireSessionCallbackStep}from"#subagents/callback-step.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{bindTurnCallerContextStep,notifyCancelledTaskCallerStep,notifyDelegatedParentStep,notifyTurnCallerStep,resolveInitialTurnCallerStep}from"#subagents/parent-notification.js";import{createDelegatedSubagentErrorResult}from"#subagents/parent-result.js";import{terminateChildSessionsStep}from"#execution/terminate-child-sessions-step.js";import{createSafeOuterWorkflowError,hasDelegatedCallerContext,resolveCallerForCrash}from"#execution/workflow-entry-crash.js";import{nextTurnDelivery}from"#execution/parked-delivery-wait.js";import{rebaseTaskAgentHandleMutations}from"#subagents/handles/rebase.js";import{dispatchAndAwaitTurn}from"#execution/turn-dispatch.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{finalizeDone,finalizeExpiredSession}from"#execution/workflow-entry-finalization.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";import{settleContinuationConflictStep}from"#execution/continuation-conflict-step.js";async function workflowEntry(e){"use workflow";let{workflowRunId:t,workflowStartedAt:n}=getWorkflowMetadata(),r=e.serializedContext[`eve.continuationToken`]||``,i=e.serializedContext[`eve.mode`],a=e.serializedContext[`eve.capabilities`],o=e.serializedContext[`eve.bundle`];e.serializedContext[`eve.sessionId`]=t,e.serializedContext[SESSION_INBOX_CONTEXT_KEY]={sessionId:t,version:SESSION_INBOX_WIRE_VERSION};let s=getWritable(),c={caller:void 0,callerResolved:!1,lastSessionState:void 0,serializedContext:e.serializedContext,terminalEmitted:!1};try{let l=readRootSessionId(e.serializedContext),u=e.serializedContext[`eve.dynamicSubagentAgentConfig`],d=createSessionCommandInbox(),f=sessionCommandHookToken(t),p=`${t}:auth`,m,h;try{let[g,_,v,y]=await Promise.allSettled([createSessionStep({compiledArtifactsSource:o.source,continuationToken:r,dynamicSubagentAgentConfig:u,inheritedLimits:e.limits,nodeId:o.nodeId,outputSchema:e.input.outputSchema,rootSessionId:l,sessionId:t,taskId:e.taskId}),d.claimStable(f),d.claimAuthorization(p),d.rekeyContinuation(r)]);if(g.status===`rejected`)throw g.reason;if(_.status===`rejected`)throw _.reason;if(v.status===`rejected`)throw v.reason;if(y.status===`rejected`){if(isHookConflictError(y.reason))return(e.activityCollectorRunId!==void 0||e.continuationConflictCommand!==void 0)&&await settleContinuationConflictStep({activityCollectorRunId:e.activityCollectorRunId,command:e.continuationConflictCommand,continuationToken:r,ownerSessionId:typeof y.reason.conflictingRunId==`string`?y.reason.conflictingRunId:void 0}),{output:``};throw y.reason}m=g.value.state,c.lastSessionState=m,c.caller=hasDelegatedCallerContext(e.serializedContext)?await resolveInitialTurnCallerStep({serializedContext:e.serializedContext}):void 0,c.callerResolved=!0,h=await runDriverLoop({capabilities:a,commandInbox:d,driverWritable:s,initialInput:{deliveryMetadata:e.serializedContext[`eve.channelDelivery`]===void 0?void 0:[{...e.serializedContext[`eve.channelDelivery`],payloadIndex:0}],kind:`deliver`,payloads:[attachClientContext({message:e.input.message,context:e.input.context,outputSchema:e.input.outputSchema},readClientContext(e.input))],requestId:readChannelRequestId(e.serializedContext)},crashCleanupState:c,mode:i,retention:e.retention,serializedContext:e.serializedContext,sessionState:m,sessionTimeoutDeadline:e.sessionTimeoutMs===!1?void 0:new Date(n.getTime()+(e.sessionTimeoutMs??DEFAULT_SESSION_TIMEOUT_MS)),stableCommandToken:f})}finally{await d.dispose()}return h.kind===`result`?h.result:await finalizeExpiredSession({caller:c.caller,driverWritable:s,mode:i,serializedContext:h.serializedContext,sessionState:h.sessionState,terminalState:c})}catch(e){let n=c.terminalEmitted;throw!c.terminalEmitted&&c.lastSessionState!==void 0&&await terminateChildSessionsStep({serializedContext:c.serializedContext,sessionState:c.lastSessionState}),c.terminalEmitted||=(await emitTerminalSessionFailureStep({error:normalizeSerializableError(e),parentWritable:s,serializedContext:c.serializedContext,turnId:c.turnId}),!0),n||(i===`task`?(await fireSessionCallbackStep({error:normalizeSerializableError(e),serializedContext:c.serializedContext,status:`failed`}),await notifyDelegatedParentStep({result:createDelegatedSubagentErrorResult(c.serializedContext,e),serializedContext:c.serializedContext})):(c.caller!==void 0||!c.callerResolved)&&await notifyTurnCallerStep({caller:await resolveCallerForCrash(c,c.serializedContext),lifecycle:`terminal`,sessionId:t,settled:{isError:!0,output:e}})),createSafeOuterWorkflowError()}}async function runDriverLoop(e){let t=e.commandInbox,n=new Map,nextParkedActivity=async r=>{let l=new Set(r.expectedAttemptIds);for(let e of n.keys())l.has(e)||n.delete(e);for(;;){if(l.size>0&&[...l].every(e=>n.has(e))){let e=[...l].map(e=>n.get(e));return n.clear(),{kind:`authorization-resume`,payloads:e}}let r=await nextTurnDelivery({awaitAuthorizationCallbacks:l.size>0,bufferedDeliveries:i,bufferedSessionControls:a,cancelledTaskIds:o,commandInbox:t,deferDeliveries:e.mode===`task`&&l.size>0,driverWritable:e.driverWritable,seenTaskDeliveries:s,stateCursor:c});if(r.kind!==`authorization`)return r;for(let e of r.payloads){let t=e.authorizationCallback;typeof t?.attemptId==`string`&&l.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=new SessionStateCursor({serializedContext:e.serializedContext,sessionState:e.sessionState}),l=e.sessionTimeoutDeadline===void 0?void 0:createSessionTimeoutControl({deadline:e.sessionTimeoutDeadline,token:e.stableCommandToken}),u,runTurn=async n=>{let l=c.sessionState,d=e.crashCleanupState.caller;d?.taskId!==void 0&&s.add(d.taskId);let f=d===void 0?c.serializedContext:await bindTurnCallerContextStep({caller:d,serializedContext:c.serializedContext});e.crashCleanupState.turnId=`turn_${String(r)}`;let p=await dispatchAndAwaitTurn({bufferedDeliveries:i,bufferedSessionControls:a,cancelledTaskIds:o,capabilities:e.capabilities,commandInbox:t,controlToken:nextTurnControlToken(),delivery:n,mode:e.mode,parentWritable:e.driverWritable,retention:e.retention,serializedContext:f,seenTaskDeliveries:s,sessionState:c.sessionState,stateCursor:c});await u?.(),u=p.dispose;let m=c.sessionState===l?p.action:rebaseTaskAgentHandleMutations(p.action,c.sessionState,l);return c.adoptState(m),e.crashCleanupState.lastSessionState=c.sessionState,e.crashCleanupState.serializedContext=c.serializedContext,m};try{await l?.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,terminalState:e.crashCleanupState})};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:c.serializedContext,sessionState:c.sessionState});c.adoptState(t),e.crashCleanupState.serializedContext=c.serializedContext;let n={caller:e.crashCleanupState.caller,sessionId:c.sessionState.sessionId};await notifyCancelledTaskCallerStep(t.usage===void 0?n:{...n,usage:t.usage}),e.crashCleanupState.lastSessionState=c.sessionState}c.sessionState.continuationToken&&await t.rekeyContinuation(c.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:c.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=c.sessionState,i.kind===`authorization-resume`){n=await runTurn({kind:`deliver`,payloads:i.payloads});continue}if(i.kind===`expired`)return{kind:`expired`,serializedContext:c.serializedContext,sessionState:c.sessionState};if(i.kind===`reset`)return{kind:`result`,result:await finalizeExpiredSession({caller:e.crashCleanupState.caller,driverWritable:e.driverWritable,mode:e.mode,serializedContext:c.serializedContext,sessionState:c.sessionState,terminalState:e.crashCleanupState})};if(i.kind===`clear`||i.kind===`compact`){n=await runTurn({kind:i.kind});continue}if(i.kind===`closed`)return{kind:`result`,result:await finalizeExpiredSession({caller:e.crashCleanupState.caller,driverWritable:e.driverWritable,mode:e.mode,serializedContext:c.serializedContext,sessionState:c.sessionState,terminalState:e.crashCleanupState})};if(i.kind===`cancel-turn`){await cancelDescendantTurnsStep({serializedContext:c.serializedContext,sessionState:c.sessionState});let t=await settleCancelledTurnStep({parentWritable:e.driverWritable,serializedContext:c.serializedContext,sessionState:c.sessionState});c.adoptState(t),e.crashCleanupState.serializedContext=c.serializedContext,n={...n,settled:void 0},e.crashCleanupState.caller=void 0,e.crashCleanupState.lastSessionState=c.sessionState;continue}i.delivery.caller!==void 0&&(e.crashCleanupState.caller=i.delivery.caller),n=await runTurn(i.delivery)}}finally{await u?.(),await l?.dispose()}}workflowEntry.workflowId=`workflow//eve//workflowEntry`;export{workflowEntry};

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

@@ -1 +0,0 @@
-import{callAdapterEventHandler,defaultDeliverResult}from"#channel/adapter.js";import{contextStorage}from"#context/container.js";import{AuthKey,CapabilitiesKey,ChannelDeliveryKey,HandleEventKey,ModeKey,ScheduleIdKey,SessionDynamicSubagentRuntimeRevisionKey,SessionDynamicToolRuntimeRevisionKey,StaticModelReferenceKey,TurnDeliveryIdsKey,TurnTaskDeliveryKey}from"#context/keys.js";import{createAuthorizationCompletedEvent,createSessionStartedEvent,createTurnStartedEvent,encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{coalesceTurnInputs}from"#harness/messages.js";import{emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{dispatchDynamicSubagentEvent,refreshDynamicSessionSubagentsForRuntimeRevision}from"#context/dynamic-subagent-lifecycle.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{hydrateDurableSession,refreshSessionFromTurnAgent}from"#execution/session.js";import{readRetainedBackgroundToolResult,runBackgroundStep}from"#execution/tasks/parent/tool-execution.js";import{preserveSerializedBackgroundTaskObservabilityState}from"#shared/serialized-observability-state.js";import*as agentTraceState from"#tracing/agent-trace-context-store.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{activeTurnId}from"#harness/active-turn-id.js";import{getPendingWorkflowInterrupt}from"#harness/workflow-interrupt-state.js";import{getWorkflowTaskCallIds,isWorkflowTaskInterrupt}from"#harness/workflow-task-state.js";import{deferMismatchedInlineTurnStep}from"#execution/accepted-delivery-deployment.js";import{isTurnCancellation,throwIfTurnAborted}from"#harness/turn-cancellation.js";import{derivePendingState}from"#execution/pending-turn-state.js";import{dispatchDynamicModelEvent}from"#context/dynamic-model-lifecycle.js";import{dispatchDynamicToolEvent,rebindMissingCompiledDynamicToolCallbacks,refreshDynamicSessionToolsForRuntimeRevision}from"#context/dynamic-tool-lifecycle.js";import{CallbackBaseUrlKey,PendingAuthorizationResultKey,clearPendingAuthorization,getPendingAuthorization}from"#harness/authorization.js";import{hasPendingInputBatch}from"#harness/input-requests.js";import{setChannelContext}from"#execution/channel-context.js";import{dispatchStreamEventHooks}from"#context/hook-lifecycle.js";import{observeSessionActivity}from"#execution/session-activity-projection.js";import{reconcileSessionContinuationToken}from"#execution/reconcile-session-continuation-token.js";import{bindSessionInstrumentation}from"#instrumentation/runtime.js";import{getTurnUsageState,takeSessionUsageDelta,toUsage}from"#harness/turn-tag-state.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{dispatchDynamicInstructionEvent,drainDynamicInstructionUserMessages,prepareDynamicInstructionPreamble}from"#context/dynamic-instruction-lifecycle.js";import{dispatchDynamicSkillEvent}from"#context/dynamic-skill-lifecycle.js";import{dispatchMemoryLifecycleEvent}from"#context/memory-event-lifecycle.js";import{RuntimeActionSettlementTimesKey}from"#harness/runtime-action-settlement-state.js";import{matchAuthorizationCallbacks}from"#execution/authorization-callback-match.js";import{forwardTaskEventToSessionCallback}from"#execution/task-event-callback.js";import{resolveEffectiveOutputSchema}from"#execution/effective-output-schema.js";import{buildRuntimeIdentity,createExecutionNodeStep}from"#execution/node-step.js";import{getBackgroundTaskDelivery,markBackgroundTaskStepInput,resolveInitiatingTaskContext,resolveTaskDeliveryContext}from"#tasks/delivery-context.js";import{scheduledLaunchDeliveryEvent}from"#execution/scheduled-launch-delivery.js";import{prepareWorkflowPreambleTrace}from"#execution/workflow-trace-context.js";import{createExecutionHistoryView}from"#execution/history-view.js";import{resolveRuntimeCompiledArtifactsVersionedCacheKey}from"#runtime/cache-key.js";import{bindDynamicConnections}from"#execution/dynamic-connections.js";import{runModelCallBatch}from"#execution/model-call-batching.js";import{createCancelledModelCallBatchResult}from"#execution/cancelled-model-call-batch.js";import*as activityCohort from"#execution/activity-cohort.js";function channelDeliveryErrorCode(e){if(typeof e==`object`&&e&&`code`in e){let t=e.code;if(typeof t==`string`&&t.length>0)return t}return`CHANNEL_DELIVERY_FAILED`}async function turnStep(e){"use step";let t=deferMismatchedInlineTurnStep(e);if(t!==void 0)return t;let n=e,r=await readDurableSession(n.sessionState),i=await deserializeContext(n.serializedContext);e.input?.kind===`deliver`&&i.set(TurnTaskDeliveryKey,`none`);let a=i.require(ChannelKey),o=i.require(BundleKey),s=resolveEffectiveAgentRuntime(o,i);try{let{getWorkflowMetadata:e}=await import(`#compiled/@workflow/core/index.js`),t=e();typeof t.url==`string`&&i.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(t.url))}catch{}let c=getPendingAuthorization(r.state),l;if(c&&n.input?.kind===`deliver`){let{matches:e,remainingPayloads:t}=matchAuthorizationCallbacks(c,n.input.payloads);if(n={...n,input:{...n.input,payloads:t}},e.length>0){let a=activityCohort.restoreAuthorizationActivity({ctx:i,matches:e,pending:c}),o=e.map(e=>e.result);i.set(PendingAuthorizationResultKey,o),r={...r,state:clearPendingAuthorization(r.state,a)},l=e,t.length===0&&(n={...n,input:void 0})}}n.input?.kind===`deliver`&&n.input.auth!==void 0&&i.set(AuthKey,n.input.auth??null);let u=getBackgroundTaskDelivery(n.input),d=hydrateDurableSession({compactionOverrides:{thresholdPercent:s.thresholdPercent},durable:r,turnAgent:s.turnAgent}),f=createExecutionHistoryView(d),p=bindSessionInstrumentation({agentName:s.turnAgent.id,ctx:i,rootSessionId:d.rootSessionId??d.sessionId,sessionId:d.sessionId}),m=getHarnessEmissionState(d.state);e.input?.kind===`deliver`&&e.input.payloads.some(e=>e.message!==void 0)?i.set(TurnDeliveryIdsKey,e.input.deliveryMetadata?.map(e=>e.deliveryId)??[]):!m.sessionStarted&&i.get(ChannelDeliveryKey)!==void 0&&i.set(TurnDeliveryIdsKey,[i.require(ChannelDeliveryKey).deliveryId]),e.input?.kind===`deliver`&&await contextStorage.run(i,()=>p?.instrumentChannelDelivery({agentName:o.turnAgent.id,ctx:i,delivery:e.input,rootSessionId:d.rootSessionId??d.sessionId,sequence:m.sequence,sessionId:d.sessionId,turnId:activeTurnId(m)}));let failChannelDeliveries=async e=>{await contextStorage.run(i,()=>p?.instrumentChannelDelivery({ctx:i,error:e,errorCode:channelDeliveryErrorCode(e),includeTurn:!1,outcome:`failed`})),await p?.flush()},h=buildAdapterContext(a,i),g;if(n.input?.kind===`deliver`){let e=[];try{for(let t of n.input.payloads){let n=a.deliver?await a.deliver(t,h):defaultDeliverResult(t);n!=null&&e.push(u===void 0?n:markBackgroundTaskStepInput(n))}}catch(e){throw await failChannelDeliveries(e),e}g=e.length===0?void 0:e.reduce(coalesceTurnInputs)}else n.input?.kind===`runtime-action-result`&&(n.input.acceptedAtMsByCallId!==void 0&&i.set(RuntimeActionSettlementTimesKey,n.input.acceptedAtMsByCallId),g={runtimeActionResults:n.input.results});let _;if(g!==void 0&&u!==void 0){let e=resolveTaskDeliveryContext({state:r.state,taskDeliveryId:u.taskDeliveryId});e!==void 0&&(i.set(TurnTaskDeliveryKey,e.phase),_=e.rootTurnId,g={...g,context:[...g.context??[],e.context]})}activityCohort.updateActivityRootForDelivery({activeTurnId:activeTurnId(m),ctx:i,delivery:e.input?.kind===`deliver`?e.input:void 0,sessionState:r.state,taskRootTurnId:_});let v=i.get(TurnTaskDeliveryKey);if(v===`none`||v===`initiating`){let e=resolveInitiatingTaskContext({state:r.state,turnId:activeTurnId(m)});e!==void 0&&i.set(TurnTaskDeliveryKey,e.phase)}if(n.input?.kind===`deliver`){let e={...a,state:{...h.state}};setChannelContext(i,e)}if(n.input?.kind===`deliver`&&g===void 0){await contextStorage.run(i,()=>p?.instrumentChannelDelivery({ctx:i,includeTurn:!1,outcome:`completed`})),await p?.flush();let e=reconcileSessionContinuationToken(i,d),t=serializeContext(i),r=e===d?n.sessionState:createDurableSessionState({session:e});return{action:`park`,...derivePendingState(e),serializedContext:t,sessionState:r}}let y=o.hookRegistry,b=bindDynamicConnections(i,o.resolvedAgent),x=o.resolvedAgent.dynamicInstructionsResolvers??[],S=o.resolvedAgent.dynamicSkillResolvers??[],C=o.subagentRegistry.dynamicResolvers??[],w=o.resolvedAgent.dynamicToolResolvers??[],T={...o.graph.root,turnAgent:s.turnAgent},E=buildRuntimeIdentity(T);try{let e=process.env.VERCEL_DEPLOYMENT_ID?.trim(),t=e?`deployment:${e}`:await resolveRuntimeCompiledArtifactsVersionedCacheKey(o.compiledArtifactsSource),n=m.sessionStarted;if(i.setVirtualContext(StaticModelReferenceKey,s.turnAgent.model??null),!n)i.set(SessionDynamicSubagentRuntimeRevisionKey,t),i.set(SessionDynamicToolRuntimeRevisionKey,t);else{let e=createSessionStartedEvent({runtime:E});await Promise.all([refreshDynamicSessionSubagentsForRuntimeRevision({ctx:i,resolvers:C,event:e,messages:f.initial.messages,runtimeRevision:t}),refreshDynamicSessionToolsForRuntimeRevision({ctx:i,resolvers:w,event:e,messages:f.initial.messages,runtimeRevision:t})]),await rebindMissingCompiledDynamicToolCallbacks({ctx:i,event:createTurnStartedEvent({sequence:m.sequence,turnId:activeTurnId(m)}),messages:f.initial.messages,resolvers:w})}}catch(e){throw await failChannelDeliveries(e),e}let D=n.parentWritable.getWriter(),emit=async e=>{let t=scheduledLaunchDeliveryEvent(e,{isFirstTurn:m.sequence===0,isScheduled:i.get(ScheduleIdKey)!==void 0,taskPhase:i.get(TurnTaskDeliveryKey)});if(t===void 0)return{event:stampMessageStreamEvent(e,i.get(TurnDeliveryIdsKey)),suppressed:!0};let n=await callAdapterEventHandler(a,t,h);setChannelContext(i,{...a,state:{...h.state}});let r=stampMessageStreamEvent(n,i.get(TurnDeliveryIdsKey));return await D.write(encodeMessageStreamEvent(r)),{event:r,suppressed:!1}},handleEvent=async(e,t)=>{activityCohort.updateActivityBlockers(i,e);let r=await forwardTaskEventToSessionCallback(i,e)?{event:stampMessageStreamEvent(e,i.get(TurnDeliveryIdsKey)),suppressed:!1}:await emit(e),a=await dispatchMemoryLifecycleEvent({abortSignal:n.abortSignal,appRoot:T.agent?.metadata?.appRoot??``,ctx:i,event:e,instrumentation:p?.memory,memories:T.agent?.memories??[],messages:t,nodeId:o.nodeId??`__root__`});observeSessionActivity({ctx:i,event:r.event,sessionId:d.sessionId}),r.suppressed||await dispatchStreamEventHooks({ctx:i,registry:y,event:r.event}),r.event.type!==`step.started`&&await dispatchDynamicModelEvent({ctx:i,dynamicModel:s.turnAgent.dynamicModel,event:r.event,messages:a,scope:{moduleMap:o.moduleMap,nodeId:o.nodeId}}),await b.dispatch(r.event),await dispatchDynamicSubagentEvent({ctx:i,resolvers:C,event:r.event,messages:a}),await dispatchDynamicToolEvent({ctx:i,resolvers:w,event:r.event,messages:a}),await dispatchDynamicSkillEvent({ctx:i,resolvers:S,event:r.event,messages:a}),await dispatchDynamicInstructionEvent({ctx:i,resolvers:x,event:r.event,messages:a})},O=i.require(ModeKey),k=o.resolvedAgent.config?.experimental?.workflow?.modelCallsPerStep??1,A=i.get(CapabilitiesKey),runHarnessStep=async(e,t)=>{let r=refreshSessionFromTurnAgent({compactionOverrides:{thresholdPercent:s.thresholdPercent},session:e,turnAgent:s.turnAgent}),i=r;return createExecutionNodeStep({abortSignal:n.abortSignal,capabilities:A,clearOnly:n.input?.kind===`clear`,compactOnly:n.input?.kind===`compact`,createRuntime:createWorkflowRuntime,handleEvent,historyProjector:f.projector,historyView:f.prepare(i),instrumentation:p,mode:O,modelResolutionScope:{moduleMap:o.moduleMap,nodeId:o.nodeId},node:T,workflowMaxSubagents:r.workflowMaxSubagents})(i,t)},j,M;try{throwIfTurnAborted(n.abortSignal),M=await runModelCallBatch({initialInput:g,initialSession:d,modelCallsPerStep:k,runStep:async({firstCall:e,session:t,stepInput:r})=>{let a=await runBackgroundStep(i,t,async t=>{i.setVirtualContext(HandleEventKey,handleEvent),i.setVirtualContext(StaticModelReferenceKey,s.turnAgent.model??null);let n=e?resolveEffectiveOutputSchema({agentOutputSchema:s.turnAgent.outputSchema,input:g,mode:O,session:t}):t;if(await b.rehydrate(getHarnessEmissionState(n.state),E,isHarnessBetweenTurns(n)),e&&l){let e=getHarnessEmissionState(n.state);if(isHarnessBetweenTurns(n)){prepareDynamicInstructionPreamble(i,f.messages(n));let t=[],r=await prepareWorkflowPreambleTrace({emissionState:e,instrumentation:p});try{e=await emitTurnPreamble(handleEvent,{},e,E,r)}finally{t=drainDynamicInstructionUserMessages(i),n={...n,history:[...n.history,...t]}}n=setHarnessEmissionState(n,e)}for(let{authorization:t,result:n}of l){let r=c?.challenges.find(e=>e.attemptId===n.attemptId)?.candidateId;await handleEvent(createAuthorizationCompletedEvent({attemptId:n.attemptId,authorization:t,candidateId:r,name:n.name,outcome:`authorized`,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId}))}}return runHarnessStep(n,r)});return throwIfTurnAborted(n.abortSignal),j={result:a,serializedContext:serializeContext(i)},a}})}catch(e){if(!isTurnCancellation(e)&&n.abortSignal?.aborted!==!0)throw await failChannelDeliveries(e),e;D.releaseLock();let t=readRetainedBackgroundToolResult(i);return p?.rememberBackgroundTasks(t?.backgroundTasks??[]),createCancelledModelCallBatchResult({beforeBatchContext:n.serializedContext,checkpoint:j,ctx:i,initialSession:d,stepInput:g})}p?.rememberBackgroundTasks(M.backgroundTasks??[]);let N=reconcileSessionContinuationToken(i,M.session);agentTraceState.pruneAgentTraceState(i,N.sessionId,N.state);let P=serializeContext(i);M={...M,session:N};let F=createDurableSessionState({session:M.session}),I=M.backgroundTasks===void 0||M.backgroundTaskSession===void 0?{}:{backgroundTaskContext:preserveSerializedBackgroundTaskObservabilityState(n.serializedContext,P,M.backgroundTasks),backgroundTaskState:createDurableSessionState({session:M.backgroundTaskSession}),backgroundTasks:M.backgroundTasks};if(M.next!==null&&typeof M.next==`object`&&`done`in M.next){if(O===`task`&&hasPendingInputBatch(M.session.state))throw D.releaseLock(),Error(`Task mode cannot complete while input requests remain pending.`);await D.close();let e=getTurnUsageState(M.session.state)?.session;return{action:`done`,...I,output:M.next.output,isError:M.next.isError,serializedContext:P,sessionState:F,usage:e===void 0?void 0:toUsage(e),usageDelta:takeSessionUsageDelta(M.session).delta}}if(M.next===null){D.releaseLock();let e=getPendingWorkflowInterrupt(M.session.state);if(e!==void 0&&isWorkflowTaskInterrupt(e.interrupt))return{action:`dispatch-workflow-tasks`,...I,pendingTaskCallIds:getWorkflowTaskCallIds(e.interrupt),serializedContext:P,sessionState:F};let t=derivePendingState(M.session);if(M.settledTurn!==void 0){let{delta:e,session:n}=takeSessionUsageDelta(M.session);return{action:`park`,...I,...t,serializedContext:P,sessionState:createDurableSessionState({session:n}),settled:{output:M.settledTurn.output,isError:M.settledTurn.isError,usage:e}}}return{action:`park`,...I,...t,serializedContext:P,sessionState:F}}return D.releaseLock(),{action:`continue`,...I,serializedContext:P,sessionState:F}}export{turnStep};

package/dist/src/harness/workflow-continuation-security.d.ts

@@ -1,5 +0,0 @@
-import type { HarnessSession } from "#harness/types.js";
-import type { WorkflowSandboxContinuationSecurity } from "#shared/workflow-sandbox.js";
-export declare function ensureWorkflowContinuationSecurity(session: HarnessSession): HarnessSession;
-export declare function readWorkflowContinuationSecurity(session: HarnessSession): WorkflowSandboxContinuationSecurity | undefined;
-export declare function getWorkflowContinuationSecurity(session: HarnessSession): WorkflowSandboxContinuationSecurity;

package/dist/src/harness/workflow-continuation-security.js

@@ -1 +0,0 @@
-import{randomBytes}from"node:crypto";const WORKFLOW_CONTINUATION_SECURITY_KEY=`eve.harness.workflowContinuationSecurity`;function ensureWorkflowContinuationSecurity(e){return e.state?.[WORKFLOW_CONTINUATION_SECURITY_KEY]===void 0?{...e,state:{...e.state,[WORKFLOW_CONTINUATION_SECURITY_KEY]:{signingKey:randomBytes(32).toString(`base64url`),version:1}}}:(getWorkflowContinuationSecurity(e),e)}function readWorkflowContinuationSecurity(e){let t=e.state?.[WORKFLOW_CONTINUATION_SECURITY_KEY];if(typeof t==`object`&&t&&t.version===1&&typeof t.signingKey==`string`&&/^[A-Za-z0-9_-]{43}$/.test(t.signingKey))return{signingKey:t.signingKey,maxAgeMs:31536e6}}function getWorkflowContinuationSecurity(e){let t=readWorkflowContinuationSecurity(e);if(t===void 0)throw Error(`Workflow continuation security state is missing or invalid.`);return t}export{ensureWorkflowContinuationSecurity,getWorkflowContinuationSecurity,readWorkflowContinuationSecurity};

package/dist/src/harness/workflow-interrupt-state.d.ts

@@ -1,20 +0,0 @@
-import type { ModelMessage } from "ai";
-import type { HarnessSession, SessionStateMap } from "#harness/types.js";
-import type { WorkflowSandboxInterrupt } from "#shared/workflow-sandbox.js";
-export interface PendingWorkflowInterrupt {
-    readonly interrupt: WorkflowSandboxInterrupt;
-    readonly responseMessages: readonly ModelMessage[];
-    readonly usedCalls: number;
-}
-export declare function getPendingWorkflowInterrupt(state: SessionStateMap | undefined): PendingWorkflowInterrupt | undefined;
-export declare function setPendingWorkflowInterrupt(input: {
-    readonly interrupt: WorkflowSandboxInterrupt;
-    readonly responseMessages: readonly ModelMessage[];
-    readonly session: HarnessSession;
-    readonly usedCalls: number;
-}): HarnessSession;
-export declare function setPendingWorkflowUsedCalls(input: {
-    readonly session: HarnessSession;
-    readonly usedCalls: number;
-}): HarnessSession;
-export declare function clearPendingWorkflowInterrupt(session: HarnessSession): HarnessSession;

package/dist/src/harness/workflow-interrupt-state.js

@@ -1 +0,0 @@
-import{WORKFLOW_TASK_INTERRUPT_KIND}from"#harness/workflow-task-state.js";const PENDING_KEY=`eve.harness.pendingWorkflowInterrupt`;function getPendingWorkflowInterrupt(e){let t=e?.[PENDING_KEY];if(isRecord(t)&&isWorkflowInterruptShape(t.interrupt)&&Array.isArray(t.responseMessages)&&!(!Number.isSafeInteger(t.usedCalls)||t.usedCalls<0))return{interrupt:t.interrupt,responseMessages:t.responseMessages,usedCalls:t.usedCalls}}function setPendingWorkflowInterrupt(e){return{...e.session,state:{...e.session.state,[PENDING_KEY]:{interrupt:e.interrupt,responseMessages:e.responseMessages,usedCalls:e.usedCalls}}}}function setPendingWorkflowUsedCalls(e){let t=getPendingWorkflowInterrupt(e.session.state);return t===void 0?e.session:setPendingWorkflowInterrupt({...t,session:e.session,usedCalls:e.usedCalls})}function clearPendingWorkflowInterrupt(e){if(e.state?.[PENDING_KEY]===void 0)return e;let t={...e.state};return delete t[PENDING_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function isWorkflowInterruptShape(e){return isRecord(e)&&e.type===`code-mode-interrupt`&&typeof e.interruptId==`string`&&typeof e.outerToolCallId==`string`&&isRecord(e.payload)&&e.payload.kind===WORKFLOW_TASK_INTERRUPT_KIND&&isRecord(e.continuation)&&e.continuation.version===2&&typeof e.continuation.outerToolCallId==`string`&&Array.isArray(e.continuation.pendingInterruptions)&&Array.isArray(e.continuation.resolutions)}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{clearPendingWorkflowInterrupt,getPendingWorkflowInterrupt,setPendingWorkflowInterrupt,setPendingWorkflowUsedCalls};

package/dist/src/harness/workflow-lifecycle.d.ts

@@ -1,32 +0,0 @@
-import type { HarnessEmissionState } from "#harness/emission.js";
-import type { HarnessEmitFn, HarnessToolMap } from "#harness/types.js";
-import type { WorkflowSandboxInterrupt } from "#shared/workflow-sandbox.js";
-export declare function createWorkflowLifecycle(input: {
-    readonly emit: EmitWorkflowLifecycleEvent;
-    readonly emissionState: HarnessEmissionState;
-    readonly skipReplayed?: boolean;
-    readonly tools: HarnessToolMap;
-}): {
-    onAfterExecute?: (input: {
-        readonly result: unknown;
-    }) => Promise<void>;
-};
-type EmitWorkflowLifecycleEvent = HarnessEmitFn;
-/** Projects newly parked workflow calls onto eve's existing action stream. */
-export declare function emitWorkflowActionsRequested(input: {
-    readonly emit: EmitWorkflowLifecycleEvent;
-    readonly emissionState: HarnessEmissionState;
-    readonly interrupts: readonly WorkflowSandboxInterrupt[];
-    readonly tools: HarnessToolMap;
-}): Promise<void>;
-/** Projects completed workflow children before replaying their continuation. */
-export declare function emitWorkflowActionResults(input: {
-    readonly emit: EmitWorkflowLifecycleEvent;
-    readonly emissionState: HarnessEmissionState;
-    readonly interrupts: readonly WorkflowSandboxInterrupt[];
-    readonly results: readonly {
-        readonly isError?: boolean;
-        readonly output?: unknown;
-    }[];
-}): Promise<void>;
-export {};

package/dist/src/harness/workflow-lifecycle.js

@@ -1 +0,0 @@
-import{createActionResultEvent,createActionsRequestedEvent}from"#protocol/message.js";import{collectActionPresentation,createPresentedRuntimeActionRequestFromToolCall}from"#harness/action-presentation.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";import{getWorkflowSandboxInterrupt}from"#shared/workflow-sandbox.js";function createWorkflowLifecycle(e){return{async onAfterExecute(t){if(e.skipReplayed)return;let n=await getWorkflowSandboxInterrupt(t.result,{});n!==void 0&&await emitWorkflowActionsRequested({emit:e.emit,emissionState:e.emissionState,interrupts:[n],tools:e.tools})}}}async function emitWorkflowActionsRequested(e){for(let t of e.interrupts){let n={input:t.input,toolCallId:t.toolCallId,toolName:t.toolName,type:`tool-call`},r=createPresentedRuntimeActionRequestFromToolCall({toolCall:n,tools:e.tools});await e.emit(createActionsRequestedEvent({actions:[r.action],presentation:collectActionPresentation([r]),sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId}))}}async function emitWorkflowActionResults(e){for(let[t,n]of e.results.entries()){let r=e.interrupts[t];if(r===void 0)break;await e.emit(createActionResultEvent({result:createRuntimeToolResultFromValue({callId:r.toolCallId,isError:n.isError,output:n.output,toolName:r.toolName}),sequence:e.emissionState.sequence,stepIndex:e.emissionState.stepIndex,turnId:e.emissionState.turnId}))}}export{createWorkflowLifecycle,emitWorkflowActionResults,emitWorkflowActionsRequested};