eve 0.47.2 → 0.47.3

package/dist/src/execution/web-fetch/request.js

@@ -1 +1 @@
-import{isIP}from"node:net";import{isLoopbackHostname,isPrivateOrReservedIpAddress}from"#shared/network-address.js";import{lookup}from"node:dns";const REDIRECT_STATUSES=new Set([301,302,303,307,308]),UNSAFE_DESTINATION_ERROR=`URL must not target localhost, private, link-local, or reserved IP addresses.`;async function requestPublicUrl(e,t){let n=parseHttpsUrl(e);for(let e=0;;e++){let{dispatcher:r,response:a}=await requestOnce(n,t);try{let r=a.headers.get(`location`);if(r!==null&&REDIRECT_STATUSES.has(a.status)&&e<10){await cancelResponseBody(a),n=parseHttpsUrl(new URL(r,n).toString());continue}return await consumeResponse(a,t.maxResponseSize)}finally{await r.close()}}}function parseHttpsUrl(e){let t;try{t=new URL(e)}catch{throw Error(`URL must be a valid absolute https:// URL.`)}if(t.protocol!==`https:`)throw Error(`URL must start with https://`);return t}async function requestOnce(e,t){assertPublicHostname(e.hostname);let{Agent:n,Dispatcher1Wrapper:r}=await import(`undici`),i=new r(new n({connect:{lookup:createPublicLookup()}}));try{return{dispatcher:i,response:await fetchWithDispatcher(e,{dispatcher:i,headers:t.headers,redirect:`manual`,signal:t.signal})}}catch(e){throw await i.close(),e}}function fetchWithDispatcher(e,t){return fetch(e,t)}function assertPublicHostname(n){let r=n.replace(/^\[(.*)\]$/u,`$1`);if(isIP(r)!==0){assertPublicAddress(r);return}if(isLoopbackHostname(r))throw Error(UNSAFE_DESTINATION_ERROR)}function assertPublicAddress(e){if(isPrivateOrReservedIpAddress(e))throw Error(UNSAFE_DESTINATION_ERROR)}function createPublicLookup(){return(e,t,n)=>{lookup(e,{all:!0,verbatim:!0},(r,i)=>{if(r!==null){n(r,``,0);return}try{for(let{address:e}of i)assertPublicAddress(e)}catch(e){n(e,``,0);return}let a=t.family===void 0||t.family===0?i:i.filter(({family:e})=>e===t.family);if(a.length===0){let t=Error(`Unable to resolve URL hostname "${e}" in the requested IP family.`);Object.assign(t,{code:`ENOTFOUND`}),n(t,``,0);return}if(t.all===!0){n(null,a);return}let o=a[0];n(null,o.address,o.family)})}}async function consumeResponse(e,t){let n=parseContentLength(e.headers.get(`content-length`));if(n!==void 0&&n>t)throw await cancelResponseBody(e),createResponseTooLargeError();let r=await readBoundedBody(e,t),i=r.byteLength===0?null:Uint8Array.from(r).buffer;return new Response(i,{headers:e.headers,status:e.status,statusText:e.statusText})}function parseContentLength(e){if(e===null)return;let t=Number.parseInt(e,10);return Number.isFinite(t)&&t>=0?t:void 0}async function readBoundedBody(e,t){if(e.body===null)return new Uint8Array;let n=e.body.getReader(),r=[],i=0;try{for(;;){let{done:e,value:a}=await n.read();if(e)break;if(i+=a.byteLength,i>t)throw await n.cancel(),createResponseTooLargeError();r.push(a)}}finally{n.releaseLock()}let a=new Uint8Array(i),o=0;for(let e of r)a.set(e,o),o+=e.byteLength;return a}async function cancelResponseBody(e){try{await e.body?.cancel()}catch{}}function createResponseTooLargeError(){return Error(`Response too large (exceeds 5 MB limit).`)}export{requestPublicUrl};
+import{isLoopbackHostname,isPrivateOrReservedIpAddress}from"#shared/network-address.js";import{isIP}from"node:net";import{lookup}from"node:dns";const REDIRECT_STATUSES=new Set([301,302,303,307,308]),UNSAFE_DESTINATION_ERROR=`URL must not target localhost, private, link-local, or reserved IP addresses.`;async function requestPublicUrl(e,t){let n=parseHttpsUrl(e);for(let e=0;;e++){let{dispatcher:r,response:a}=await requestOnce(n,t);try{let r=a.headers.get(`location`);if(r!==null&&REDIRECT_STATUSES.has(a.status)&&e<10){await cancelResponseBody(a),n=parseHttpsUrl(new URL(r,n).toString());continue}return await consumeResponse(a,t.maxResponseSize)}finally{await r.close()}}}function parseHttpsUrl(e){let t;try{t=new URL(e)}catch{throw Error(`URL must be a valid absolute https:// URL.`)}if(t.protocol!==`https:`)throw Error(`URL must start with https://`);return t}async function requestOnce(e,t){assertPublicHostname(e.hostname);let{Agent:n,Dispatcher1Wrapper:r}=await import(`undici`),i=new r(new n({connect:{lookup:createPublicLookup()}}));try{return{dispatcher:i,response:await fetchWithDispatcher(e,{dispatcher:i,headers:t.headers,redirect:`manual`,signal:t.signal})}}catch(e){throw await i.close(),e}}function fetchWithDispatcher(e,t){return fetch(e,t)}function assertPublicHostname(t){let r=t.replace(/^\[(.*)\]$/u,`$1`);if(isIP(r)!==0){assertPublicAddress(r);return}if(isLoopbackHostname(r))throw Error(UNSAFE_DESTINATION_ERROR)}function assertPublicAddress(e){if(isPrivateOrReservedIpAddress(e))throw Error(UNSAFE_DESTINATION_ERROR)}function createPublicLookup(){return(e,t,n)=>{lookup(e,{all:!0,verbatim:!0},(r,i)=>{if(r!==null){n(r,``,0);return}try{for(let{address:e}of i)assertPublicAddress(e)}catch(e){n(e,``,0);return}let a=t.family===void 0||t.family===0?i:i.filter(({family:e})=>e===t.family);if(a.length===0){let t=Error(`Unable to resolve URL hostname "${e}" in the requested IP family.`);Object.assign(t,{code:`ENOTFOUND`}),n(t,``,0);return}if(t.all===!0){n(null,a);return}let o=a[0];n(null,o.address,o.family)})}}async function consumeResponse(e,t){let n=parseContentLength(e.headers.get(`content-length`));if(n!==void 0&&n>t)throw await cancelResponseBody(e),createResponseTooLargeError();let r=await readBoundedBody(e,t),i=r.byteLength===0?null:Uint8Array.from(r).buffer;return new Response(i,{headers:e.headers,status:e.status,statusText:e.statusText})}function parseContentLength(e){if(e===null)return;let t=Number.parseInt(e,10);return Number.isFinite(t)&&t>=0?t:void 0}async function readBoundedBody(e,t){if(e.body===null)return new Uint8Array;let n=e.body.getReader(),r=[],i=0;try{for(;;){let{done:e,value:a}=await n.read();if(e)break;if(i+=a.byteLength,i>t)throw await n.cancel(),createResponseTooLargeError();r.push(a)}}finally{n.releaseLock()}let a=new Uint8Array(i),o=0;for(let e of r)a.set(e,o),o+=e.byteLength;return a}async function cancelResponseBody(e){try{await e.body?.cancel()}catch{}}function createResponseTooLargeError(){return Error(`Response too large (exceeds 5 MB limit).`)}export{requestPublicUrl};

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

