eve 0.67.2 → 0.69.0

package/dist/src/subagents/handles/store.js

@@ -1 +0,0 @@
-import{AGENT_HANDLES_STATE_KEY}from"./state-key.js";import{z}from"#compiled/zod/index.js";const EMPTY_AGENT_HANDLE_STORE={handles:[]},nonEmptyString=z.string().min(1),identitySchema=z.looseObject({id:nonEmptyString,name:nonEmptyString,nodeId:nonEmptyString}),startOperationSchema=z.looseObject({callId:nonEmptyString,id:nonEmptyString,kind:z.literal(`start`),parentTurnId:nonEmptyString}),continueOperationSchema=z.looseObject({callId:nonEmptyString,id:nonEmptyString,kind:z.literal(`continue`),parentTurnId:nonEmptyString,previousStatus:z.string().max(120)}),startTargetSchema=z.discriminatedUnion(`kind`,[z.looseObject({continuationToken:nonEmptyString,kind:z.literal(`agent/local`)}),z.looseObject({continuationToken:nonEmptyString,kind:z.literal(`agent/self`)}),z.looseObject({callbackBaseUrl:z.url(),credentialResolver:z.looseObject({resolverId:nonEmptyString.optional()}).optional(),kind:z.literal(`agent/remote`),url:z.url()})]),addressSchema=z.discriminatedUnion(`kind`,[z.looseObject({continuationToken:nonEmptyString,kind:z.literal(`agent/local`),sessionId:nonEmptyString}),z.looseObject({continuationToken:nonEmptyString,kind:z.literal(`agent/self`),sessionId:nonEmptyString}),z.looseObject({callbackBaseUrl:z.url(),credentialResolver:z.looseObject({resolverId:nonEmptyString.optional()}).optional(),kind:z.literal(`agent/remote`),sessionId:nonEmptyString,url:z.url()})]),agentHandleStoreCommandSchema=z.discriminatedUnion(`kind`,[z.strictObject({kind:z.literal(`read`)}),z.strictObject({identity:identitySchema,callId:nonEmptyString.optional(),kind:z.literal(`reserve`),operationId:nonEmptyString,ownerId:nonEmptyString}),z.strictObject({address:addressSchema,kind:z.literal(`confirm`),operationId:nonEmptyString,ownerId:nonEmptyString}),z.strictObject({agentId:nonEmptyString,callId:nonEmptyString.optional(),expectedTarget:z.enum([`local`,`remote`]),invokedName:nonEmptyString,kind:z.literal(`claim`),operationId:nonEmptyString,ownerId:nonEmptyString}),z.strictObject({agentId:nonEmptyString,kind:z.literal(`remove`),ownerId:nonEmptyString}),z.strictObject({kind:z.literal(`release-owner`),ownerId:nonEmptyString})]),turnOwnedAgentHandleSchema=z.discriminatedUnion(`phase`,[z.looseObject({identity:identitySchema,operation:startOperationSchema,phase:z.literal(`starting`),target:startTargetSchema}),z.looseObject({address:addressSchema,identity:identitySchema,operation:z.discriminatedUnion(`kind`,[startOperationSchema,continueOperationSchema]),phase:z.literal(`running`)}),z.looseObject({address:addressSchema,identity:identitySchema,lastStatus:z.string().max(120),phase:z.literal(`parked`)})]),taskOwnedAgentHandleSchema=z.discriminatedUnion(`phase`,[z.looseObject({callId:nonEmptyString.optional(),identity:identitySchema,operationId:nonEmptyString,phase:z.literal(`reserved`),ownerId:nonEmptyString}),z.looseObject({address:addressSchema,callId:nonEmptyString.optional(),identity:identitySchema,operationId:nonEmptyString,phase:z.literal(`claimed`),ownerId:nonEmptyString}),z.looseObject({address:addressSchema,identity:identitySchema,phase:z.literal(`available`)})]),agentHandleSchema=z.union([turnOwnedAgentHandleSchema,taskOwnedAgentHandleSchema]),agentHandleStoreSchema=z.looseObject({handles:z.array(agentHandleSchema)}).refine(e=>new Set(e.handles.map(e=>e.identity.id)).size===e.handles.length,{message:`Agent handle ids must be unique.`});function deriveAgentId(e,t){return`ag_${e}:${t.slice(0,12)}`}function formatAgentStatus(e){return(typeof e==`string`?e:JSON.stringify(e)??``).replaceAll(/\s+/g,` `).trim().slice(0,120)}function assertPersistableAgentHandleStore(e){let t=agentHandleStoreSchema.safeParse(e);if(!t.success)throw Error(`Refusing to persist a corrupt agent handle store: ${t.error.message}`);return t.data}function parseAgentHandleStoreCommand(e){let t=agentHandleStoreCommandSchema.safeParse(e);return t.success?t.data:void 0}function getAgentHandleStore(e){let t=e?.[AGENT_HANDLES_STATE_KEY];if(t===void 0)return;let n=agentHandleStoreSchema.safeParse(t);if(!n.success)throw Error(`Corrupt agent handle store under session state key "${AGENT_HANDLES_STATE_KEY}": ${n.error.message}`);return n.data}function setAgentHandleStore(e,t){return{...e,[AGENT_HANDLES_STATE_KEY]:assertPersistableAgentHandleStore(t)}}function writeHandles(e,t){return{...e,state:setAgentHandleStore(e.state,{handles:t})}}export{AGENT_HANDLES_STATE_KEY,EMPTY_AGENT_HANDLE_STORE,assertPersistableAgentHandleStore,deriveAgentId,formatAgentStatus,getAgentHandleStore,parseAgentHandleStoreCommand,setAgentHandleStore,writeHandles};

package/dist/src/subagents/handles/transitions.d.ts

@@ -1,103 +0,0 @@
-import { type AgentAddress, type AgentHandleStore, type AgentHandleStoreCommand, type AgentHandleStoreCommandResult, type AgentIdentity, type StartOperation, type TurnOwnedAgentHandle } from "#subagents/handles/store.js";
-import type { HarnessSession, SessionStateMap } from "#harness/types.js";
-import type { AgentTurnOutcome } from "#shared/agent-turn-outcome.js";
-/**
- * Records intent to start a fresh child. Must be applied to the step's
- * working snapshot before the start side effect runs, so the returned state
- * owns any child the step may have created.
- *
- * The guarantee is intra-step, not exactly-once: the prepared handle
- * durably commits only when the enclosing dispatch step's result commits.
- * A crash between an accepted start and that commit replays the step from
- * the pre-step snapshot and re-runs the side effect.
- *
- * Throws when the identity or operation already exists: fresh starts mint
- * a new identity, so a collision means corrupted derivation, not a replay.
- */
-export declare function prepareAgentStart(session: HarnessSession, input: {
-    readonly identity: AgentIdentity;
-    readonly operation: StartOperation;
-    readonly target: AgentStartTargetInput;
-}): HarnessSession;
-type AgentStartTargetInput = Extract<TurnOwnedAgentHandle, {
-    phase: "starting";
-}>["target"];
-/**
- * Confirms a started child: `starting` becomes `running` with the child's
- * confirmed address. Throws when no starting handle carries the operation,
- * because confirming an unprepared start means ownership was never
- * committed. Re-confirming an already-running handle with the same
- * operation and address is a replay no-op.
- */
-export declare function confirmAgentStarted(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly address: AgentAddress;
-}): HarnessSession;
-/**
- * Resolves a dispatch that definitively failed.
- *
- * - A dead start or dead continuation deletes the handle: there is no
- *   child left to own.
- * - A retryable continuation failure restores `parked` with the status the
- *   handle showed before the delivery, so the model may retry the same
- *   `agentId` later.
- *
- * Unknown operations are a no-op: the failure raced a settlement that
- * already resolved the handle.
- */
-export declare function rejectAgentEffect(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly disposition: "dead" | "retryable";
-}): HarnessSession;
-/**
- * Parks every running child when the parent abandons a cancelled turn.
- *
- * Cancellation requests each running descendant's cancellation and then
- * tears down the turn inbox — the only hook a child settlement can
- * resume — so no later settlement can move these handles. Without this
- * transition they would stay `running` forever: invisible to the model,
- * unresumable, and retried by every future cancellation.
- *
- * A cancelled child settles its own turn as a park, so `parked` with
- * `"(cancelled)"` mirrors {@link settleAgentTurn}'s cancelled outcome. If
- * the child instead died, a later continuation attempt discovers the dead
- * session and {@link rejectAgentEffect} deletes the handle.
- */
-export declare function abandonRunningAgentTurns(session: HarnessSession): HarnessSession;
-/** Result of applying a settled child turn to the store. */
-export type SettleAgentTurnResult = {
-    readonly kind: "settled";
-    readonly session: HarnessSession;
-} | {
-    readonly kind: "ignored";
-    readonly reason: "unknown-operation";
-};
-/**
- * Applies one settled child turn: `running` becomes `parked` for a parked
- * outcome or is deleted for a terminal outcome.
- *
- * The settlement must carry the operation currently recorded on the
- * running handle; anything else is ignored so a stale delivery can never
- * move a newer turn.
- */
-export declare function settleAgentTurn(session: HarnessSession, input: {
-    readonly operationId: string;
-    readonly outcome: AgentTurnOutcome;
-}): SettleAgentTurnResult;
-/** Applies one atomic owner lease command to the shared agent handle store. */
-export declare function applyAgentHandleStoreCommand(store: AgentHandleStore, command: AgentHandleStoreCommand): {
-    readonly result: AgentHandleStoreCommandResult;
-    readonly store: AgentHandleStore;
-};
-/** Parks child turns still owned by workflow runs when their parent turn is cancelled. */
-export declare function abandonAgentInvocationOwners<Session extends {
-    readonly state?: SessionStateMap;
-}>(session: Session, ownerIds: ReadonlySet<string>): Session;
-/** Applies one owner-scoped handle transition to a harness session. */
-export declare function applyTaskAgentHandleCommand<Session extends {
-    readonly state?: SessionStateMap;
-}>(session: Session, command: AgentHandleStoreCommand): {
-    readonly result: AgentHandleStoreCommandResult;
-    readonly session: Session;
-};
-export {};

