eve 0.50.0 → 0.51.1

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

@@ -0,0 +1,3 @@
+import type { VersionMigration } from "#execution/durable-session-migrations/chain.js";
+/** Advances version-4 payloads to the additive token-cost schema. */
+export declare const sessionInboxWireV4Migration: VersionMigration;

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

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const sessionInboxWireV4Migration={from:4,migrate(e){if(!isObject(e))throw Error(`session inbox wire v4 value is not an object.`);return{...e,version:5}},to:5};export{sessionInboxWireV4Migration};

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

@@ -0,0 +1,341 @@
+import { z } from "#compiled/zod/index.js";
+import type { DeliverHookPayload, SessionCommand, SessionTimeoutHookPayload } from "#channel/types.js";
+/** Version 6 adds session-owned task cancellation to the cancel command. */
+export declare const sessionInboxWireV6Schema: 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";
+    }>>;
+    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>>;
+    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>>;
+    version: z.ZodLiteral<6>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"session-timeout">;
+    version: z.ZodLiteral<6>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"clear">;
+    version: z.ZodLiteral<6>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"compact">;
+    version: z.ZodLiteral<6>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reset">;
+    reason: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<6>;
+}, 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<6>;
+}, z.core.$strict>], "kind">;
+export type SessionInboxWireV6 = z.infer<typeof sessionInboxWireV6Schema>;
+/** Builds and validates one complete version-6 wire value. */
+export declare function encodeSessionCommandV6(command: DeliverHookPayload | SessionCommand | SessionTimeoutHookPayload): SessionInboxWireV6;

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

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{formatValidationError}from"#runtime/validation.js";import{SessionInboxWireError}from"#execution/wire/session-inbox-contract.js";import{encodeSessionCommandV5,sessionInboxWireV5Schema}from"#execution/wire/session-inbox-wire.v5.js";const v5=sessionInboxWireV5Schema.options,v5Cancel=v5[5],version=z.literal(6),sessionInboxWireV6Schema=z.discriminatedUnion(`kind`,[v5[0].extend({version}),v5[1].extend({version}),v5[2].extend({version}),v5[3].extend({version}),v5[4].extend({version}),v5Cancel.extend({tasks:z.boolean().optional(),version})]);function encodeSessionCommandV6(e){let r={...encodeSessionCommandV5(withoutOwnedTaskCancellation(e)),version:6};e.kind===`cancel`&&(r.tasks=e.tasks);let i=sessionInboxWireV6Schema.safeParse(r);if(!i.success)throw new SessionInboxWireError(`Produced a session inbox payload that does not match wire version 6: ${formatValidationError(i.error)}`);return i.data}function withoutOwnedTaskCancellation(e){if(e.kind!==`cancel`||e.tasks===void 0)return e;let{tasks:t,...n}=e;return n}export{encodeSessionCommandV6,sessionInboxWireV6Schema};

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

@@ -8,6 +8,9 @@ export declare function finalizeExpiredSession(input: {
     readonly mode: RunMode;
     readonly serializedContext: Record<string, unknown>;
     readonly sessionState: DurableSessionState;
+    readonly terminalState?: {
+        terminalEmitted: boolean;
+    };
 }): Promise<{
     readonly output: unknown;
 }>;
@@ -17,6 +20,9 @@ export declare function finalizeDone(input: {
     };
     readonly caller: TurnCaller | undefined;
     readonly mode: RunMode;
+    readonly terminalState?: {
+        terminalEmitted: boolean;
+    };
 }): Promise<{
     readonly output: unknown;
 }>;

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

@@ -1 +1 @@
-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};
+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(t){return await terminateChildSessionsStep({serializedContext:t.serializedContext,sessionState:t.sessionState}),await emitTerminalSessionCompletionStep({parentWritable:t.driverWritable,serializedContext:t.serializedContext}),t.terminalState!==void 0&&(t.terminalState.terminalEmitted=!0),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.terminalState!==void 0&&(n.terminalState.terminalEmitted=!0),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.d.ts

@@ -13,6 +13,7 @@ export interface WorkflowEntryInput {
     readonly limits?: RunInput["limits"];
     readonly sessionTimeoutMs?: number | false;
     readonly serializedContext: Record<string, unknown>;
+    readonly taskId?: string;
 }
 export interface WorkflowEntryResult {
     readonly output: unknown;
@@ -26,7 +27,7 @@ export interface WorkflowEntryResult {
  *
  * 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 `NextDriverAction` contract. The
+ * `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.

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{activeTurnId}from"#harness/active-turn-id.js";import{readSerializedSubagentDepth}from"#harness/subagent-depth.js";import{readChannelRequestId,readRootSessionId}from"#execution/eve-workflow-attributes.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";import{settleContinuationConflictStep}from"#execution/continuation-conflict-step.js";async function workflowEntry(r){"use workflow";let{workflowRunId:i,workflowStartedAt:l}=getWorkflowMetadata(),u=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,d,p,T]=await Promise.allSettled([createSessionStep({compiledArtifactsSource:_.source,continuationToken:u,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(u)]);if(n.status===`rejected`)throw n.reason;if(d.status===`rejected`)throw d.reason;if(p.status===`rejected`)throw p.reason;if(T.status===`rejected`){if(isHookConflictError(T.reason))return(r.activityCollectorRunId!==void 0||r.continuationConflictCommand!==void 0)&&await settleContinuationConflictStep({activityCollectorRunId:r.activityCollectorRunId,command:r.continuationConflictCommand,continuationToken:u,ownerSessionId:typeof T.reason.conflictingRunId==`string`?T.reason.conflictingRunId:void 0}),{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}),d,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}),f=activeTurnId(l.sessionState.emissionState);e.crashCleanupState.activeTurnId=f;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,serializedContext:c,seenTaskDeliveries:s,sessionState:l.sessionState});return e.crashCleanupState.activeTurnId=p.action.kind===`park`&&p.action.cancelled===!0?f:void 0,e.crashCleanupState.lastSessionState=p.action.sessionState,e.crashCleanupState.serializedContext=p.action.serializedContext,p.action.kind===`done`&&(e.crashCleanupState.terminalEmitted=!0),await d?.(),d=p.dispose,l.adoptState(p.action),p.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 d?.(),await c?.dispose()}}export{workflowEntry};
+import{attachClientContext,readClientContext}from"#internal/client-context.js";import{sessionCommandHookToken}from"#execution/session-command-token.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{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(c){"use workflow";let{workflowRunId:d,workflowStartedAt:f}=getWorkflowMetadata(),p=c.serializedContext[`eve.continuationToken`]||``,v=c.serializedContext[`eve.mode`],y=c.serializedContext[`eve.capabilities`],b=c.serializedContext[`eve.bundle`];c.serializedContext[`eve.sessionId`]=d;let x=getWritable(),C={caller:void 0,callerResolved:!1,lastSessionState:void 0,serializedContext:c.serializedContext,terminalEmitted:!1};try{let r=readRootSessionId(c.serializedContext),i=c.serializedContext[`eve.dynamicSubagentAgentConfig`],l=createSessionCommandInbox(),u=sessionCommandHookToken(d),m=`${d}:auth`,h,g;try{let[n,s,_,S]=await Promise.allSettled([createSessionStep({compiledArtifactsSource:b.source,continuationToken:p,dynamicSubagentAgentConfig:i,inheritedLimits:c.limits,nodeId:b.nodeId,outputSchema:c.input.outputSchema,rootSessionId:r,sessionId:d,taskId:c.taskId}),l.claimStable(u),l.claimAuthorization(m),l.rekeyContinuation(p)]);if(n.status===`rejected`)throw n.reason;if(s.status===`rejected`)throw s.reason;if(_.status===`rejected`)throw _.reason;if(S.status===`rejected`){if(isHookConflictError(S.reason))return(c.activityCollectorRunId!==void 0||c.continuationConflictCommand!==void 0)&&await settleContinuationConflictStep({activityCollectorRunId:c.activityCollectorRunId,command:c.continuationConflictCommand,continuationToken:p,ownerSessionId:typeof S.reason.conflictingRunId==`string`?S.reason.conflictingRunId:void 0}),{output:``};throw S.reason}h=n.value.state,C.lastSessionState=h,C.caller=hasDelegatedCallerContext(c.serializedContext)?await resolveInitialTurnCallerStep({serializedContext:c.serializedContext}):void 0,C.callerResolved=!0,g=await runDriverLoop({capabilities:y,commandInbox:l,driverWritable:x,initialInput:{deliveryMetadata:c.serializedContext[`eve.channelDelivery`]===void 0?void 0:[{...c.serializedContext[`eve.channelDelivery`],payloadIndex:0}],kind:`deliver`,payloads:[attachClientContext({message:c.input.message,context:c.input.context,outputSchema:c.input.outputSchema},readClientContext(c.input))],requestId:readChannelRequestId(c.serializedContext)},crashCleanupState:C,mode:v,serializedContext:c.serializedContext,sessionState:h,sessionTimeoutDeadline:c.sessionTimeoutMs===!1?void 0:new Date(f.getTime()+(c.sessionTimeoutMs??DEFAULT_SESSION_TIMEOUT_MS)),stableCommandToken:u})}finally{await l.dispose()}return g.kind===`result`?g.result:await finalizeExpiredSession({caller:C.caller,driverWritable:x,mode:v,serializedContext:g.serializedContext,sessionState:g.sessionState,terminalState:C})}catch(e){let t=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:x,serializedContext:C.serializedContext,turnId:C.turnId}),!0),t||(v===`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:d,settled:{isError:!0,output:e}})),createSafeOuterWorkflowError()}}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}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,l=new SessionStateCursor({serializedContext:e.serializedContext,sessionState:e.sessionState}),u=e.sessionTimeoutDeadline===void 0?void 0:createSessionTimeoutControl({deadline:e.sessionTimeoutDeadline,token:e.stableCommandToken}),m,runTurn=async n=>{let c=l.sessionState,u=e.crashCleanupState.caller;u?.taskId!==void 0&&s.add(u.taskId);let d=u===void 0?l.serializedContext:await bindTurnCallerContextStep({caller:u,serializedContext:l.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,serializedContext:d,seenTaskDeliveries:s,sessionState:l.sessionState,stateCursor:l});await m?.(),m=p.dispose;let h=l.sessionState===c?p.action:rebaseTaskAgentHandleMutations(p.action,l.sessionState,c);return l.adoptState(h),e.crashCleanupState.lastSessionState=l.sessionState,e.crashCleanupState.serializedContext=l.serializedContext,h};try{await u?.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:l.serializedContext,sessionState:l.sessionState});l.adoptState(t),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}),e.crashCleanupState.lastSessionState=l.sessionState}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,i.kind===`authorization-resume`){n=await runTurn({kind:`deliver`,payloads:i.payloads});continue}if(i.kind===`expired`)return{kind:`expired`,serializedContext:l.serializedContext,sessionState:l.sessionState};if(i.kind===`reset`)return{kind:`result`,result:await finalizeExpiredSession({caller:e.crashCleanupState.caller,driverWritable:e.driverWritable,mode:e.mode,serializedContext:l.serializedContext,sessionState:l.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:l.serializedContext,sessionState:l.sessionState,terminalState:e.crashCleanupState})};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),e.crashCleanupState.serializedContext=l.serializedContext,n={...n,settled:void 0},e.crashCleanupState.caller=void 0,e.crashCleanupState.lastSessionState=l.sessionState;continue}i.delivery.caller!==void 0&&(e.crashCleanupState.caller=i.delivery.caller),n=await runTurn(i.delivery)}}finally{await m?.(),await u?.dispose()}}workflowEntry.workflowId=`workflow//eve//workflowEntry`;export{workflowEntry};

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