@@ -1,8 +1,8 @@
 /** Every explicit session-inbox wire version still supported by producers. */
-export declare const SESSION_INBOX_WIRE_VERSIONS: readonly [1];
+export declare const SESSION_INBOX_WIRE_VERSIONS: readonly [1, 2];
 export type SessionInboxWireVersion = (typeof SESSION_INBOX_WIRE_VERSIONS)[number];
 /** Current persisted session-inbox wire version. */
-export declare const SESSION_INBOX_WIRE_VERSION: 1;
+export declare const SESSION_INBOX_WIRE_VERSION: 1 | 2;
 /** Hook metadata field advertising the consumer's inbox wire capability. */
 export declare const SESSION_INBOX_WIRE_VERSION_METADATA_KEY = "sessionInboxWireVersion";
 /**

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

@@ -1 +1 @@
-const SESSION_INBOX_WIRE_VERSIONS=[1],SESSION_INBOX_WIRE_VERSION=SESSION_INBOX_WIRE_VERSIONS[SESSION_INBOX_WIRE_VERSIONS.length-1],SESSION_INBOX_WIRE_VERSION_METADATA_KEY=`sessionInboxWireVersion`;function isSessionInboxWireVersion(t){return SESSION_INBOX_WIRE_VERSIONS.some(e=>e===t)}var SessionInboxWireError=class extends Error{constructor(e){super(e),this.name=`SessionInboxWireError`}};export{SESSION_INBOX_WIRE_VERSION,SESSION_INBOX_WIRE_VERSIONS,SESSION_INBOX_WIRE_VERSION_METADATA_KEY,SessionInboxWireError,isSessionInboxWireVersion};
+const SESSION_INBOX_WIRE_VERSIONS=[1,2],SESSION_INBOX_WIRE_VERSION=SESSION_INBOX_WIRE_VERSIONS[SESSION_INBOX_WIRE_VERSIONS.length-1],SESSION_INBOX_WIRE_VERSION_METADATA_KEY=`sessionInboxWireVersion`;function isSessionInboxWireVersion(t){return SESSION_INBOX_WIRE_VERSIONS.some(e=>e===t)}var SessionInboxWireError=class extends Error{constructor(e){super(e),this.name=`SessionInboxWireError`}};export{SESSION_INBOX_WIRE_VERSION,SESSION_INBOX_WIRE_VERSIONS,SESSION_INBOX_WIRE_VERSION_METADATA_KEY,SessionInboxWireError,isSessionInboxWireVersion};

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

@@ -1,9 +1,10 @@
 import type { DeliverHookPayload, SessionCommand, SessionTimeoutHookPayload } from "#channel/types.js";
 import { type SessionInboxWireV1 } from "#execution/wire/session-inbox-wire.v1.js";
+import { type SessionInboxWireV2 } from "#execution/wire/session-inbox-wire.v2.js";
 import { type SessionInboxWireTarget, type SessionInboxWireVersion } from "#execution/wire/session-inbox-contract.js";
 type SessionInboxCommand = DeliverHookPayload | SessionCommand | SessionTimeoutHookPayload;
 /** Current wire type consumed after migration. */