package/dist/src/subagents/handles/transitions.js

@@ -1 +0,0 @@
-import{EMPTY_AGENT_HANDLE_STORE,formatAgentStatus,getAgentHandleStore,writeHandles}from"#subagents/handles/store.js";function prepareAgentStart(e,t){let n=getAgentHandleStore(e.state)?.handles??[];if(n.some(e=>e.identity.id===t.identity.id))throw Error(`Agent handle "${t.identity.id}" already exists.`);return writeHandles(e,[...n,{identity:t.identity,operation:t.operation,phase:`starting`,target:t.target}])}function findActiveHandle(e,t){return e.find(e=>(e.phase===`starting`||e.phase===`running`)&&e.operation.id===t)}function confirmAgentStarted(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=findActiveHandle(n,t.operationId);if(r===void 0)throw Error(`No prepared agent handle for operation "${t.operationId}".`);return r.phase===`running`?e:writeHandles(e,n.map(e=>e===r?{address:t.address,identity:r.identity,operation:r.operation,phase:`running`}:e))}function rejectAgentEffect(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=findActiveHandle(n,t.operationId);if(r===void 0)return e;if(t.disposition===`retryable`&&r.phase===`running`){let{operation:t}=r;if(t.kind===`continue`)return writeHandles(e,n.map(e=>e===r?{address:r.address,identity:r.identity,lastStatus:t.previousStatus,phase:`parked`}:e))}return writeHandles(e,n.filter(e=>e!==r))}function abandonRunningAgentTurns(e){let t=getAgentHandleStore(e.state)?.handles??[];return t.some(e=>e.phase===`running`)?writeHandles(e,t.map(e=>e.phase===`running`?{address:e.address,identity:e.identity,lastStatus:`(cancelled)`,phase:`parked`}:e)):e}function settleAgentTurn(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=n.find(e=>e.phase===`running`&&e.operation.id===t.operationId);if(r===void 0||r.phase!==`running`)return{kind:`ignored`,reason:`unknown-operation`};if(t.outcome.kind===`terminal`)return{kind:`settled`,session:writeHandles(e,n.filter(e=>e!==r))};let{result:i}=t.outcome,a=i.kind===`succeeded`?formatAgentStatus(i.output):i.kind===`failed`?formatAgentStatus(i.error):`(cancelled)`;return{kind:`settled`,session:writeHandles(e,n.map(e=>e===r?{address:r.address,identity:r.identity,lastStatus:a,phase:`parked`}:e))}}function applyAgentHandleStoreCommand(e,t){switch(t.kind){case`read`:return{result:{kind:`ready`},store:e};case`reserve`:{let n=e.handles.find(e=>e.identity.id===t.identity.id);if(n!==void 0)return(n.phase===`reserved`||n.phase===`claimed`)&&n.operationId===t.operationId&&n.ownerId===t.ownerId?{result:{handle:n,kind:`ready`},store:e}:{result:{handle:n,kind:`busy`},store:e};let r={callId:t.callId,identity:t.identity,operationId:t.operationId,phase:`reserved`,ownerId:t.ownerId};return{result:{handle:r,kind:`ready`},store:{handles:[...e.handles,r]}}}case`confirm`:{let n=e.handles.find(e=>(e.phase===`claimed`||e.phase===`reserved`)&&e.operationId===t.operationId&&e.ownerId===t.ownerId);return n===void 0?{result:{kind:`unknown`},store:e}:n.phase===`claimed`?{result:{handle:n,kind:`ready`},store:e}:replaceHandle(e,n,{address:t.address,callId:n.callId,identity:n.identity,operationId:n.operationId,phase:`claimed`,ownerId:n.ownerId})}case`claim`:{let n=e.handles.find(e=>e.identity.id===t.agentId);return n===void 0?{result:{kind:`unknown`},store:e}:n.phase===`starting`||n.phase===`running`||n.identity.name!==t.invokedName||n.phase!==`reserved`&&n.address.kind===`agent/remote`!=(t.expectedTarget===`remote`)?{result:{handle:n,kind:`mismatch`},store:e}:n.phase===`claimed`?n.operationId===t.operationId&&n.ownerId===t.ownerId?{result:{handle:n,kind:`ready`},store:e}:{result:{handle:n,kind:`busy`},store:e}:n.phase===`reserved`?{result:{handle:n,kind:`busy`},store:e}:replaceHandle(e,n,{address:n.address,callId:t.callId,identity:n.identity,operationId:t.operationId,phase:`claimed`,ownerId:t.ownerId})}case`remove`:{let n=e.handles.find(e=>e.identity.id===t.agentId);return n===void 0?{result:{kind:`ready`},store:e}:n.phase===`claimed`&&n.ownerId!==t.ownerId?{result:{handle:n,kind:`busy`},store:e}:{result:{kind:`ready`},store:{handles:e.handles.filter(e=>e!==n)}}}case`release-owner`:{let n=e.handles.flatMap(e=>e.phase===`reserved`&&e.ownerId===t.ownerId?[]:e.phase!==`claimed`||e.ownerId!==t.ownerId?[e]:[{address:e.address,identity:e.identity,phase:`available`}]);return{result:{kind:`ready`},store:handlesEqual(e.handles,n)?e:{handles:n}}}}}function abandonAgentInvocationOwners(e,t){let n=getAgentHandleStore(e.state)?.handles??[],r=n.flatMap(e=>e.phase===`reserved`&&t.has(e.ownerId)?[]:e.phase!==`claimed`||!t.has(e.ownerId)?[e]:[{address:e.address,identity:e.identity,lastStatus:`(cancelled)`,phase:`parked`}]);return handlesEqual(n,r)?e:writeHandles(e,r)}function applyTaskAgentHandleCommand(e,t){let n=getAgentHandleStore(e.state)??EMPTY_AGENT_HANDLE_STORE,r=applyAgentHandleStoreCommand(n,t);return{result:r.result,session:r.store===n?e:writeHandles(e,r.store.handles)}}function replaceHandle(e,t,n){return{result:{handle:n,kind:`ready`},store:{handles:e.handles.map(e=>e===t?n:e)}}}function handlesEqual(e,t){return e.length===t.length&&e.every((e,n)=>e===t[n])}export{abandonAgentInvocationOwners,abandonRunningAgentTurns,applyAgentHandleStoreCommand,applyTaskAgentHandleCommand,confirmAgentStarted,prepareAgentStart,rejectAgentEffect,settleAgentTurn};