@@ -36,7 +36,7 @@ export declare const activityCollectorWorkflowReference: {
     workflowId: string;
 };
 /** Stable workflow reference for authored workflow tool runs. */
-export declare const toolRunWorkflowReference: {
+export declare const workflowToolRunWorkflowReference: {
     workflowId: string;
 };
 /**

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

@@ -1 +1 @@
-import{randomBytes}from"node:crypto";import{createEveActivityRoutePath}from"#protocol/routes.js";import{createLogger,logError}from"#internal/logging.js";import{getChannelActivityPresentation}from"#channel/activity-renderer.js";import{sessionCommandHookToken}from"#execution/session-command-token.js";import{ActivityObserverKey}from"#context/keys.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{walkCauseChain}from"#shared/errors.js";import{normalizePersistedMessageStreamEvent}from"#protocol/message-version.js";import{cancelRun,getHookByToken,getRun,getWorld,start}from"#internal/workflow/runtime.js";import{createWorkflowCallbackUrl,resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{serializeContext}from"#context/serialize.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";import{resumeSessionInbox}from"#execution/wire/session-inbox-resume.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{buildSessionAttributes,buildSubagentRootAttributes,readParentLineage}from"#execution/eve-workflow-attributes.js";import{normalizeEveAttributes}from"#runtime/attributes/normalize.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{initializeSessionInstrumentation}from"#instrumentation/runtime.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{buildRunContext}from"#execution/runtime-context.js";import{parseNdjsonStream}from"#execution/ndjson-stream.js";import{buildInvocationAttributes}from"#internal/invocation/metadata.js";import{isAgentTraceContext}from"#tracing/agent-trace-context.js";import{ACTIVITY_COLLECTOR_WORKFLOW_NAME,SESSION_TIMEOUT_WORKFLOW_NAME,TASK_RUN_WORKFLOW_NAME,TOOL_RUN_WORKFLOW_NAME,TURN_WORKFLOW_NAME,WORKFLOW_ENTRY_NAME}from"#execution/stable-workflow-names.js";const EVE_PACKAGE_INFO=resolveInstalledPackageInfo(),COMMAND_HOOK_READY_TIMEOUT_MS=3e4,STABLE_ID_BASE=EVE_PACKAGE_INFO.name,log=createLogger(`execution.workflow-runtime`),workflowEntryReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_ENTRY_NAME}`},turnWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${TURN_WORKFLOW_NAME}`},sessionTimeoutWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${SESSION_TIMEOUT_WORKFLOW_NAME}`},taskRunWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${TASK_RUN_WORKFLOW_NAME}`},activityCollectorWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${ACTIVITY_COLLECTOR_WORKFLOW_NAME}`},toolRunWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${TOOL_RUN_WORKFLOW_NAME}`};function createWorkflowRuntime(n){return{async createSession(a){let o=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:n.compiledArtifactsSource,nodeId:n.nodeId}),s=buildRunContext({bundle:o,dynamicSubagentAgentConfig:n.dynamicSubagentAgentConfig,run:a}),c=resolveEffectiveAgentRuntime(o,s);initializeSessionInstrumentation({agentName:c.turnAgent.id,ctx:s,parentTraceContext:a.parentTraceContext});let l=c.limits?.sessionTimeoutMs,u,d=a.activityObserver;if(a.parent===void 0&&d===void 0&&(getChannelActivityPresentation(a.adapter)?.renderers.length??0)>0){let n=serializeContext(s),r=randomBytes(32).toString(`base64url`),i={expiresAt:new Date(Date.now()+(typeof l==`number`?l:864e5)).toISOString(),serializedContext:n,token:r};try{u=(await startWorkflowOnCurrentDeployment(activityCollectorWorkflowReference,[i])).runId,d={sink:{url:createWorkflowCallbackUrl(resolveWorkflowCallbackBaseUrl(process.env.VERCEL_URL?`https://${process.env.VERCEL_URL}`:`http://localhost:3000`),createEveActivityRoutePath(r)),version:1}},s.set(ActivityObserverKey,d)}catch{await cancelActivityCollector(u),u=void 0,log.warn(`failed to start activity collector`)}}let f=serializeContext(s),p=readParentLineage(f),m={input:a.input,limits:a.limits,serializedContext:f};u!==void 0&&(m.activityCollectorRunId=u),a.continuationConflictCommand!==void 0&&(m.continuationConflictCommand=a.continuationConflictCommand),l!==void 0&&(m.sessionTimeoutMs=l);let h={...p.sessionId===void 0?buildSessionAttributes({inputMessage:a.title??a.input.message,serializedContext:f}):buildSubagentRootAttributes({identity:{nodeId:o.nodeId??ROOT_RUNTIME_AGENT_NODE_ID},parentCallId:p.callId,parentSessionId:p.sessionId,parentTurnId:p.turnId,rootSessionId:p.rootSessionId??p.sessionId,serializedContext:f}),...a.externalInvocation===void 0?{}:buildInvocationAttributes(a.externalInvocation)},g;try{g=await startWorkflowOnCurrentDeployment(workflowEntryReference,[m],{allowReservedAttributes:!0,attributes:normalizeEveAttributes(h)})}catch(e){throw await cancelActivityCollector(u),logError(log,`failed to start workflow run`,e,{continuationToken:a.continuationToken}),e}let _,getEvents=()=>(_??=parseNdjsonStream(()=>getRun(g.runId).getReadable(),normalizePersistedEvent),_);return{get events(){return getEvents()},sessionId:g.runId}},async dispatchContinuation(e){return await dispatchWorkflowCommand(e.continuationToken,e.command)},async dispatchSession(e){return await dispatchWorkflowCommand(sessionCommandHookToken(e.sessionId),e.command)},async getEventStream(e,t){return parseNdjsonStream(()=>getRun(e).getReadable({startIndex:t?.startIndex}),normalizePersistedEvent)},async getStreamTailIndex(e){let t=getRun(e).getReadable();try{return await t.getTailIndex()}finally{await t.cancel().catch(()=>{})}},async resolveContinuation(e){try{return{sessionId:(await getHookByToken(e)).runId}}catch(t){if(HookNotFoundError.is(t))return;throw logError(log,`failed to resolve session by continuation token`,t,{continuationToken:e}),t}}}}function normalizePersistedEvent(e){return normalizePersistedMessageStreamEvent(e)}async function cancelActivityCollector(e){if(e!==void 0)try{await cancelRun(await getWorld(),e,{cancelReason:`Root session creation did not complete`})}catch{log.warn(`failed to cancel unowned activity collector`)}}async function dispatchWorkflowCommand(e,t){let n;try{n=normalizeWorkflowHook(await resumeSessionInbox(e,t))}catch(n){if(isInactiveCommandTarget(n))return inactiveCommandResult(t);throw logError(log,`failed to dispatch session command`,n,{command:t.kind,token:e}),n}return t.kind===`reset`&&await waitForCommandHookRelease(sessionCommandHookToken(n.runId),n.runId),activeCommandResult(t,n.runId)}function activeCommandResult(e,t){return e.kind===`reset`?{previousSessionId:t,status:`reset`}:(e.kind,{sessionId:t,status:`accepted`})}function inactiveCommandResult(e){return e.kind===`send`?{status:`session_not_active`}:e.kind===`cancel`?{status:`no_active_turn`}:{status:`no_active_session`}}async function requestWorkflowTurnCancellation(e){let t={kind:`cancel`};return e.taskId!==void 0&&(t.taskId=e.taskId),e.turnId!==void 0&&(t.turnId=e.turnId),await dispatchWorkflowCommand(sessionCommandHookToken(e.sessionId),t)}function isInactiveCommandTarget(e){if(HookNotFoundError.is(e))return!0;for(let t of walkCauseChain(e))if(WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}async function waitForCommandHookOwner(e){let t=Date.now()+COMMAND_HOOK_READY_TIMEOUT_MS;for(;;)try{return normalizeWorkflowHook(await getHookByToken(e))}catch(e){if(!HookNotFoundError.is(e)||Date.now()>=t)throw e;await new Promise(e=>setTimeout(e,20))}}async function waitForCommandHookRelease(e,t){let n=Date.now()+COMMAND_HOOK_READY_TIMEOUT_MS;for(;;){try{if(normalizeWorkflowHook(await getHookByToken(e)).runId!==t)return}catch(e){if(HookNotFoundError.is(e))return;throw e}if(Date.now()>=n)throw Error(`Timed out waiting for session "${t}" to release its command inbox.`);await new Promise(e=>setTimeout(e,20))}}async function startWorkflowOnCurrentDeployment(e,t,n){return await startWorkflowOnDeployment(e,t,process.env.VERCEL_DEPLOYMENT_ID?.trim()||void 0,n)}async function startWorkflowOnAcceptedDeployment(e,t,n,r){return n===void 0?await startWorkflowOnCurrentDeployment(e,t,r):await startWorkflowOnDeployment(e,t,n,r)}async function startWorkflowOnDeployment(e,t,n,r){return await withWorkflowStartContext(async()=>n===void 0?r===void 0?await start(e,t):await start(e,t,r):await start(e,t,{...r,deploymentId:n}))}async function withWorkflowStartContext(e){let t=context.active(),n=isAgentTraceContext(t)?trace.deleteSpan(t):t;return await context.with(n,e)}function normalizeWorkflowHook(e){if(typeof e!=`object`||!e||!(`runId`in e))throw Error(`Workflow hook did not include a run id.`);let t=e.runId;if(typeof t!=`string`||t.length===0)throw Error(`Workflow hook did not include a run id.`);return{runId:t}}export{activityCollectorWorkflowReference,createWorkflowRuntime,requestWorkflowTurnCancellation,sessionTimeoutWorkflowReference,startWorkflowOnAcceptedDeployment,startWorkflowOnCurrentDeployment,taskRunWorkflowReference,toolRunWorkflowReference,turnWorkflowReference,waitForCommandHookOwner,workflowEntryReference};
+import{randomBytes}from"node:crypto";import{createEveActivityRoutePath}from"#protocol/routes.js";import{createLogger,logError}from"#internal/logging.js";import{getChannelActivityPresentation}from"#channel/activity-renderer.js";import{sessionCommandHookToken}from"#execution/session-command-token.js";import{ActivityObserverKey}from"#context/keys.js";import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{walkCauseChain}from"#shared/errors.js";import{normalizePersistedMessageStreamEvent}from"#protocol/message-version.js";import{cancelRun,getHookByToken,getRun,getWorld,start}from"#internal/workflow/runtime.js";import{serializeContext}from"#context/serialize.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";import{resumeSessionInbox}from"#execution/wire/session-inbox-resume.js";import{getCompiledRuntimeAgentBundle}from"#runtime/sessions/compiled-agent-cache.js";import{buildSessionAttributes,buildSubagentRootAttributes,readParentLineage}from"#execution/eve-workflow-attributes.js";import{normalizeEveAttributes}from"#runtime/attributes/normalize.js";import{ROOT_RUNTIME_AGENT_NODE_ID}from"#runtime/graph.js";import{initializeSessionInstrumentation}from"#instrumentation/runtime.js";import{createWorkflowCallbackUrl,resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{context,trace}from"#compiled/@opentelemetry/api/index.js";import{buildRunContext}from"#execution/runtime-context.js";import{parseNdjsonStream}from"#execution/ndjson-stream.js";import{buildInvocationAttributes}from"#internal/invocation/metadata.js";import{isAgentTraceContext}from"#tracing/agent-trace-context.js";import{ACTIVITY_COLLECTOR_WORKFLOW_NAME,SESSION_TIMEOUT_WORKFLOW_NAME,TASK_RUN_WORKFLOW_NAME,TURN_WORKFLOW_NAME,WORKFLOW_ENTRY_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME}from"#execution/stable-workflow-names.js";const EVE_PACKAGE_INFO=resolveInstalledPackageInfo(),COMMAND_HOOK_READY_TIMEOUT_MS=3e4,STABLE_ID_BASE=EVE_PACKAGE_INFO.name,log=createLogger(`execution.workflow-runtime`),workflowEntryReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_ENTRY_NAME}`},turnWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${TURN_WORKFLOW_NAME}`},sessionTimeoutWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${SESSION_TIMEOUT_WORKFLOW_NAME}`},taskRunWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${TASK_RUN_WORKFLOW_NAME}`},activityCollectorWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${ACTIVITY_COLLECTOR_WORKFLOW_NAME}`},workflowToolRunWorkflowReference={workflowId:`workflow//${STABLE_ID_BASE}//${WORKFLOW_TOOL_RUN_WORKFLOW_NAME}`};function createWorkflowRuntime(n){return{async createSession(a){let o=await getCompiledRuntimeAgentBundle({compiledArtifactsSource:n.compiledArtifactsSource,nodeId:n.nodeId}),s=buildRunContext({bundle:o,dynamicSubagentAgentConfig:n.dynamicSubagentAgentConfig,run:a}),c=resolveEffectiveAgentRuntime(o,s);initializeSessionInstrumentation({agentName:c.turnAgent.id,ctx:s,parentTraceContext:a.parentTraceContext});let l=c.limits?.sessionTimeoutMs,u,d=a.activityObserver;if(a.parent===void 0&&d===void 0&&(getChannelActivityPresentation(a.adapter)?.renderers.length??0)>0){let n=serializeContext(s),r=randomBytes(32).toString(`base64url`),i={expiresAt:new Date(Date.now()+(typeof l==`number`?l:864e5)).toISOString(),serializedContext:n,token:r};try{u=(await startWorkflowOnCurrentDeployment(activityCollectorWorkflowReference,[i])).runId,d={sink:{url:createWorkflowCallbackUrl(resolveWorkflowCallbackBaseUrl(process.env.VERCEL_URL?`https://${process.env.VERCEL_URL}`:`http://localhost:3000`),createEveActivityRoutePath(r)),version:1}},s.set(ActivityObserverKey,d)}catch{await cancelActivityCollector(u),u=void 0,log.warn(`failed to start activity collector`)}}let f=serializeContext(s),p=readParentLineage(f),m={input:a.input,limits:a.limits,serializedContext:f},h=a.taskId??a.callback?.taskId;h!==void 0&&(m.taskId=h),u!==void 0&&(m.activityCollectorRunId=u),a.continuationConflictCommand!==void 0&&(m.continuationConflictCommand=a.continuationConflictCommand),l!==void 0&&(m.sessionTimeoutMs=l);let g={...p.sessionId===void 0?buildSessionAttributes({inputMessage:a.title??a.input.message,serializedContext:f}):buildSubagentRootAttributes({identity:{nodeId:o.nodeId??ROOT_RUNTIME_AGENT_NODE_ID},parentCallId:p.callId,parentSessionId:p.sessionId,parentTurnId:p.turnId,rootSessionId:p.rootSessionId??p.sessionId,serializedContext:f}),...a.externalInvocation===void 0?{}:buildInvocationAttributes(a.externalInvocation)},_;try{_=await startWorkflowOnCurrentDeployment(workflowEntryReference,[m],{allowReservedAttributes:!0,attributes:normalizeEveAttributes(g)})}catch(e){throw await cancelActivityCollector(u),logError(log,`failed to start workflow run`,e,{continuationToken:a.continuationToken}),e}let v,getEvents=()=>(v??=parseNdjsonStream(()=>getRun(_.runId).getReadable(),normalizePersistedEvent),v);return{get events(){return getEvents()},sessionId:_.runId}},async dispatchContinuation(e){return await dispatchWorkflowCommand(e.continuationToken,e.command)},async dispatchSession(e){return await dispatchWorkflowCommand(sessionCommandHookToken(e.sessionId),e.command)},async getEventStream(e,t){return parseNdjsonStream(()=>getRun(e).getReadable({startIndex:t?.startIndex}),normalizePersistedEvent)},async getStreamTailIndex(e){let t=getRun(e).getReadable();try{return await t.getTailIndex()}finally{await t.cancel().catch(()=>{})}},async resolveContinuation(e){try{return{sessionId:(await getHookByToken(e)).runId}}catch(t){if(HookNotFoundError.is(t))return;throw logError(log,`failed to resolve session by continuation token`,t,{continuationToken:e}),t}}}}function normalizePersistedEvent(e){return normalizePersistedMessageStreamEvent(e)}async function cancelActivityCollector(e){if(e!==void 0)try{await cancelRun(await getWorld(),e,{cancelReason:`Root session creation did not complete`})}catch{log.warn(`failed to cancel unowned activity collector`)}}async function dispatchWorkflowCommand(e,t){let n;try{n=normalizeWorkflowHook(await resumeSessionInbox(e,t))}catch(n){if(isInactiveCommandTarget(n))return inactiveCommandResult(t);throw logError(log,`failed to dispatch session command`,n,{command:t.kind,token:e}),n}return t.kind===`reset`&&await waitForCommandHookRelease(sessionCommandHookToken(n.runId),n.runId),activeCommandResult(t,n.runId)}function activeCommandResult(e,t){return e.kind===`reset`?{previousSessionId:t,status:`reset`}:(e.kind,{sessionId:t,status:`accepted`})}function inactiveCommandResult(e){return e.kind===`send`?{status:`session_not_active`}:e.kind===`cancel`?{status:`no_active_turn`}:{status:`no_active_session`}}async function requestWorkflowTurnCancellation(e){let t={kind:`cancel`};return e.taskId!==void 0&&(t.taskId=e.taskId),e.tasks!==void 0&&(t.tasks=e.tasks),e.turnId!==void 0&&(t.turnId=e.turnId),await dispatchWorkflowCommand(sessionCommandHookToken(e.sessionId),t)}function isInactiveCommandTarget(e){if(HookNotFoundError.is(e))return!0;for(let t of walkCauseChain(e))if(WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}async function waitForCommandHookOwner(e){let t=Date.now()+COMMAND_HOOK_READY_TIMEOUT_MS;for(;;)try{return normalizeWorkflowHook(await getHookByToken(e))}catch(e){if(!HookNotFoundError.is(e)||Date.now()>=t)throw e;await new Promise(e=>setTimeout(e,20))}}async function waitForCommandHookRelease(e,t){let n=Date.now()+COMMAND_HOOK_READY_TIMEOUT_MS;for(;;){try{if(normalizeWorkflowHook(await getHookByToken(e)).runId!==t)return}catch(e){if(HookNotFoundError.is(e))return;throw e}if(Date.now()>=n)throw Error(`Timed out waiting for session "${t}" to release its command inbox.`);await new Promise(e=>setTimeout(e,20))}}async function startWorkflowOnCurrentDeployment(e,t,n){return await startWorkflowOnDeployment(e,t,process.env.VERCEL_DEPLOYMENT_ID?.trim()||void 0,n)}async function startWorkflowOnAcceptedDeployment(e,t,n,r){return n===void 0?await startWorkflowOnCurrentDeployment(e,t,r):await startWorkflowOnDeployment(e,t,n,r)}async function startWorkflowOnDeployment(e,t,n,r){return await withWorkflowStartContext(async()=>n===void 0?r===void 0?await start(e,t):await start(e,t,r):await start(e,t,{...r,deploymentId:n}))}async function withWorkflowStartContext(e){let t=context.active(),n=isAgentTraceContext(t)?trace.deleteSpan(t):t;return await context.with(n,e)}function normalizeWorkflowHook(e){if(typeof e!=`object`||!e||!(`runId`in e))throw Error(`Workflow hook did not include a run id.`);let t=e.runId;if(typeof t!=`string`||t.length===0)throw Error(`Workflow hook did not include a run id.`);return{runId:t}}export{activityCollectorWorkflowReference,createWorkflowRuntime,requestWorkflowTurnCancellation,sessionTimeoutWorkflowReference,startWorkflowOnAcceptedDeployment,startWorkflowOnCurrentDeployment,taskRunWorkflowReference,turnWorkflowReference,waitForCommandHookOwner,workflowEntryReference,workflowToolRunWorkflowReference};

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

@@ -1 +1 @@
-import{callAdapterEventHandler,defaultDeliverResult}from"#channel/adapter.js";import{contextStorage}from"#context/container.js";import{AuthKey,CapabilitiesKey,HandleEventKey,ModeKey,SessionDynamicSubagentRuntimeRevisionKey,SessionDynamicToolRuntimeRevisionKey,TasksEnabledKey,TurnTaskDeliveryKey,TurnTaskStateKey}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{emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.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{coalesceTurnInputs}from"#harness/messages.js";import{hydrateDurableSession,refreshSessionFromTurnAgent}from"#execution/session.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{TASK_UPDATE_SESSION_INSTRUCTION,isTaskOwnedSerializedContext}from"#execution/tasks/child/instructions.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{activeTurnId}from"#harness/active-turn-id.js";import{preserveSerializedAgentTraceState}from"#tracing/agent-trace-context-store.js";import{deferMismatchedInlineTurnStep}from"#execution/accepted-delivery-deployment.js";import{getPendingWorkflowInterrupt}from"#harness/workflow-interrupt-state.js";import{getRuntimeActionKeysFromWorkflowInterrupt,isWorkflowRuntimeActionInterrupt}from"#harness/workflow-runtime-action-state.js";import{isTurnCancellation,throwIfTurnAborted}from"#harness/turn-cancellation.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{readTurnSleepDurationMs}from"#harness/turn-sleep.js";import{preserveSerializedSessionDynamicModelSelection}from"#context/serialized-dynamic-model-selection.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{preserveSerializedInstrumentationState}from"#instrumentation/state.js";import{RuntimeActionSettlementTimesKey}from"#harness/runtime-action-settlement-state.js";import{matchAuthorizationCallbacks}from"#execution/authorization-callback-match.js";import{derivePendingState}from"#execution/pending-turn-state.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{appendTaskAgentAnnouncement}from"#execution/tasks/parent/agent-views.js";import{resolveInitiatingTaskContext,resolveTaskDeliveryContext}from"#tasks/delivery-context.js";import{readRetainedBackgroundToolResult,runBackgroundStep}from"#execution/tasks/parent/tool-execution.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{preserveCancelledTurnMessage}from"#execution/cancelled-turn-message.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(a){"use step";let o=deferMismatchedInlineTurnStep(a);if(o!==void 0)return o;let s=a,c=await readDurableSession(s.sessionState),l=await deserializeContext(s.serializedContext);a.input?.kind===`deliver`&&(l.set(TurnTaskDeliveryKey,`none`),l.delete(TurnTaskStateKey));let u=l.require(ChannelKey),d=l.require(BundleKey),f=d.resolvedAgent.config?.experimental?.tasks===!0;l.set(TasksEnabledKey,f);let p=resolveEffectiveAgentRuntime(d,l),m=isTaskOwnedSerializedContext(s.serializedContext)&&f&&p.turnAgent.tools.some(e=>e.kind===`authored-tool`&&e.behavior?.handling?.kind===`dispatch`&&e.behavior.handling.target.kind===`task-update`);try{let{getWorkflowMetadata:e}=await import(`#compiled/@workflow/core/index.js`),t=e();typeof t.url==`string`&&l.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(t.url))}catch{}let h=getPendingAuthorization(c.state),g;if(h&&s.input?.kind===`deliver`){let{matches:e,remainingPayloads:t}=matchAuthorizationCallbacks(h,s.input.payloads);if(s={...s,input:{...s.input,payloads:t}},e.length>0){let n=e.map(e=>e.result);l.set(PendingAuthorizationResultKey,n),c={...c,state:clearPendingAuthorization(c.state,n.map(e=>e.attemptId??e.name))},g=e,t.length===0&&(s={...s,input:void 0})}}s.input?.kind===`deliver`&&s.input.auth!==void 0&&l.set(AuthKey,s.input.auth??null);let _=hydrateDurableSession({compactionOverrides:{thresholdPercent:p.thresholdPercent},durable:c,turnAgent:p.turnAgent}),v=createExecutionHistoryView(_),y=bindSessionInstrumentation({agentName:p.turnAgent.id,ctx:l,rootSessionId:_.rootSessionId??_.sessionId,sessionId:_.sessionId}),b=getHarnessEmissionState(_.state);a.input?.kind===`deliver`&&await contextStorage.run(l,()=>y?.instrumentChannelDelivery({agentName:d.turnAgent.id,ctx:l,delivery:a.input,rootSessionId:_.rootSessionId??_.sessionId,sequence:b.sequence,sessionId:_.sessionId,turnId:activeTurnId(b)}));let failChannelDeliveries=async e=>{await contextStorage.run(l,()=>y?.instrumentChannelDelivery({ctx:l,error:e,errorCode:channelDeliveryErrorCode(e),includeTurn:!1,outcome:`failed`})),await y?.flush()},x=buildAdapterContext(u,l),S;if(s.input?.kind===`deliver`){let e=[];try{for(let n of s.input.payloads){let r=u.deliver?await u.deliver(n,x):defaultDeliverResult(n);r!=null&&e.push(r)}}catch(e){throw await failChannelDeliveries(e),e}S=e.length===0?void 0:e.reduce(coalesceTurnInputs)}else s.input?.kind===`runtime-action-result`&&(s.input.acceptedAtMsByCallId!==void 0&&l.set(RuntimeActionSettlementTimesKey,s.input.acceptedAtMsByCallId),S={runtimeActionResults:s.input.results});if(S!==void 0&&a.input?.kind===`deliver`&&a.input.taskDeliveryId!==void 0){let e=resolveTaskDeliveryContext({state:c.state,taskDeliveryId:a.input.taskDeliveryId});e!==void 0&&(l.set(TurnTaskDeliveryKey,e.phase),S={...S,context:[...S.context??[],e.context]})}if(f&&l.get(TurnTaskDeliveryKey)===`none`){let e=resolveInitiatingTaskContext({state:c.state,turnId:activeTurnId(b)});e!==void 0&&(l.set(TurnTaskDeliveryKey,e.phase),l.set(TurnTaskStateKey,e.context))}if(s.input?.kind===`deliver`&&setChannelContext(l,{...u,state:{...x.state}}),s.input?.kind===`deliver`&&S===void 0){await contextStorage.run(l,()=>y?.instrumentChannelDelivery({ctx:l,includeTurn:!1,outcome:`completed`})),await y?.flush();let e=reconcileSessionContinuationToken(l,_),t=serializeContext(l),r=e===_?s.sessionState:createDurableSessionState({session:e});return{action:`park`,...derivePendingState(e),serializedContext:t,sessionState:r,tasksEnabled:f}}let C=d.hookRegistry,w=bindDynamicConnections(l,d.resolvedAgent),T=d.resolvedAgent.dynamicInstructionsResolvers??[],E=d.resolvedAgent.dynamicSkillResolvers??[],D=d.subagentRegistry.dynamicResolvers??[],O=d.resolvedAgent.dynamicToolResolvers??[],k={...d.graph.root,turnAgent:p.turnAgent},A=buildRuntimeIdentity(k);try{let e=process.env.VERCEL_DEPLOYMENT_ID?.trim(),t=e?`deployment:${e}`:await resolveRuntimeCompiledArtifactsVersionedCacheKey(d.compiledArtifactsSource);if(!b.sessionStarted)l.set(SessionDynamicSubagentRuntimeRevisionKey,t),l.set(SessionDynamicToolRuntimeRevisionKey,t);else{let e=createSessionStartedEvent({runtime:A});await Promise.all([refreshDynamicSessionSubagentsForRuntimeRevision({ctx:l,resolvers:D,event:e,messages:v.initial.messages,runtimeRevision:t}),refreshDynamicSessionToolsForRuntimeRevision({ctx:l,resolvers:O,event:e,messages:v.initial.messages,runtimeRevision:t})]),await rebindMissingCompiledDynamicToolCallbacks({ctx:l,event:createTurnStartedEvent({sequence:b.sequence,turnId:activeTurnId(b)}),messages:v.initial.messages,resolvers:O})}}catch(e){throw await failChannelDeliveries(e),e}let j=s.parentWritable.getWriter(),emit=async t=>{let n=await callAdapterEventHandler(u,t,x);setChannelContext(l,{...u,state:{...x.state}});let r=stampMessageStreamEvent(n);return await j.write(encodeMessageStreamEvent(r)),r},handleEvent=async(e,t)=>{let n=await forwardTaskEventToSessionCallback(l,e)?stampMessageStreamEvent(e):await emit(e),r=await dispatchMemoryLifecycleEvent({abortSignal:s.abortSignal,appRoot:k.agent?.metadata?.appRoot??``,ctx:l,event:e,memories:k.agent?.memories??[],messages:t,nodeId:d.nodeId??`__root__`});observeSessionActivity({ctx:l,event:n,sessionId:_.sessionId}),await dispatchStreamEventHooks({ctx:l,registry:C,event:n}),n.type!==`step.started`&&await dispatchDynamicModelEvent({ctx:l,dynamicModel:p.turnAgent.dynamicModel,event:n,messages:r,scope:{moduleMap:d.moduleMap,nodeId:d.nodeId}}),await w.dispatch(n),await dispatchDynamicSubagentEvent({ctx:l,resolvers:D,event:n,messages:r}),await dispatchDynamicToolEvent({ctx:l,resolvers:O,event:n,messages:r}),await dispatchDynamicSkillEvent({ctx:l,resolvers:E,event:n,messages:r}),await dispatchDynamicInstructionEvent({ctx:l,resolvers:T,event:n,messages:r})},M=l.require(ModeKey),N;try{throwIfTurnAborted(s.abortSignal),N=await runBackgroundStep(l,_,async e=>{l.setVirtualContext(HandleEventKey,handleEvent);let t=resolveEffectiveOutputSchema({agentOutputSchema:p.turnAgent.outputSchema,input:S,mode:M,session:e});if(await w.rehydrate(b,A,isHarnessBetweenTurns(t)),g){let e=getHarnessEmissionState(t.state);if(isHarnessBetweenTurns(t)){prepareDynamicInstructionPreamble(l,v.messages(t));let n=[],r=await prepareWorkflowPreambleTrace({emissionState:e,instrumentation:y});try{e=await emitTurnPreamble(handleEvent,{},e,A,r)}finally{n=drainDynamicInstructionUserMessages(l),t={...t,history:[...t.history,...n]}}t=setHarnessEmissionState(t,e)}for(let{authorization:t,result:n}of g){let r=h?.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}))}}let n=l.get(CapabilitiesKey);return(async(e,t)=>{let r=refreshSessionFromTurnAgent({compactionOverrides:{thresholdPercent:p.thresholdPercent},session:e,systemPromptAdditions:m?[TASK_UPDATE_SESSION_INSTRUCTION]:void 0,turnAgent:p.turnAgent}),i=f?await appendTaskAgentAnnouncement(r,v.messages(r)):r;return createExecutionNodeStep({abortSignal:s.abortSignal,capabilities:n,clearOnly:s.input?.kind===`clear`,compactOnly:s.input?.kind===`compact`,createRuntime:createWorkflowRuntime,handleEvent,historyProjector:v.projector,historyView:v.prepare(i),instrumentation:y,mode:M,modelResolutionScope:{moduleMap:d.moduleMap,nodeId:d.nodeId},node:k,workflowMaxSubagents:r.workflowMaxSubagents})(i,t)})(t,S)})}catch(e){if(!isTurnCancellation(e))throw await failChannelDeliveries(e),e;j.releaseLock();let t=serializeContext(l),n=readRetainedBackgroundToolResult(l),r=await preserveCancelledTurnMessage(n?.backgroundTaskSession??_,S);return{action:`cancelled`,...n===void 0?{}:{backgroundTaskState:createDurableSessionState({session:r}),backgroundTasks:n.backgroundTasks},serializedContext:preserveSerializedInstrumentationState(preserveSerializedAgentTraceState(preserveSerializedSessionDynamicModelSelection(s.serializedContext,t),t),t),sessionState:createDurableSessionState({session:r})}}let P=reconcileSessionContinuationToken(l,N.session),F=serializeContext(l);N={...N,session:P};let I=createDurableSessionState({session:N.session}),L=readTurnSleepDurationMs(l),R=L===void 0?{}:{sleepDurationMs:L},z=N.backgroundTasks===void 0||N.backgroundTaskSession===void 0?{}:{backgroundTaskState:createDurableSessionState({session:N.backgroundTaskSession}),backgroundTasks:N.backgroundTasks};if(N.next!==null&&typeof N.next==`object`&&`done`in N.next){if(M===`task`&&hasPendingInputBatch(N.session.state))throw j.releaseLock(),Error(`Task mode cannot complete while input requests remain pending.`);await j.close();let e=getTurnUsageState(N.session.state)?.session;return{action:`done`,...z,output:N.next.output,isError:N.next.isError,...R,serializedContext:F,sessionState:I,usage:e===void 0?void 0:toUsage(e),usageDelta:takeSessionUsageDelta(N.session).delta}}if(N.next===null){j.releaseLock();let e=getPendingWorkflowInterrupt(N.session.state);if(e!==void 0&&isWorkflowRuntimeActionInterrupt(e.interrupt))return{action:`dispatch-workflow-runtime-actions`,...z,pendingRuntimeActionKeys:getRuntimeActionKeysFromWorkflowInterrupt(e.interrupt),...R,serializedContext:F,sessionState:I};let t=derivePendingState(N.session);if(N.settledTurn!==void 0){let{delta:e,session:n}=takeSessionUsageDelta(N.session);return{action:`park`,...z,...t,...R,serializedContext:F,sessionState:createDurableSessionState({session:n}),settled:{output:N.settledTurn.output,isError:N.settledTurn.isError,usage:e},tasksEnabled:f}}return{action:`park`,...z,...t,...R,serializedContext:F,sessionState:I,tasksEnabled:f}}return j.releaseLock(),{action:`continue`,...z,...R,serializedContext:F,sessionState:I}}export{turnStep};
+import{callAdapterEventHandler,defaultDeliverResult}from"#channel/adapter.js";import{contextStorage}from"#context/container.js";import{AuthKey,CapabilitiesKey,HandleEventKey,ModeKey,SessionDynamicSubagentRuntimeRevisionKey,SessionDynamicToolRuntimeRevisionKey,TurnTaskDeliveryKey,TurnTaskStateKey}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{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{coalesceTurnInputs}from"#harness/messages.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{activeTurnId}from"#harness/active-turn-id.js";import{preserveSerializedAgentTraceState}from"#tracing/agent-trace-context-store.js";import{getPendingWorkflowInterrupt}from"#harness/workflow-interrupt-state.js";import{getWorkflowTaskCallIds,isWorkflowTaskInterrupt}from"#harness/workflow-task-state.js";import{TASK_UPDATE_SESSION_INSTRUCTION}from"#tools/framework/task-update.js";import{deferMismatchedInlineTurnStep}from"#execution/accepted-delivery-deployment.js";import{isTurnCancellation,throwIfTurnAborted}from"#harness/turn-cancellation.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{preserveSerializedSessionDynamicModelSelection}from"#context/serialized-dynamic-model-selection.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{preserveSerializedInstrumentationState}from"#instrumentation/state.js";import{RuntimeActionSettlementTimesKey}from"#harness/runtime-action-settlement-state.js";import{matchAuthorizationCallbacks}from"#execution/authorization-callback-match.js";import{derivePendingState}from"#execution/pending-turn-state.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{resolveInitiatingTaskContext,resolveTaskDeliveryContext}from"#tasks/delivery-context.js";import{readRetainedBackgroundToolResult,runBackgroundStep}from"#execution/tasks/parent/tool-execution.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{preserveCancelledTurnMessage}from"#execution/cancelled-turn-message.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(a){"use step";let o=deferMismatchedInlineTurnStep(a);if(o!==void 0)return o;let s=a,c=await readDurableSession(s.sessionState),l=await deserializeContext(s.serializedContext);a.input?.kind===`deliver`&&(l.set(TurnTaskDeliveryKey,`none`),l.delete(TurnTaskStateKey));let u=l.require(ChannelKey),d=l.require(BundleKey),f=resolveEffectiveAgentRuntime(d,l),p=c.taskId!==void 0&&f.turnAgent.tools.some(e=>e.kind===`authored-tool`&&e.behavior?.handling?.kind===`dispatch`&&e.behavior.handling.target.kind===`task-update`);try{let{getWorkflowMetadata:e}=await import(`#compiled/@workflow/core/index.js`),t=e();typeof t.url==`string`&&l.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(t.url))}catch{}let m=getPendingAuthorization(c.state),h;if(m&&s.input?.kind===`deliver`){let{matches:e,remainingPayloads:t}=matchAuthorizationCallbacks(m,s.input.payloads);if(s={...s,input:{...s.input,payloads:t}},e.length>0){let n=e.map(e=>e.result);l.set(PendingAuthorizationResultKey,n),c={...c,state:clearPendingAuthorization(c.state,n.map(e=>e.attemptId??e.name))},h=e,t.length===0&&(s={...s,input:void 0})}}s.input?.kind===`deliver`&&s.input.auth!==void 0&&l.set(AuthKey,s.input.auth??null);let g=hydrateDurableSession({compactionOverrides:{thresholdPercent:f.thresholdPercent},durable:c,turnAgent:f.turnAgent}),_=createExecutionHistoryView(g),v=bindSessionInstrumentation({agentName:f.turnAgent.id,ctx:l,rootSessionId:g.rootSessionId??g.sessionId,sessionId:g.sessionId}),y=getHarnessEmissionState(g.state);a.input?.kind===`deliver`&&await contextStorage.run(l,()=>v?.instrumentChannelDelivery({agentName:d.turnAgent.id,ctx:l,delivery:a.input,rootSessionId:g.rootSessionId??g.sessionId,sequence:y.sequence,sessionId:g.sessionId,turnId:activeTurnId(y)}));let failChannelDeliveries=async e=>{await contextStorage.run(l,()=>v?.instrumentChannelDelivery({ctx:l,error:e,errorCode:channelDeliveryErrorCode(e),includeTurn:!1,outcome:`failed`})),await v?.flush()},b=buildAdapterContext(u,l),x;if(s.input?.kind===`deliver`){let e=[];try{for(let n of s.input.payloads){let r=u.deliver?await u.deliver(n,b):defaultDeliverResult(n);r!=null&&e.push(r)}}catch(e){throw await failChannelDeliveries(e),e}x=e.length===0?void 0:e.reduce(coalesceTurnInputs)}else s.input?.kind===`runtime-action-result`&&(s.input.acceptedAtMsByCallId!==void 0&&l.set(RuntimeActionSettlementTimesKey,s.input.acceptedAtMsByCallId),x={runtimeActionResults:s.input.results});if(x!==void 0&&a.input?.kind===`deliver`&&a.input.taskDeliveryId!==void 0){let e=resolveTaskDeliveryContext({state:c.state,taskDeliveryId:a.input.taskDeliveryId});e!==void 0&&(l.set(TurnTaskDeliveryKey,e.phase),x={...x,context:[...x.context??[],e.context]})}if(l.get(TurnTaskDeliveryKey)===`none`){let e=resolveInitiatingTaskContext({state:c.state,turnId:activeTurnId(y)});e!==void 0&&(l.set(TurnTaskDeliveryKey,e.phase),l.set(TurnTaskStateKey,e.context))}if(s.input?.kind===`deliver`&&setChannelContext(l,{...u,state:{...b.state}}),s.input?.kind===`deliver`&&x===void 0){await contextStorage.run(l,()=>v?.instrumentChannelDelivery({ctx:l,includeTurn:!1,outcome:`completed`})),await v?.flush();let e=reconcileSessionContinuationToken(l,g),t=serializeContext(l),r=e===g?s.sessionState:createDurableSessionState({session:e});return{action:`park`,...derivePendingState(e),serializedContext:t,sessionState:r}}let S=d.hookRegistry,C=bindDynamicConnections(l,d.resolvedAgent),w=d.resolvedAgent.dynamicInstructionsResolvers??[],T=d.resolvedAgent.dynamicSkillResolvers??[],E=d.subagentRegistry.dynamicResolvers??[],D=d.resolvedAgent.dynamicToolResolvers??[],O={...d.graph.root,turnAgent:f.turnAgent},k=buildRuntimeIdentity(O);try{let e=process.env.VERCEL_DEPLOYMENT_ID?.trim(),t=e?`deployment:${e}`:await resolveRuntimeCompiledArtifactsVersionedCacheKey(d.compiledArtifactsSource);if(!y.sessionStarted)l.set(SessionDynamicSubagentRuntimeRevisionKey,t),l.set(SessionDynamicToolRuntimeRevisionKey,t);else{let e=createSessionStartedEvent({runtime:k});await Promise.all([refreshDynamicSessionSubagentsForRuntimeRevision({ctx:l,resolvers:E,event:e,messages:_.initial.messages,runtimeRevision:t}),refreshDynamicSessionToolsForRuntimeRevision({ctx:l,resolvers:D,event:e,messages:_.initial.messages,runtimeRevision:t})]),await rebindMissingCompiledDynamicToolCallbacks({ctx:l,event:createTurnStartedEvent({sequence:y.sequence,turnId:activeTurnId(y)}),messages:_.initial.messages,resolvers:D})}}catch(e){throw await failChannelDeliveries(e),e}let A=s.parentWritable.getWriter(),emit=async t=>{let n=await callAdapterEventHandler(u,t,b);setChannelContext(l,{...u,state:{...b.state}});let r=stampMessageStreamEvent(n);return await A.write(encodeMessageStreamEvent(r)),r},handleEvent=async(e,t)=>{let n=await forwardTaskEventToSessionCallback(l,e)?stampMessageStreamEvent(e):await emit(e),r=await dispatchMemoryLifecycleEvent({abortSignal:s.abortSignal,appRoot:O.agent?.metadata?.appRoot??``,ctx:l,event:e,memories:O.agent?.memories??[],messages:t,nodeId:d.nodeId??`__root__`});observeSessionActivity({ctx:l,event:n,sessionId:g.sessionId}),await dispatchStreamEventHooks({ctx:l,registry:S,event:n}),n.type!==`step.started`&&await dispatchDynamicModelEvent({ctx:l,dynamicModel:f.turnAgent.dynamicModel,event:n,messages:r,scope:{moduleMap:d.moduleMap,nodeId:d.nodeId}}),await C.dispatch(n),await dispatchDynamicSubagentEvent({ctx:l,resolvers:E,event:n,messages:r}),await dispatchDynamicToolEvent({ctx:l,resolvers:D,event:n,messages:r}),await dispatchDynamicSkillEvent({ctx:l,resolvers:T,event:n,messages:r}),await dispatchDynamicInstructionEvent({ctx:l,resolvers:w,event:n,messages:r})},j=l.require(ModeKey),M;try{throwIfTurnAborted(s.abortSignal),M=await runBackgroundStep(l,g,async e=>{l.setVirtualContext(HandleEventKey,handleEvent);let t=resolveEffectiveOutputSchema({agentOutputSchema:f.turnAgent.outputSchema,input:x,mode:j,session:e});if(await C.rehydrate(y,k,isHarnessBetweenTurns(t)),h){let e=getHarnessEmissionState(t.state);if(isHarnessBetweenTurns(t)){prepareDynamicInstructionPreamble(l,_.messages(t));let n=[],r=await prepareWorkflowPreambleTrace({emissionState:e,instrumentation:v});try{e=await emitTurnPreamble(handleEvent,{},e,k,r)}finally{n=drainDynamicInstructionUserMessages(l),t={...t,history:[...t.history,...n]}}t=setHarnessEmissionState(t,e)}for(let{authorization:t,result:n}of h){let r=m?.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}))}}let n=l.get(CapabilitiesKey);return(async(e,t)=>{let r=refreshSessionFromTurnAgent({compactionOverrides:{thresholdPercent:f.thresholdPercent},session:e,systemPromptAdditions:p?[TASK_UPDATE_SESSION_INSTRUCTION]:void 0,turnAgent:f.turnAgent}),i=r;return createExecutionNodeStep({abortSignal:s.abortSignal,capabilities:n,clearOnly:s.input?.kind===`clear`,compactOnly:s.input?.kind===`compact`,createRuntime:createWorkflowRuntime,handleEvent,historyProjector:_.projector,historyView:_.prepare(i),instrumentation:v,mode:j,modelResolutionScope:{moduleMap:d.moduleMap,nodeId:d.nodeId},node:O,workflowMaxSubagents:r.workflowMaxSubagents})(i,t)})(t,x)})}catch(e){if(!isTurnCancellation(e))throw await failChannelDeliveries(e),e;A.releaseLock();let t=serializeContext(l),n=readRetainedBackgroundToolResult(l),r=await preserveCancelledTurnMessage(n?.backgroundTaskSession??g,x);return{action:`cancelled`,...n===void 0?{}:{backgroundTaskState:createDurableSessionState({session:r}),backgroundTasks:n.backgroundTasks},serializedContext:preserveSerializedInstrumentationState(preserveSerializedAgentTraceState(preserveSerializedSessionDynamicModelSelection(s.serializedContext,t),t),t),sessionState:createDurableSessionState({session:r})}}let N=reconcileSessionContinuationToken(l,M.session),P=serializeContext(l);M={...M,session:N};let F=createDurableSessionState({session:M.session}),I=M.backgroundTasks===void 0||M.backgroundTaskSession===void 0?{}:{backgroundTaskState:createDurableSessionState({session:M.backgroundTaskSession}),backgroundTasks:M.backgroundTasks};if(M.next!==null&&typeof M.next==`object`&&`done`in M.next){if(j===`task`&&hasPendingInputBatch(M.session.state))throw A.releaseLock(),Error(`Task mode cannot complete while input requests remain pending.`);await A.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){A.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 A.releaseLock(),{action:`continue`,...I,serializedContext:P,sessionState:F}}export{turnStep};

package/dist/src/framework/sources/registry.js

@@ -1 +1 @@
-import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{createAgentSourceRegistry,defineProgrammaticAgentSource,loadProgrammaticModuleNamespace,memoizeModuleNamespaceFactories}from"#compiler/source-graph.js";const revision=`eve@${resolveInstalledPackageInfo().version}:compiled-manifest-v46`,localDefaults=defineProgrammaticAgentSource({id:`eve:defaults`,revision,modules:[{logicalPath:`agent.ts`,loadNamespace:()=>import(`#framework/sources/modules/agent.js`)},{logicalPath:`sandbox.ts`,semanticRevision:`eve:default-sandbox:v1`,loadNamespace:()=>import(`#framework/sources/modules/sandbox.js`)},{logicalPath:`tools/bash.ts`,loadNamespace:()=>import(`#tools/provided/bash.js`)},{logicalPath:`tools/read_file.ts`,loadNamespace:()=>import(`#tools/provided/read-file.js`)},{logicalPath:`tools/write_file.ts`,loadNamespace:()=>import(`#tools/provided/write-file.js`)},{logicalPath:`tools/todo.ts`,loadNamespace:()=>import(`#tools/provided/todo.js`)},{logicalPath:`tools/web_fetch.ts`,loadNamespace:()=>import(`#tools/provided/web-fetch.js`)},{logicalPath:`tools/load_skill.ts`,loadNamespace:()=>import(`#tools/provided/load-skill.js`)},{logicalPath:`tools/connection_search.ts`,loadNamespace:()=>import(`#tools/framework/connection-search.js`)},{logicalPath:`tools/ask_question.ts`,loadNamespace:()=>import(`#tools/framework/ask-question.js`)},{logicalPath:`tools/web_search.ts`,loadNamespace:()=>import(`#tools/provided/web-search.js`)}]}),rootDefaults=defineProgrammaticAgentSource({id:`eve:root-defaults`,revision,modules:[{logicalPath:`tools/agent.ts`,loadNamespace:()=>import(`#tools/framework/agent.js`)},{logicalPath:`tools/task_update.ts`,loadNamespace:()=>import(`#tools/framework/task-update.js`)},{logicalPath:`tools/task_cancel.ts`,loadNamespace:()=>import(`#tools/framework/task-cancel.js`)},{logicalPath:`channels/eve.ts`,loadNamespace:()=>import(`#framework/sources/modules/eve-channel.js`)},{logicalPath:`channels/home.ts`,loadNamespace:()=>import(`#framework/sources/modules/home-channel.js`)}]}),memoryWrapperTemplateSource=defineProgrammaticAgentSource({id:`eve:memory-wrapper`,revision,modules:[{logicalPath:`tools/memory-wrapper.ts`,loadNamespace:async e=>{let{loadMemoryWrapperNamespace:t}=await import(`#framework/sources/modules/memory-wrapper.js`);return await t(e)}}]}),frameworkAgentSourceRegistry=createAgentSourceRegistry([{applyTo:`all-local-nodes`,source:localDefaults},{applyTo:`root`,source:rootDefaults}],{templates:[memoryWrapperTemplateSource]}),memoryWrapperTemplate=frameworkAgentSourceRegistry.templates.get(memoryWrapperTemplateSource.id);async function loadFrameworkProgrammaticModule(e,t){return memoizeModuleNamespaceFactories(await loadProgrammaticModuleNamespace({backing:e,dependencyNamespaces:t,registries:[frameworkAgentSourceRegistry]}))}export{frameworkAgentSourceRegistry,loadFrameworkProgrammaticModule,memoryWrapperTemplate};
+import{resolveInstalledPackageInfo}from"#internal/application/package.js";import{createAgentSourceRegistry,defineProgrammaticAgentSource,loadProgrammaticModuleNamespace,memoizeModuleNamespaceFactories}from"#compiler/source-graph.js";const revision=`eve@${resolveInstalledPackageInfo().version}:compiled-manifest-v46`,localDefaults=defineProgrammaticAgentSource({id:`eve:defaults`,revision,modules:[{logicalPath:`agent.ts`,loadNamespace:()=>import(`#framework/sources/modules/agent.js`)},{logicalPath:`sandbox.ts`,semanticRevision:`eve:default-sandbox:v1`,loadNamespace:()=>import(`#framework/sources/modules/sandbox.js`)},{logicalPath:`tools/bash.ts`,loadNamespace:()=>import(`#tools/provided/bash.js`)},{logicalPath:`tools/read_file.ts`,loadNamespace:()=>import(`#tools/provided/read-file.js`)},{logicalPath:`tools/write_file.ts`,loadNamespace:()=>import(`#tools/provided/write-file.js`)},{logicalPath:`tools/todo.ts`,loadNamespace:()=>import(`#tools/provided/todo.js`)},{logicalPath:`tools/web_fetch.ts`,loadNamespace:()=>import(`#tools/provided/web-fetch.js`)},{logicalPath:`tools/load_skill.ts`,loadNamespace:()=>import(`#tools/provided/load-skill.js`)},{logicalPath:`tools/connection_search.ts`,loadNamespace:()=>import(`#tools/framework/connection-search.js`)},{logicalPath:`tools/ask_question.ts`,loadNamespace:()=>import(`#tools/framework/ask-question.js`)},{logicalPath:`tools/task_update.ts`,loadNamespace:()=>import(`#tools/framework/task-update.js`)},{logicalPath:`tools/task_cancel.ts`,loadNamespace:()=>import(`#tools/framework/task-cancel.js`)},{logicalPath:`tools/web_search.ts`,loadNamespace:()=>import(`#tools/provided/web-search.js`)}]}),rootDefaults=defineProgrammaticAgentSource({id:`eve:root-defaults`,revision,modules:[{logicalPath:`tools/agent.ts`,loadNamespace:()=>import(`#tools/framework/agent.js`)},{logicalPath:`channels/eve.ts`,loadNamespace:()=>import(`#framework/sources/modules/eve-channel.js`)},{logicalPath:`channels/home.ts`,loadNamespace:()=>import(`#framework/sources/modules/home-channel.js`)}]}),memoryWrapperTemplateSource=defineProgrammaticAgentSource({id:`eve:memory-wrapper`,revision,modules:[{logicalPath:`tools/memory-wrapper.ts`,loadNamespace:async e=>{let{loadMemoryWrapperNamespace:t}=await import(`#framework/sources/modules/memory-wrapper.js`);return await t(e)}}]}),frameworkAgentSourceRegistry=createAgentSourceRegistry([{applyTo:`all-local-nodes`,source:localDefaults},{applyTo:`root`,source:rootDefaults}],{templates:[memoryWrapperTemplateSource]}),memoryWrapperTemplate=frameworkAgentSourceRegistry.templates.get(memoryWrapperTemplateSource.id);async function loadFrameworkProgrammaticModule(e,t){return memoizeModuleNamespaceFactories(await loadProgrammaticModuleNamespace({backing:e,dependencyNamespaces:t,registries:[frameworkAgentSourceRegistry]}))}export{frameworkAgentSourceRegistry,loadFrameworkProgrammaticModule,memoryWrapperTemplate};