eve 0.62.0 → 0.63.0

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

@@ -1 +0,0 @@
-import{createLogger}from"#internal/logging.js";import{getWritable}from"#compiled/@workflow/core/index.js";import{resumeSessionInbox}from"#execution/session-inbox/resume.js";import{resumeWorkflowToolRunAnswers}from"#execution/tools/workflow/answer.js";import{submitActivity}from"#execution/submit-activity.js";import{isTaskWorkflowTargetGone}from"#execution/tasks/workflow-target.js";import{TASK_PROGRESS_STREAM_NAMESPACE,TASK_VIEW_STREAM_NAMESPACE,isTerminalTaskStatus,taskAuthorizationRequestId}from"#tasks/types.js";const log=createLogger(`execution.tasks.run`);async function appendTaskViewStep(e){"use step";let t=getWritable({namespace:TASK_VIEW_STREAM_NAMESPACE}).getWriter();try{await t.write(e.view)}finally{t.releaseLock()}let n=projectTaskActivity({activityObserver:e.activityObserver,settledAt:new Date().toISOString(),view:e.view});await submitActivity({events:n,sink:e.activityObserver?.sink})}function projectTaskActivity(e){let t=e.activityObserver?.workIdentity;if(t===void 0)return[];let n=e.view.status;return n===`working`?[{eventId:`${t.id}:started`,kind:`work.started`,startedAt:e.settledAt,work:t}]:n!==`completed`&&n!==`failed`&&n!==`cancelled`?[]:[{eventId:`${t.id}:settled:${n}`,kind:`work.settled`,outcome:n,settledAt:e.settledAt,workId:t.id}]}async function appendTaskProgressStep(e){"use step";let t=getWritable({namespace:TASK_PROGRESS_STREAM_NAMESPACE}).getWriter();try{await t.write(e.progress)}finally{t.releaseLock()}}async function wakeTaskParentStep(e){"use step";let t={message:formatTaskNotification(e.view)};isTerminalTaskStatus(e.view.status)&&(t.task={views:[e.view]});let n={kind:`send`,payload:t,taskDeliveryId:`${e.view.taskId}:ready:${e.view.status}`};try{await resumeSessionInbox(e.token,n)}catch(t){if(isTaskWorkflowTargetGone(t)){log.warn(`task wake target is gone; the parent session already ended`,{status:e.view.status,taskId:e.view.taskId});return}throw t}}async function wakeTaskUpdateParentStep(e){"use step";let t={kind:`send`,payload:{message:`Background task ${e.view.taskId} (${e.view.metadata.name}) update: ${e.update.message}`},taskDeliveryId:`${e.view.taskId}:update:${e.update.updateEpoch}:${e.update.updateIndex}:${e.update.callId}`};try{await resumeSessionInbox(e.token,t)}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}async function wakeTaskMessageParentStep(e){"use step";let t={kind:`send`,payload:{message:e.message.message},taskDeliveryId:`${e.taskId}:message:${e.message.messageEpoch}:${e.message.messageIndex}:${e.message.callId}`};try{await resumeSessionInbox(e.token,t)}catch(e){if(isTaskWorkflowTargetGone(e))return;throw e}}async function wakeTaskAgentRequestParentStep(e){"use step";let t=e.request.request;if(t.kind!==`agent-invoke`&&t.kind!==`agent-settled`)throw Error(`Cannot forward task input as an agent request.`);let n={replyTo:e.request.replyTo,request:t,taskId:e.taskId},r=t.kind===`agent-invoke`?t.invocationId:`${t.result.callId}:settled`,i={kind:`send`,payload:{task:{agentRequests:[n]}},taskDeliveryId:`${e.taskId}:agent:${e.request.from.runId}:${r}`};try{await resumeSessionInbox(e.token,i)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}async function wakeTaskAuthorizationParentStep(e){"use step";let{event:t}=e.request,n=t.event.data,r={task:{authorizationEvents:[{hookPayload:t,taskId:e.taskId}]}};t.event.type===`authorization.required`&&(r.message=`Background task ${e.taskId} needs authorization.`);let i={kind:`send`,payload:r,taskDeliveryId:`${e.taskId}:authorization:${t.event.type}:${n.turnId}:${n.stepIndex}:${n.sequence}:${taskAuthorizationRequestId(t.event)}`};try{await resumeSessionInbox(e.token,i)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}async function wakeWorkflowTaskInputRequestParentStep(e){"use step";let t={kind:`send`,payload:{task:{inputRequests:[e.request.requests===void 0?{replyTo:e.request.replyTo,request:e.request.request,sequence:e.request.sequence,stepIndex:e.request.stepIndex,taskId:e.taskId,turnId:e.request.turnId}:{replyTo:e.request.replyTo,requests:e.request.requests,sequence:e.request.sequence,stepIndex:e.request.stepIndex,taskId:e.taskId,turnId:e.request.turnId}]}},taskDeliveryId:`${e.taskId}:input:${e.request.turnId}:${e.request.stepIndex}:${e.request.sequence}`};try{await resumeSessionInbox(e.token,t)}catch(e){if(!isTaskWorkflowTargetGone(e))throw e}}async function deliverTaskInputResponsesStep(e){"use step";let t=new Set(e.requestIds),n={auth:e.answer.auth,kind:`send`,payload:{inputResponses:e.answer.inputResponses.filter(e=>t.has(e.requestId))},taskDeliveryId:`${e.answer.taskId}:${[...e.requestIds].sort().join(`,`)}`};try{if(e.answer.childResponseUrl!==void 0){let t=await fetch(e.answer.childResponseUrl,{body:JSON.stringify({inputResponses:n.payload.inputResponses}),headers:{"content-type":`application/json`},method:`POST`,redirect:`error`});if(t.status===404)return`unreachable`;if(!t.ok)throw Error(`Remote task input delivery failed with HTTP ${t.status}.`)}else e.answerHook===void 0?await resumeSessionInbox(e.answer.childSessionInbox??e.answer.childContinuationToken,n):await resumeWorkflowToolRunAnswers(e.answer.childContinuationToken,n.payload.inputResponses);return`delivered`}catch(t){if(isTaskWorkflowTargetGone(t))return log.warn(`task input answer target is gone; the child turn already ended`,{taskId:e.answer.taskId}),`unreachable`;throw t}}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`}export{appendTaskProgressStep,appendTaskViewStep,deliverTaskInputResponsesStep,formatTaskNotification,projectTaskActivity,wakeTaskAgentRequestParentStep,wakeTaskAuthorizationParentStep,wakeTaskMessageParentStep,wakeTaskParentStep,wakeTaskUpdateParentStep,wakeWorkflowTaskInputRequestParentStep};

package/dist/src/execution/tasks/child/workflow.d.ts

@@ -1,28 +0,0 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import { type WorkflowBodyDefinition } from "#execution/tools/workflow/body.js";
-import { type TaskInputRequest, type TaskView } from "#tasks/types.js";
-export interface TaskRunWorkflowInput {
-    readonly activityObserver?: ActivityObserverConfig;
-    readonly initialView: TaskView;
-    readonly parentContinuationToken: string;
-    readonly taskInboxToken: string;
-    readonly workflow?: WorkflowBodyDefinition;
-}
-/** A workflow-body question routed through the task that owns the workflow tool run. */
-interface WorkflowToolRunTaskInputRequestBase {
-    readonly kind: "task-input-request";
-    readonly replyTo: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}
-export type WorkflowToolRunTaskInputRequest = WorkflowToolRunTaskInputRequestBase & ({
-    readonly request: TaskInputRequest;
-    readonly requests?: never;
-} | {
-    readonly request?: never;
-    readonly requests: readonly TaskInputRequest[];
-});
-/** Owns lifecycle for one background task and consumes its executor traffic. */
-export declare function taskRunWorkflow(input: TaskRunWorkflowInput): Promise<void>;
-export {};

package/dist/src/execution/tasks/child/workflow.js

@@ -1 +0,0 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,isHookConflictError}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{workflowToolRunOutcomeToTaskCommand,workflowToolRunReportToTaskPayload,workflowToolRunRequestToTaskInputRequest}from"#execution/tools/workflow/owner-inbox.js";import{isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";import{appendTaskProgressStep,appendTaskViewStep,deliverTaskInputResponsesStep,wakeTaskAgentRequestParentStep,wakeTaskAuthorizationParentStep,wakeTaskMessageParentStep,wakeTaskParentStep,wakeTaskUpdateParentStep,wakeWorkflowTaskInputRequestParentStep}from"#execution/tasks/child/steps.js";import{createWorkflowBodyRef,executeWorkflowBody}from"#execution/tools/workflow/body.js";import{createChannelReader,raceChannelReads}from"#execution/tools/workflow/owner-channels.js";import{openWorkflowToolRunOwnerInbox}from"#execution/tools/workflow/owner.js";import{applyTaskTransition}from"#tasks/transitions.js";async function taskRunWorkflow(e){"use workflow";let t=createHook({token:e.taskInboxToken}),n=openWorkflowToolRunOwnerInbox(),r=[n.reader,createChannelReader(`commands`,t)],i=e.initialView,a=!1,o=!1,s,c=[],l=0,u={messages:[],ownerRequests:[]},d=new Map,f=new AbortController,p,m=e.workflow===void 0,h;try{await claimHookOwnership(t)}catch(e){if(isHookConflictError(e))return;throw e}for(await appendTaskViewStep({activityObserver:e.activityObserver,view:i});h!==void 0&&l>=h.reportCount&&(m=!0,await applyPayload({command:workflowToolRunOutcomeToTaskCommand({from:createWorkflowBodyRef({...e.workflow,execution:`background`}),result:h.outcome}),kind:`task-command`}),h=void 0,i.status===`cancelled`&&a&&!o&&await wakeTaskParentStep({token:e.parentContinuationToken,view:i})),!isFinished();){let e=await raceChannelReads(p===void 0?r:[...r,p]);if(e.channel===`body`){if(p=void 0,e.next.done)continue;h=e.next.value;continue}if(e.next.done)return;if(e.channel===`workflow`){let t=e.next.value;if(t.kind===`report`){await applyPayload(workflowToolRunReportToTaskPayload(t,i.taskId,l++));continue}if(t.kind===`outcome`){await applyPayload({command:workflowToolRunOutcomeToTaskCommand(t),kind:`task-command`});continue}let n=t,r=n.request.kind;if(r===`agent-invoke`||r===`agent-settled`||r===`authorization-request`){await handleOwnerRequest(n);continue}n.requestCoordinates===void 0&&d.set(n.replyTo,{runId:n.from.runId}),await applyPayload(workflowToolRunRequestToTaskInputRequest(n));continue}await applyPayload(e.next.value)}function isFinished(){return isTerminalTaskStatus(i.status)&&a&&m}async function handleUpdate(t){if(i.metadata.kind===`subagent`){if(o)return;a&&!isTerminalTaskStatus(i.status)?await wakeTaskUpdateParentStep({token:e.parentContinuationToken,update:t,view:i}):c.push(t);return}await appendTaskProgressStep({progress:{callId:t.callId,kind:`task-progress`,taskId:i.taskId,update:t.message,updateIndex:t.updateIndex}})}async function handleMessage(t){if(!(o||isTerminalTaskStatus(i.status))){if(!a){u.messages.push(t);return}await wakeTaskMessageParentStep({message:t,taskId:i.taskId,token:e.parentContinuationToken})}}async function applyPayload(t){let r=t.kind===`task-command`&&t.command.kind===`ready`,c=t.kind===`task-command`&&t.command.kind===`reject-dispatch`;if((r||c)&&(a=!0),c&&(o=!0),(r||c)&&(c||isTerminalTaskStatus(i.status)?m=!0:e.workflow!==void 0&&p===void 0&&h===void 0&&!m&&(p=createChannelReader(`body`,awaitBodyResult(executeWorkflowBody({...e.workflow,execution:`background`,owner:n.owner},f.signal)))),await flushPendingTraffic()),t.kind===`task-input-request`&&(s=t),t.kind===`task-message`){await handleMessage(t);return}if(t.kind===`task-update`){await handleUpdate(t);return}let l;if(t.kind===`input-response`)l=i.status===`input_required`?await resolveAnsweredCommand(i,t,d.get(t.childContinuationToken)):void 0;else if(t.kind===`task-input-request`)l={inputRequests:t.requests??[t.request],kind:`require-input`};else if(t.kind===`task-command`)l=t.command;else return;if(l===void 0)return;if(r&&isTerminalTaskStatus(i.status)){await flushUpdates(!0),await wakeTaskParentStep({token:e.parentContinuationToken,view:i});return}let u=i;await transitionTask(l)&&(l.kind===`cancel`&&(f.abort(Error(`Task ${i.taskId} was cancelled.`)),p===void 0&&(m=!0)),isTerminalTaskStatus(i.status)||await flushUpdates(),s!==void 0&&a&&i.status===`input_required`?(await wakeWorkflowTaskInputRequestParentStep({request:s,taskId:i.taskId,token:e.parentContinuationToken}),s=void 0):!o&&a&&(l.kind!==`cancel`||m)&&(!isTerminalTaskStatus(u.status)&&isTerminalTaskStatus(i.status)||!isReadyTaskStatus(u.status)&&isReadyTaskStatus(i.status)&&s===void 0)&&await wakeTaskParentStep({token:e.parentContinuationToken,view:i}),i.status!==`input_required`&&(s=void 0))}async function flushUpdates(t=!1){if(!(!a||isTerminalTaskStatus(i.status)&&!t)){for(let t of c)await wakeTaskUpdateParentStep({token:e.parentContinuationToken,update:t,view:i});c=[]}}async function transitionTask(t){let n=applyTaskTransition(i,t);return n.action===`accepted`&&(i=n.view,await appendTaskViewStep({activityObserver:e.activityObserver,view:i}),!0)}async function handleOwnerRequest(t){if(!a){u.ownerRequests.push(t);return}let{request:n,replyTo:r}=t;if(n.kind===`authorization-request`&&n.event.childSessionId===t.from.runId){await handleStepAuthorization(n,r);return}if(!(o||isTerminalTaskStatus(i.status))){if(n.kind===`authorization-request`){await wakeTaskAuthorizationParentStep({request:n,taskId:i.taskId,token:e.parentContinuationToken});return}await wakeTaskAgentRequestParentStep({request:t,taskId:i.taskId,token:e.parentContinuationToken})}}async function handleStepAuthorization(t,n){let r=t.event.event,a=r.type===`authorization.completed`;if(!o&&(!isTerminalTaskStatus(i.status)||a)){let n=`attemptId`in r.data?r.data.attemptId:void 0;n!==void 0&&r.type===`authorization.required`?await transitionTask({kind:`require-input`,inputRequests:[...i.status===`input_required`?i.inputRequests:[],{kind:`authorization`,requestId:n,name:r.data.name}]}):n!==void 0&&await transitionTask({kind:`answered`,requestIds:[n]}),await wakeTaskAuthorizationParentStep({request:t,taskId:i.taskId,token:e.parentContinuationToken})}await resumeHookStep(n,null,{ifPresent:!0})}async function flushPendingTraffic(){if(!o)for(let t of u.messages)await wakeTaskMessageParentStep({message:t,taskId:i.taskId,token:e.parentContinuationToken});for(let e of u.ownerRequests)await handleOwnerRequest(e);u.messages.length=0,u.ownerRequests.length=0}}async function*awaitBodyResult(e){yield await e}async function resolveAnsweredCommand(e,t,n){if(t.taskId!==e.taskId)return;let r=new Set(e.inputRequests.flatMap(e=>{let t=readTaskInputRequestId(e);return t===void 0?[]:[t]})),i=t.inputResponses.map(e=>e.requestId).filter(e=>r.has(e));if(i.length!==0)return await deliverTaskInputResponsesStep({answer:t,answerHook:n,requestIds:i})===`delivered`?{kind:`answered`,requestIds:i}:void 0}taskRunWorkflow.workflowId=`workflow//eve//taskRunWorkflow`;export{taskRunWorkflow};

package/dist/src/execution/tools/subagent/emit-called-step.d.ts

@@ -1,9 +0,0 @@
-import { type UnstampedMessageStreamEvent } from "#protocol/message.js";
-/** Emits an already-projected task-owned `subagent.called` event on the parent stream. */
-export declare function emitTaskSubagentCalledStep(input: {
-    readonly event: UnstampedMessageStreamEvent;
-    readonly sessionWritable: WritableStream<Uint8Array>;
-    readonly serializedContext: Record<string, unknown>;
-}): Promise<{
-    readonly serializedContext: Record<string, unknown>;
-}>;

package/dist/src/execution/tools/subagent/emit-called-step.js

@@ -1 +0,0 @@
-import{callAdapterEventHandler}from"#channel/adapter.js";import{encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{buildAdapterContext}from"#channel/adapter-context.js";async function emitTaskSubagentCalledStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=t.require(ChannelKey),r=await callAdapterEventHandler(n,e.event,buildAdapterContext(n,t)),i=e.sessionWritable.getWriter();try{await i.write(encodeMessageStreamEvent(stampMessageStreamEvent(r)))}finally{i.releaseLock()}return{serializedContext:serializeContext(t)}}export{emitTaskSubagentCalledStep};

package/dist/src/execution/tools/workflow/run-control.d.ts

@@ -1,14 +0,0 @@
-/**
- * The run's control inbox. An unawaited hook read is not scheduled under
- * replay, so `cancelled` must be raced for a cancel to be observed at all.
- */
-export interface WorkflowToolRunControlInbox {
-    readonly signal: AbortSignal;
-    /** Rejects with {@link WorkflowToolRunCancelledError} when a cancel message arrives; never resolves. */
-    readonly cancelled: Promise<never>;
-    reason(): string | undefined;
-}
-export declare function openWorkflowToolRunControlInbox(hookToken: string): WorkflowToolRunControlInbox;
-export declare class WorkflowToolRunCancelledError extends Error {
-    constructor(reason: string);
-}

package/dist/src/execution/tools/workflow/run-control.js

@@ -1 +0,0 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{isWorkflowToolRunControlMessage}from"#execution/tools/workflow/messages.js";function openWorkflowToolRunControlInbox(e){let t=createHook({token:e})[Symbol.asyncIterator](),n=new AbortController,r,i=consumeCancel(t,e=>{r=e,n.abort(new WorkflowToolRunCancelledError(e))});return i.catch(()=>{}),{cancelled:i,reason:()=>r,signal:n.signal}}async function consumeCancel(e,t){for(;;){let n=await e.next();if(n.done===!0)return await new Promise(()=>{});if(isWorkflowToolRunControlMessage(n.value))throw t(n.value.reason),new WorkflowToolRunCancelledError(n.value.reason)}}var WorkflowToolRunCancelledError=class extends Error{constructor(e){super(e),this.name=`WorkflowToolRunCancelledError`}};export{WorkflowToolRunCancelledError,openWorkflowToolRunControlInbox};

package/dist/src/tasks/session-index.d.ts

@@ -1,65 +0,0 @@
-import type { HarnessSession, SessionStateMap } from "#harness/types.js";
-import { type ActivityWorkIdentityV1 } from "#protocol/activity.js";
-import type { TaskExecutorBinding } from "#tools/task.js";
-import { type TaskMetadata, type TaskView } from "#tasks/types.js";
-import { type DurableDynamicSubagentSelection, type SessionAuth } from "#context/keys.js";
-/**
- * Session-state key for the parent's live-task index.
- *
- * The parent session stores only this index; the mutable task record
- * lives in the dedicated durable task run. The PR #1190 spike found the
- * session-state boundary unworkable for task state itself: session state
- * threads through step results, while callback routes and child
- * executors must update tasks without holding the current snapshot.
- */
-export { SESSION_TASKS_STATE_KEY } from "#tasks/session-task-cohorts.js";
-/**
- * One task owned by this session. Immutable model-safe metadata keeps the
- * task-to-agent join available before the task run publishes its first view.
- *
- * `taskInboxToken` is the private routing credential for the task run's
- * inbound hook. It must never render into model context, history, task
- * views, or compaction summaries — the model addresses tasks by
- * `taskId` only, and lookup verifies ownership through this index.
- */
-export interface SessionTaskIndexEntry {
-    readonly activityWorkIdentity?: ActivityWorkIdentityV1;
-    readonly dispatchContext: SessionTaskDispatchContext;
-    readonly taskId: string;
-    readonly taskRunId: string;
-    /** Immutable fallback once the owning workflow run expires. */
-    readonly terminalView?: TaskView;
-    readonly taskInboxToken: string;
-    readonly createdByStepIndex?: number;
-    readonly createdByTurnId: string;
-    /** Immutable join target; absent on the task that starts a cohort. */
-    readonly cohortId?: string;
-    readonly executor?: TaskExecutorBinding;
-    readonly metadata: TaskMetadata;
-}
-export interface TaskAgentDispatchContext {
-    readonly auth: SessionAuth;
-    readonly sessionDynamicSubagentSelections?: Readonly<Record<string, DurableDynamicSubagentSelection>>;
-    readonly turnDynamicSubagentSelections?: Readonly<Record<string, DurableDynamicSubagentSelection>>;
-}
-export declare const LEGACY_TASK_AGENT_DISPATCH_CONTEXT: {
-    readonly legacy: true;
-};
-export type SessionTaskDispatchContext = TaskAgentDispatchContext | typeof LEGACY_TASK_AGENT_DISPATCH_CONTEXT;
-/**
- * Reads and validates the task index from session state.
- *
- * A present but invalid index throws: treating corruption as absence
- * would silently orphan every live task's routing credential.
- */
-export declare function getSessionTaskIndex(state: SessionStateMap | undefined): readonly SessionTaskIndexEntry[];
-/** Caches one terminal view beside its task-run address. */
-export declare function cacheTerminalTaskView(state: SessionStateMap | undefined, view: TaskView): SessionStateMap | undefined;
-/** Finds one owned task; `undefined` enforces parent-session ownership. */
-export declare function findSessionTaskEntry(state: SessionStateMap | undefined, taskId: string): SessionTaskIndexEntry | undefined;
-/**
- * Joins the indexed cohort that still has unreported/nonterminal work. Cached
- * terminal siblings remain members until the whole cohort settles. Membership
- * and creation provenance survive replay, even after that cohort has settled.
- */
-export declare function recordSessionTask(session: HarnessSession, entry: Omit<SessionTaskIndexEntry, "cohortId">): HarnessSession;

package/dist/src/tasks/session-index.js

@@ -1 +0,0 @@
-import{z}from"#compiled/zod/index.js";import"#context/keys.js";import{parseActivityWorkIdentityV1}from"#protocol/activity.js";import{SESSION_TASKS_STATE_KEY,SESSION_TASKS_STATE_KEY as SESSION_TASKS_STATE_KEY$1,SESSION_TASKS_STATE_VERSION,getTaskCohortId}from"#tasks/session-task-cohorts.js";import{sameTaskMetadata}from"#tasks/types.js";const taskMetadataSchema=z.looseObject({kind:z.string().min(1),name:z.string().min(1)}),LEGACY_TASK_AGENT_DISPATCH_CONTEXT={legacy:!0},sessionAuthContextSchema=z.strictObject({attributes:z.record(z.string(),z.union([z.string(),z.array(z.string()).readonly()])),authenticator:z.string(),issuer:z.string().optional(),principalId:z.string(),principalType:z.string(),subject:z.string().optional()}),dynamicSubagentSelectionsSchema=z.record(z.string(),z.custom()),taskAgentDispatchContextSchema=z.strictObject({auth:z.strictObject({current:sessionAuthContextSchema.nullable(),initiator:sessionAuthContextSchema.nullable()}),sessionDynamicSubagentSelections:dynamicSubagentSelectionsSchema.optional(),turnDynamicSubagentSelections:dynamicSubagentSelectionsSchema.optional()}),sessionTaskDispatchContextSchema=z.union([taskAgentDispatchContextSchema,z.strictObject({legacy:z.literal(!0)})]),taskViewBaseShape={inputRequests:z.never().optional(),executor:z.looseObject({binding:z.looseObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional()}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),usage:z.looseObject({cacheReadTokens:z.number().nonnegative(),cacheWriteTokens:z.number().nonnegative(),costUsd:z.number().finite().nonnegative().optional(),inputTokens:z.number().nonnegative(),outputTokens:z.number().nonnegative()}).optional()},taskViewSchema=z.discriminatedUnion(`status`,[z.looseObject({...taskViewBaseShape,lastOutput:z.looseObject({data:z.custom(),type:z.literal(`result`)}),status:z.literal(`completed`)}),z.looseObject({...taskViewBaseShape,lastOutput:z.looseObject({data:z.custom(),type:z.literal(`error`)}),status:z.literal(`failed`)}),z.looseObject({...taskViewBaseShape,lastOutput:z.never().optional(),status:z.literal(`cancelled`)})]),storedSessionTaskIndexEntrySchema=z.looseObject({activityWorkIdentity:z.custom(e=>parseActivityWorkIdentityV1(e)!==void 0).optional(),taskInboxToken:z.string().min(1),createdByStepIndex:z.number().int().nonnegative().optional(),createdByTurnId:z.string().min(1),cohortId:z.string().min(1).optional(),dispatchContext:sessionTaskDispatchContextSchema.optional(),executor:z.looseObject({data:z.record(z.string(),z.custom()),kind:z.string().min(1)}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),taskRunId:z.string().min(1),terminalView:taskViewSchema.optional()}),sessionTaskIndexSchema=z.looseObject({tasks:z.array(storedSessionTaskIndexEntrySchema),version:z.literal(SESSION_TASKS_STATE_VERSION)}).refine(e=>new Set(e.tasks.map(e=>e.taskId)).size===e.tasks.length,{message:`Task ids must be unique.`}).refine(e=>e.tasks.every(e=>e.terminalView===void 0||e.terminalView.taskId===e.taskId&&sameTaskMetadata(e.terminalView.metadata,e.metadata)),{message:`Cached terminal views must match their task index entry.`});function getSessionTaskIndex(e){return readSessionTaskIndex(e).tasks}function readSessionTaskIndex(e){let t=e?.[SESSION_TASKS_STATE_KEY$1];if(t===void 0)return{tasks:[],version:SESSION_TASKS_STATE_VERSION};let n=typeof t==`object`&&t?Reflect.get(t,`version`):void 0;if(n!==SESSION_TASKS_STATE_VERSION)throw Error(`Unsupported task index version ${JSON.stringify(n)} under session state key "${SESSION_TASKS_STATE_KEY$1}"; expected version ${SESSION_TASKS_STATE_VERSION}.`);let r=sessionTaskIndexSchema.safeParse(t);if(!r.success)throw Error(`Corrupt task index under session state key "${SESSION_TASKS_STATE_KEY$1}": ${r.error.message}`);return{...r.data,tasks:r.data.tasks.map(e=>({...e,dispatchContext:e.dispatchContext??LEGACY_TASK_AGENT_DISPATCH_CONTEXT}))}}function cacheTerminalTaskView(e,t){if(!isValidTerminalView(t))throw Error(`Cannot cache invalid terminal task "${t.taskId}".`);let n=readSessionTaskIndex(e),r=n.tasks,i=r.findIndex(e=>e.taskId===t.taskId);if(i<0)return e;if(!sameTaskMetadata(r[i].metadata,t.metadata))throw Error(`Task view metadata does not match index entry "${t.taskId}".`);let a=[...r],o=a[i].terminalView;return a[i]={...a[i],terminalView:taskViewSchema.parse({...o,...t,metadata:{...o?.metadata,...t.metadata},lastOutput:t.lastOutput===void 0?void 0:{...o?.lastOutput,...t.lastOutput},usage:t.usage===void 0?void 0:{...o?.usage,...t.usage},executor:t.executor===void 0?void 0:{...o?.executor,...t.executor,binding:t.executor.binding===void 0?void 0:{...o?.executor?.binding,...t.executor.binding}}})},{...e,[SESSION_TASKS_STATE_KEY$1]:{...n,tasks:a}}}function isValidTerminalView(e){if(e.inputRequests!==void 0)return!1;switch(e.status){case`completed`:return e.lastOutput?.type===`result`;case`failed`:return e.lastOutput?.type===`error`;case`cancelled`:return e.lastOutput===void 0;case`working`:return!1}}function findSessionTaskEntry(e,t){return getSessionTaskIndex(e).find(e=>e.taskId===t)}function recordSessionTask(e,t){let n=readSessionTaskIndex(e.state),r=[...n.tasks],i=r.findIndex(e=>e.taskId===t.taskId),a=r[i];if(a!==void 0)r[i]={...a,...t,metadata:{...a.metadata,...t.metadata},activityWorkIdentity:t.activityWorkIdentity===void 0?a.activityWorkIdentity:{...a.activityWorkIdentity,...t.activityWorkIdentity},executor:t.executor===void 0?a.executor:{...a.executor,...t.executor},cohortId:a.cohortId,createdByStepIndex:a.createdByStepIndex,createdByTurnId:a.createdByTurnId,dispatchContext:a.dispatchContext,terminalView:a.terminalView??t.terminalView};else{let e=r.find(e=>e.terminalView===void 0);r.push({...t,cohortId:e===void 0?void 0:getTaskCohortId(e)})}return{...e,state:{...e.state,[SESSION_TASKS_STATE_KEY$1]:{...n,tasks:r,version:SESSION_TASKS_STATE_VERSION}}}}export{LEGACY_TASK_AGENT_DISPATCH_CONTEXT,SESSION_TASKS_STATE_KEY,cacheTerminalTaskView,findSessionTaskEntry,getSessionTaskIndex,recordSessionTask};

package/dist/src/tools/task.d.ts

@@ -1,55 +0,0 @@
-import type { BackgroundTask } from "#execution/tasks/parent/delegate.js";
-import type { HarnessSession } from "#harness/types.js";
-import type { JsonObject, JsonValue } from "#shared/json.js";
-declare const TASK_MESSAGE_KIND: "eve:task-message";
-export type TaskMessage = JsonObject & {
-    readonly kind: typeof TASK_MESSAGE_KIND;
-    readonly message: string;
-};
-export declare function createTaskMessage(message: string): TaskMessage;
-export declare function isTaskMessage(value: unknown): value is TaskMessage;
-/** Opaque, framework-private address used to control a task executor. */
-export interface TaskExecutorBinding {
-    readonly kind: string;
-    readonly data: JsonObject;
-}
-/** @deprecated Use workflow-backed background tools with yield descriptors. */
-export interface TaskBinding {
-    readonly taskId: string;
-    readonly token: string;
-    readonly url?: string;
-}
-/** @deprecated Use workflow-backed background tools with yield descriptors. */
-export type TaskSendCommand = {
-    readonly kind: "update";
-    readonly message: string;
-} | {
-    readonly kind: "complete";
-    readonly data: JsonValue;
-} | {
-    readonly kind: "fail";
-    readonly data: JsonValue;
-} | {
-    readonly kind: "cancel";
-};
-/** Fixed acknowledgement returned when a background task is admitted. */
-export interface TaskReceipt {
-    readonly status: "working";
-    readonly taskId: string;
-}
-/** Capability passed only to tools declared with `execution: "background"`. */
-export interface TaskExec {
-    /** Model-facing durable task identity. */
-    readonly taskId: string;
-    /** Returns a descriptor which sends one message to the parent when yielded. */
-    postMessage(message: string): TaskMessage;
-    /** @deprecated Use yields from a workflow-backed background tool. */
-    readonly binding: TaskBinding;
-    /** @deprecated Use yields from a workflow-backed background tool. */
-    readonly send: (command: TaskSendCommand) => Promise<void>;
-    /** @deprecated Use ctx.session. */
-    readonly session: HarnessSession;
-    /** @deprecated Framework-owned task internals are not part of the authoring API. */
-    readonly task: BackgroundTask;
-}
-export {};

package/dist/src/tools/task.js

@@ -1 +0,0 @@
-const TASK_MESSAGE_KIND=`eve:task-message`;function createTaskMessage(e){if(e.trim()===``)throw TypeError(`Task messages must not be empty.`);return{kind:TASK_MESSAGE_KIND,message:e}}function isTaskMessage(e){return typeof e==`object`&&!!e&&Reflect.get(e,`kind`)===TASK_MESSAGE_KIND}export{createTaskMessage,isTaskMessage};