package/dist/src/subagents/remote-dispatch.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{createEveCallbackRoutePath,createEveSessionCancelRoutePath,createEveSessionResetRoutePath,createEveSessionRoutePath}from"#protocol/routes.js";import{decisionToTraceContentCeiling}from"#shared/forwarded-trace-policy.js";import{expectFunction,expectObjectRecord}from"#internal/authored-module.js";import{CancelTurnResponseSchema}from"#protocol/cancel-turn.js";import{ResetResponseSchema}from"#protocol/reset-session.js";import{formatTraceparent,writeAgentDispatchTracestate}from"#protocol/traceparent.js";import{writeForwardedAudienceBaggage,writeForwardedParentSessionBaggage}from"#protocol/baggage.js";import{writeConversationBaggage}from"#tracing/conversation-context.js";import{createWorkflowCallbackUrl}from"#execution/workflow-callback-url.js";import{formatSubagentInput,normalizeRequestedOutputSchema}from"#subagents/invocation.js";import{readTaskIdFromInboxToken}from"#tasks/task-inbox-token.js";import{AgentHandleError}from"#protocol/agent-handle-error.js";import{createRemoteAgentRouteUrl}from"#subagents/remote-route-url.js";const CreateSessionResponseSchema=z.object({ok:z.literal(!0),sessionId:z.string().min(1),status:z.literal(`accepted`)});var RemoteAgentCancelRequestError=class extends Error{retryable;constructor(e,t){super(e),this.name=`RemoteAgentCancelRequestError`,this.retryable=t.retryable}};async function startRemoteAgentSession(e){let t=e.parent?.continuationToken??e.session.continuationToken;if(!t)throw Error(`Cannot dispatch remote agent without a parent continuation token.`);if(!e.callbackBaseUrl)throw Error(`Cannot dispatch remote agent without a callback base URL.`);let n=buildForwardedPrincipalField(e),r={capabilities:{},callback:{callId:e.action.callId,subagentName:e.action.remoteAgentName,taskId:e.taskId??readTaskIdFromInboxToken(t),token:t,url:createWorkflowCallbackUrl(e.callbackBaseUrl,createEveCallbackRoutePath(t))},message:formatRemoteAgentCallInputMessage({action:e.action,remote:e.remote}),outputSchema:normalizeRequestedOutputSchema(e.action.input.outputSchema)};e.activityObserver!==void 0&&(r.activityObserver=e.activityObserver),n!==void 0&&(r.forwardedPrincipal=n),e.operationId!==void 0&&(r.operationId=e.operationId);let i=await resolveRemoteAgentRequestHeaders(e.remote),a=formatTraceparent(e.parent?.traceContext);a!==void 0&&setHeader(i,`traceparent`,a),setHeader(i,`tracestate`,writeAgentDispatchTracestate(readHeader(i,`tracestate`),e.parent?.traceContext));let o=writeForwardedAudienceBaggage(readHeader(i,`baggage`),buildForwardedTraceAssertion({forwardedPrincipal:n,originAudience:e.originAudience,parentTraceContext:e.parent?.traceContext,traceparent:a})),s=writeConversationBaggage(o,e.parent?.conversationId);setHeader(i,`baggage`,writeForwardedParentSessionBaggage(s,e.parent?.lineage));let c=await fetch(createRemoteAgentSessionUrl(e.remote),{body:JSON.stringify(r),headers:{"content-type":`application/json`,...i},method:`POST`});if(!c.ok)throw Error(`Remote agent "${e.action.remoteAgentName}" create-session request failed with HTTP ${c.status}.`);let l;try{l=await c.json()}catch{throw Error(`Remote agent "${e.action.remoteAgentName}" create-session response was not valid JSON.`)}let u=CreateSessionResponseSchema.safeParse(l);if(!u.success)throw Error(`Remote agent "${e.action.remoteAgentName}" create-session response was invalid.`);return{sessionId:u.data.sessionId}}function buildForwardedTraceAssertion(e){let t=decisionToTraceContentCeiling(e.parentTraceContext?.decision);if(e.forwardedPrincipal!==void 0&&e.parentTraceContext!==void 0&&(e.parentTraceContext.traceFlags&1)==1&&e.traceparent!==void 0&&t!==void 0)return{ceiling:t,originAudience:e.originAudience??`unknown`}}async function continueRemoteAgentSession(e){let t=buildForwardedPrincipalField(e),n={activityObserver:e.activityObserver,callback:e.callback,message:e.message,outputSchema:e.outputSchema};t!==void 0&&(n.forwardedPrincipal=t);let r=await fetch(createRemoteAgentContinueUrl(e.remote,e.sessionId),{body:JSON.stringify(n),headers:{"content-type":`application/json`,...await resolveRemoteAgentRequestHeaders(e.remote)},method:`POST`});if(!r.ok){let n=await readRemoteAgentErrorCode(r),i=r.status===404||n===AgentHandleError.SessionNotResumable.code,a=r.status===400&&t!==void 0?` The receiver may support forwarded principals only on session creation; upgrade it before retrying.`:``;throw new RemoteAgentContinueRequestError(`Remote agent "${e.remote.name}" continue-session request failed${i?` permanently`:``} with HTTP ${r.status}.${a}`,{deliveryAmbiguous:isAmbiguousRemoteContinueStatus(r.status),retryable:!i})}}var RemoteAgentContinueRequestError=class extends Error{deliveryAmbiguous;retryable;constructor(e,t){super(e),this.name=`RemoteAgentContinueRequestError`,this.deliveryAmbiguous=t.deliveryAmbiguous,this.retryable=t.retryable}};function isRetryableRemoteAgentContinueError(e){return!(e instanceof RemoteAgentContinueRequestError)||e.retryable}function isAmbiguousRemoteAgentContinueError(e){return!(e instanceof RemoteAgentContinueRequestError)||e.deliveryAmbiguous}function isAmbiguousRemoteContinueStatus(e){return e===408||e===425||e>=500}async function readRemoteAgentErrorCode(e){let t;try{t=await e.json()}catch{return}if(typeof t!=`object`||!t)return;let n=Reflect.get(t,`code`);return typeof n==`string`?n:void 0}function buildForwardedPrincipalField(e){if(e.remote.forwardPrincipal!==!0||e.auth===null||e.auth===void 0)return;let t={current:e.auth};return e.initiatorAuth!==null&&e.initiatorAuth!==void 0&&(t.initiator=e.initiatorAuth),t}async function cancelRemoteAgentTurn(e){let t=e.headers??await resolveRemoteAgentRequestHeaders(e.remote),n=await fetch(createRemoteAgentCancelTurnUrl(e.remote,e.sessionId),{body:e.turnId===void 0&&e.taskId===void 0&&e.tasks===void 0?void 0:JSON.stringify({taskId:e.taskId,tasks:e.tasks,turnId:e.turnId}),headers:t,method:`POST`});if(!n.ok)throw new RemoteAgentCancelRequestError(`Remote agent "${e.remote.name}" cancel-turn request failed with HTTP ${n.status}.`,{retryable:isRetryableRemoteCancelStatus(n.status)});let r;try{r=await n.json()}catch{throw new RemoteAgentCancelRequestError(`Remote agent "${e.remote.name}" cancel-turn response was not valid JSON.`,{retryable:!1})}let i=CancelTurnResponseSchema.safeParse(r);if(!i.success||i.data.status===`accepted`&&i.data.sessionId!==e.sessionId)throw new RemoteAgentCancelRequestError(`Remote agent "${e.remote.name}" cancel-turn response was invalid.`,{retryable:!1});return i.data.status===`accepted`?{sessionId:i.data.sessionId,status:`accepted`}:{status:`no_active_turn`}}function readHeader(e,t){let n=Object.keys(e).find(e=>e.toLowerCase()===t);return n===void 0?void 0:e[n]}function setHeader(e,t,n){for(let n of Object.keys(e))n.toLowerCase()===t&&delete e[n];n!==void 0&&(e[t]=n)}async function resetRemoteAgentSession(e){let t=e.headers??await resolveRemoteAgentRequestHeaders(e.remote),n=await fetch(createRemoteAgentRouteUrl(e.remote.url,createEveSessionResetRoutePath(e.sessionId)),{body:JSON.stringify({reason:`Parent session ended`}),headers:{"content-type":`application/json`,...t},method:`POST`});if(!n.ok)throw Error(`Remote agent "${e.remote.name}" reset-session request failed with HTTP ${n.status}.`);let r=ResetResponseSchema.safeParse(await n.json());if(!r.success||r.data.status===`reset`&&r.data.previousSessionId!==e.sessionId)throw Error(`Remote agent "${e.remote.name}" reset-session response was invalid.`);return r.data}function isRetryableRemoteAgentCancelError(e){return!(e instanceof RemoteAgentCancelRequestError)||e.retryable}function resolveRemoteAgentForAction(e){let t=e.registry.get(e.nodeId)?.definition;if(e.dynamicRemoteAgent!==void 0){if(t===void 0)throw Error(`Missing remote agent "${e.remoteAgentName}" in runtime registry.`);let n=resolveDynamicRemoteAgentCredentials(e.dynamicRemoteAgent),r=e.dynamicRemoteAgent,i={description:r.description,kind:`remote`,logicalPath:t.logicalPath,name:e.remoteAgentName,nodeId:e.nodeId,path:r.path,sourceId:t.sourceId,sourceKind:`module`,url:r.url};return r.forwardPrincipal!==void 0&&(i.forwardPrincipal=r.forwardPrincipal),n.auth!==void 0&&(i.auth=n.auth),n.headers!==void 0&&(i.headers=n.headers),i}if(t?.kind!==`remote`)throw Error(`Missing remote agent "${e.remoteAgentName}" in runtime registry.`);return t}async function resolveRemoteAgentStreamHeaders(e){if(e.resolverId===void 0)return{};let t=new Set([e.bundle.graph.root,...e.bundle.graph.nodesByNodeId.values()]);for(let n of t){let t=n.subagentRegistry.subagentsByNodeId.get(e.resolverId)?.definition;if(t!==void 0){if(t.kind!==`remote`||t.name!==e.name||t.url!==e.url)throw Error(`Remote child stream resolver does not match the authored remote agent.`);return await resolveRemoteAgentRequestHeaders(t)}}return await resolveRemoteAgentRequestHeaders(resolveDynamicRemoteAgentCredentials({credentialsStepId:e.resolverId,description:``,path:``,url:e.url}))}function resolveDynamicRemoteAgentCredentials(e){if(e.credentialsStepId===void 0)return{};let t=getStepRegistry().get(e.credentialsStepId);if(t===void 0)throw Error(`Dynamic remote subagent credentials function "${e.credentialsStepId}" is not registered.`);let n=expectObjectRecord(t(),`Dynamic remote subagent credentials are invalid.`),r={};return n.auth!==void 0&&(r.auth=expectFunction(n.auth,`Dynamic remote subagent auth is invalid.`)),n.headers!==void 0&&(r.headers=resolveDynamicRemoteAgentHeaders(n.headers)),r}function resolveDynamicRemoteAgentHeaders(e){if(typeof e==`function`)return e;let t=expectObjectRecord(e,`Dynamic remote subagent headers are invalid.`);for(let e of Object.values(t))if(typeof e!=`string`)throw Error(`Dynamic remote subagent headers are invalid.`);return t}function getStepRegistry(){let e=Symbol.for(`@workflow/core//registeredSteps`),t=globalThis,n=t[e];return n===void 0&&(n=new Map,t[e]=n),n}function createRemoteAgentSessionUrl(e){return createRemoteAgentRouteUrl(e.url,e.path)}function createRemoteAgentCancelTurnUrl(e,t){return createRemoteAgentRouteUrl(e.url,createEveSessionCancelRoutePath(t))}function createRemoteAgentContinueUrl(e,t){return createRemoteAgentRouteUrl(e.url,createEveSessionRoutePath(t))}function isRetryableRemoteCancelStatus(e){return e===408||e===425||e===429||e>=500}async function resolveRemoteAgentRequestHeaders(e){let t={};return e.headers!==void 0&&Object.assign(t,typeof e.headers==`function`?await e.headers():e.headers),e.auth!==void 0&&Object.assign(t,(await e.auth()).headers),t}function formatRemoteAgentCallInputMessage(e){let t=typeof e.action.input.message==`string`?e.action.input.message:``;return formatSubagentInput({description:e.remote.description,message:t,name:e.action.remoteAgentName,type:`remote`}).message}export{RemoteAgentContinueRequestError,cancelRemoteAgentTurn,continueRemoteAgentSession,isAmbiguousRemoteAgentContinueError,isRetryableRemoteAgentCancelError,isRetryableRemoteAgentContinueError,resetRemoteAgentSession,resolveRemoteAgentForAction,resolveRemoteAgentStreamHeaders,startRemoteAgentSession};

