eve 0.68.0 → 0.69.0

package/dist/src/execution/session-workflow-tool-run.d.ts

@@ -1,10 +1,19 @@
-import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunAgentStartedMessage, WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
 import type { SessionStateCursor } from "#execution/session/state-cursor.js";
 import type { RuntimeActionResult } from "#shared/action-types.js";
 interface HandlerInput<T> {
-    readonly callbackMetadataUrl: string;
     readonly cursor: SessionStateCursor;
     readonly message: T;
 }
 export declare function handleWorkflowToolRunMessage(input: HandlerInput<WorkflowToolRunMessage>): Promise<RuntimeActionResult | undefined>;
+/** Boundary messages in admission order, with consecutive `agent-started` messages grouped. */
+type BoundaryBatch = {
+    readonly kind: "agent-started";
+    readonly messages: WorkflowToolRunAgentStartedMessage[];
+} | {
+    readonly kind: "message";
+    readonly message: WorkflowToolRunMessage;
+};
+/** Groups consecutive `agent-started` messages so one `emitAgentStartedStep` publishes each group. */
+export declare function batchAgentStarts(messages: readonly WorkflowToolRunMessage[]): BoundaryBatch[];
 export {};

package/dist/src/execution/session-workflow-tool-run.js

@@ -1 +1 @@
-import{findBlockingWorkflowToolRun,isInboxToolResultFromRecordedWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{cancelAgentInvocationOwnerStep}from"#execution/tools/subagent/task-cancel.js";import{runProxySubagentEventStep}from"#subagents/event-proxy-step.js";import{applyTaskAgentRequest}from"#execution/tools/subagent/task-agent-requests.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{deliverWorkflowAuthorization}from"#execution/tools/workflow/owner.js";import{emitWorkflowToolRunReportStep}from"#execution/tools/workflow/emit-workflow-tool-run-report-step.js";import{releaseAgentInvocationOwnerStep}from"#execution/tools/subagent/invoke-step.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{workflowToolRunOutcomeToToolResult,workflowToolRunRequestToInputRequestPayload}from"#execution/tools/workflow/owner-inbox.js";async function handleWorkflowToolRunMessage(e){let{message:t}=e;switch(t.kind){case`outcome`:return await handleWorkflowToolRunOutcome({...e,message:t});case`request`:await handleWorkflowToolRunRequest({...e,message:t});return;case`report`:await emitWorkflowToolRunReportStep({from:t.from,sessionWritable:e.cursor.sessionWritable,update:t.update});return}}async function handleWorkflowToolRunOutcome(e){let{cursor:t,message:n}=e;if(findBlockingWorkflowToolRun(t.sessionState.snapshot.session.state,n.from.callId,n.from.turnId)?.address.runId!==n.from.runId)return;let r=workflowToolRunOutcomeToToolResult(n);await cancelAgentInvocationOwnerStep({ownerId:n.from.runId,serializedContext:t.serializedContext,sessionState:t.sessionState});let i=await releaseAgentInvocationOwnerStep({cancelled:n.result.status===`cancelled`,ownerId:n.from.runId,sessionState:t.sessionState});return await t.apply({serializedContext:t.serializedContext,sessionState:i.sessionState}),isInboxToolResultFromRecordedWorkflowToolRun(t.sessionState.snapshot.session.state,r)?r:void 0}async function handleWorkflowToolRunRequest(e){let{cursor:t,message:n}=e;if(n.request.kind===`agent-invoke`||n.request.kind===`agent-settled`){if(findBlockingWorkflowToolRun(t.sessionState.snapshot.session.state,n.from.callId,n.from.turnId)?.address.runId!==n.from.runId){n.request.kind===`agent-invoke`&&await resumeHookStep(n.replyTo,{kind:`runtime-action-result`,results:[{callId:n.request.invocationId,isError:!0,kind:`subagent-result`,origin:`dispatch`,output:{code:`AGENT_INVOCATION_NOT_ADMITTED`,message:`The workflow tool run no longer owns this agent invocation.`},subagentName:n.request.input.target}]});return}await t.apply(await applyTaskAgentRequest({ownerId:n.from.runId,replyTo:n.replyTo,request:n.request},requestContext(e)));return}if(n.request.kind===`authorization-request`){let e=n.request;await deliverWorkflowAuthorization({...n,request:e},async()=>{await t.apply(await runProxySubagentEventStep({hookPayload:e.event,sessionWritable:t.sessionWritable,serializedContext:t.serializedContext,sessionState:t.sessionState}))});return}await t.apply(await runProxySubagentEventStep({...n.requestCoordinates===void 0?{answerHook:createAnswerHookRoute(n)}:{},hookPayload:workflowToolRunRequestToInputRequestPayload(n),sessionWritable:t.sessionWritable,serializedContext:t.serializedContext,sessionState:t.sessionState}))}function createAnswerHookRoute(e){if(e.request.kind!==`ask`)return{runId:e.from.runId};let{allowFreeform:t,dismissible:n,options:r}=e.request.request;return{question:{...t!==void 0&&{allowFreeform:t},...n!==void 0&&{dismissible:n},...r!==void 0&&{options:[...r]}},runId:e.from.runId}}function requestContext(e){return{callbackBaseUrl:resolveWorkflowCallbackBaseUrl(e.callbackMetadataUrl),sessionWritable:e.cursor.sessionWritable,serializedContext:e.cursor.serializedContext,sessionState:e.cursor.sessionState}}export{handleWorkflowToolRunMessage};
+import{findBlockingWorkflowToolRun,isInboxToolResultFromRecordedWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{emitAgentStartedStep,emitWorkflowToolRunReportStep}from"#execution/tools/workflow/emit-workflow-tool-run-report-step.js";import{deliverWorkflowAuthorization}from"#execution/tools/workflow/owner.js";import{withdrawFinishedRunQuestionsStep,withdrawWorkflowToolRunQuestionStep}from"#execution/tools/workflow/withdraw-step.js";import{workflowToolRunOutcomeToToolResult,workflowToolRunRequestToInputRequestPayload}from"#execution/tools/workflow/owner-inbox.js";import{runProxySubagentEventStep}from"#subagents/event-proxy-step.js";async function handleWorkflowToolRunMessage(e){let{message:t}=e;switch(t.kind){case`started`:case`reply`:case`usage`:return;case`outcome`:return await handleWorkflowToolRunOutcome({...e,message:t});case`request`:await handleWorkflowToolRunRequest({...e,message:t});return;case`withdraw`:await handleWorkflowToolRunWithdraw({...e,message:t});return;case`report`:await e.cursor.advance(e=>emitWorkflowToolRunReportStep({...e,from:t.from,update:t.update}));return;case`agent-started`:await e.cursor.advance(e=>emitAgentStartedStep({...e,messages:[t]}));return}}function batchAgentStarts(e){let t=[];for(let n of e){let e=t.at(-1);n.kind===`agent-started`?e?.kind===`agent-started`?e.messages.push(n):t.push({kind:`agent-started`,messages:[n]}):t.push({kind:`message`,message:n})}return t}async function handleWorkflowToolRunOutcome(e){let{cursor:t,message:n}=e,r=t.sessionState.snapshot.session.state;if(findBlockingWorkflowToolRun(r,n.from.callId,n.from.turnId)?.address.runId!==n.from.runId)return;let i=workflowToolRunOutcomeToToolResult(n);if(isInboxToolResultFromRecordedWorkflowToolRun(r,i)){if(t.sessionState.hasProxyInputRequests){let{runId:e}=n.from;await t.advance(t=>withdrawFinishedRunQuestionsStep({...t,runId:e}))}return i}}async function handleWorkflowToolRunRequest(e){let{cursor:t,message:n}=e;if(n.request.kind===`authorization-request`){let e=n.request;await deliverWorkflowAuthorization({...n,request:e},async()=>{await t.advance(t=>runProxySubagentEventStep({hookPayload:e.event,...t}))});return}await t.advance(e=>runProxySubagentEventStep({...n.request.kind===`ask`&&{workflowAsk:createWorkflowAskRoute(n.request)},hookPayload:workflowToolRunRequestToInputRequestPayload(n),runId:n.from.runId,...e}))}async function handleWorkflowToolRunWithdraw(e){let{cursor:t,message:n}=e;await t.advance(e=>withdrawWorkflowToolRunQuestionStep({...e,control:n.control,requestId:n.replyTo,runId:n.from.runId}))}function createWorkflowAskRoute(e){let{allowFreeform:t,options:n}=e.request;return{control:e.control,question:{...t!==void 0&&{allowFreeform:t},...n!==void 0&&{options:[...n]}}}}export{batchAgentStarts,handleWorkflowToolRunMessage};

package/dist/src/execution/session.d.ts

@@ -46,7 +46,6 @@ interface CreateSessionInput {
     readonly turnAgent: RuntimeTurnAgent;
     readonly limits?: AuthoredSessionLimits;
     readonly outputSchema?: HarnessSession["outputSchema"];
-    readonly taskId?: string;
 }
 /** Creates a fresh {@link HarnessSession} from the current `turnAgent`. */
 export declare function createSession(input: CreateSessionInput): HarnessSession;

package/dist/src/execution/session.js

@@ -1,3 +1,3 @@
-import{validateHarnessModelMessages}from"#harness/messages.js";import{formatAvailableSkillsSection}from"#execution/skills/instructions.js";const DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION=4e7;function createCompactionConfig(e={}){let t=e.thresholdPercent??.9,n={recentWindowSize:10,threshold:e.contextWindowTokens===void 0?1e5:Math.max(1,Math.floor(e.contextWindowTokens*t)),thresholdPercent:t};return e.lastKnownInputTokens===void 0?n:{...n,lastKnownInputTokens:e.lastKnownInputTokens,lastKnownPromptMessageCount:e.lastKnownPromptMessageCount}}function createSession(e){let{turnAgent:t}=e,n=createSessionToolDefinitions(t),r={agent:createSessionAgent(t,createSessionSystemPrompt(t),n),compaction:createCompactionConfig({contextWindowTokens:t.model?.contextWindowTokens,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:e.continuationToken,history:[...t.initialMessages??[]],sessionId:e.sessionId};return e.rootSessionId!==void 0&&(r.rootSessionId=e.rootSessionId),r.limits=resolveSessionLimits(e),e.outputSchema!==void 0&&(r.outputSchema=e.outputSchema),e.taskId!==void 0&&(r.taskId=e.taskId),r}function createSessionAgent(e,t,n){let r={compactionModelReference:e.compactionModel,reasoning:e.reasoning,system:t,tools:n};if(e.model!==void 0)return{...r,modelReference:e.model};if(e.dynamicModel!==void 0)return{...r,dynamicModel:!0};throw Error(`Cannot create a session before dynamic subagent config is selected.`)}function refreshSessionFromTurnAgent(e){return{...e.session,agent:createSessionAgent(e.turnAgent,createSessionSystemPrompt(e.turnAgent),createSessionToolDefinitions(e.turnAgent)),compaction:createCompactionConfig({contextWindowTokens:e.turnAgent.model?.contextWindowTokens,lastKnownInputTokens:e.session.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.session.compaction.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent})}}function createSessionSystemPrompt(e){let t=formatAvailableSkillsSection(e.availableSkills??[]);return(t===null?e.instructions:[...e.instructions,t]).join(`
+import{validateHarnessModelMessages}from"#harness/messages.js";import{formatAvailableSkillsSection}from"#execution/skills/instructions.js";const DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION=4e7;function createCompactionConfig(e={}){let t=e.thresholdPercent??.9,n={recentWindowSize:10,threshold:e.contextWindowTokens===void 0?1e5:Math.max(1,Math.floor(e.contextWindowTokens*t)),thresholdPercent:t};return e.lastKnownInputTokens===void 0?n:{...n,lastKnownInputTokens:e.lastKnownInputTokens,lastKnownPromptMessageCount:e.lastKnownPromptMessageCount}}function createSession(e){let{turnAgent:t}=e,n=createSessionToolDefinitions(t),r={agent:createSessionAgent(t,createSessionSystemPrompt(t),n),compaction:createCompactionConfig({contextWindowTokens:t.model?.contextWindowTokens,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:e.continuationToken,history:[...t.initialMessages??[]],sessionId:e.sessionId};return e.rootSessionId!==void 0&&(r.rootSessionId=e.rootSessionId),r.limits=resolveSessionLimits(e),e.outputSchema!==void 0&&(r.outputSchema=e.outputSchema),r}function createSessionAgent(e,t,n){let r={compactionModelReference:e.compactionModel,reasoning:e.reasoning,system:t,tools:n};if(e.model!==void 0)return{...r,modelReference:e.model};if(e.dynamicModel!==void 0)return{...r,dynamicModel:!0};throw Error(`Cannot create a session before dynamic subagent config is selected.`)}function refreshSessionFromTurnAgent(e){return{...e.session,agent:createSessionAgent(e.turnAgent,createSessionSystemPrompt(e.turnAgent),createSessionToolDefinitions(e.turnAgent)),compaction:createCompactionConfig({contextWindowTokens:e.turnAgent.model?.contextWindowTokens,lastKnownInputTokens:e.session.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.session.compaction.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent})}}function createSessionSystemPrompt(e){let t=formatAvailableSkillsSection(e.availableSkills??[]);return(t===null?e.instructions:[...e.instructions,t]).join(`
 
-`)}function mintSubagentContinuationToken(e){return`subagent:${e??crypto.randomUUID()}`}function projectToDurableSession(e){let t={agent:{system:e.agent.system},continuationToken:e.continuationToken,history:e.history,sessionId:e.sessionId};return(e.compaction.lastKnownInputTokens!==void 0||e.compaction.lastKnownPromptMessageCount!==void 0)&&(t.compaction={lastKnownInputTokens:e.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.compaction.lastKnownPromptMessageCount}),e.rootSessionId!==void 0&&(t.rootSessionId=e.rootSessionId),e.limits!==void 0&&(t.limits=e.limits),e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),e.sandboxState!==void 0&&(t.sandboxState=e.sandboxState),e.state!==void 0&&(t.state=e.state),e.taskId!==void 0&&(t.taskId=e.taskId),t}function hydrateDurableSession(e){let{durable:t,turnAgent:n}=e,r=createSessionToolDefinitions(n),i={agent:createSessionAgent(n,t.agent.system,r),compaction:createCompactionConfig({contextWindowTokens:n.model?.contextWindowTokens,lastKnownInputTokens:t.compaction?.lastKnownInputTokens,lastKnownPromptMessageCount:t.compaction?.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:t.continuationToken,history:validateHarnessModelMessages(t.history),sessionId:t.sessionId};return t.rootSessionId!==void 0&&(i.rootSessionId=t.rootSessionId),t.limits!==void 0&&(i.limits=t.limits),t.outputSchema!==void 0&&(i.outputSchema=t.outputSchema),t.sandboxState!==void 0&&(i.sandboxState=t.sandboxState),t.state!==void 0&&(i.state=t.state),t.taskId!==void 0&&(i.taskId=t.taskId),i}function createSessionToolDefinitions(e){return e.tools.map(e=>({description:e.description??``,inputSchema:e.inputSchema,name:e.name,outputSchema:e.outputSchema}))}function resolveSessionLimits(e){let t=resolveSessionTokenLimit({authored:e.limits?.maxInputTokensPerSession,fallback:DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION}),n=resolveSessionTokenLimit({authored:e.limits?.maxOutputTokensPerSession,fallback:void 0}),r=resolveSessionTokenLimit({authored:e.limits?.maxTokenCostUsdPerSession,fallback:void 0}),i={};return t!==void 0&&(i.maxInputTokensPerSession=t),n!==void 0&&(i.maxOutputTokensPerSession=n),r!==void 0&&(i.maxTokenCostUsdPerSession=r),i}function resolveSessionTokenLimit(e){return e.authored===!1?void 0:e.authored??e.fallback}export{DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION,createCompactionConfig,createSession,hydrateDurableSession,mintSubagentContinuationToken,projectToDurableSession,refreshSessionFromTurnAgent};
+`)}function mintSubagentContinuationToken(e){return`subagent:${e??crypto.randomUUID()}`}function projectToDurableSession(e){let t={agent:{system:e.agent.system},continuationToken:e.continuationToken,history:e.history,sessionId:e.sessionId};return(e.compaction.lastKnownInputTokens!==void 0||e.compaction.lastKnownPromptMessageCount!==void 0)&&(t.compaction={lastKnownInputTokens:e.compaction.lastKnownInputTokens,lastKnownPromptMessageCount:e.compaction.lastKnownPromptMessageCount}),e.rootSessionId!==void 0&&(t.rootSessionId=e.rootSessionId),e.limits!==void 0&&(t.limits=e.limits),e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),e.sandboxState!==void 0&&(t.sandboxState=e.sandboxState),e.state!==void 0&&(t.state=e.state),t}function hydrateDurableSession(e){let{durable:t,turnAgent:n}=e,r=createSessionToolDefinitions(n),i={agent:createSessionAgent(n,t.agent.system,r),compaction:createCompactionConfig({contextWindowTokens:n.model?.contextWindowTokens,lastKnownInputTokens:t.compaction?.lastKnownInputTokens,lastKnownPromptMessageCount:t.compaction?.lastKnownPromptMessageCount,thresholdPercent:e.compactionOverrides?.thresholdPercent}),continuationToken:t.continuationToken,history:validateHarnessModelMessages(t.history),sessionId:t.sessionId};return t.rootSessionId!==void 0&&(i.rootSessionId=t.rootSessionId),t.limits!==void 0&&(i.limits=t.limits),t.outputSchema!==void 0&&(i.outputSchema=t.outputSchema),t.sandboxState!==void 0&&(i.sandboxState=t.sandboxState),t.state!==void 0&&(i.state=t.state),i}function createSessionToolDefinitions(e){return e.tools.map(e=>({description:e.description??``,inputSchema:e.inputSchema,name:e.name,outputSchema:e.outputSchema}))}function resolveSessionLimits(e){let t=resolveSessionTokenLimit({authored:e.limits?.maxInputTokensPerSession,fallback:DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION}),n=resolveSessionTokenLimit({authored:e.limits?.maxOutputTokensPerSession,fallback:void 0}),r=resolveSessionTokenLimit({authored:e.limits?.maxTokenCostUsdPerSession,fallback:void 0}),i={};return t!==void 0&&(i.maxInputTokensPerSession=t),n!==void 0&&(i.maxOutputTokensPerSession=n),r!==void 0&&(i.maxTokenCostUsdPerSession=r),i}function resolveSessionTokenLimit(e){return e.authored===!1?void 0:e.authored??e.fallback}export{DEFAULT_ROOT_MAX_INPUT_TOKENS_PER_SESSION,createCompactionConfig,createSession,hydrateDurableSession,mintSubagentContinuationToken,projectToDurableSession,refreshSessionFromTurnAgent};

package/dist/src/execution/settle-cancelled-turn-step.d.ts

@@ -1,18 +1,30 @@
-import { type DurableSessionState } from "#execution/durable-session-store.js";
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import { type WithSessionStateDelta } from "#execution/session/state-delta.js";
 import type { TokenUsage } from "#shared/token-usage.js";
 export interface CancelledTurnSettleResult {
     readonly serializedContext: Record<string, unknown>;
     readonly sessionState: DurableSessionState;
+    /** What the session spent since its caller's last report, when asked to report it. */
     readonly usage?: TokenUsage;
 }
-/**
- * Settles one cancelled turn: emits `turn.cancelled` → `session.waiting`,
- * drops pending coordination state, and persists the between-turns
- * session. Runs in the owner, whose wake sources exclude the
- * cancel hook, so a queued cancel wake cannot re-dispatch it.
- */
-export declare function settleCancelledTurnStep(input: {
+interface CancelledTurnSettleInput {
+    /**
+     * Whether a caller receives the turn's usage. Only then is it marked
+     * reported; otherwise the next settled turn reports it.
+     */
+    readonly reportUsage: boolean;
     readonly sessionWritable: WritableStream<Uint8Array>;
     readonly serializedContext: Record<string, unknown>;
     readonly sessionState: DurableSessionState;
-}): Promise<CancelledTurnSettleResult>;
+}
+/**
+ * Settles one cancelled turn: relays `input.resolved` for every request the
+ * session proxies, emits `turn.cancelled` → `session.waiting`, drops pending
+ * coordination state, and persists the between-turns session. Runs in the
+ * owner, whose wake sources exclude the cancel hook, so a queued cancel wake
+ * cannot re-dispatch it.
+ */
+export declare function settleCancelledTurnStep(input: CancelledTurnSettleInput): Promise<WithSessionStateDelta<CancelledTurnSettleResult>>;
+/** {@link settleCancelledTurnStep} for a caller that is already a step and adopts the whole state. */
+export declare function settleCancelledTurn(input: CancelledTurnSettleInput): Promise<CancelledTurnSettleResult>;
+export {};

package/dist/src/execution/settle-cancelled-turn-step.js

@@ -1 +1 @@
-import{TurnDeliveryIdsKey}from"#context/keys.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission.js";import{clearPendingCoordinationBatch,getPendingCoordinationBatch}from"#harness/coordination.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{getBlockingWorkflowToolRuns,removeBlockingWorkflowToolRuns}from"#harness/workflow-tool-runs.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{hydrateDurableSession}from"#execution/session.js";import{buildAdapterContext}from"#channel/adapter-context.js";import{withContextScope}from"#context/run-step.js";import{activeTurnId}from"#harness/active-turn-id.js";import{clearAllProxyInputRequests,getProxyInputRequests,hasProxyInputRequests}from"#harness/proxy-input-requests.js";import{publishChannelEvent}from"#execution/publish-channel-event.js";import{observeSessionActivity}from"#execution/session-activity-projection.js";import{getTurnUsageState,toUsage}from"#harness/turn-tag-state.js";import{clearPendingSessionLimitPrompt}from"#harness/input-requests.js";import{bindSessionInstrumentation}from"#instrumentation/runtime.js";import{reconcileSessionContinuationToken}from"#execution/reconcile-session-continuation-token.js";import{emitCancelledTurn}from"#harness/cancelled-turn-emission.js";import{abandonAgentInvocationOwners,abandonRunningAgentTurns}from"#subagents/handles/transitions.js";async function settleCancelledTurnStep(e){"use step";let t=readDurableSession(e.sessionState),n=await deserializeContext(e.serializedContext),r=n.require(ChannelKey),i=buildAdapterContext(r,n),a=n.require(BundleKey),o=resolveEffectiveAgentRuntime(a,n),s=hydrateDurableSession({compactionOverrides:{thresholdPercent:o.thresholdPercent},durable:t,turnAgent:o.turnAgent}),c=bindSessionInstrumentation({agentName:o.turnAgent.id,ctx:n,rootSessionId:s.rootSessionId??s.sessionId,sessionId:s.sessionId}),l=getHarnessEmissionState(t.state),u=[...getProxyInputRequests(t.state).values()].some(e=>e.kind===`session-limit`);if(!(isHarnessBetweenTurns(s)&&hasProxyInputRequests(t.state)&&!u)){let t=e.sessionWritable.getWriter();try{let e=await withContextScope(n,s,async e=>{let baseEmit=async e=>{let a=await publishChannelEvent({adapter:r,adapterCtx:i,ctx:n,writer:t,event:e,deliveryIds:n.get(TurnDeliveryIdsKey)});observeSessionActivity({ctx:n,event:a,sessionId:s.sessionId})},a=c?.createHandleEvent({handleEvent:baseEmit,turnId:activeTurnId(l)})??baseEmit;return{result:await emitCancelledTurn(a,l),session:e}});l=e.result,s=e.session}finally{await c?.flush(),t.releaseLock()}}let d=getPendingCoordinationBatch(s.state)?.event.turnId??e.sessionState.emissionState.turnId,f=getBlockingWorkflowToolRuns(s.state,d);s=abandonAgentInvocationOwners(s,new Set(f.map(e=>e.address.runId)));let p=reconcileSessionContinuationToken(n,setHarnessEmissionState(clearPendingSessionLimitPrompt(clearAllProxyInputRequests(clearPendingCoordinationBatch(removeBlockingWorkflowToolRuns(abandonRunningAgentTurns({...s,outputSchema:void 0}),d)))),l)),m=getTurnUsageState(s.state)?.session,h={serializedContext:serializeContext(n),sessionState:createDurableSessionState({session:p})};return m===void 0?h:{...h,usage:toUsage(m)}}export{settleCancelledTurnStep};
+import{getHarnessEmissionState,setHarnessEmissionState}from"#harness/emission.js";import{getTurnUsageState,takeSessionUsageDelta}from"#harness/turn-tag-state.js";import{commitCancelledCoordinationBatch,getPendingCoordinationBatch}from"#harness/coordination.js";import{removeBlockingWorkflowToolRuns}from"#harness/workflow-tool-runs.js";import{publishFromSessionStep,restoreSessionStep}from"#execution/publish-session-events.js";import{withSessionStateDelta}from"#execution/session/state-delta.js";import{clearPendingSessionLimitPrompt}from"#harness/input-requests.js";import{relayWithdrawnRequests}from"#execution/tools/workflow/withdraw-step.js";import{emitCancelledTurn}from"#harness/cancelled-turn-emission.js";async function settleCancelledTurnStep(e){"use step";return await withSessionStateDelta(e,settleCancelledTurn)}async function settleCancelledTurn(e){let t=await relayWithdrawnRequests(e,()=>!0),n=await restoreSessionStep({...t,sessionWritable:e.sessionWritable}),r=n.durableSession.state,{published:i,result:a}=await publishFromSessionStep(n,{origin:`own`,publish:e=>emitCancelledTurn(e,getHarnessEmissionState(r)),updateSession(t,n){let r=getPendingCoordinationBatch(t.state)?.event.turnId??e.sessionState.emissionState.turnId,i=setHarnessEmissionState(clearPendingSessionLimitPrompt(commitCancelledCoordinationBatch(removeBlockingWorkflowToolRuns({...t,outputSchema:void 0},r))),n);if(!e.reportUsage||getTurnUsageState(t.state)===void 0)return{session:i};let a=takeSessionUsageDelta(i);return{result:a.delta,session:a.session}}});return a===void 0?i:{...i,usage:a}}export{settleCancelledTurn,settleCancelledTurnStep};

package/dist/src/execution/stable-workflow-names.d.ts

@@ -1,5 +1,4 @@
 export declare const WORKFLOW_ENTRY_NAME = "workflowEntry";
 export declare const SESSION_TIMEOUT_WORKFLOW_NAME = "sessionTimeoutWorkflow";
 export declare const WORKFLOW_TOOL_RUN_WORKFLOW_NAME = "workflowToolRunWorkflow";
-export declare const ACTIVITY_COLLECTOR_WORKFLOW_NAME = "activityCollectorWorkflow";
 export declare const STABLE_WORKFLOW_NAMES: ReadonlySet<string>;

package/dist/src/execution/stable-workflow-names.js

@@ -1 +1 @@
-const WORKFLOW_ENTRY_NAME=`workflowEntry`,SESSION_TIMEOUT_WORKFLOW_NAME=`sessionTimeoutWorkflow`,WORKFLOW_TOOL_RUN_WORKFLOW_NAME=`workflowToolRunWorkflow`,ACTIVITY_COLLECTOR_WORKFLOW_NAME=`activityCollectorWorkflow`,STABLE_WORKFLOW_NAMES=new Set([WORKFLOW_ENTRY_NAME,`turnWorkflow`,SESSION_TIMEOUT_WORKFLOW_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME,ACTIVITY_COLLECTOR_WORKFLOW_NAME]);export{ACTIVITY_COLLECTOR_WORKFLOW_NAME,SESSION_TIMEOUT_WORKFLOW_NAME,STABLE_WORKFLOW_NAMES,WORKFLOW_ENTRY_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME};
+const WORKFLOW_ENTRY_NAME=`workflowEntry`,SESSION_TIMEOUT_WORKFLOW_NAME=`sessionTimeoutWorkflow`,WORKFLOW_TOOL_RUN_WORKFLOW_NAME=`workflowToolRunWorkflow`,STABLE_WORKFLOW_NAMES=new Set([WORKFLOW_ENTRY_NAME,`turnWorkflow`,SESSION_TIMEOUT_WORKFLOW_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME]);export{SESSION_TIMEOUT_WORKFLOW_NAME,STABLE_WORKFLOW_NAMES,WORKFLOW_ENTRY_NAME,WORKFLOW_TOOL_RUN_WORKFLOW_NAME};

package/dist/src/execution/tasks/calls.d.ts

@@ -0,0 +1,42 @@
+import type { ModelMessage } from "ai";
+import type { RuntimeToolResultActionResult } from "#shared/action-types.js";
+import type { JsonValue } from "#shared/json.js";
+/**
+ * Calls to the task tools. They defer out of the model step like
+ * workflow tool calls; the session answers them instead of a workflow run.
+ */
+export type TaskToolCall = {
+    readonly callId: string;
+    readonly kind: "task_wait";
+    readonly timeoutMs?: number;
+} | {
+    readonly callId: string;
+    readonly kind: "task_cancel";
+    readonly taskId: string;
+};
+/**
+ * The task tool calls a parked step's response still waits on. The response
+ * is the one record of these calls: a call without a result is pending, and
+ * a call with invalid input already carries its error result. The names are
+ * reserved, so no authored tool's call matches.
+ */
+export declare function pendingTaskToolCalls(messages: readonly ModelMessage[]): TaskToolCall[];
+/** Why a `task_wait` call, or a held turn, stopped waiting. */
+export type TaskWaitResult = {
+    readonly status: "settled";
+    /** Tasks whose results follow; both lists are empty when nothing was working. */
+    readonly settled: readonly {
+        readonly id: string;
+        readonly status: "completed" | "failed";
+    }[];
+    readonly working: readonly string[];
+} | {
+    readonly status: "timeout" | "interrupt";
+    readonly working: readonly string[];
+};
+export interface TaskCancelResult {
+    readonly resumable: boolean;
+    readonly status: "cancelled" | "already_finished";
+    readonly tool: string;
+}
+export declare function taskToolResult(callId: string, toolName: string, output: JsonValue): RuntimeToolResultActionResult;

package/dist/src/execution/tasks/calls.js

@@ -0,0 +1 @@
+import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";function pendingTaskToolCalls(e){let t=new Set;for(let n of e)if(typeof n.content!=`string`)for(let e of n.content)e.type===`tool-result`&&t.add(e.toolCallId);let n=[];for(let r of e)if(r.role===`assistant`&&typeof r.content!=`string`)for(let e of r.content){if(e.type!==`tool-call`||t.has(e.toolCallId))continue;let r=typeof e.input==`object`&&e.input!==null?e.input:{};if(e.toolName===TASK_CANCEL_TOOL_NAME){let t=String(Reflect.get(r,`taskId`));n.push({callId:e.toolCallId,kind:`task_cancel`,taskId:t})}else if(e.toolName===TASK_WAIT_TOOL_NAME){let t=Reflect.get(r,`timeoutSeconds`);n.push(typeof t==`number`?{callId:e.toolCallId,kind:`task_wait`,timeoutMs:t*1e3}:{callId:e.toolCallId,kind:`task_wait`})}}return n}function taskToolResult(e,t,n){return{callId:e,kind:`tool-result`,output:n,toolName:t}}export{pendingTaskToolCalls,taskToolResult};

package/dist/src/execution/tasks/model-step.d.ts

@@ -0,0 +1,58 @@
+import type { ModelMessage, SystemModelMessage } from "ai";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import { type HarnessModelMessage } from "#harness/messages.js";
+import type { HarnessSession, HarnessToolMap } from "#harness/types.js";
+import type { WorkflowToolCallEntry } from "#shared/action-types.js";
+import type { JsonObject } from "#shared/json.js";
+export declare function isTaskTool(definition: HarnessToolDefinition | undefined): boolean;
+/** Whether the agent can start tasks, so the task tools and system block are offered. */
+export declare function offersTasks(tools: HarnessToolMap): boolean;
+/** Adds `task_wait` and `task_cancel` to a tool set that can start tasks. */
+export declare function withTaskTools(tools: HarnessToolMap): HarnessToolMap;
+/**
+ * The task block, when the agent can start tasks. `finalReplyOnly` is set for a
+ * child or schedule session, which hides a held turn's text, so a reply before
+ * a result would reach no one.
+ */
+export declare function taskSystemMessages(tools: HarnessToolMap, options: {
+    readonly finalReplyOnly: boolean;
+}): SystemModelMessage[];
+/** A deferred call as the model made it, before the session knows what it enters. */
+export interface DeferredCall {
+    readonly callId: string;
+    readonly definition: HarnessToolDefinition | undefined;
+    /** The call's model input. */
+    readonly input: JsonObject;
+    readonly toolName: string;
+    readonly turnId: string;
+}
+/** How a deferred call enters its workflow, with the tool's own input. */
+export interface CommittedCallEntry {
+    readonly entry: WorkflowToolCallEntry;
+    readonly input: JsonObject;
+    readonly session: HarnessSession;
+}
+/**
+ * How a deferred call enters its workflow. A call that starts a task commits
+ * the task's record alongside the call, so the run starts with its id; a
+ * `serve` tool's call with `taskId` goes to that task's `receive()`, which the
+ * session checks when it sends the call.
+ */
+export declare function commitCallEntry(session: HarnessSession, call: DeferredCall): CommittedCallEntry;
+export declare function workingTaskIds(session: HarnessSession): readonly string[];
+/**
+ * The messages a model step appends for tasks, before any new input: one
+ * `task.result` message with every settled result, then the
+ * `[Tasks]` note when the listing changed. The results are marked delivered
+ * in the same step. The message lives only in the model's history: clients
+ * read outcomes from `task.settled`.
+ */
+export declare function appendTaskContext(input: {
+    readonly messages: readonly HarnessModelMessage[];
+    readonly projectHistory: (messages: readonly ModelMessage[], state: HarnessSession["state"]) => readonly ModelMessage[];
+    readonly session: HarnessSession;
+    readonly tools: HarnessToolMap;
+}): Promise<{
+    readonly messages: readonly HarnessModelMessage[];
+    readonly session: HarnessSession;
+}>;

package/dist/src/execution/tasks/model-step.js

@@ -0,0 +1 @@
+import{TASK_CANCEL_TOOL_NAME,TASK_WAIT_TOOL_NAME}from"#protocol/task-tools.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{FINAL_REPLY_TASK_SYSTEM_BLOCK,TASKS_NOTE_LABEL,TASK_SYSTEM_BLOCK,renderModelOutputText,renderTaskResults,renderTasksNote}from"#execution/tasks/render.js";import{createTask,idleTasks,readTaskTable,takeTaskResults,workingTasks,writeTaskTable}from"#execution/tasks/table.js";import{splitTaskIdInput}from"#execution/tasks/task-id-input.js";import{entryPointOf,isAgentTool,startsTasks}from"#execution/tasks/tool-entry-point.js";import{taskCancelTool}from"#tools/provided/task-cancel.js";import{taskWaitTool}from"#tools/provided/task-wait.js";function isTaskTool(e){return e?.frameworkAction===`task-wait`||e?.frameworkAction===`task-cancel`}function offersTasks(e){for(let t of e.values())if(startsTasks(t))return!0;return!1}function withTaskTools(e){return offersTasks(e)?new Map([...e,[TASK_WAIT_TOOL_NAME,taskWaitTool],[TASK_CANCEL_TOOL_NAME,taskCancelTool]]):e}function taskSystemMessages(e,t){return offersTasks(e)?[{content:t.finalReplyOnly?FINAL_REPLY_TASK_SYSTEM_BLOCK:TASK_SYSTEM_BLOCK,role:`system`}]:[]}function commitCallEntry(e,t){let n=entryPointOf(t.definition);switch(n){case`execute`:return{entry:{entryPoint:n},input:t.input,session:e};case`task`:return commitTask(e,t,n,t.input);case`serve`:{let{input:r,taskId:i}=splitTaskIdInput(t.input);return i===void 0?commitTask(e,t,n,r):{entry:{entryPoint:`receive`,taskId:i},input:r,session:e}}}}function commitTask(e,t,n,r){let i=createTask(readTaskTable(e.state),{callId:t.callId,kind:isAgentTool(t.definition)?`agent`:`tool`,name:t.toolName,resumable:n===`serve`,turnId:t.turnId});return{entry:{entryPoint:n,taskId:i.taskId},input:r,session:writeTaskTable(e,i.table)}}function workingTaskIds(e){return workingTasks(readTaskTable(e.state)).map(e=>e.id)}async function appendTaskContext(e){let t=[],n=await deliverTaskResults(e);n.message!==void 0&&t.push(createFrameworkUserMessage(`task.result`,n.message));let r=resolveTasksNote({messages:e.projectHistory([...e.messages,...t],n.session.state),session:n.session});return r!==void 0&&t.push(createFrameworkUserMessage(`context.state`,r)),{messages:t,session:n.session}}async function deliverTaskResults(e){let{table:t,taken:n}=takeTaskResults(readTaskTable(e.session.state));if(n.length===0)return{session:e.session};let r=[];for(let t of n)for(let n of t.results)r.push(await toResultBlock(t,n,e.tools.get(t.name)));return{message:renderTaskResults(r),session:writeTaskTable(e.session,t)}}async function toResultBlock(e,t,n){let r={taskId:e.id,tool:e.name};return t.status===`failed`?{...r,body:t.error,status:`failed`}:{...r,body:await projectOutput(t.output,n),status:`completed`}}async function projectOutput(e,t){if(t?.toModelOutput===void 0)return renderModelOutputText(e);try{return renderModelOutputText(await t.toModelOutput(e))}catch{return renderModelOutputText(e)}}function resolveTasksNote(e){let t=readTaskTable(e.session.state),n=workingTasks(t).map(toListedTask),r=idleTasks(t).map(toListedTask),i=e.messages.findLast(isTasksNote);if(i===void 0&&n.length===0&&r.length===0)return;let a=renderTasksNote({idle:r,working:n});return i?.content===a?void 0:a}function toListedTask(e){return{id:e.id,tool:e.name}}function isTasksNote(e){return e.role===`user`&&typeof e.content==`string`&&e.content.startsWith(TASKS_NOTE_LABEL)}export{appendTaskContext,commitCallEntry,isTaskTool,offersTasks,taskSystemMessages,withTaskTools,workingTaskIds};

package/dist/src/execution/tasks/render.d.ts

@@ -0,0 +1,66 @@
+import type { TaskCancelResult, TaskWaitResult } from "#execution/tasks/calls.js";
+export declare const TASK_WAIT_DESCRIPTION = "Call task_wait sparingly, only when you deliberately want to withhold a message from the user while waiting for a task result. Tasks keep running and their results reach you without calling task_wait. If the user should hear from you now, reply instead. Wait silently until any of your tasks has a result, a new message arrives, or timeoutSeconds pass. It returns after the first result, which follows in a <task_result> message; wait again only if you still want to withhold a reply until another result arrives. Waiting never stops a task.";
+export declare const TASK_WAIT_TIMEOUT_DESCRIPTION = "Optional. Seconds to wait before returning without a result. Omit it to wait for a result or a new message, which is almost always right. Don't use short timeouts to check on tasks: results reach you without checking.";
+export declare const TASK_CANCEL_DESCRIPTION = "Stop a task's current work. That work never reports back; if it already had a result, that result is still delivered. An agent, or any task that accepts more input, stays available: call its tool with its taskId to give it new work.";
+export declare const TASK_CANCEL_TASK_ID_DESCRIPTION = "The id of the task to stop, copied from its \"Started task\" receipt or the [Tasks] note.";
+/** The task block for a session a person reads, where a reply before a result is posted. */
+export declare const TASK_SYSTEM_BLOCK: string;
+/** The task block for a child or schedule session, whose caller reads only the final reply. */
+export declare const FINAL_REPLY_TASK_SYSTEM_BLOCK: string;
+/** Appended to a `serve` tool's description. */
+export declare const SERVE_TOOL_DESCRIPTION = "To send this task more input, call this tool again with its taskId; without taskId, each call starts a new task.";
+/** Appended to an agent tool's description, in place of the `serve` tool sentence. */
+export declare const AGENT_SERVE_TOOL_DESCRIPTION = "It does not see this conversation, so put everything it needs in message. To correct or continue an agent task, call this tool again with its taskId; without taskId, each call starts a new agent.";
+/** Describes the `taskId` eve adds to a `serve` tool's model input. */
+export declare const TASK_ID_INPUT_DESCRIPTION = "The id of a task this tool started, copied from its \"Started task\" receipt or the [Tasks] note, to send it this input. Omit it to start a new task.";
+/** Labels the `context.state` note that lists the turn's tasks. */
+export declare const TASKS_NOTE_LABEL = "[Tasks]";
+/** Opens every block of a `task.result` message. */
+export declare const TASK_RESULT_TAG = "<task_result";
+/** The failure a task reports when its record could not be decoded. */
+export declare const UNREADABLE_TASK_ERROR = "The task's state could not be read.";
+/** The receipt for a call that starts a task; a resumable task's says how to reach it again. */
+export declare function renderTaskReceipt(task: {
+    readonly id: string;
+    readonly resumable: boolean;
+    readonly tool: string;
+}): string;
+/** The receipt for a call that reaches a resumable task by its `taskId`. */
+export declare function renderTaskSentReceipt(taskId: string): string;
+export declare function renderUnknownTaskError(taskId: string, tool: string): string;
+export declare function renderUnknownCancelTaskError(taskId: string): string;
+/** What the model reads when `task_cancel` answers. */
+export declare function renderTaskCancelResult(taskId: string, result: TaskCancelResult): string;
+export declare function renderTooManyTasksError(max: number, workingIds: readonly string[]): string;
+export declare function renderFinalOutputWhileWorkingError(workingIds: readonly string[]): string;
+/** What the model reads when `task_wait` returns after waiting `waitedMs`. */
+export declare function renderTaskWaitResult(result: TaskWaitResult, waitedMs: number): string;
+/** One `<task_result>` block of a `task.result` message. */
+export interface TaskResultBlock {
+    readonly body: string;
+    readonly status: "completed" | "failed";
+    readonly taskId: string;
+    readonly tool: string;
+}
+/**
+ * The `task.result` message: one `<task_result>` block per result. All
+ * bodies share one size budget; a body past it is cut and marked.
+ */
+export declare function renderTaskResults(results: readonly TaskResultBlock[]): string;
+/**
+ * The blocks of a `task.result` message, in order, as a deterministic mock
+ * model reads them back; empty for any other text.
+ */
+export declare function readTaskResults(message: string): TaskResultBlock[];
+/** The text of a tool's `toModelOutput` result, or of a raw output without one. */
+export declare function renderModelOutputText(output: unknown): string;
+/** A task as the `[Tasks]` note lists it. */
+export interface ListedTask {
+    readonly id: string;
+    readonly tool: string;
+}
+/** The `[Tasks]` note: working tasks, then idle resumable tasks when there are any. */
+export declare function renderTasksNote(input: {
+    readonly idle: readonly ListedTask[];
+    readonly working: readonly ListedTask[];
+}): string;

package/dist/src/execution/tasks/render.js

@@ -0,0 +1,8 @@
+import{formatDuration}from"#shared/format-duration.js";const TASK_WAIT_DESCRIPTION=`Call task_wait sparingly, only when you deliberately want to withhold a message from the user while waiting for a task result. Tasks keep running and their results reach you without calling task_wait. If the user should hear from you now, reply instead. Wait silently until any of your tasks has a result, a new message arrives, or timeoutSeconds pass. It returns after the first result, which follows in a <task_result> message; wait again only if you still want to withhold a reply until another result arrives. Waiting never stops a task.`,TASK_WAIT_TIMEOUT_DESCRIPTION=`Optional. Seconds to wait before returning without a result. Omit it to wait for a result or a new message, which is almost always right. Don't use short timeouts to check on tasks: results reach you without checking.`,TASK_CANCEL_DESCRIPTION=`Stop a task's current work. That work never reports back; if it already had a result, that result is still delivered. An agent, or any task that accepts more input, stays available: call its tool with its taskId to give it new work.`,TASK_ID_SOURCE=`copied from its "Started task" receipt or the [Tasks] note`,TASK_CANCEL_TASK_ID_DESCRIPTION=`The id of the task to stop, ${TASK_ID_SOURCE}.`,TASK_SYSTEM_BLOCK_OPENING=[`Tasks`,`- A call that returns "Started task <id>" is a task: it keeps working while you continue. Every agent call is a task.`,`- Each result arrives once, in a <task_result> message. Until then you know nothing about it, so don't guess or report its result.`,`- Ending your reply doesn't end your turn. While tasks work, eve holds your turn and calls you again with each result.`],TASK_SYSTEM_BLOCK_CLOSING=[`- Don't redo work you delegated. Never use sleep or shell commands to wait for a task.`,`- To correct or continue an agent, or any task that accepts more input, call its tool again with its taskId. A new message never stops your tasks: answer it if it asks you something, decide whether it changes the work, then keep each task, correct an agent by taskId, or stop a task with task_cancel.`],TASK_SYSTEM_BLOCK=[...TASK_SYSTEM_BLOCK_OPENING,`- If you have nothing to tell the person until a result arrives, call task_wait. Start every independent task first, then wait.`,`- If the person should hear from you now, for example to confirm work is underway when they don't need the result yet, reply. When results arrive, report them without repeating yourself.`,...TASK_SYSTEM_BLOCK_CLOSING].join(`
+`),FINAL_REPLY_TASK_SYSTEM_BLOCK=[...TASK_SYSTEM_BLOCK_OPENING,`- Only your final reply reaches your caller. While tasks work, call task_wait instead of replying. Start every independent task first, then wait.`,...TASK_SYSTEM_BLOCK_CLOSING].join(`
+`),SERVE_TOOL_DESCRIPTION=`To send this task more input, call this tool again with its taskId; without taskId, each call starts a new task.`,AGENT_SERVE_TOOL_DESCRIPTION=`It does not see this conversation, so put everything it needs in message. To correct or continue an agent task, call this tool again with its taskId; without taskId, each call starts a new agent.`,TASK_ID_INPUT_DESCRIPTION=`The id of a task this tool started, ${TASK_ID_SOURCE}, to send it this input. Omit it to start a new task.`,TASKS_NOTE_LABEL=`[Tasks]`,TASK_RESULT_TAG=`<task_result`,UNREADABLE_TASK_ERROR=`The task's state could not be read.`;function renderTaskReceipt(e){let t=`Started task ${e.id}. Its result will arrive in a <task_result> message.`;return e.resumable?`${t} To send it another message, call ${e.tool} again with taskId ${e.id}.`:t}function renderTaskSentReceipt(e){return`Sent to task ${e}. Its reply will arrive in a <task_result> message.`}function renderUnknownTaskError(e,t){return`No task "${e}" is available to ${t}: it may have ended or belong to another tool. Start a new one by calling ${t} without taskId.`}function renderUnknownCancelTaskError(e){return`No task "${e}" is in this session. Copy an id from a "Started task" receipt or the [Tasks] note.`}function renderTaskCancelResult(e,t){return t.status===`already_finished`?`${e} had no work to stop.`:t.resumable?`Stopped ${e}'s current work; it won't report back. To give it new work, call ${t.tool} again with taskId ${e}.`:`Stopped ${e}; it won't report back.`}function renderTooManyTasksError(e,t){return`${String(e)} tasks are already working (${t.join(`, `)}). Wait with task_wait or stop one with task_cancel, then try again.`}function renderFinalOutputWhileWorkingError(e){return`You can't give your final output while tasks you started are working (${e.join(`, `)}). Wait for their results with task_wait, or stop a task with task_cancel, then call final_output.`}function renderTaskWaitResult(e,t){switch(e.status){case`settled`:return renderSettledWait(e.settled,e.working);case`timeout`:return`Stopped waiting after ${formatDuration(t)}; ${countWorking(e.working)}. ${resultsArriveLater(e.working.length)}`;case`interrupt`:return`A new message arrived, so the wait ended after ${formatDuration(t)}; ${countWorking(e.working)}. Read the message, answer it if it asks you something, and decide whether it changes this work: ${interruptChoices(e.working.length)}`}}function renderSettledWait(e,t){if(e.length===0&&t.length===0)return`No tasks are working.`;let n=[];if(e.length>0){let t=e.map(e=>`${e.id} ${e.status}`),r=e.length===1?`its result follows`:`their results follow`;n.push(`${joinList(t)}; ${r}.`)}return t.length>0&&n.push(`${capitalize(countWorking(t))}: ${t.join(`, `)}.`),n.join(` `)}function countWorking(e){return e.length===1?`1 task is still working`:`${String(e.length)} tasks are still working`}function resultsArriveLater(e){return e===1?`Its result arrives before your turn ends; wait again only if you need it now.`:`Their results arrive before your turn ends; wait again only if you need them now.`}function interruptChoices(e){return`${e===1?`keep the task`:`keep the tasks`}, call an agent again with its taskId to correct it, or stop a task with task_cancel.`}function renderTaskResults(e){let t={bytes:51200,lines:2e3};return e.map(e=>{let n=fitToBudget(escapeTaskResultBody(e.body),t),r=`id="${escapeAttribute(e.taskId)}" tool="${escapeAttribute(e.tool)}" status="${e.status}"`;return`${TASK_RESULT_TAG} ${r}>${n}</task_result>`}).join(`
+`)}const TASK_RESULT_BLOCK=RegExp(`${TASK_RESULT_TAG} id="([^"]*)" tool="([^"]*)" status="(completed|failed)">([\\s\\S]*?)</task_result>`,`g`);function readTaskResults(e){return[...e.matchAll(TASK_RESULT_BLOCK)].map(([,e,t,n,r])=>({body:r.replaceAll(`<\\/task_result`,`</task_result`),status:n,taskId:e,tool:t}))}function fitToBudget(e,t){let n=new TextEncoder,r=e.split(`
+`),i=[];for(let e of r){let r=n.encode(e).byteLength+1;if(t.lines===0||r>t.bytes){i.push(`[truncated]`),t.lines=0,t.bytes=0;break}i.push(e),--t.lines,t.bytes-=r}return i.join(`
+`)}function escapeTaskResultBody(e){return e.replaceAll(`</task_result`,`<\\/task_result`)}function renderModelOutputText(e){if(typeof e==`string`)return e;if(isModelOutput(e))switch(e.type){case`text`:return String(e.value);case`json`:return JSON.stringify(e.value);case`content`:return renderContentParts(e.value)}return JSON.stringify(e??null)}function renderContentParts(e){return Array.isArray(e)?e.map(e=>e.type===`text`?String(e.text):`[file: ${typeof e.filename==`string`?e.filename:String(e.mediaType)}]`).join(`
+`):``}function isModelOutput(e){if(typeof e!=`object`||!e)return!1;let t=Reflect.get(e,`type`);return(t===`text`||t===`json`||t===`content`)&&`value`in e}function renderTasksNote(e){let t=[TASKS_NOTE_LABEL,`<tasks>`];for(let n of e.working)t.push(`<task ${listedTaskAttributes(n)} status="working"/>`);if(t.push(`</tasks>`),e.idle.length>0){t.push(`<idle>`);for(let n of e.idle)t.push(`<task ${listedTaskAttributes(n)}/>`);t.push(`</idle>`)}return t.join(`
+`)}function listedTaskAttributes(e){return`id="${escapeAttribute(e.id)}" tool="${escapeAttribute(e.tool)}"`}function joinList(e){return e.length<=1?e.join(``):`${e.slice(0,-1).join(`, `)} and ${e.at(-1)}`}function capitalize(e){return e.charAt(0).toUpperCase()+e.slice(1)}function escapeAttribute(e){return e.replaceAll(`&`,`&amp;`).replaceAll(`"`,`&quot;`).replaceAll(`<`,`&lt;`).replaceAll(`>`,`&gt;`)}export{AGENT_SERVE_TOOL_DESCRIPTION,FINAL_REPLY_TASK_SYSTEM_BLOCK,SERVE_TOOL_DESCRIPTION,TASKS_NOTE_LABEL,TASK_CANCEL_DESCRIPTION,TASK_CANCEL_TASK_ID_DESCRIPTION,TASK_ID_INPUT_DESCRIPTION,TASK_RESULT_TAG,TASK_SYSTEM_BLOCK,TASK_WAIT_DESCRIPTION,TASK_WAIT_TIMEOUT_DESCRIPTION,UNREADABLE_TASK_ERROR,readTaskResults,renderFinalOutputWhileWorkingError,renderModelOutputText,renderTaskCancelResult,renderTaskReceipt,renderTaskResults,renderTaskSentReceipt,renderTaskWaitResult,renderTasksNote,renderTooManyTasksError,renderUnknownCancelTaskError,renderUnknownTaskError};

package/dist/src/execution/tasks/session.d.ts

@@ -0,0 +1,19 @@
+import type { SessionStateCursor } from "#execution/session/state-cursor.js";
+import { type TaskToolCall } from "#execution/tasks/calls.js";
+import { type TaskRunMessage } from "#execution/tasks/steps.js";
+import { type TaskTable } from "#execution/tasks/table.js";
+import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
+import type { TaskCancelReason } from "#protocol/message.js";
+import type { RuntimeActionResult } from "#shared/action-types.js";
+/** Whether a run's message changes a task record. */
+export declare function isTaskRunMessage(message: WorkflowToolRunMessage): message is TaskRunMessage;
+/** The session's task table as the workflow body last committed it. */
+export declare function sessionTaskTable(cursor: SessionStateCursor): TaskTable;
+/**
+ * Cancels every working task: `session.cancel()` stops them, and a turn that
+ * ends anyway, such as by failing, cancels the tasks it held on.
+ */
+export declare function cancelWorkingTasks(cursor: SessionStateCursor, reason: Exclude<TaskCancelReason, "task_cancel">): Promise<void>;
+export declare function answerTaskCancel(cursor: SessionStateCursor, call: Extract<TaskToolCall, {
+    readonly kind: "task_cancel";
+}>): Promise<RuntimeActionResult>;

package/dist/src/execution/tasks/session.js

@@ -0,0 +1 @@
+import{TASK_CANCEL_TOOL_NAME,UNKNOWN_TASK_CODE}from"#protocol/task-tools.js";import{renderTaskCancelResult,renderUnknownCancelTaskError}from"#execution/tasks/render.js";import{readTaskTable,taskCancelResult,workingTasks}from"#execution/tasks/table.js";import{taskToolResult}from"#execution/tasks/calls.js";import{cancelTasksStep}from"#execution/tasks/steps.js";function isTaskRunMessage(e){return e.from.taskId===void 0?!1:e.kind===`started`||e.kind===`reply`||e.kind===`usage`||e.kind===`outcome`}function sessionTaskTable(e){return readTaskTable(e.sessionState.snapshot.session.state)}async function cancelWorkingTasks(e,t){let n=workingTasks(sessionTaskTable(e)).map(e=>e.id);n.length!==0&&await e.advance(e=>cancelTasksStep({...e,reason:t,taskIds:n}))}async function answerTaskCancel(e,t){let n=taskCancelResult(sessionTaskTable(e),t.taskId);if(n===void 0){let e={code:UNKNOWN_TASK_CODE,message:renderUnknownCancelTaskError(t.taskId)};return{...taskToolResult(t.callId,TASK_CANCEL_TOOL_NAME,e),isError:!0}}return n.status===`cancelled`&&await e.advance(e=>cancelTasksStep({...e,reason:`task_cancel`,taskIds:[t.taskId]})),taskToolResult(t.callId,TASK_CANCEL_TOOL_NAME,renderTaskCancelResult(t.taskId,n))}export{answerTaskCancel,cancelWorkingTasks,isTaskRunMessage,sessionTaskTable};

package/dist/src/execution/tasks/start.d.ts

@@ -0,0 +1,34 @@
+import { type StartWorkflowTaskInput } from "#execution/tools/workflow/start.js";
+import type { HarnessSession } from "#harness/types.js";
+import { type TaskStartedStreamEvent } from "#protocol/message.js";
+import type { RuntimeToolResultActionResult, WorkflowToolRunEntry } from "#shared/action-types.js";
+type TaskDispatchInput = StartWorkflowTaskInput & {
+    readonly taskId: string;
+};
+/** The call's answer, and the `task.started` event the dispatch step publishes for it. */
+interface TaskDispatchResult {
+    readonly result: RuntimeToolResultActionResult;
+    readonly session: HarnessSession;
+    readonly started?: TaskStartedStreamEvent;
+}
+/** The entry of a run that does a task's work. */
+type TaskRunEntry = Extract<WorkflowToolRunEntry, {
+    readonly taskId: string;
+}>;
+/**
+ * Starts the run for a task its model step committed, once, and answers the
+ * call with its receipt and the `task.started` event the dispatch step
+ * publishes. Runs inside that step, where the task's cap is enforced: past
+ * it, the record is dropped and the call fails.
+ */
+export declare function startTaskRun(input: StartWorkflowTaskInput & {
+    readonly entry: TaskRunEntry;
+}): Promise<TaskDispatchResult>;
+/**
+ * Sends a call to the `serve` task it names by `taskId`. The task must be
+ * available to the tool, and a call that makes an idle task work again
+ * counts toward the cap. The call is recorded, reported as started, and sent
+ * to the task's run, whose body receives it from `receive()`.
+ */
+export declare function sendToTask(input: TaskDispatchInput): Promise<TaskDispatchResult>;
+export {};

package/dist/src/execution/tasks/start.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{TOO_MANY_TASKS_CODE,UNKNOWN_TASK_CODE}from"#protocol/task-tools.js";import{createTaskStartedEvent}from"#protocol/message.js";import{renderTaskReceipt,renderTaskSentReceipt,renderTooManyTasksError,renderUnknownTaskError}from"#execution/tasks/render.js";import{MAX_WORKING_TASKS,findTask,isTaskAvailable,isTaskWorking,readTaskTable,recordTaskCall,recordTaskRun,removeTask,workingTasks,writeTaskTable}from"#execution/tasks/table.js";import{startFailureResult,startWorkflowToolCallRun}from"#execution/tools/workflow/start.js";import{sendTaskRunCommands}from"#execution/tasks/steps.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`execution.tasks`);async function startTaskRun(e){let{entry:t,session:n,task:r}=e,{taskId:i}=t,a={...e,taskId:i},o=startReceipt(a,t.entryPoint===`serve`),s=readTaskTable(n.state),c=findTask(s,i);if(c===void 0||!isTaskWorking(c))return{result:o,session:n};let l=tooManyTasks(a,s);if(l!==void 0)return{result:l,session:writeTaskTable(n,removeTask(s,i))};let u;try{u=await startWorkflowToolCallRun(e,t)}catch(e){return logError(log,`task run failed to start`,e,{taskId:i,toolName:r.toolName}),{result:startFailureResult(r,e),session:writeTaskTable(n,removeTask(s,i))}}return{result:o,session:writeTaskTable(n,recordTaskRun(s,i,u)),started:taskStartedEvent(a,c)}}async function sendToTask(e){let{session:t,task:n,taskId:r}=e,i=readTaskTable(t.state),a=findTask(i,r);if(!isTaskAvailable(a,n.toolName))return{result:unknownTaskResult(e),session:t};if(!isTaskWorking(a)){let n=tooManyTasks(e,i);if(n!==void 0)return{result:n,session:t}}let o=recordTaskCall(i,r,{agentContext:e.agentContext,auth:e.auth,callId:n.callId,executeInput:n.executeInput,input:n.input,sequence:e.batchEvent.sequence,stepIndex:e.batchEvent.stepIndex,turnId:e.batchEvent.turnId});return o.send!==void 0&&await sendTaskRunCommands(o.send),{result:toolResult(e,renderTaskSentReceipt(r)),session:writeTaskTable(t,o.table),started:taskStartedEvent(e,a)}}function tooManyTasks(e,t){let n=workingTasks(t).filter(e=>e.run!==void 0);if(n.length<MAX_WORKING_TASKS)return;let r=n.map(e=>e.id);return createRuntimeToolResultFromValue({callId:e.task.callId,isError:!0,output:{code:TOO_MANY_TASKS_CODE,message:renderTooManyTasksError(MAX_WORKING_TASKS,r)},toolName:e.task.toolName})}function unknownTaskResult(e){return createRuntimeToolResultFromValue({callId:e.task.callId,isError:!0,output:{code:UNKNOWN_TASK_CODE,message:renderUnknownTaskError(e.taskId,e.task.toolName)},toolName:e.task.toolName})}function taskStartedEvent(e,t){return createTaskStartedEvent({callId:e.task.callId,kind:t.kind,name:e.task.toolName,taskId:e.taskId,turnId:e.batchEvent.turnId})}function startReceipt(e,t){return toolResult(e,renderTaskReceipt({id:e.taskId,resumable:t,tool:e.task.toolName}))}function toolResult(e,t){return createRuntimeToolResultFromValue({callId:e.task.callId,output:t,toolName:e.task.toolName})}export{sendToTask,startTaskRun};

package/dist/src/execution/tasks/steps.d.ts

@@ -0,0 +1,31 @@
+import { type TaskRunCommands } from "#execution/tasks/table.js";
+import { type SessionStepState } from "#execution/publish-session-events.js";
+import { type SessionStateTransition } from "#execution/session/state-delta.js";
+import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
+import { type TaskCancelReason } from "#protocol/message.js";
+/** The messages a task's run sends that change its record. */
+export type TaskRunMessage = Extract<WorkflowToolRunMessage, {
+    readonly kind: "outcome" | "reply" | "started" | "usage";
+}>;
+/** Applies one message from a task's run: started, a reply, usage no reply carried, or the run's outcome. */
+export declare function applyTaskRunMessageStep(input: SessionStepState & {
+    readonly message: TaskRunMessage;
+}): Promise<SessionStateTransition>;
+/**
+ * Cancels tasks: their calls settle as cancelled and their runs are told to
+ * stop. A run ends itself within its cleanup deadline and reports cancelled.
+ * A `task()` run's cancel settles every request it relayed, so the session
+ * withdraws them in the same step and accepts no answer after it. A `serve()`
+ * run withdraws its stretch's questions itself, and the session decides each one.
+ */
+export declare function cancelTasksStep(input: SessionStepState & TaskCancellationInput): Promise<SessionStateTransition>;
+interface TaskCancellationInput {
+    readonly reason: TaskCancelReason;
+    readonly taskIds: readonly string[];
+}
+/**
+ * Sends commands to a task's run, in order. A run that already finished takes
+ * none; its outcome settles any call still waiting.
+ */
+export declare function sendTaskRunCommands(commands: TaskRunCommands): Promise<void>;
+export {};

package/dist/src/execution/tasks/steps.js

@@ -0,0 +1 @@
+import{createTaskSettledEvent}from"#protocol/message.js";import{cancelTask,findTask,finishTaskRun,markTaskRunStarted,readTaskTable,recordTaskRunUsage,settleRemainingTaskCalls,settleTaskCalls,writeTaskTable}from"#execution/tasks/table.js";import{readDurableSession,replaceDurableSessionSnapshot}from"#execution/durable-session-store.js";import{publishSessionEvents,relaySessionEvents}from"#execution/publish-session-events.js";import{withSessionStateDelta}from"#execution/session/state-delta.js";import{withdrawProxyInputRequests}from"#harness/proxy-input-requests.js";import{resumeHook}from"#internal/workflow/runtime.js";import{countRunUsage}from"#execution/agent-sessions/usage.js";import{workflowToolRunFailureOutput}from"#execution/tools/workflow/owner-inbox.js";import{ignoreGoneTarget}from"#execution/tasks/workflow-target.js";async function applyTaskRunMessageStep(e){"use step";return await withSessionStateDelta(e,applyTaskRunMessage)}async function applyTaskRunMessage(e){let{message:t}=e,n=t.from.taskId,r=readDurableSession(e.sessionState);if(n===void 0)return{serializedContext:e.serializedContext,sessionState:e.sessionState};let i=readTaskTable(r.state),a=[],o=[];switch(t.kind){case`started`:{let e=markTaskRunStarted(i,n,t.from.runId);i=e.table,e.held!==void 0&&await sendTaskRunCommands(e.held);break}case`reply`:{({session:r,table:i}=countTaskRunUsage(r,i,n,t));let e={output:t.output,status:`completed`},o=findTask(i,n),s=settleTaskCalls(i,{callIds:t.callIds,outcome:e,taskId:n});i=s.table,a.push(...taskSettledEvents(o,s.settled,e));break}case`usage`:({session:r,table:i}=countTaskRunUsage(r,i,n,t));break;case`outcome`:{({session:r,table:i}=countTaskRunUsage(r,i,n,t));let e=toOutcome(t),s=findTask(i,n),c=settleRemainingTaskCalls(i,n,e);a.push(...taskSettledEvents(s,c.settled,e)),i=finishTaskRun(c.table,n,t.from.runId),{events:o,session:r}=withdrawProxyInputRequests(r,(e,n)=>n.runId===t.from.runId);break}}let s=await relaySessionEvents({...e,sessionState:saveTable(e.sessionState,r,i)},o);return await publishSessionEvents({...e,...s},a)}async function cancelTasksStep(e){"use step";return await withSessionStateDelta(e,cancelTasks)}async function cancelTasks(e){let t=readDurableSession(e.sessionState),n=readTaskTable(t.state),r=[],i=new Set,a={reason:e.reason,status:`cancelled`};for(let t of e.taskIds){let e=findTask(n,t),o=cancelTask(n,t);n=o.table,r.push(...taskSettledEvents(e,o.settled,a)),o.send!==void 0&&(e?.resumable===!1&&i.add(o.send.run.runId),await sendTaskRunCommands(o.send))}let o=withdrawProxyInputRequests(t,(e,t)=>t.runId!==void 0&&i.has(t.runId)),s=await relaySessionEvents({...e,sessionState:saveTable(e.sessionState,o.session,n)},o.events);return await publishSessionEvents({...e,...s},r)}function taskSettledEvents(e,t,n){return e===void 0?[]:t.map(t=>taskSettledEvent(e,t,n))}function taskSettledEvent(e,t,n){let r={callId:t.callId,kind:e.kind,name:e.name,taskId:e.id,turnId:t.turnId};switch(n.status){case`completed`:return createTaskSettledEvent({...r,output:n.output,status:`completed`});case`failed`:return createTaskSettledEvent({...r,error:{message:n.error},status:`failed`});case`cancelled`:return createTaskSettledEvent(n.reason===void 0?{...r,status:`cancelled`}:{...r,cancel:{reason:n.reason},status:`cancelled`})}}async function sendTaskRunCommands(e){for(let t of e.commands)await ignoreGoneTarget(resumeHook(e.run.hookToken,toControlMessage(t)))}function toControlMessage(e){switch(e.kind){case`cancel`:return{kind:`cancel`,reason:`The task was cancelled.`};case`call`:return{call:e.call,kind:`call`}}}function toOutcome(e){switch(e.result.status){case`completed`:return{output:e.result.output,status:`completed`};case`failed`:return{error:failureMessage(e),status:`failed`};case`cancelled`:return{status:`cancelled`}}}function failureMessage(e){let t=workflowToolRunFailureOutput(e);if(typeof t==`string`)return t;let n=typeof t==`object`&&t?Reflect.get(t,`message`):void 0;return typeof n==`string`?n:JSON.stringify(t)}function countTaskRunUsage(e,t,n,r){let i=findTask(t,n)?.run;return r.usage===void 0||i?.runId!==r.from.runId?{session:e,table:t}:{session:countRunUsage(e,r.usage,i.usage),table:recordTaskRunUsage(t,n,r.usage)}}function saveTable(e,t,n){return replaceDurableSessionSnapshot({session:writeTaskTable(t,n),state:e})}export{applyTaskRunMessageStep,cancelTasksStep,sendTaskRunCommands};