-export type SessionInboxWire = SessionInboxWireV1;
+export type SessionInboxWire = SessionInboxWireV2;
 type LegacySessionInboxWireTarget = Extract<SessionInboxWireTarget, {
     readonly version: 0;
 }>;
@@ -11,11 +12,14 @@ type LegacySessionInboxWireTarget = Extract<SessionInboxWireTarget, {
 declare function encode(command: SessionInboxCommand, target: {
     readonly version: 1;
 }): SessionInboxWireV1;
+declare function encode(command: SessionInboxCommand, target: {
+    readonly version: 2;
+}): SessionInboxWireV2;
 declare function encode(command: SessionInboxCommand, target: {
     readonly version: SessionInboxWireVersion;
 }): unknown;
 declare function encode(command: SessionInboxCommand, target: LegacySessionInboxWireTarget): Record<string, unknown>;
-declare function encode(command: SessionInboxCommand, target: SessionInboxWireTarget): SessionInboxWireV1 | Record<string, unknown>;
+declare function encode(command: SessionInboxCommand, target: SessionInboxWireTarget): SessionInboxWireV1 | SessionInboxWireV2 | Record<string, unknown>;
 /** Server/step-safe producer facade. */
 export declare const sessionInboxWire: {
     readonly encode: typeof encode;

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

@@ -1 +1 @@
-import{SessionInboxWireError,isSessionInboxWireVersion}from"#execution/wire/session-inbox-contract.js";import{encodeSessionCommandV1}from"#execution/wire/session-inbox-wire.v1.js";import{encodeSessionCommandV0}from"#execution/wire/session-inbox-wire.v0.js";const versionedEncoders={1:encodeSessionCommandV1};function encode(e,t){if(t.version===0)return encodeSessionCommandV0(encodeSessionCommandV1(e),t.variant);if(isSessionInboxWireVersion(t.version))return versionedEncoders[t.version](e);throw new SessionInboxWireError(`Cannot encode session inbox payload for unknown wire version ${JSON.stringify(t.version)}.`)}const sessionInboxWire={encode};export{sessionInboxWire};
+import{SessionInboxWireError,isSessionInboxWireVersion}from"#execution/wire/session-inbox-contract.js";import{encodeSessionCommandV1}from"#execution/wire/session-inbox-wire.v1.js";import{encodeSessionCommandV2}from"#execution/wire/session-inbox-wire.v2.js";import{encodeSessionCommandV0}from"#execution/wire/session-inbox-wire.v0.js";const versionedEncoders={1:e=>encodeSessionCommandV1(withoutActivityObserver(e)),2:encodeSessionCommandV2};function encode(r,i){if(i.version===0)return encodeSessionCommandV0(encodeSessionCommandV1(withoutActivityObserver(r)),i.variant);if(isSessionInboxWireVersion(i.version))return versionedEncoders[i.version](r);throw new SessionInboxWireError(`Cannot encode session inbox payload for unknown wire version ${JSON.stringify(i.version)}.`)}function withoutActivityObserver(e){if(!(`caller`in e)||e.caller?.activityObserver===void 0)return e;let{activityObserver:t,...n}=e.caller;return{...e,caller:n}}const sessionInboxWire={encode};export{sessionInboxWire};

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

@@ -1 +1 @@
-import{SESSION_INBOX_WIRE_VERSION,SessionInboxWireError,SessionInboxWireError as SessionInboxWireError$1}from"#execution/wire/session-inbox-contract.js";import{sessionInboxWireV0Migration}from"#execution/wire/session-inbox-wire.v0.js";import{runMigrationChain}from"#execution/durable-session-migrations/chain.js";const WIRE_LABEL=`session inbox payload`,sessionInboxMigrations=[sessionInboxWireV0Migration];function decode(t){let n;try{n=runMigrationChain({initialVersion:0,label:WIRE_LABEL,migrations:sessionInboxMigrations,targetVersion:SESSION_INBOX_WIRE_VERSION,value:t})}catch(e){throw new SessionInboxWireError$1(e instanceof Error?e.message:String(e))}let r=n;if(r.version!==SESSION_INBOX_WIRE_VERSION)throw new SessionInboxWireError$1(`${WIRE_LABEL} declares version ${JSON.stringify(r.version)}, expected ${SESSION_INBOX_WIRE_VERSION}.`);return normalizeWire(r)}const sessionInboxWire={decode};function normalizeWire(e){switch(e.kind){case`deliver`:return{auth:e.auth,caller:e.caller,deliveryMetadata:e.deliveryMetadata,kind:`deliver`,payloads:e.payloads,requestId:e.requestId,taskDeliveryId:e.taskDeliveryId,turnPolicy:e.turnPolicy};case`session-timeout`:return{kind:`session-timeout`};case`clear`:return{kind:`clear`};case`compact`:return{kind:`compact`};case`reset`:return{kind:`reset`,reason:e.reason};case`cancel`:return{kind:`cancel`,taskId:e.taskId,turnId:e.turnId};default:throw new SessionInboxWireError$1(`${WIRE_LABEL} has an unrecognized kind ${JSON.stringify(e.kind)}.`)}}export{SessionInboxWireError,sessionInboxWire};
+import{SESSION_INBOX_WIRE_VERSION,SessionInboxWireError,SessionInboxWireError as SessionInboxWireError$1}from"#execution/wire/session-inbox-contract.js";import{sessionInboxWireV0Migration}from"#execution/wire/session-inbox-wire.v0.js";import{runMigrationChain}from"#execution/durable-session-migrations/chain.js";import{normalizeSessionInboxWireV2,sessionInboxWireV1Migration}from"#execution/wire/session-inbox-wire.v2-migration.js";const WIRE_LABEL=`session inbox payload`,sessionInboxMigrations=[sessionInboxWireV0Migration,sessionInboxWireV1Migration];function decode(t){let n=typeof t==`object`&&t&&`version`in t?t.version:void 0,r;try{r=runMigrationChain({initialVersion:0,label:WIRE_LABEL,migrations:sessionInboxMigrations,targetVersion:SESSION_INBOX_WIRE_VERSION,value:t})}catch(e){throw new SessionInboxWireError$1(e instanceof Error?e.message:String(e))}let i=normalizeSessionInboxWireV2(r);if(i.version!==SESSION_INBOX_WIRE_VERSION)throw new SessionInboxWireError$1(`${WIRE_LABEL} declares version ${JSON.stringify(i.version)}, expected ${SESSION_INBOX_WIRE_VERSION}.`);if(n===2&&i.kind===`deliver`&&!(`payload`in i))throw new SessionInboxWireError$1(`${WIRE_LABEL} does not match wire version 2.`);return normalizeWire(i)}const sessionInboxWire={decode};function normalizeWire(e){switch(e.kind){case`deliver`:return{auth:e.auth,caller:e.caller,deliveryMetadata:e.deliveryMetadata,kind:`deliver`,payloads:e.payloads,requestId:e.requestId,taskDeliveryId:e.taskDeliveryId,turnPolicy:e.turnPolicy};case`session-timeout`:return{kind:`session-timeout`};case`clear`:return{kind:`clear`};case`compact`:return{kind:`compact`};case`reset`:return{kind:`reset`,reason:e.reason};case`cancel`:return{kind:`cancel`,taskId:e.taskId,turnId:e.turnId};default:throw new SessionInboxWireError$1(`${WIRE_LABEL} has an unrecognized kind ${JSON.stringify(e.kind)}.`)}}export{SessionInboxWireError,sessionInboxWire};

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

@@ -0,0 +1,4 @@
+import type { VersionMigration } from "#execution/durable-session-migrations/chain.js";
+export declare const sessionInboxWireV1Migration: VersionMigration;
+/** Converts Workflow-VM records into this realm before wire consumption. */
+export declare function normalizeSessionInboxWireV2(value: unknown, arrayFallback?: boolean): unknown;

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

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const sessionInboxWireV1Migration={from:1,migrate(e){let t=normalizeSessionInboxWireV2(e);return{...t,...t.kind===`deliver`&&!(`payload`in t)?{payload:{}}:{},version:2}},to:2};function normalizeSessionInboxWireV2(e,t=!1){return e===void 0?t?null:void 0:Array.isArray(e)?e.map(e=>normalizeSessionInboxWireV2(e,!0)):isPlainRecord$1(e)?Object.fromEntries(Object.entries(e).filter(e=>e[1]!==void 0).map(([e,t])=>[e,normalizeSessionInboxWireV2(t)])):e}function isPlainRecord$1(t){if(!isObject(t))return!1;let n=Object.getPrototypeOf(t);return n===null||n===Object.prototype||Object.getPrototypeOf(n)===null}export{normalizeSessionInboxWireV2,sessionInboxWireV1Migration};

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

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

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

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{formatValidationError}from"#runtime/validation.js";import{coalesceDeliverPayloads}from"#execution/deliver-payloads.js";import{SessionInboxWireError}from"#execution/wire/session-inbox-contract.js";import{sessionInboxWireV1Schema}from"#execution/wire/session-inbox-wire.v1.js";import{normalizeSessionInboxWireV2}from"#execution/wire/session-inbox-wire.v2-migration.js";const activityWorkIdentitySchema=z.object({callId:z.string().optional(),id:z.string(),kind:z.enum([`root-turn`,`subagent`,`remote-agent`,`task`]),name:z.string().optional(),parentId:z.string().optional(),rootSessionId:z.string(),rootTurnId:z.string(),sessionId:z.string().optional(),turnId:z.string().optional()}).strict(),activityObserverSchema=z.object({sink:z.object({url:z.string(),version:z.literal(1)}).strict(),workIdentity:activityWorkIdentitySchema.optional()}).strict(),v1=sessionInboxWireV1Schema.options,v1Deliver=v1[0],v1Caller=v1Deliver.shape.caller.unwrap(),version=z.literal(2),sessionInboxWireV2Schema=z.discriminatedUnion(`kind`,[v1Deliver.extend({caller:v1Caller.extend({activityObserver:activityObserverSchema.optional()}).optional(),payload:v1Deliver.shape.payload.unwrap(),version}),v1[1].extend({version}),v1[2].extend({version}),v1[3].extend({version}),v1[4].extend({version}),v1[5].extend({version})]);function parseSessionInboxWireV2(e){return sessionInboxWireV2Schema.safeParse(normalizeSessionInboxWireV2(e))}function encodeSessionCommandV2(e){let t=parseSessionInboxWireV2(e.kind===`send`?{auth:e.auth,caller:e.caller,deliveryMetadata:e.delivery===void 0?void 0:[{...e.delivery,payloadIndex:0}],kind:`deliver`,payload:e.payload,payloads:[e.payload],requestId:e.requestId,taskDeliveryId:e.taskDeliveryId,turnPolicy:e.turnPolicy,version:2}:e.kind===`deliver`?{...e,payload:coalesceDeliverPayloads(e.payloads),version:2}:{...e,version:2});if(!t.success)throw new SessionInboxWireError(`Produced a session inbox payload that does not match wire version 2: ${formatValidationError(t.error)}`);return t.data}export{encodeSessionCommandV2,parseSessionInboxWireV2,sessionInboxWireV2Schema};

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

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

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

@@ -44,6 +44,10 @@ export declare const sessionTimeoutWorkflowReference: {
 export declare const taskRunWorkflowReference: {
     workflowId: string;
 };
+/** Stable workflow reference for root-session activity collectors. */
+export declare const activityCollectorWorkflowReference: {
+    workflowId: string;
+};
 /**
  * Creates a workflow-backed runtime whose long-lived driver owns the
  * event stream and dispatches each turn as a child workflow run.