package/dist/src/subagents/start-local.d.ts

@@ -1,29 +0,0 @@
-import type { DispatchOutcome, RuntimeSession } from "#subagents/handle-dispatch.js";
-import type { LocalDevRequestProvenance } from "#context/keys.js";
-import { buildSubagentRunInput, type SubagentInputSource } from "#subagents/tool.js";
-import { createWorkflowRuntime } from "#execution/workflow-runtime.js";
-import type { RuntimeSubagentDispatchRequest } from "#shared/action-types.js";
-import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
-import type { SubagentParentContext } from "#subagents/invocation.js";
-type DynamicSubagentAgentConfig = Parameters<typeof createWorkflowRuntime>[0]["dynamicSubagentAgentConfig"];
-/** Starts one local subagent after dispatch planning has selected its target. */
-export declare function startLocalSubagent(input: {
-    readonly action: RuntimeSubagentDispatchRequest;
-    readonly auth: Parameters<typeof buildSubagentRunInput>[0]["auth"];
-    readonly bundle: CompiledBundle;
-    readonly capabilities: Parameters<typeof buildSubagentRunInput>[0]["capabilities"];
-    readonly channelMetadata: Parameters<typeof buildSubagentRunInput>[0]["channelMetadata"];
-    readonly inheritedConversation?: Parameters<typeof buildSubagentRunInput>[0]["inheritedConversation"];
-    readonly currentSession: RuntimeSession;
-    readonly dynamicSubagentAgentConfig?: DynamicSubagentAgentConfig;
-    readonly fanoutSize: number;
-    readonly initiatorAuth: Parameters<typeof buildSubagentRunInput>[0]["initiatorAuth"];
-    readonly localDevRequest?: LocalDevRequestProvenance;
-    readonly parent: SubagentParentContext;
-    readonly activityObserver?: Parameters<typeof buildSubagentRunInput>[0]["activityObserver"];
-    readonly sandboxSessionId: string;
-    readonly session: RuntimeSession;
-    readonly source: SubagentInputSource;
-    readonly taskId?: string;
-}): Promise<DispatchOutcome>;
-export {};

