eve 0.47.2 → 0.47.5

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

@@ -1 +1 @@
-import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{migrateTurnWorkflowInput}from"#execution/durable-session-migrations/turn-workflow.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";import{dispatchTaskStep}from"#execution/tasks/parent/dispatch-task-step.js";import{routeDeliverToChildren}from"#execution/route-child-delivery.js";import{getRuntimeActionResultKey}from"#runtime/actions/keys.js";import{runProxySubagentEventStep}from"#execution/subagent-event-proxy-step.js";import{createHook,getWorkflowMetadata,sleep}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{activeTurnId}from"#harness/active-turn-id.js";import{acknowledgeDelegatedTasksStep}from"#execution/tasks/parent/delegate.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{sendTurnControlStep}from"#execution/turn-control-protocol.js";import{isInboxSubagentResultFromRunningHandle}from"#harness/handles/query.js";import{preserveSerializedSessionDynamicModelSelection}from"#context/serialized-dynamic-model-selection.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{dispatchWorkflowRuntimeActionsStep}from"#execution/dispatch-workflow-runtime-actions-step.js";import{createTurnCancellationControl}from"#execution/turn-cancellation-control.js";import{TurnExecutionCursor}from"#execution/turn-execution-cursor.js";import{turnStep}from"#execution/workflow-steps.js";import{resolveRuntimeActionResultsForKeys}from"#runtime/actions/results.js";const TASK_MODE_WAIT_ERROR_MESSAGE="Task mode cannot wait for follow-up input (`next: null`).";async function turnWorkflow(e){"use workflow";let n=migrateTurnWorkflowInput(e);return n.driverCapabilities?.turnInbox===!0?runTurnOwnedWorkflow(n):runLegacyTurnWorkflow(n)}async function runTurnOwnedWorkflow(t){let i=createHook({token:`${t.completionToken}:inbox`}),a=i[Symbol.asyncIterator](),o=new TurnExecutionCursor({controlToken:t.completionToken,parentWritable:t.stepInput.parentWritable,serializedContext:t.stepInput.serializedContext,sessionState:t.stepInput.sessionState}),l=0,nextDeliveryRequestId=()=>`${i.token}:delivery:${String(l++)}`,m=[],h=t.stepInput.input,g=!1,_;try{try{await claimHookOwnership(i),g=!0}catch(e){if(isHookConflictError(e))return;throw e}for(t.driverCapabilities?.cancelledTurnSettle===!0&&(_=await createTurnCancellationControl({controlToken:t.completionToken,expectedTurnId:activeTurnId(t.stepInput.sessionState.emissionState)}));;){let s={serializedContext:o.serializedContext,sessionState:o.sessionState},l=await turnStep(o.createStepInput(h,_?.signal)),u=l.action===`dispatch-workflow-runtime-actions`||l.action===`park`?l.pendingRuntimeActionKeys:void 0,d=(l.backgroundTasks?.length??0)>0;if(d){if(l.backgroundTaskState===void 0)throw Error(`Background tasks were returned without their committed session state.`);await o.adopt({serializedContext:s.serializedContext,sessionState:l.backgroundTaskState}),await acknowledgeDelegatedTasksStep({tasks:l.backgroundTasks??[]})}if(l.action===`cancelled`){await o.adopt({serializedContext:l.serializedContext,sessionState:l.backgroundTaskState??l.sessionState}),await finishCancelledTurn({bufferedDeliveries:m,cancellation:_,cursor:o});return}if(_?.signal.aborted===!0&&(u===void 0||d)){await o.adopt({serializedContext:preserveSerializedSessionDynamicModelSelection(s.serializedContext,l.serializedContext),sessionState:o.sessionState}),await finishCancelledTurn({bufferedDeliveries:m,cancellation:_,cursor:o});return}if(l.sleepDurationMs!==void 0&&await waitForTurnSleep(l.sleepDurationMs,_)===`cancel`){await finishCancelledTurn({bufferedDeliveries:m,cancellation:_,cursor:o});return}if(l.action===`done`){await _?.dispose(),await o.finish(l,{kind:`done`,output:l.output??``,isError:l.isError,usage:l.usage,usageDelta:l.usageDelta},m);return}if(u!==void 0){await o.adopt(l);let t=l.action===`park`&&l.tasksEnabled,s;s=l.action===`dispatch-workflow-runtime-actions`?dispatchWorkflowRuntimeActionsStep:t?dispatchTaskStep:dispatchRuntimeActionsStep;let d=await s({callbackBaseUrl:resolveWorkflowCallbackBaseUrl(getWorkflowMetadata().url),parentContinuationToken:i.token,parentWritable:o.parentWritable,serializedContext:o.serializedContext,sessionState:o.sessionState}),f=d.results.length===0?void 0:Date.now();await o.adopt(d),await acknowledgeDelegatedTasksStep({tasks:d.pendingTasks});let p=await waitForRuntimeActionResults({bufferedDeliveries:m,cancellation:_,cursor:o,inboxToken:i.token,initialAcceptedAtMs:f,initialResults:d.results,iterator:a,nextDeliveryRequestId,pendingActionKeys:u});if(p===`cancelled`){h=void 0;continue}if(p===`cancel-turn`){await finishCancelledTurn({bufferedDeliveries:m,cancellation:_,cursor:o});return}h={kind:`runtime-action-result`,...p};continue}if(l.action===`park`){if(!(l.hasPendingAuthorization||l.hasPendingInputBatch&&t.capabilities?.requestInput===!0||t.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);await _?.dispose(),await o.finish(l,{authorizationAttemptIds:l.authorizationAttemptIds,authorizationNames:l.authorizationNames,kind:`park`,settled:l.settled},m);return}await o.adopt(l),h=void 0}}catch(e){throw await o.send({error:normalizeSerializableError(e),kind:`turn-error`}),e}finally{_!==void 0&&await _.dispose(),g&&await disposeHook(i)}}async function finishCancelledTurn(e){await cancelDescendantTurnsStep({serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState}),await e.cancellation?.dispose(),await e.cursor.finish({sessionState:e.cursor.sessionState},{cancelled:!0,kind:`park`},e.bufferedDeliveries)}async function waitForTurnSleep(e,t){if(t?.signal.aborted===!0)return`cancel`;let n=sleep(e).then(()=>`slept`);return t===void 0?n:Promise.race([n,t.requested])}async function waitForRuntimeActionResults(e){let t,n=[...e.initialResults],r=new Map;if(e.initialAcceptedAtMs!==void 0)for(let t of e.initialResults)r.set(getRuntimeActionResultKey(t),e.initialAcceptedAtMs);for(;;){let s=resolveRuntimeActionResultsForKeys({pendingKeys:e.pendingActionKeys,results:n});if(s!==void 0)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),{acceptedAtMsByCallId:Object.fromEntries(s.map(e=>[e.callId,r.get(getRuntimeActionResultKey(e))])),results:s};e.cursor.sessionState.hasProxyInputRequests&&t===void 0&&(t=e.nextDeliveryRequestId(),await e.cursor.send({continuationToken:e.cursor.sessionState.continuationToken,inboxToken:e.inboxToken,kind:`turn-delivery-request`,requestId:t}));let c=e.iterator.next();c.catch(()=>{});let l=await(e.cancellation===void 0?c:Promise.race([c,e.cancellation.requested]));if(l===`cancel`)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),`cancelled`;if(l.done)throw Error(`Turn inbox closed before runtime actions completed.`);let u=l.value;if(u.kind===`runtime-action-result`){let t=e.cursor.sessionState.snapshot?.session.state,i=u.results.filter(e=>isInboxSubagentResultFromRunningHandle(t,e));if(i.length>0){let e=Date.now();n.push(...i);for(let t of i)r.set(getRuntimeActionResultKey(t),e)}continue}if(u.kind===`subagent-input-request`||u.kind===`subagent-authorization-event`){let t=await runProxySubagentEventStep({hookPayload:u,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});await e.cursor.adopt(t);continue}if(u.kind===`driver-delivery`&&u.requestId===t){await e.cursor.send({kind:`turn-delivery-accepted`,requestId:u.requestId}),t=void 0;let n=await routeDeliverToChildren({delivery:u.delivery,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});if(await e.cursor.adopt({serializedContext:n.serializedContext??e.cursor.serializedContext,sessionState:n.sessionState??e.cursor.sessionState}),n.kind===`cancel-turn`)return n.kind;n.remainder!==void 0&&e.bufferedDeliveries.push(n.remainder)}}}async function runLegacyTurnWorkflow(e){let t=e.stepInput;try{for(;;){let n=await turnStep(t);if(n.action!==`cancelled`&&n.sleepDurationMs!==void 0&&await sleep(n.sleepDurationMs),n.action===`done`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`done`,output:n.output??``,isError:n.isError,serializedContext:n.serializedContext,sessionState:n.sessionState,usage:n.usage,usageDelta:n.usageDelta},kind:`turn-result`}});return}if(n.action===`dispatch-workflow-runtime-actions`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`dispatch-workflow-runtime-actions`,pendingActionKeys:n.pendingRuntimeActionKeys,serializedContext:n.serializedContext,sessionState:n.sessionState},kind:`turn-result`}});return}if(n.action===`park`){let t=n.pendingRuntimeActionKeys;if(!(t!==void 0||n.hasPendingAuthorization||n.hasPendingInputBatch&&e.capabilities?.requestInput===!0||e.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);let r=t===void 0?{kind:`park`,serializedContext:n.serializedContext,sessionState:n.sessionState,authorizationAttemptIds:n.authorizationAttemptIds,authorizationNames:n.authorizationNames,settled:n.settled}:{kind:`dispatch-runtime-actions`,pendingActionKeys:t,serializedContext:n.serializedContext,sessionState:n.sessionState};await sendTurnControlStep({controlToken:e.completionToken,payload:{action:r,kind:`turn-result`}});return}t={input:void 0,parentWritable:t.parentWritable,serializedContext:n.serializedContext,sessionState:n.sessionState}}}catch(t){throw await sendTurnControlStep({controlToken:e.completionToken,payload:{error:normalizeSerializableError(t),kind:`turn-error`}}),t}}export{turnWorkflow};
+import{createHook,getWorkflowMetadata,sleep}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook,isHookConflictError}from"#execution/hook-ownership.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{migrateTurnWorkflowInput}from"#execution/durable-session-migrations/turn-workflow.js";import{dispatchRuntimeActionsStep}from"#execution/dispatch-runtime-actions-step.js";import{dispatchTaskStep}from"#execution/tasks/parent/dispatch-task-step.js";import{activeTurnId}from"#harness/active-turn-id.js";import{routeDeliverToChildren}from"#execution/route-child-delivery.js";import{getRuntimeActionResultKey}from"#runtime/actions/keys.js";import{runProxySubagentEventStep}from"#execution/subagent-event-proxy-step.js";import{acknowledgeDelegatedTasksStep}from"#execution/tasks/parent/delegate.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{sendTurnControlStep}from"#execution/turn-control-protocol.js";import{isInboxSubagentResultFromRunningHandle}from"#harness/handles/query.js";import{preserveSerializedSessionDynamicModelSelection}from"#context/serialized-dynamic-model-selection.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{dispatchWorkflowRuntimeActionsStep}from"#execution/dispatch-workflow-runtime-actions-step.js";import{createTurnCancellationControl}from"#execution/turn-cancellation-control.js";import{TurnExecutionCursor}from"#execution/turn-execution-cursor.js";import{turnStep}from"#execution/workflow-steps.js";import{resolveRuntimeActionResultsForKeys}from"#runtime/actions/results.js";const TASK_MODE_WAIT_ERROR_MESSAGE="Task mode cannot wait for follow-up input (`next: null`).";async function turnWorkflow(e){"use workflow";let t=migrateTurnWorkflowInput(e);return t.driverCapabilities?.turnInbox===!0?runTurnOwnedWorkflow(t):runLegacyTurnWorkflow(t)}async function runTurnOwnedWorkflow(n){let s=createHook({token:`${n.completionToken}:inbox`}),l=s[Symbol.asyncIterator](),u=new TurnExecutionCursor({controlToken:n.completionToken,parentWritable:n.stepInput.parentWritable,serializedContext:n.stepInput.serializedContext,sessionState:n.stepInput.sessionState}),d=0,nextDeliveryRequestId=()=>`${s.token}:delivery:${String(d++)}`,f=[],p=n.stepInput.input,m=!1,h;try{try{await claimHookOwnership(s),m=!0}catch(e){if(isHookConflictError(e))return;throw e}for(n.driverCapabilities?.cancelledTurnSettle===!0&&(h=await createTurnCancellationControl({controlToken:n.completionToken,expectedTurnId:activeTurnId(n.stepInput.sessionState.emissionState)}));;){let e={serializedContext:u.serializedContext,sessionState:u.sessionState},r=await turnStep(u.createStepInput(p,h?.signal)),i=r.action===`dispatch-workflow-runtime-actions`||r.action===`park`?r.pendingRuntimeActionKeys:void 0,a=(r.backgroundTasks?.length??0)>0;if(a){if(r.backgroundTaskState===void 0)throw Error(`Background tasks were returned without their committed session state.`);await u.adopt({serializedContext:e.serializedContext,sessionState:r.backgroundTaskState}),await acknowledgeDelegatedTasksStep({tasks:r.backgroundTasks??[]})}if(r.action===`cancelled`){await u.adopt({serializedContext:r.serializedContext,sessionState:r.backgroundTaskState??r.sessionState}),await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}if(h?.signal.aborted===!0&&(i===void 0||a)){await u.adopt({serializedContext:preserveSerializedSessionDynamicModelSelection(e.serializedContext,r.serializedContext),sessionState:u.sessionState}),await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}if(r.sleepDurationMs!==void 0&&await waitForTurnSleep(r.sleepDurationMs,h)===`cancel`){await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}if(r.action===`done`){await h?.dispose(),await u.finish(r,{kind:`done`,output:r.output??``,isError:r.isError,usage:r.usage,usageDelta:r.usageDelta},f);return}if(i!==void 0){await u.adopt(r);let e=r.action===`park`&&r.tasksEnabled,n;n=r.action===`dispatch-workflow-runtime-actions`?dispatchWorkflowRuntimeActionsStep:e?dispatchTaskStep:dispatchRuntimeActionsStep;let a=await n({callbackBaseUrl:resolveWorkflowCallbackBaseUrl(getWorkflowMetadata().url),parentContinuationToken:s.token,parentWritable:u.parentWritable,serializedContext:u.serializedContext,sessionState:u.sessionState}),c=a.results.length===0?void 0:Date.now();await u.adopt(a),await acknowledgeDelegatedTasksStep({tasks:a.pendingTasks});let d=await waitForRuntimeActionResults({bufferedDeliveries:f,cancellation:h,cursor:u,inboxToken:s.token,initialAcceptedAtMs:c,initialResults:a.results,iterator:l,nextDeliveryRequestId,pendingActionKeys:i});if(d===`cancelled`){p=void 0;continue}if(d===`cancel-turn`){await finishCancelledTurn({bufferedDeliveries:f,cancellation:h,cursor:u});return}p={kind:`runtime-action-result`,...d};continue}if(r.action===`park`){if(!(r.hasPendingAuthorization||r.hasPendingInputBatch&&n.capabilities?.requestInput===!0||n.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);await h?.dispose(),await u.finish(r,{authorizationAttemptIds:r.authorizationAttemptIds,authorizationNames:r.authorizationNames,kind:`park`,settled:r.settled},f);return}await u.adopt(r),p=void 0}}catch(e){throw await u.send({error:normalizeSerializableError(e),kind:`turn-error`}),e}finally{h!==void 0&&await h.dispose(),m&&await disposeHook(s)}}async function finishCancelledTurn(e){await cancelDescendantTurnsStep({serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState}),await e.cancellation?.dispose(),await e.cursor.finish({sessionState:e.cursor.sessionState},{cancelled:!0,kind:`park`},e.bufferedDeliveries)}async function waitForTurnSleep(e,t){if(t?.signal.aborted===!0)return`cancel`;let r=sleep(e).then(()=>`slept`);return t===void 0?r:Promise.race([r,t.requested])}async function waitForRuntimeActionResults(e){let t,n=[...e.initialResults],r=new Map;if(e.initialAcceptedAtMs!==void 0)for(let t of e.initialResults)r.set(getRuntimeActionResultKey(t),e.initialAcceptedAtMs);for(;;){let i=resolveRuntimeActionResultsForKeys({pendingKeys:e.pendingActionKeys,results:n});if(i!==void 0)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),{acceptedAtMsByCallId:Object.fromEntries(i.map(e=>[e.callId,r.get(getRuntimeActionResultKey(e))])),results:i};e.cursor.sessionState.hasProxyInputRequests&&t===void 0&&(t=e.nextDeliveryRequestId(),await e.cursor.send({continuationToken:e.cursor.sessionState.continuationToken,inboxToken:e.inboxToken,kind:`turn-delivery-request`,requestId:t}));let a=e.iterator.next();a.catch(()=>{});let o=await(e.cancellation===void 0?a:Promise.race([a,e.cancellation.requested]));if(o===`cancel`)return t!==void 0&&await e.cursor.send({kind:`turn-delivery-cancelled`,requestId:t}),`cancelled`;if(o.done)throw Error(`Turn inbox closed before runtime actions completed.`);let s=o.value;if(s.kind===`runtime-action-result`){let t=e.cursor.sessionState.snapshot?.session.state,i=s.results.filter(e=>isInboxSubagentResultFromRunningHandle(t,e));if(i.length>0){let e=Date.now();n.push(...i);for(let t of i)r.set(getRuntimeActionResultKey(t),e)}continue}if(s.kind===`subagent-input-request`||s.kind===`subagent-authorization-event`){let t=await runProxySubagentEventStep({hookPayload:s,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});await e.cursor.adopt(t);continue}if(s.kind===`driver-delivery`&&s.requestId===t){await e.cursor.send({kind:`turn-delivery-accepted`,requestId:s.requestId}),t=void 0;let n=await routeDeliverToChildren({delivery:s.delivery,parentWritable:e.cursor.parentWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState});if(await e.cursor.adopt({serializedContext:n.serializedContext??e.cursor.serializedContext,sessionState:n.sessionState??e.cursor.sessionState}),n.kind===`cancel-turn`)return n.kind;n.remainder!==void 0&&e.bufferedDeliveries.push(n.remainder)}}}async function runLegacyTurnWorkflow(e){let t=e.stepInput;try{for(;;){let r=await turnStep(t);if(r.action!==`cancelled`&&r.sleepDurationMs!==void 0&&await sleep(r.sleepDurationMs),r.action===`done`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`done`,output:r.output??``,isError:r.isError,serializedContext:r.serializedContext,sessionState:r.sessionState,usage:r.usage,usageDelta:r.usageDelta},kind:`turn-result`}});return}if(r.action===`dispatch-workflow-runtime-actions`){await sendTurnControlStep({controlToken:e.completionToken,payload:{action:{kind:`dispatch-workflow-runtime-actions`,pendingActionKeys:r.pendingRuntimeActionKeys,serializedContext:r.serializedContext,sessionState:r.sessionState},kind:`turn-result`}});return}if(r.action===`park`){let t=r.pendingRuntimeActionKeys;if(!(t!==void 0||r.hasPendingAuthorization||r.hasPendingInputBatch&&e.capabilities?.requestInput===!0||e.mode===`conversation`))throw Error(TASK_MODE_WAIT_ERROR_MESSAGE);let n=t===void 0?{kind:`park`,serializedContext:r.serializedContext,sessionState:r.sessionState,authorizationAttemptIds:r.authorizationAttemptIds,authorizationNames:r.authorizationNames,settled:r.settled}:{kind:`dispatch-runtime-actions`,pendingActionKeys:t,serializedContext:r.serializedContext,sessionState:r.sessionState};await sendTurnControlStep({controlToken:e.completionToken,payload:{action:n,kind:`turn-result`}});return}t={input:void 0,parentWritable:t.parentWritable,serializedContext:r.serializedContext,sessionState:r.sessionState}}}catch(t){throw await sendTurnControlStep({controlToken:e.completionToken,payload:{error:normalizeSerializableError(t),kind:`turn-error`}}),t}}export{turnWorkflow};

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};