package/dist/src/subagents/start-local.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{sessionInboxHookToken}from"#execution/session-inbox/address.js";import{ContextContainer,contextStorage}from"#context/container.js";import{toErrorMessage}from"#shared/errors.js";import{createWorkflowRuntime,waitForCommandHookOwner}from"#execution/workflow-runtime.js";import{buildSubagentRunInput}from"#subagents/tool.js";import{SUBAGENT_START_FAILED}from"#subagents/agent-handle-errors.js";const log=createLogger(`execution.subagent-start-local`);async function startLocalSubagent(e){let{action:t,source:n}=e,r=createWorkflowRuntime({compiledArtifactsSource:e.bundle.compiledArtifactsSource,dynamicSubagentAgentConfig:e.dynamicSubagentAgentConfig,nodeId:t.nodeId}),{childContinuationToken:i,runInput:a}=buildSubagentRunInput({action:t,auth:e.auth,capabilities:e.capabilities,channelMetadata:e.channelMetadata,inheritedConversation:e.inheritedConversation,fanoutSize:e.fanoutSize,initiatorAuth:e.initiatorAuth,graph:e.bundle.graph,parent:e.parent,activityObserver:e.activityObserver,sandboxSessionId:e.sandboxSessionId,session:e.session,selfAgent:n.type===`runtime`,source:n,taskId:e.taskId}),o=n.type===`runtime`?`agent/self`:`agent/local`,s;try{await contextStorage.run(new ContextContainer({localDevRequest:e.localDevRequest}),()=>r.createSession(a)),s=(await waitForCommandHookOwner(sessionInboxHookToken(i))).runId}catch(n){return logError(log,`local subagent start failed`,n,{callId:t.callId,nodeId:t.nodeId,subagentName:t.subagentName}),{kind:`error`,result:{callId:t.callId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:SUBAGENT_START_FAILED,message:toErrorMessage(n)},subagentName:t.subagentName},session:e.currentSession}}return{address:{continuationToken:i,kind:o,sessionId:s},callId:t.callId,kind:`called`,name:t.name,session:e.currentSession,toolName:t.subagentName}}export{startLocalSubagent};

package/dist/src/subagents/start-remote.d.ts

@@ -1,21 +0,0 @@
-import type { DispatchOutcome, RuntimeSession } from "#subagents/handle-dispatch.js";
-import { resolveRemoteAgentForAction, startRemoteAgentSession } from "#subagents/remote-dispatch.js";
-import type { RuntimeRemoteAgentDispatchRequest } from "#shared/action-types.js";
-import type { CompiledBundle } from "#runtime/sessions/runtime-context-keys.js";
-import type { SubagentParentContext } from "#subagents/invocation.js";
-/** Starts one remote subagent after dispatch planning has selected its target. */
-export declare function startRemoteSubagent(input: {
-    readonly action: RuntimeRemoteAgentDispatchRequest;
-    readonly auth: Parameters<typeof startRemoteAgentSession>[0]["auth"];
-    readonly bundle: CompiledBundle;
-    readonly callbackBaseUrl: string | undefined;
-    readonly currentSession: RuntimeSession;
-    readonly dynamicRemoteAgent?: NonNullable<Parameters<typeof resolveRemoteAgentForAction>[0]["dynamicRemoteAgent"]>;
-    readonly initiatorAuth: Parameters<typeof startRemoteAgentSession>[0]["initiatorAuth"];
-    readonly parent: SubagentParentContext;
-    readonly activityObserver?: Parameters<typeof startRemoteAgentSession>[0]["activityObserver"];
-    /** Already resolved task-owned work; do not derive another child identity. */
-    readonly taskActivityObserver?: Parameters<typeof startRemoteAgentSession>[0]["activityObserver"];
-    readonly session: RuntimeSession;
-    readonly taskId?: string;
-}): Promise<DispatchOutcome>;

package/dist/src/subagents/start-remote.js

@@ -1 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{resolveRemoteAgentForAction,startRemoteAgentSession}from"#subagents/remote-dispatch.js";import{deriveChildActivityObserverConfig}from"#execution/activity-work.js";import{createRemoteAgentStartFailureResult}from"#execution/dispatch-action-failures.js";import{mintStartOperation}from"#execution/dispatch-start-operation.js";const log=createLogger(`execution.subagent-start-remote`);async function startRemoteSubagent(e){let{action:t}=e,n=e.taskActivityObserver??deriveChildActivityObserverConfig({activityObserver:e.activityObserver,callId:t.callId,kind:`remote-agent`,name:t.remoteAgentName,parentSessionId:e.session.sessionId,parentTurnId:e.parent.lineage.turn.id}),r,i;try{if(e.callbackBaseUrl===void 0)throw Error(`Cannot dispatch remote agent without a callback base URL.`);r=e.callbackBaseUrl,i=resolveRemoteAgentForAction({dynamicRemoteAgent:e.dynamicRemoteAgent,nodeId:t.nodeId,remoteAgentName:t.remoteAgentName,registry:e.bundle.subagentRegistry.subagentsByNodeId})}catch(n){return logError(log,`remote agent start failed`,n,{remoteAgentName:t.remoteAgentName,nodeId:t.nodeId,callId:t.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:t,error:n}),session:e.currentSession}}let{operation:a}=mintStartOperation({callId:t.callId,name:t.remoteAgentName,nodeId:t.nodeId,parentSessionId:e.session.sessionId,parentTurnId:e.parent.lineage.turn.id}),o={resolverId:e.dynamicRemoteAgent===void 0?t.nodeId:e.dynamicRemoteAgent.credentialsStepId};try{let s=await startRemoteAgentSession({action:t,auth:e.auth,callbackBaseUrl:r,originAudience:e.parent.originAudience,initiatorAuth:e.initiatorAuth,operationId:a.id,parent:e.parent,activityObserver:n,remote:i,session:e.session,taskId:e.taskId});return{address:{callbackBaseUrl:r,credentialResolver:o,kind:`agent/remote`,sessionId:s.sessionId,url:i.url},callId:t.callId,kind:`called`,name:t.name,session:e.currentSession,toolName:t.remoteAgentName}}catch(n){return logError(log,`remote agent start failed`,n,{remoteAgentName:t.remoteAgentName,nodeId:t.nodeId,callId:t.callId}),{kind:`error`,result:createRemoteAgentStartFailureResult({action:t,error:n}),session:e.currentSession}}}export{startRemoteSubagent};

package/dist/src/tasks/delivery-context.d.ts

@@ -1,32 +0,0 @@
-import type { TaskDeliveryPolicy, DeliverHookPayload } from "#channel/types.js";
-import type { SessionStateMap, StepInput } from "#harness/types.js";
-export declare const TASK_DELIVERY_CONTEXT_LABEL = "[Task state]";
-export declare const TASK_DELIVERY_INITIATING_INSTRUCTION = "Background task reporting: launch acknowledgement\nThe latest [Task state] message is runtime-authored and lists background tasks accepted so far from the current turn. They continue independently after this turn.\n\nContinue carrying out the user's request, including starting any remaining background work. When no further tool calls are needed in this turn, send one brief user-facing acknowledgement that the background work has started. Do not wait for results or report results that are not available yet. End the turn after the acknowledgement.";
-export declare const TASK_DELIVERY_SETTLED_INSTRUCTION = "Background task reporting\nFor this background-task update, the accompanying [Task state] message is runtime-authored and lists the settled tasks in this cohort and their available terminal outputs. Report their useful results together in one user-facing response without repeating results already reported. Do not reply with <eve-empty-delivery/>.";
-export declare const TASK_DELIVERY_AUTO_INSTRUCTION = "Background task reporting\nFor this background-task update, the accompanying [Task state] message is runtime-authored and lists the whole cohort, including pending tasks and every available terminal output. A received result has not necessarily been reported to the user. Report new results only when they are useful independently of unfinished work. When that work settles, combine its results with any previously withheld results. If there is nothing new and useful to report, reply with exactly <eve-empty-delivery/>. Do not repeat results already reported or send an acknowledgement just to say you are waiting.";
-type BackgroundTaskDelivery = DeliverHookPayload & {
-    readonly taskDeliveryId: string;
-};
-/** Returns task delivery provenance when a child task wakes its parent. */
-export declare function getBackgroundTaskDelivery(input: unknown): BackgroundTaskDelivery | undefined;
-/** Marks a task-produced user message before the harness coalesces delivery results. */
-export declare function markBackgroundTaskStepInput(input: StepInput): StepInput;
-/** Projects the report group without changing the delivered task's activity root. */
-export declare function resolveTaskDeliveryContext(input: {
-    readonly state: SessionStateMap | undefined;
-    readonly taskDeliveryIds: readonly string[];
-    readonly taskDeliveryPolicy: TaskDeliveryPolicy;
-}): {
-    readonly context: string;
-    readonly phase: "pending" | "settled";
-    readonly rootTurnId: string;
-} | undefined;
-/** Returns model context for durable tasks launched by the active parent turn. */
-export declare function resolveInitiatingTaskContext(input: {
-    readonly state: SessionStateMap | undefined;
-    readonly turnId: string;
-}): {
-    readonly context: string;
-    readonly phase: "initiating";
-} | undefined;
-export {};

package/dist/src/tasks/delivery-context.js

@@ -1,4 +0,0 @@
-import{markFrameworkStepInput}from"#harness/messages.js";import{getBackgroundTasks}from"#harness/workflow-tool-runs.js";import{taskIdOfDelivery}from"#tasks/notification.js";import{EMPTY_DELIVERY_SENTINEL}from"#shared/empty-delivery.js";const TASK_DELIVERY_CONTEXT_LABEL=`[Task state]`,TASK_DELIVERY_INITIATING_INSTRUCTION=`Background task reporting: launch acknowledgement
-The latest ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists background tasks accepted so far from the current turn. They continue independently after this turn.
-
-Continue carrying out the user's request, including starting any remaining background work. When no further tool calls are needed in this turn, send one brief user-facing acknowledgement that the background work has started. Do not wait for results or report results that are not available yet. End the turn after the acknowledgement.`,TASK_DELIVERY_SETTLED_INSTRUCTION=`Background task reporting\nFor this background-task update, the accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists the settled tasks in this cohort and their available terminal outputs. Report their useful results together in one user-facing response without repeating results already reported. Do not reply with ${EMPTY_DELIVERY_SENTINEL}.`,TASK_DELIVERY_AUTO_INSTRUCTION=`Background task reporting\nFor this background-task update, the accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists the whole cohort, including pending tasks and every available terminal output. A received result has not necessarily been reported to the user. Report new results only when they are useful independently of unfinished work. When that work settles, combine its results with any previously withheld results. If there is nothing new and useful to report, reply with exactly ${EMPTY_DELIVERY_SENTINEL}. Do not repeat results already reported or send an acknowledgement just to say you are waiting.`;function getBackgroundTaskDelivery(e){if(typeof e!=`object`||!e)return;let t=e;return t.kind===`deliver`&&typeof t.taskDeliveryId==`string`?e:void 0}function markBackgroundTaskStepInput(e){return e.message===void 0?e:markFrameworkStepInput(e,`execution.background_task`)}function resolveTaskDeliveryContext(e){let t=e.taskDeliveryIds[0];if(t===void 0)return;let n=getBackgroundTasks(e.state),r=n.get(taskIdOfDelivery(t));if(r!==void 0)return{...projectTaskCohort(n.query({cohortId:r.cohortId}),e.taskDeliveryPolicy===`auto`),rootTurnId:r.turnId}}function resolveInitiatingTaskContext(e){let t=getBackgroundTasks(e.state);if(t.query({state:`working`,turnId:e.turnId}).length!==0)return{...projectTaskCohort(t.query({turnId:e.turnId}),!1),phase:`initiating`}}function projectTaskCohort(e,t){let n=e.every(e=>e.status!==`working`),r=e.map(e=>({name:e.metadata.name,output:n||t?e.lastOutput:void 0,status:e.status===`working`?`pending`:e.status,taskId:e.taskId}));return{context:`${TASK_DELIVERY_CONTEXT_LABEL}\n${JSON.stringify({tasks:r})}`,phase:n?`settled`:`pending`}}export{TASK_DELIVERY_AUTO_INSTRUCTION,TASK_DELIVERY_CONTEXT_LABEL,TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION,getBackgroundTaskDelivery,markBackgroundTaskStepInput,resolveInitiatingTaskContext,resolveTaskDeliveryContext};

package/dist/src/tasks/delivery-policy.d.ts

@@ -1,14 +0,0 @@
-import type { TaskDeliveryPolicy } from "#channel/types.js";
-export interface DeliveryPolicy {
-    readonly allowsEmptyDelivery: boolean;
-    readonly instruction?: string;
-}
-/** Resolves one policy for both model prompting and empty-response recovery. */
-export declare function resolveDeliveryPolicy(input: {
-    readonly hasOutputSchema: boolean;
-    readonly isChild: boolean;
-    readonly isFirstTurn: boolean;
-    readonly hasScheduleProvenance: boolean;
-    readonly taskDeliveryPolicy: TaskDeliveryPolicy | undefined;
-    readonly taskDeliveryPhase: "none" | "initiating" | "pending" | "settled" | undefined;
-}): DeliveryPolicy;

package/dist/src/tasks/delivery-policy.js

@@ -1 +0,0 @@
-import{TASK_DELIVERY_AUTO_INSTRUCTION,TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION}from"#tasks/delivery-context.js";import{CONDITIONAL_DELIVERY_INSTRUCTION}from"#shared/empty-delivery.js";const POLICIES={auto:{allowsEmptyDelivery:!0,instruction:TASK_DELIVERY_AUTO_INSTRUCTION},conditional:{allowsEmptyDelivery:!0,instruction:CONDITIONAL_DELIVERY_INSTRUCTION},initiating:{allowsEmptyDelivery:!1,instruction:TASK_DELIVERY_INITIATING_INSTRUCTION},normal:{allowsEmptyDelivery:!1},pending:{allowsEmptyDelivery:!0},settled:{allowsEmptyDelivery:!1,instruction:TASK_DELIVERY_SETTLED_INSTRUCTION}};function resolveDeliveryPolicy(e){return e.hasOutputSchema||e.isChild?POLICIES.normal:e.taskDeliveryPolicy===`auto`&&(e.taskDeliveryPhase===`pending`||e.taskDeliveryPhase===`settled`)?POLICIES.auto:e.taskDeliveryPhase===`pending`?POLICIES.pending:e.taskDeliveryPhase===`settled`?POLICIES.settled:e.isFirstTurn&&e.hasScheduleProvenance?POLICIES.conditional:e.taskDeliveryPhase===`initiating`?POLICIES.initiating:POLICIES.normal}export{resolveDeliveryPolicy};

package/dist/src/tasks/json.d.ts

@@ -1,88 +0,0 @@
-import { z } from "#compiled/zod/index.js";
-import type { JsonValue } from "#shared/json.js";
-import type { TaskView } from "#tasks/types.js";
-/** Strict model-visible task projection. */
-declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    status: z.ZodLiteral<"working">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    inputRequests: z.ZodReadonly<z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
-    status: z.ZodLiteral<"input_required">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    lastOutput: z.ZodObject<{
-        data: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
-        type: z.ZodLiteral<"result">;
-    }, z.core.$strip>;
-    status: z.ZodLiteral<"completed">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    lastOutput: z.ZodObject<{
-        data: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
-        type: z.ZodLiteral<"error">;
-    }, z.core.$strip>;
-    status: z.ZodLiteral<"failed">;
-}, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodObject<{
-        agentId: z.ZodOptional<z.ZodString>;
-        kind: z.ZodString;
-        mode: z.ZodOptional<z.ZodEnum<{
-            local: "local";
-            remote: "remote";
-        }>>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    taskId: z.ZodString;
-    status: z.ZodLiteral<"cancelled">;
-}, z.core.$strip>], "status">;
-/**
- * Model-visible task view, inferred from {@link TASK_VIEW_JSON_SCHEMA}.
- *
- * This is the public projection of `TaskView` (#tasks/types.js), not a
- * replacement for it: the durable view additionally carries private
- * `executor` and `usage`, and its module must stay zod-free because it is
- * bundled into workflow bodies.
- */
-type TaskViewJson = z.infer<typeof TASK_VIEW_JSON_SCHEMA>;
-/** Projects a task view into the JSON value carried by tool results. */
-export declare function taskViewToJson(view: TaskView): TaskViewJson;
-/** Projects many views into one `{ tasks }` tool output. */
-export declare function taskViewsToJson(views: readonly TaskView[]): JsonValue;
-export {};

package/dist/src/tasks/json.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import{jsonValueSchema}from"#shared/json-schemas.js";const taskMetadataJsonSchema=z.object({agentId:z.string().optional(),kind:z.string(),mode:z.enum([`local`,`remote`]).optional(),name:z.string()}),taskOutputJsonSchema=z.object({data:jsonValueSchema,type:z.enum([`result`,`error`])}),taskViewJsonBaseShape={metadata:taskMetadataJsonSchema,taskId:z.string()},TASK_VIEW_JSON_SCHEMA=z.discriminatedUnion(`status`,[z.object({...taskViewJsonBaseShape,status:z.literal(`working`)}),z.object({...taskViewJsonBaseShape,inputRequests:z.array(jsonValueSchema).readonly(),status:z.literal(`input_required`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`result`)}),status:z.literal(`completed`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`error`)}),status:z.literal(`failed`)}),z.object({...taskViewJsonBaseShape,status:z.literal(`cancelled`)})]);function taskViewToJson(e){return TASK_VIEW_JSON_SCHEMA.parse(e)}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};

package/dist/src/tasks/notification.d.ts

@@ -1,10 +0,0 @@
-import type { DeliverHookPayload } from "#channel/types.js";
-import type { SessionStateMap } from "#harness/types.js";
-import type { JsonValue } from "#shared/json.js";
-import type { TaskView } from "#tasks/types.js";
-export declare function formatTaskNotification(view: TaskView): string;
-export declare function formatTaskOutput(output: JsonValue): string;
-/** Task delivery ids are `<taskId>` or `<taskId>:<event>`; derived task ids never contain `:`. */
-export declare function taskIdOfDelivery(deliveryId: string): string;
-/** The parent already recorded this task's outcome, so the delivery cannot notify the model again. */
-export declare function hasRecordedTaskOutcome(delivery: DeliverHookPayload, state: SessionStateMap | undefined): boolean;

package/dist/src/tasks/notification.js

@@ -1 +0,0 @@
-import{getBackgroundTasks}from"#harness/workflow-tool-runs.js";function formatTaskNotification(e){let t=`Background task ${e.taskId} (${e.metadata.name})`;return e.status===`input_required`?`${t} needs input.`:e.status===`completed`?`${t} is completed.\n\nResult:\n${formatTaskOutput(e.lastOutput.data)}`:e.status===`failed`?`${t} failed.\n\nError:\n${formatTaskOutput(e.lastOutput.data)}`:`${t} is cancelled.`}function formatTaskOutput(e){return typeof e==`string`?e:JSON.stringify(e)??`null`}function taskIdOfDelivery(e){let t=e.indexOf(`:`);return t<0?e:e.slice(0,t)}function hasRecordedTaskOutcome(e,t){let n=e.taskDeliveryId;if(n===void 0)return!1;let r=getBackgroundTasks(t).get(taskIdOfDelivery(n));return r!==void 0&&r.status!==`working`}export{formatTaskNotification,formatTaskOutput,hasRecordedTaskOutcome,taskIdOfDelivery};

package/dist/src/tasks/task-id.d.ts

@@ -1,31 +0,0 @@
-/**
- * Derives the stable task id for one originating background call.
- *
- * Uses `hash(parentSessionId, parentTurnId, callId)` so replayed creation
- * for the same call yields the same task, and a
- * task can never be confused with a child session id or continuation
- * token.
- *
- * Lives apart from the pure task modules because the derivation needs
- * `node:crypto`, which workflow bodies reject; ids are only ever minted
- * inside dispatch steps.
- */
-export declare function deriveTaskId(input: {
-    readonly callId: string;
-    readonly parentSessionId: string;
-    readonly parentTurnId: string;
-}): string;
-/**
- * Derives the task run's private inbox token.
- *
- * Deterministic on purpose: a durable replay of the dispatch step must
- * re-derive the same token so the duplicate task run loses the hook
- * claim and exits instead of splitting the lifecycle across two runs.
- * Unguessable in practice: the parent session's continuation token is
- * itself a private capability, and the derived token never renders to
- * the model.
- */
-export declare function deriveTaskInboxToken(input: {
-    readonly parentContinuationToken: string;
-    readonly taskId: string;
-}): string;

package/dist/src/tasks/task-id.js

@@ -1 +0,0 @@
-import{createHash}from"node:crypto";function deriveTaskId(e){return`task_${createHash(`sha256`).update(`${e.parentSessionId}\0${e.parentTurnId}\0${e.callId}`).digest(`hex`).slice(0,24)}`}function deriveTaskInboxToken(e){return`task:${e.taskId}:${createHash(`sha256`).update(`${e.taskId}\0${e.parentContinuationToken}`).digest(`hex`).slice(0,32)}`}export{deriveTaskId,deriveTaskInboxToken};

package/dist/src/tasks/task-inbox-token.d.ts

@@ -1,2 +0,0 @@
-/** Reads the non-secret task id embedded in a private task inbox token. */
-export declare function readTaskIdFromInboxToken(token: string): string | undefined;

package/dist/src/tasks/task-inbox-token.js

@@ -1 +0,0 @@
-function readTaskIdFromInboxToken(e){return/^task:(task_[^:]+):[a-f0-9]{32}$/.exec(e)?.[1]}export{readTaskIdFromInboxToken};

package/dist/src/tasks/transitions.d.ts

@@ -1,17 +0,0 @@
-import type { WorkflowToolRunOutcomeMessage } from "#execution/tools/workflow/messages.js";
-import { type TaskCommand, type TaskView } from "#tasks/types.js";
-export type TaskTransitionResult = {
-    readonly action: "accepted";
-    readonly view: TaskView;
-} | {
-    readonly action: "noop";
-    readonly view: TaskView;
-} | {
-    readonly action: "rejected";
-    readonly view: TaskView;
-    readonly reason: string;
-};
-/** Pure transition function for the background invocation view. */
-export declare function applyTaskTransition(view: TaskView, command: TaskCommand | ({
-    readonly kind: "outcome";
-} & WorkflowToolRunOutcomeMessage)): TaskTransitionResult;

package/dist/src/tasks/transitions.js

@@ -1 +0,0 @@
-import{workflowToolRunFailureOutput}from"#execution/tools/workflow/owner-inbox.js";import{isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";function applyTaskTransition(e,t){if(isTerminalTaskStatus(e.status))return t.kind===`cancel`&&e.status===`cancelled`?{action:`noop`,view:e}:{action:`rejected`,reason:`Task "${e.taskId}" is already ${e.status}; "${t.kind}" cannot change a terminal task.`,view:e};let n={metadata:e.metadata,taskId:e.taskId};if(t.kind===`outcome`){let e=t.result;return{action:`accepted`,view:e.status===`completed`?{...n,status:`completed`,lastOutput:{type:`result`,data:e.output}}:e.status===`failed`?{...n,status:`failed`,lastOutput:{type:`error`,data:workflowToolRunFailureOutput(t)}}:{...n,status:`cancelled`}}}switch(t.kind){case`reject-dispatch`:return{action:`accepted`,view:{...n,lastOutput:{data:t.data,type:`error`},status:`failed`}};case`cancel`:return{action:`accepted`,view:t.usage===void 0?{...n,status:`cancelled`}:{...n,status:`cancelled`,usage:t.usage}};case`require-input`:return isValidInputRequestBatch(t.inputRequests)?{action:`accepted`,view:{inputRequests:t.inputRequests,metadata:e.metadata,status:`input_required`,taskId:e.taskId}}:{action:`rejected`,reason:`Task "${e.taskId}" received an invalid input request batch.`,view:e};case`ready`:return{action:`accepted`,view:e};case`answered`:{if(e.status!==`input_required`)return{action:`noop`,view:e};let n=new Set(t.requestIds),r=e.inputRequests.filter(e=>{let t=readTaskInputRequestId(e);return t===void 0||!n.has(t)});return r.length===e.inputRequests.length?{action:`noop`,view:e}:r.length>0?{action:`accepted`,view:{...e,inputRequests:r}}:{action:`accepted`,view:{metadata:e.metadata,status:`working`,taskId:e.taskId}}}}}function isValidInputRequestBatch(e){if(e.length===0)return!1;let t=e.map(readTaskInputRequestId);return t.every(e=>e!==void 0&&e.length>0)&&new Set(t).size===t.length}export{applyTaskTransition};

package/dist/src/tasks/types.d.ts

@@ -1,136 +0,0 @@
-import type { SubagentAuthorizationEvent, SubagentAuthorizationEventHookPayload } from "#channel/types.js";
-import type { WorkflowToolAgentRequest } from "#execution/tools/workflow/messages.js";
-import type { SessionInboxAddress } from "#execution/session-inbox/address.js";
-import { type JsonValue } from "#shared/json.js";
-/** Durable lifecycle status for one unit of background work. */
-export type TaskStatus = "working" | "input_required" | "completed" | "failed" | "cancelled";
-/** Executor-neutral identity shown for one task. */
-export interface TaskMetadata {
-    readonly kind: string;
-    readonly name: string;
-    readonly [key: string]: JsonValue | undefined;
-}
-export declare function sameTaskMetadata(left: TaskMetadata, right: TaskMetadata): boolean;
-export type TaskOutput = {
-    readonly type: "result";
-    readonly data: JsonValue;
-} | {
-    readonly type: "error";
-    readonly data: JsonValue;
-};
-/** An outstanding request carried opaquely by the task lifecycle. */
-export type TaskInputRequest = JsonValue;
-export interface TaskUsage {
-    readonly cacheReadTokens: number;
-    readonly cacheWriteTokens: number;
-    readonly costUsd?: number;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-}
-/** Reads valid provider usage without making task settlement depend on it. */
-export declare function readTaskUsage(value: unknown): TaskUsage | undefined;
-/** Reads the request identity from one opaque request. */
-export declare function readTaskInputRequestId(request: TaskInputRequest): string | undefined;
-interface TaskViewBase {
-    readonly taskId: string;
-    readonly metadata: TaskMetadata;
-    /** Retained for accounting, excluded from model-visible JSON. */
-    readonly usage?: TaskUsage;
-}
-export type TaskView = TaskViewBase & ({
-    readonly status: "working";
-    readonly inputRequests?: never;
-    readonly lastOutput?: never;
-} | {
-    readonly status: "input_required";
-    readonly inputRequests: readonly TaskInputRequest[];
-    readonly lastOutput?: never;
-} | {
-    readonly status: "completed";
-    readonly inputRequests?: never;
-    readonly lastOutput: Extract<TaskOutput, {
-        type: "result";
-    }>;
-} | {
-    readonly status: "failed";
-    readonly inputRequests?: never;
-    readonly lastOutput: Extract<TaskOutput, {
-        type: "error";
-    }>;
-} | {
-    readonly status: "cancelled";
-    readonly inputRequests?: never;
-    readonly lastOutput?: never;
-});
-/** Admission, cancellation, and input state changes for a background invocation. */
-export type TaskCommand = {
-    readonly kind: "reject-dispatch";
-    readonly data: JsonValue;
-} | {
-    readonly kind: "cancel";
-    readonly usage?: TaskUsage;
-} | {
-    readonly kind: "require-input";
-    readonly inputRequests: readonly TaskInputRequest[];
-} | {
-    readonly kind: "ready";
-} | {
-    readonly kind: "answered";
-    readonly requestIds: readonly string[];
-};
-export interface TaskCommandHookPayload {
-    readonly kind: "task-command";
-    readonly command: TaskCommand;
-}
-/** One human answer routed through the task that owns the blocked executor. */
-export interface TaskInboundAnswerInput {
-    readonly auth?: unknown;
-    readonly childContinuationToken: string;
-    readonly childSessionInbox?: SessionInboxAddress;
-    readonly childResponseUrl?: string;
-    readonly inputResponses: readonly {
-        readonly optionId?: string;
-        readonly requestId: string;
-        readonly text?: string;
-    }[];
-    readonly kind: "input-response";
-    readonly taskId: string;
-}
-export type TaskRunInboundPayload = TaskCommandHookPayload | TaskInboundAnswerInput;
-/** Generic task-owned request sent through the parent session payload. */
-interface TaskInputRequestDeliveryBase {
-    readonly replyTo: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId: string;
-    readonly turnId: string;
-}
-export type TaskInputRequestDelivery = TaskInputRequestDeliveryBase & ({
-    readonly request: TaskInputRequest;
-    readonly requests?: never;
-} | {
-    readonly request?: never;
-    readonly requests: readonly TaskInputRequest[];
-});
-/**
- * Child authorization event projected through the parent channel. Display
- * only: the authorization callback completes against the child directly.
- */
-export interface TaskAuthorizationEventDelivery {
-    readonly hookPayload: SubagentAuthorizationEventHookPayload;
-    readonly taskId: string;
-}
-/** Stable id shared by one authorization attempt's events, used to dedupe deliveries. */
-export declare function taskAuthorizationRequestId(event: SubagentAuthorizationEvent): string;
-/**
- * Agent spawn or settlement a task-owned workflow tool run asks its parent to
- * apply, forwarded after task admission. `replyTo` is the run's reply hook.
- */
-export interface TaskAgentRequestDelivery {
-    readonly replyTo: string;
-    readonly request: WorkflowToolAgentRequest;
-    readonly taskId: string;
-}
-export declare function isTerminalTaskStatus(status: TaskStatus): boolean;
-export declare function isReadyTaskStatus(status: TaskStatus): boolean;
-export {};

package/dist/src/tasks/types.js

@@ -1 +0,0 @@
-import{jsonValuesEqual}from"#shared/json.js";function sameTaskMetadata(e,t){return jsonValuesEqual(e,t)}function readTaskUsage(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=readUsageAxis(e,`cacheReadTokens`),n=readUsageAxis(e,`cacheWriteTokens`),r=readUsageAxis(e,`costUsd`),i=readUsageAxis(e,`inputTokens`),a=readUsageAxis(e,`outputTokens`);if(t===void 0||n===void 0||i===void 0||a===void 0)return;let o={cacheReadTokens:t,cacheWriteTokens:n,inputTokens:i,outputTokens:a};return r!==void 0&&(o.costUsd=r),o}function readUsageAxis(e,t){let n=Reflect.get(e,t);return typeof n==`number`&&Number.isFinite(n)&&n>=0?n:void 0}function readTaskInputRequestId(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`requestId`);return typeof t==`string`?t:void 0}const TASK_AUTHORIZATION_REQUEST_ID_PREFIX=`task:authorization`;function taskAuthorizationRequestId(e){return e.type===`approval.candidate`||e.type===`approval.settled`?`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.requestId}`:`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.attemptId??e.data.name}`}function isTerminalTaskStatus(e){return e===`completed`||e===`failed`||e===`cancelled`}function isReadyTaskStatus(e){return e===`input_required`||isTerminalTaskStatus(e)}export{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId,readTaskUsage,sameTaskMetadata,taskAuthorizationRequestId};

package/dist/src/tools/framework/connection-search.d.ts

@@ -1,3 +0,0 @@
-/** Canonical definition for dynamic connection tool discovery. */
-export declare const connectionSearch: import("#dynamic/definition.js").DynamicSentinel<Record<string, object> | null>;
-export default connectionSearch;

package/dist/src/tools/framework/connection-search.js

@@ -1 +0,0 @@
-import{defineDynamic}from"#dynamic/definition.js";import{resolveConnectionSearchDynamicTools}from"#execution/tools/connection-search.js";const connectionSearch=defineDynamic({events:{"step.started":resolveConnectionSearchDynamicTools}});export{connectionSearch,connectionSearch as default};

package/dist/src/tools/framework/task-cancel.d.ts

@@ -1,4 +0,0 @@
-export declare const taskCancel: import("../definition.ts").PublicToolDefinition<{
-    taskIds: string[];
-}, unknown>;
-export default taskCancel;

package/dist/src/tools/framework/task-cancel.js

@@ -1 +0,0 @@
-import{TASK_CANCEL_INPUT_SCHEMA,TASK_VIEWS_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";import{defineNativeTool}from"#tools/native-definition.js";const taskCancel=defineNativeTool({description:`Request cooperative cancellation of one or more background tasks. Cancellation is final: a task that finishes after you cancel it stays cancelled. Cancelling an already-finished task changes nothing.`,inputSchema:TASK_CANCEL_INPUT_SCHEMA,outputSchema:TASK_VIEWS_OUTPUT_SCHEMA},{availability:[`root-session`],handling:{action:`task-cancel`,kind:`dispatch`}});export{taskCancel as default,taskCancel};