eve 0.68.0 → 0.70.0

package/dist/src/execution/tools/workflow/emit-workflow-tool-run-report-step.js

@@ -1 +1 @@
-import{createActionPartialEvent,encodeMessageStreamEvent,stampMessageStreamEvent}from"#protocol/message.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";async function emitWorkflowToolRunReportStep(e){"use step";let t=createActionPartialEvent({result:createRuntimeToolResultFromValue({callId:e.from.callId,output:e.update,toolName:e.from.toolName}),sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId}),n=e.sessionWritable.getWriter();try{await n.write(encodeMessageStreamEvent(stampMessageStreamEvent(t)))}finally{n.releaseLock()}}export{emitWorkflowToolRunReportStep};
+import{createActionPartialEvent,createAgentStartedEvent}from"#protocol/message.js";import{publishSessionEvents}from"#execution/publish-session-events.js";import{withSessionStateDelta}from"#execution/session/state-delta.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";async function emitWorkflowToolRunReportStep(e){"use step";let t=createActionPartialEvent({result:createRuntimeToolResultFromValue({callId:e.from.callId,output:e.update,toolName:e.from.toolName}),sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId});return await withSessionStateDelta(e,e=>publishSessionEvents(e,[t]))}async function emitAgentStartedStep(e){"use step";let t=e.messages.map(({from:t,session:n})=>createAgentStartedEvent({callId:t.callId,name:n.name,parentSessionId:e.sessionState.sessionId,remote:n.kind===`remote`?{url:n.url,...n.resolverId!==void 0&&{resolverId:n.resolverId}}:void 0,sessionId:n.sessionId,...t.taskId!==void 0&&{taskId:t.taskId},turnId:t.turnId}));return await withSessionStateDelta(e,e=>publishSessionEvents(e,t))}export{emitAgentStartedStep,emitWorkflowToolRunReportStep};

package/dist/src/execution/tools/workflow/{background.d.ts → harness-definition.d.ts}

@@ -1,14 +1,14 @@
 import type { HarnessToolDefinition } from "#harness/execute-tool.js";
 import type { PreparedRuntimeTool } from "#runtime/sessions/turn.js";
-import { parseJsonObject, type JsonValue } from "#shared/json.js";
-interface WorkflowToolHarnessDefinitionInput {
+import type { JsonValue } from "#shared/json.js";
+export interface WorkflowToolHarnessDefinitionInput {
     readonly definition: HarnessToolDefinition;
     readonly executeInput?: (input: unknown) => JsonValue;
-    /** Selected agent definition's runtime graph ID; absent for authored workflow tools. */
-    readonly nodeId?: string;
     readonly workflowId: string;
 }
+/**
+ * Workflow tools run outside the model step, so the harness definition carries
+ * no `execute`. A `serve` tool's model input gains `taskId`.
+ */
 export declare function createWorkflowToolHarnessDefinition(input: WorkflowToolHarnessDefinitionInput): HarnessToolDefinition;
 export declare function createPreparedWorkflowToolHarnessDefinition(tool: PreparedRuntimeTool): HarnessToolDefinition;
-export declare function parseWorkflowToolInput(toolInput: unknown, toolName: string): ReturnType<typeof parseJsonObject>;
-export {};

package/dist/src/execution/tools/workflow/harness-definition.js

@@ -0,0 +1 @@
+import{UNSPECIFIED_INPUT_SCHEMA,toInputSchema,toOutputSchema}from"#tools/schema.js";import{workflowIdForHandling}from"#runtime/subagents/workflow-reference.js";import{withTaskIdInput}from"#execution/tasks/task-id-input.js";import{entryPointOf}from"#execution/tasks/tool-entry-point.js";function createWorkflowToolHarnessDefinition(e){return{...entryPointOf(e.definition)===`serve`?withTaskIdInput(e.definition):e.definition,execute:void 0,executeInput:e.executeInput,workflowId:e.workflowId}}function createPreparedWorkflowToolHarnessDefinition(e){let t=workflowIdForHandling(e.behavior?.handling);if(t===void 0)throw Error(`Prepared tool "${e.name}" is not backed by a workflow.`);return createWorkflowToolHarnessDefinition({definition:{behavior:e.behavior,description:e.description,inputSchema:toInputSchema(e.inputSchema)??UNSPECIFIED_INPUT_SCHEMA,name:e.name,outputSchema:toOutputSchema(e.outputSchema),rootOnly:e.rootOnly},workflowId:t})}export{createPreparedWorkflowToolHarnessDefinition,createWorkflowToolHarnessDefinition};

package/dist/src/execution/tools/workflow/interrupt.d.ts

@@ -0,0 +1,6 @@
+import type { WorkflowToolRunAddress } from "#execution/tools/workflow/types.js";
+/**
+ * Aborts the `execute` call's `abortSignal`. A run that already finished has nothing
+ * left to interrupt, so a missing hook is not an error.
+ */
+export declare function interruptWorkflowToolRun(run: WorkflowToolRunAddress): Promise<void>;

package/dist/src/execution/tools/workflow/interrupt.js

@@ -0,0 +1 @@
+import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";const INTERRUPT={kind:`interrupt`};async function interruptWorkflowToolRun(e){await resumeHookStep(e.hookToken,INTERRUPT,{ifPresent:!0})}export{interruptWorkflowToolRun};

package/dist/src/execution/tools/workflow/messages.d.ts

@@ -1,16 +1,16 @@
 import type { SubagentAuthorizationEventHookPayload } from "#channel/types.js";
-import type { AgentInvocationRequest, AgentSettlementRequest } from "#execution/tools/subagent/invoke-agent.js";
+import type { SessionInboxAddress } from "#execution/session-inbox/address.js";
+import type { RemoteAgentBinding } from "#eve-channel/support.js";
+import type { SessionAuth } from "#context/session-context.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import type { AgentSessionAddress } from "#execution/agent-sessions/steps.js";
 import type { InputRequest } from "#shared/input.js";
 import type { JsonObject, JsonValue } from "#shared/json.js";
-import type { ToolInputRequest } from "#tools/definition.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { ToolInputRequest, ToolInputResponse } from "#tools/definition.js";
 export interface WorkflowToolRunOwner {
     readonly inbox: string;
 }
-/**
- * Requests the owner must apply on the run's behalf because they touch
- * owner-held state: spawning an agent and releasing its handle afterwards.
- */
-export type WorkflowToolAgentRequest = AgentInvocationRequest | AgentSettlementRequest;
 /**
  * A child authorization event the owner should display. Unlike input requests
  * it has no answer: the authorization callback completes against the child
@@ -22,6 +22,8 @@ export interface WorkflowToolAuthorizationRequest {
 }
 /** A question authored with `ask()` from `eve/workflow`, before owner normalization. */
 export interface WorkflowToolAskRequest {
+    /** The run's control hook, where the session sends its decision on the question. */
+    readonly control: string;
     readonly kind: "ask";
     readonly request: ToolInputRequest;
 }
@@ -33,15 +35,16 @@ export interface WorkflowToolInputRequestBatch {
     readonly kind: "input-batch";
     readonly requests: readonly InputRequest[];
 }
-export type WorkflowToolRequest = WorkflowToolAgentRequest | WorkflowToolAuthorizationRequest | WorkflowToolAskRequest | InputRequest | WorkflowToolInputRequestBatch;
+export type WorkflowToolRequest = WorkflowToolAuthorizationRequest | WorkflowToolAskRequest | InputRequest | WorkflowToolInputRequestBatch;
 /** Identifies the sending workflow tool run to an owner shared by many runs. */
 export interface WorkflowToolRunRef {
     readonly callId: string;
-    readonly execution: "background" | "blocking";
     readonly input: JsonObject;
     readonly runId: string;
     readonly sequence: number;
     readonly stepIndex: number;
+    /** Set when the run does a task's work; the session routes its messages by it. */
+    readonly taskId?: string;
     readonly toolName: string;
     readonly turnId: string;
 }
@@ -60,7 +63,12 @@ export interface WorkflowToolRunReport {
     readonly update: JsonValue;
 }
 export interface WorkflowToolRunRequestMessage {
+    readonly childSessionInbox?: SessionInboxAddress;
+    readonly remote?: RemoteAgentBinding & {
+        readonly sessionId: string;
+    };
     readonly from: WorkflowToolRunRef;
+    readonly inputSource?: string;
     readonly replyTo: string;
     readonly request: WorkflowToolRequest;
     readonly requestCoordinates?: {
@@ -72,16 +80,133 @@ export interface WorkflowToolRunRequestMessage {
 export interface WorkflowToolRunOutcomeMessage {
     readonly from: WorkflowToolRunRef;
     readonly result: WorkflowToolRunOutcome;
+    /** What the run's `ctx.agent` sessions spent in all, once any of their turns ended. */
+    readonly usage?: TokenUsage;
+}
+/**
+ * The run asks the session to withdraw the `ctx.ask()` question sent under
+ * `replyTo`. The session answers `withdrawn` on `control`, unless it accepted
+ * an answer first.
+ */
+export interface WorkflowToolRunWithdrawMessage {
+    readonly control: string;
+    readonly from: WorkflowToolRunRef;
+    readonly replyTo: string;
+}
+/** The run opened a session with `ctx.agent`, which its session announces as `agent.started`. */
+export interface WorkflowToolRunAgentStartedMessage {
+    readonly from: WorkflowToolRunRef;
+    readonly session: AgentSessionAddress;
+}
+/**
+ * A `serve` body's reply, sent once for each `ctx.reply()`. It settles every
+ * call the body received since its last reply, so the session settles them
+ * together and the model receives the reply once.
+ */
+export interface WorkflowToolRunReplyMessage {
+    /** The calls the reply settles, oldest first. */
+    readonly callIds: readonly string[];
+    /** The latest call the reply settles, which the body serves now. */
+    readonly from: WorkflowToolRunRef;
+    readonly output: JsonValue;
+    /**
+     * What the run's `ctx.agent` sessions spent so far, once any of their turns
+     * ended. A running total, so the session counts only what it adds to the
+     * last one it counted, and a redelivered reply adds nothing.
+     */
+    readonly usage?: TokenUsage;
+}
+/**
+ * A `serve` body's delegated spend that no reply carries: its `ctx.agent`
+ * sessions ended a turn while no call waited for a reply, such as a turn a
+ * cancel stopped. A running total, like a reply's.
+ */
+export interface WorkflowToolRunUsageMessage {
+    readonly from: WorkflowToolRunRef;
+    readonly usage: TokenUsage;
+}
+/** A task's run can take commands: its control hook is registered. */
+export interface WorkflowToolRunStartedMessage {
+    readonly from: WorkflowToolRunRef;
 }
 export type WorkflowToolRunMessage = ({
+    readonly kind: "agent-started";
+} & WorkflowToolRunAgentStartedMessage) | ({
+    readonly kind: "started";
+} & WorkflowToolRunStartedMessage) | ({
     readonly kind: "report";
 } & WorkflowToolRunReport) | ({
+    readonly kind: "reply";
+} & WorkflowToolRunReplyMessage) | ({
     readonly kind: "request";
 } & WorkflowToolRunRequestMessage) | ({
+    readonly kind: "withdraw";
+} & WorkflowToolRunWithdrawMessage) | ({
+    readonly kind: "usage";
+} & WorkflowToolRunUsageMessage) | ({
     readonly kind: "outcome";
 } & WorkflowToolRunOutcomeMessage);
-export type WorkflowToolRunControlMessage = {
+/**
+ * A later call to a `serve` task, which its run hands to `receive()`. It
+ * carries everything the session knew of the call when it admitted it, as a
+ * run's input does for the call that started it: the coordinates of the model
+ * step that made it, the caller's auth, and the context of sessions opened
+ * for it, with the agents it may open. Everything the run does while serving
+ * the call comes from these.
+ */
+export interface WorkflowToolRunCall extends Pick<WorkflowToolRunRef, "callId" | "sequence" | "stepIndex" | "turnId"> {
+    /** Sessions opened while serving the call are its children, in its trace. */
+    readonly agentContext: AgentSessionContext;
+    /** The caller's auth the session admitted the call with, which messages sent while serving it carry. */
+    readonly auth: SessionAuth;
+    readonly executeInput?: JsonValue;
+    /** The call's input, without the `taskId` that named the task. */
+    readonly input: JsonObject;
+}
+/** A person's answer to a `ctx.ask()` question, as the session accepted it. */
+export type WorkflowToolRunAnswer = Extract<ToolInputResponse, {
+    readonly status: "answered";
+}>;
+/**
+ * The session's decision on one `ctx.ask()` question: it accepted an answer,
+ * or it withdrew the question first. It decides once, and the ask resolves
+ * from that decision alone.
+ */
+export type WorkflowToolRunAskDecision = {
+    readonly kind: "answer";
+    readonly requestId: string;
+    readonly response: WorkflowToolRunAnswer;
+} | {
+    readonly kind: "withdrawn";
+    readonly requestId: string;
+};
+/**
+ * Commands the body applies, in the order the session sent them.
+ *
+ * - `cancel` stops the current work: an `execute` or `task` call's run, or a
+ *   `serve` task's current stretch of work, after which it waits for more calls.
+ * - `end` stops the run for good, because the session ended.
+ * - `interrupt` aborts an `execute` call's `abortSignal` without cancelling the
+ *   call, because steering arrived while the turn waits on it.
+ * - `call` delivers a later call to a `serve` task.
+ */
+export type WorkflowBodyCommand = {
+    readonly kind: "call";
+    readonly call: WorkflowToolRunCall;
+} | {
     readonly kind: "cancel";
     readonly reason: string;
+} | {
+    readonly kind: "end";
+    readonly reason: string;
+} | {
+    readonly kind: "interrupt";
 };
+/**
+ * Everything the session sends a run, on the run's control hook: its one
+ * inbox. Only the session writes to it, so the run receives commands and
+ * decisions in the order the session made them.
+ */
+export type WorkflowToolRunControlMessage = WorkflowBodyCommand | WorkflowToolRunAskDecision;
 export declare function isWorkflowToolRunControlMessage(value: unknown): value is WorkflowToolRunControlMessage;
+export declare function isWorkflowToolRunAskDecision(message: WorkflowToolRunControlMessage): message is WorkflowToolRunAskDecision;

package/dist/src/execution/tools/workflow/messages.js

@@ -1 +1 @@
-function isWorkflowToolRunControlMessage(e){if(typeof e!=`object`||!e)return!1;let{kind:t,reason:n}=e;return t===`cancel`&&typeof n==`string`}export{isWorkflowToolRunControlMessage};
+function isWorkflowToolRunControlMessage(e){if(typeof e!=`object`||!e)return!1;let{call:t,kind:n,reason:r,requestId:i,response:a}=e;switch(n){case`interrupt`:return!0;case`cancel`:case`end`:return typeof r==`string`;case`call`:return isWorkflowToolRunCall(t);case`answer`:return typeof i==`string`&&isWorkflowToolRunAnswer(a);case`withdrawn`:return typeof i==`string`;default:return!1}}function isWorkflowToolRunAskDecision(e){return e.kind===`answer`||e.kind===`withdrawn`}function isWorkflowToolRunAnswer(e){if(typeof e!=`object`||!e)return!1;let{optionId:t,responder:n,status:r,text:i}=e;return r===`answered`&&(t===void 0||typeof t==`string`)&&(n===void 0||isToolInputResponseResponder(n))&&(i===void 0||typeof i==`string`)}function isToolInputResponseResponder(e){if(typeof e!=`object`||!e)return!1;let{authenticator:t,principalId:n,principalType:r}=e;return typeof t==`string`&&typeof n==`string`&&typeof r==`string`}function isWorkflowToolRunCall(e){if(typeof e!=`object`||!e)return!1;let{agentContext:t,auth:n,callId:r,input:i,sequence:a,stepIndex:o,turnId:s}=e;return typeof t==`object`&&!!t&&typeof n==`object`&&!!n&&typeof r==`string`&&typeof i==`object`&&!!i&&typeof a==`number`&&typeof o==`number`&&typeof s==`string`}export{isWorkflowToolRunAskDecision,isWorkflowToolRunControlMessage};

package/dist/src/execution/tools/workflow/owner-inbox.js

@@ -1 +1 @@
-import{parseJsonValue}from"#shared/json.js";function workflowToolRunOutcomeToToolResult(e){let{from:t,result:n}=e;return n.status===`completed`?{callId:t.callId,kind:`tool-result`,output:n.output,toolName:t.toolName}:{callId:t.callId,isError:!0,kind:`tool-result`,output:n.status===`failed`?workflowToolRunFailureOutput(e):n.reason??`The workflow tool run was cancelled.`,toolName:t.toolName}}function workflowToolRunFailureOutput(e){if(e.result.status!==`failed`)throw TypeError(`Expected a failed workflow outcome.`);let t=parseJsonValueOrUndefined(e.result.error);return t!==void 0&&typeof t==`object`&&t&&!Array.isArray(t)&&typeof Reflect.get(t,`code`)==`string`?t:errorMessage(e.result.error)}function errorMessage(e){if(typeof e==`object`&&e&&`message`in e){let t=e.message;if(typeof t==`string`)return t}return String(e)}function parseJsonValueOrUndefined(e){try{return parseJsonValue(e)}catch{return}}function workflowToolRunRequestToInputRequestPayload(e){let{from:t,replyTo:n,requestCoordinates:r}=e;return{callId:t.callId,childContinuationToken:n,childSessionId:t.runId,event:{requests:workflowToolRunInputRequests(e),sequence:r?.sequence??t.sequence,stepIndex:r?.stepIndex??t.stepIndex,turnId:r?.turnId??t.turnId},kind:`subagent-input-request`,subagentName:t.toolName}}function workflowToolRunInputRequests(e){return e.request.kind===`input-batch`?e.request.requests:[normalizeInputRequest(e.request,e.from,e.replyTo)]}function normalizeInputRequest(e,t,n){switch(e.kind){case`agent-invoke`:case`agent-settled`:throw TypeError(`A workflow agent request cannot be normalized as human input.`);case`authorization-request`:throw TypeError(`A workflow authorization event cannot be normalized as human input.`);case`ask`:return normalizeAskRequest(e.request,t,n);default:return e}}function normalizeAskRequest(e,t,n){if(typeof e.prompt!=`string`||e.prompt.length===0)throw TypeError("A workflow tool run request needs a non-empty `prompt`.");let r={action:{callId:t.callId,input:t.input,kind:`tool-call`,toolName:t.toolName},kind:`question`,prompt:e.prompt,requestId:n};return e.allowFreeform!==void 0&&(r.allowFreeform=e.allowFreeform),e.display!==void 0&&(r.display=e.display),e.options!==void 0&&(r.options=[...e.options]),r}export{workflowToolRunFailureOutput,workflowToolRunInputRequests,workflowToolRunOutcomeToToolResult,workflowToolRunRequestToInputRequestPayload};
+import{parseJsonValue}from"#shared/json.js";function workflowToolRunOutcomeToToolResult(e){let{from:t,result:n}=e;return n.status===`completed`?{callId:t.callId,kind:`tool-result`,output:n.output,toolName:t.toolName}:{callId:t.callId,isError:!0,kind:`tool-result`,output:n.status===`failed`?workflowToolRunFailureOutput(e):n.reason??`The workflow tool run was cancelled.`,toolName:t.toolName}}function workflowToolRunFailureOutput(e){if(e.result.status!==`failed`)throw TypeError(`Expected a failed workflow outcome.`);let t=parseJsonValueOrUndefined(e.result.error);return t!==void 0&&typeof t==`object`&&t&&!Array.isArray(t)&&typeof Reflect.get(t,`code`)==`string`?t:errorMessage(e.result.error)}function errorMessage(e){if(typeof e==`object`&&e&&`message`in e){let t=e.message;if(typeof t==`string`)return t}return String(e)}function parseJsonValueOrUndefined(e){try{return parseJsonValue(e)}catch{return}}function workflowToolRunRequestToInputRequestPayload(e){let{from:t,replyTo:n,requestCoordinates:r}=e;return{callId:t.callId,childContinuationToken:n,childSessionId:t.runId,childSessionInbox:e.childSessionInbox,remote:e.remote,inputSource:e.inputSource,event:{requests:workflowToolRunInputRequests(e),sequence:r?.sequence??t.sequence,stepIndex:r?.stepIndex??t.stepIndex,taskId:t.taskId,turnId:r?.turnId??t.turnId},kind:`subagent-input-request`,subagentName:t.toolName}}function workflowToolRunInputRequests(e){return e.request.kind===`input-batch`?e.request.requests:[normalizeInputRequest(e.request,e.from,e.replyTo)]}function normalizeInputRequest(e,t,n){switch(e.kind){case`authorization-request`:throw TypeError(`A workflow authorization event cannot be normalized as human input.`);case`ask`:return normalizeAskRequest(e.request,t,n);default:return e}}function normalizeAskRequest(e,t,n){if(typeof e.prompt!=`string`||e.prompt.length===0)throw TypeError("A workflow tool run request needs a non-empty `prompt`.");let r={action:{callId:t.callId,input:t.input,kind:`tool-call`,toolName:t.toolName},kind:`question`,prompt:e.prompt,requestId:n};return e.allowFreeform!==void 0&&(r.allowFreeform=e.allowFreeform),e.display!==void 0&&(r.display=e.display),e.options!==void 0&&(r.options=[...e.options]),r}export{workflowToolRunFailureOutput,workflowToolRunInputRequests,workflowToolRunOutcomeToToolResult,workflowToolRunRequestToInputRequestPayload};

package/dist/src/execution/tools/workflow/owner.d.ts

@@ -1,11 +1,22 @@
-import type { WorkflowToolRunMessage, WorkflowToolRunRequestMessage, WorkflowToolAuthorizationRequest, WorkflowToolRunOwner } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunMessage, WorkflowToolRunRequestMessage, WorkflowToolAuthorizationRequest } from "#execution/tools/workflow/messages.js";
 import { type ChannelReader } from "#execution/tools/workflow/owner-channels.js";
+/**
+ * The run's inbox as its body sees it. Everything the body sends its session,
+ * except the outcome, goes through the run, which relays each message before
+ * the outcome.
+ */
+export interface WorkflowToolRunInbox {
+    /** Messages that reached the run's inbox so far. */
+    readonly sent: number;
+    send(message: Exclude<WorkflowToolRunMessage, {
+        readonly kind: "outcome";
+    }>): Promise<void>;
+}
 export interface WorkflowToolRunOwnerInbox {
-    dispose(): Promise<void>;
-    readonly owner: WorkflowToolRunOwner;
+    readonly owner: WorkflowToolRunInbox;
     readonly reader: ChannelReader<"workflow", WorkflowToolRunMessage>;
 }
-/** Receives body messages before routing them to the turn or session owner. */
+/** Receives body messages before routing them to the waiting turn. */
 export declare function openWorkflowToolRunOwnerInbox(): WorkflowToolRunOwnerInbox;
 /** Acknowledge only step-owned events, after delivery or deliberate discard. */
 export declare function deliverWorkflowAuthorization(message: WorkflowToolRunRequestMessage & {

package/dist/src/execution/tools/workflow/owner.js

@@ -1 +1 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{createChannelReader}from"#execution/tools/workflow/owner-channels.js";function openWorkflowToolRunOwnerInbox(){let e=createHook();return{dispose:()=>disposeHook(e),owner:{inbox:e.token},reader:createChannelReader(`workflow`,e)}}async function deliverWorkflowAuthorization(e,t){await t(),e.request.event.childSessionId===e.from.runId&&await resumeHookStep(e.replyTo,null,{ifPresent:!0})}export{deliverWorkflowAuthorization,openWorkflowToolRunOwnerInbox};
+import{createHook}from"#compiled/@workflow/core/index.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{createChannelReader}from"#execution/tools/workflow/owner-channels.js";function openWorkflowToolRunOwnerInbox(){let e=createHook(),t=0;return{owner:{get sent(){return t},async send(n){await resumeHookStep(e.token,n),t+=1}},reader:createChannelReader(`workflow`,e)}}async function deliverWorkflowAuthorization(e,t){await t(),e.request.event.childSessionId===e.from.runId&&await resumeHookStep(e.replyTo,null,{ifPresent:!0})}export{deliverWorkflowAuthorization,openWorkflowToolRunOwnerInbox};

package/dist/src/execution/tools/workflow/serve.d.ts

@@ -0,0 +1,3 @@
+import { type StartedWorkflowBody, type WorkflowBodyInput } from "#execution/tools/workflow/body.js";
+/** Starts a `serve` body, which runs once for its task and serves every call to it. */
+export declare function startServeBody(input: WorkflowBodyInput): StartedWorkflowBody;

package/dist/src/execution/tools/workflow/serve.js

@@ -0,0 +1 @@
+import{createRunUsageTally}from"#execution/agent-sessions/usage.js";import{createAgentSessions}from"#execution/agent-sessions/session.js";import{WorkflowToolRunAsks,ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{WorkflowToolRunCancelledError,createAgentsView,createSharedContext,createWorkflowBodyRef,resolveWorkflowEntryPoint,toFailedOutcome}from"#execution/tools/workflow/body.js";var WorkflowServeCalls=class{asks;run=new AbortController;first;runRef;runSession;owner;usage=createRunUsageTally(()=>this.sendUncarriedUsage());carriedUsage;toolName;seenCallIds;firstReceived=!1;arrived=[];waiting;latest;pendingReceive;stretch;unwindingCancel=!1;endedBy;replies=Promise.resolve();constructor(e){this.runRef=createWorkflowBodyRef(e),this.asks=new WorkflowToolRunAsks(this.runRef.runId),this.runSession=e.session,this.owner=e.owner,this.toolName=e.toolName,this.seenCallIds=new Set([e.callId]),this.first=this.serve({agentContext:e.agentContext,auth:e.session.auth,callId:this.runRef.callId,executeInput:e.executeInput,input:this.runRef.input,sequence:this.runRef.sequence,stepIndex:this.runRef.stepIndex,turnId:this.runRef.turnId}),this.waiting=[this.first],this.latest=this.first}get runSignal(){return this.run.signal}get unwinding(){return this.run.signal.aborted||this.unwindingCancel}get currentSignal(){return this.stretch?.signal??this.run.signal}get current(){return this.latest}apply(e){switch(e.kind){case`call`:this.accept(e.call);return;case`cancel`:this.cancel(new WorkflowToolRunCancelledError(e.reason));return;case`end`:this.end(new WorkflowToolRunCancelledError(e.reason));return;case`interrupt`:return}}receive(){if(!this.firstReceived)return this.firstReceived=!0,Promise.resolve(this.first.call);if(this.unwindingCancel=!1,this.pendingReceive!==void 0)return this.pendingReceive.promise;if(this.endedBy!==void 0)return Promise.reject(this.endedBy);let e=this.arrived.shift();return e===void 0?(this.pendingReceive=createPendingReceive(),this.pendingReceive.promise):(this.take(e),Promise.resolve(e.call))}reply(e){let t=this.waiting;if(t.length===0)return;this.waiting=[],this.arrived.length===0&&(this.stretch=void 0),this.asks.withdrawAll();let n=this.replies;this.replies=n.then(()=>this.deliverReply(t,e))}assertWaiting(){if(!(this.waiting.length>0))throw Error(`ctx.ask() needs a call waiting for a result, but tool "${this.toolName}" already replied to every call it received.`)}async flush(){await this.asks.flush(),await this.replies}sendUncarriedUsage(){if(this.waiting.length>0||this.endedBy!==void 0)return;let{from:e}=this.latest;this.replies=this.replies.then(async()=>{let t=this.usage.total();t===void 0||isSameUsage(t,this.carriedUsage)||(this.carriedUsage=t,await this.owner.send({from:e,kind:`usage`,usage:t}))})}accept(e){if(this.endedBy!==void 0||this.seenCallIds.has(e.callId))return;this.seenCallIds.add(e.callId);let t=this.serve(e),n=this.pendingReceive;if(n===void 0){this.arrived.push(t);return}this.pendingReceive=void 0,this.take(t),n.resolve(t.call)}take(e){this.waiting.push(e),this.latest=e}cancel(e){this.pendingReceive===void 0&&(this.unwindingCancel=!0),this.stretch?.abort(e),this.stretch=void 0,this.waiting=[],this.arrived=[]}end(e){this.asks.cancelAll(),this.endedBy=e,this.run.abort(e),this.stretch?.abort(e);let t=this.pendingReceive;this.pendingReceive=void 0,t?.reject(e)}serve(e){return this.stretch??=new AbortController,{agentContext:e.agentContext,agents:createAgentsView(e.agentContext),call:{abortSignal:this.stretch.signal,callId:e.callId,input:e.executeInput??e.input},from:{...this.runRef,callId:e.callId,input:e.input,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId},session:{...this.runSession,auth:e.auth,turn:{id:e.turnId,sequence:e.sequence}}}}async deliverReply(e,t){let n=e.at(-1);if(n===void 0)return;let r=e.map(e=>e.from.callId),i=this.usage.total();this.carriedUsage=i,await this.owner.send({callIds:r,from:n.from,kind:`reply`,output:t,...i!==void 0&&{usage:i}})}};function isSameUsage(e,t){return t!==void 0&&e.inputTokens===t.inputTokens&&e.outputTokens===t.outputTokens&&e.cacheReadTokens===t.cacheReadTokens&&e.cacheWriteTokens===t.cacheWriteTokens&&e.costUsd===t.costUsd}function startServeBody(e){let t=new WorkflowServeCalls(e),n={get agentContext(){return t.current.agentContext},asks:t.asks,get auth(){return t.current.session.auth},control:e.hookToken,get from(){return t.current.from},owner:e.owner},r=createAgentSessions(n,t.usage),i=createServeContext(e,t,r.open);return attachWorkflowToolRunContext(i,n),{asks:t.asks,close:r.close,control:t,outcome:executeServeBody(e,t,i),usage:t.usage}}async function executeServeBody(e,t,n){let r;try{r={output:await resolveWorkflowEntryPoint(e)(()=>t.receive(),n),status:`completed`}}catch(e){r=toFailedOutcome(e,t.runSignal)}return await t.flush(),r}function createServeContext(e,t,n){let r={...createSharedContext(e,n,(e,n)=>(t.assertWaiting(),ask(r,e,n))),get abortSignal(){return t.currentSignal},get agents(){return t.current.agents},get callId(){return t.current.from.callId},get session(){return t.current.session},reply:e=>t.reply(e)};return r}function createPendingReceive(){let e,t;return{promise:new Promise((n,r)=>{e=n,t=r}),reject:t,resolve:e}}export{startServeBody};

package/dist/src/execution/tools/workflow/start.d.ts

@@ -1,26 +1,33 @@
 import type { SessionAuth, SessionParent } from "#context/session-context.js";
-import type { RuntimeSession } from "#subagents/handle-dispatch.js";
-import type { RuntimeToolResultActionResult, RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { AgentSessionContext } from "#execution/agent-sessions/context.js";
+import type { HarnessSessionBase } from "#harness/types.js";
+import type { RuntimeToolResultActionResult, RuntimeWorkflowTaskRequest, WorkflowToolRunEntry } from "#shared/action-types.js";
 import type { WorkflowToolRunAddress, WorkflowToolRunInput } from "#execution/tools/workflow/types.js";
 import type { WorkflowToolRunOwner } from "#execution/tools/workflow/messages.js";
 /** Starts a new run for each dispatch attempt. Call from a `"use step"` body. */
 export declare function startWorkflowToolRun(input: Omit<WorkflowToolRunInput, "hookToken">): Promise<WorkflowToolRunAddress>;
-/** Starts one durable workflow task and records it on the owning session. */
-export declare function startWorkflowTask(input: {
-    readonly agents: WorkflowToolRunInput["agents"];
-    readonly auth: SessionAuth["current"];
-    readonly canRequestInput: boolean;
+/** Everything the session knows when it starts one workflow tool call's run. */
+export interface StartWorkflowTaskInput {
+    /** Captured for this call, as the context of the sessions opened for it. */
+    readonly agentContext: AgentSessionContext;
+    /** The caller's auth the session admits the call with. */
+    readonly auth: SessionAuth;
     readonly batchEvent: {
         readonly sequence: number;
         readonly stepIndex: number;
         readonly turnId: string;
     };
-    readonly initiatorAuth: SessionAuth["initiator"];
     readonly owner: WorkflowToolRunOwner;
     readonly parentSession: SessionParent | undefined;
-    readonly session: RuntimeSession;
+    readonly session: HarnessSessionBase;
     readonly task: RuntimeWorkflowTaskRequest;
-}): Promise<{
+}
+/** Starts the run for one call, which invokes `entry`. */
+export declare function startWorkflowToolCallRun(input: StartWorkflowTaskInput, entry: WorkflowToolRunEntry): Promise<WorkflowToolRunAddress>;
+/** Starts the run of an `execute` call the turn waits on and records it on the owning session. */
+export declare function startWorkflowTask(input: StartWorkflowTaskInput): Promise<{
     readonly result?: RuntimeToolResultActionResult;
-    readonly session: RuntimeSession;
+    readonly session: HarnessSessionBase;
 }>;
+/** The call's tool result when its run could not start. */
+export declare function startFailureResult(task: RuntimeWorkflowTaskRequest, error: unknown): RuntimeToolResultActionResult;

package/dist/src/execution/tools/workflow/start.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{startWorkflowOnCurrentDeployment,workflowToolRunWorkflowReference}from"#execution/workflow-runtime.js";import{registerWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`execution.workflow-tool-run`);async function startWorkflowToolRun(e){let t=crypto.randomUUID();return{hookToken:t,runId:(await startWorkflowOnCurrentDeployment(workflowToolRunWorkflowReference,[{...e,hookToken:t}])).runId}}async function startWorkflowTask(e){let{task:t,batchEvent:n,session:r}=e;try{let i=await startWorkflowToolRun({agents:e.agents,callId:t.callId,canRequestInput:e.canRequestInput,executeInput:t.executeInput,input:t.input,owner:e.owner,session:{auth:{current:e.auth,initiator:e.initiatorAuth},id:r.sessionId,parent:e.parentSession,turn:{id:n.turnId,sequence:n.sequence}},stepIndex:n.stepIndex,toolName:t.toolName,workflowId:t.workflowId});return{session:registerWorkflowToolRun(r,{callId:t.callId,lifetime:`turn`,origin:{turnId:n.turnId,stepIndex:n.stepIndex},address:i,toolName:t.toolName})}}catch(e){return logError(log,`workflow tool run failed to start`,e,{callId:t.callId,toolName:t.toolName}),{result:createRuntimeToolResultFromValue({callId:t.callId,isError:!0,output:toError(e),toolName:t.toolName}),session:r}}}export{startWorkflowTask,startWorkflowToolRun};
+import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{startWorkflowOnCurrentDeployment,workflowToolRunWorkflowReference}from"#execution/workflow-runtime.js";import{registerWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";const log=createLogger(`execution.workflow-tool-run`);async function startWorkflowToolRun(e){let t=e.entry.entryPoint===`execute`?crypto.randomUUID():taskRunHookToken(e.session.id,e.entry.taskId);return{hookToken:t,runId:(await startWorkflowOnCurrentDeployment(workflowToolRunWorkflowReference,[{...e,hookToken:t}])).runId}}function taskRunHookToken(e,t){return`eve:task:${e}:${t}`}async function startWorkflowToolCallRun(e,t){let{task:n,batchEvent:r,session:i}=e;return await startWorkflowToolRun({agentContext:e.agentContext,callId:n.callId,entry:t,executeInput:n.executeInput,input:n.input,owner:e.owner,session:{auth:e.auth,id:i.sessionId,parent:e.parentSession,turn:{id:r.turnId,sequence:r.sequence}},stepIndex:r.stepIndex,toolName:n.toolName,workflowId:n.workflowId})}async function startWorkflowTask(e){let{task:t,batchEvent:n,session:r}=e;try{let i=await startWorkflowToolCallRun(e,{entryPoint:`execute`});return{session:registerWorkflowToolRun(r,{callId:t.callId,origin:{turnId:n.turnId,stepIndex:n.stepIndex},address:i,toolName:t.toolName})}}catch(e){return logError(log,`workflow tool run failed to start`,e,{callId:t.callId,toolName:t.toolName}),{result:startFailureResult(t,e),session:r}}}function startFailureResult(e,t){return createRuntimeToolResultFromValue({callId:e.callId,isError:!0,output:toError(t),toolName:e.toolName})}export{startFailureResult,startWorkflowTask,startWorkflowToolCallRun,startWorkflowToolRun};

package/dist/src/execution/tools/workflow/step-execution.js

@@ -1 +1 @@
-import{ContextContainer,contextStorage}from"#context/container.js";import{AuthKey,InitiatorAuthKey,SessionIdKey,SessionKey}from"#context/keys.js";import{getStepMetadata}from"#compiled/@workflow/core/index.js";import{AuthorizationHookKey,CallbackBaseUrlKey,PendingAuthorizationResultKey,isAuthorizationSignal}from"#harness/authorization.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{isConnectionAuthorizationFailedError}from"#connections/errors.js";import{completeWorkflowStepAuthorization}from"#execution/tools/workflow/authorization-completion.js";import"#execution/tools/workflow/step-context.js";function withWorkflowStepAuthorization(e){let wrapped=async function(t){let{args:n,context:r}=t;getStepMetadata();let i=new ContextContainer;return i.set(AuthKey,r.session.auth.current),i.set(InitiatorAuthKey,r.session.auth.initiator),i.set(SessionIdKey,r.session.id),i.setVirtualContext(SessionKey,{...r.session,sessionId:r.session.id}),i.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(r.baseUrl)),i.setVirtualContext(AuthorizationHookKey,r.token),i.setVirtualContext(PendingAuthorizationResultKey,r.authorizationResults),contextStorage.run(i,async()=>{let a=createAuthorizationContext({scope:r.toolName,completeAuthorization:completeWorkflowStepAuthorization}),o={...buildBaseToolContext({toolName:r.toolName,options:{abortSignal:r.abortSignal,toolCallId:r.callId}}),agent:()=>unavailableInStep(`ctx.agent()`,`Call ctx.agent() in the workflow body.`),ask:()=>unavailableInStep(`ctx.ask()`,`Call ctx.ask() in the workflow body.`),getToken:a.getToken,requireAuth:a.requireAuth};Object.defineProperty(o,"agents",{get:()=>unavailableInStep(`ctx.agents`,`Read ctx.agents in the workflow body and pass the required serializable metadata into the step.`)});let s;try{s=await a.run(()=>Reflect.apply(e,this,n.map((e,n)=>t.contextIndexes.includes(n)?o:e)))}catch(e){throw isConnectionAuthorizationFailedError(e)&&!e.retryable&&Object.assign(e,{fatal:!0}),e}let c=i.get(PendingAuthorizationResultKey)??[],l=r.authorizationResults.filter(e=>!c.includes(e)).map(e=>e.attemptId);return isAuthorizationSignal(s)?{kind:`authorization-required`,signal:s,authorized:l}:{kind:`result`,output:s,authorized:l}})};return Object.defineProperty(wrapped,"maxRetries",{get:()=>Reflect.get(e,`maxRetries`)}),wrapped}function unavailableInStep(e,t){throw Object.assign(Error(`${e} is unavailable inside a "use step" function. ${t}`),{fatal:!0})}export{withWorkflowStepAuthorization};
+import{ContextContainer,contextStorage}from"#context/container.js";import{AuthKey,InitiatorAuthKey,SessionIdKey,SessionKey}from"#context/keys.js";import{getStepMetadata}from"#compiled/@workflow/core/index.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{AuthorizationHookKey,CallbackBaseUrlKey,PendingAuthorizationResultKey,isAuthorizationSignal}from"#harness/authorization.js";import{buildBaseToolContext}from"#context/build-base-tool-context.js";import{createAuthorizationContext}from"#runtime/authorization-context.js";import{isConnectionAuthorizationFailedError}from"#connections/errors.js";import{completeWorkflowStepAuthorization}from"#execution/tools/workflow/authorization-completion.js";import"#execution/tools/workflow/step-context.js";function withWorkflowStepAuthorization(e){let wrapped=async function(t){let{args:n,context:r}=t;getStepMetadata();let i=new ContextContainer;return i.set(AuthKey,r.session.auth.current),i.set(InitiatorAuthKey,r.session.auth.initiator),i.set(SessionIdKey,r.session.id),i.setVirtualContext(SessionKey,{...r.session,sessionId:r.session.id}),i.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(r.baseUrl)),i.setVirtualContext(AuthorizationHookKey,r.token),i.setVirtualContext(PendingAuthorizationResultKey,r.authorizationResults),contextStorage.run(i,async()=>{let a=createAuthorizationContext({scope:r.toolName,completeAuthorization:completeWorkflowStepAuthorization}),o={...buildBaseToolContext({toolName:r.toolName,options:{abortSignal:r.abortSignal,toolCallId:r.callId}}),agent:()=>unavailableInStep(`ctx.agent()`,`Call ctx.agent() in the workflow body.`),ask:()=>unavailableInStep(`ctx.ask()`,`Call ctx.ask() in the workflow body.`),getToken:a.getToken,requireAuth:a.requireAuth};Object.defineProperty(o,"agents",{get:()=>unavailableInStep(`ctx.agents`,`Read ctx.agents in the workflow body and pass the required serializable metadata into the step.`)});let s;try{s=await a.run(()=>Reflect.apply(e,this,n.map((e,n)=>t.contextIndexes.includes(n)?o:e)))}catch(e){throw isConnectionAuthorizationFailedError(e)&&!e.retryable&&Object.assign(e,{fatal:!0}),e}let c=i.get(PendingAuthorizationResultKey)??[],l=r.authorizationResults.filter(e=>!c.includes(e)).map(e=>e.attemptId);return isAuthorizationSignal(s)?{kind:`authorization-required`,signal:s,authorized:l}:{kind:`result`,output:s,authorized:l}})};return Object.defineProperty(wrapped,"maxRetries",{get:()=>Reflect.get(e,`maxRetries`)}),wrapped}function unavailableInStep(e,t){throw Object.assign(Error(`${e} is unavailable inside a "use step" function. ${t}`),{fatal:!0})}export{withWorkflowStepAuthorization};

package/dist/src/execution/tools/workflow/step.js

@@ -1 +1 @@
-import{createAuthorizationCompletedEvent,createAuthorizationRequiredEvent}from"#protocol/message.js";import{createHook,getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{findWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";function workflowToolStep(e,t){return new Proxy(e,{apply(e,n,r){let i=findWorkflowContextArgument(r);return i===void 0?Reflect.apply(e,n,r):executeAuthorizedStep(t,n,r,i)}})}function findWorkflowContextArgument(e){for(let t of e){let e=findWorkflowToolRunContext(t);if(e!==void 0)return{ctx:t,run:e}}}async function executeAuthorizedStep(e,t,n,r){let{ctx:i,run:a}=r,o=[],s=new Map;for(;;){let r=createHook();try{let c;try{c=await invokeAuthorizedStep({args:n,authorizationResults:o,callbackToken:r.token,ctx:i,execute:e,receiver:t})}catch(e){throw i.abortSignal.aborted||await reportPendingAsFailed(a,i.abortSignal,s),e}if(await reconcileCompletedAuthorizations(a,i.abortSignal,s,o,c.authorized),c.kind===`result`)return await reportPendingAsFailed(a,i.abortSignal,s),c.output;await collectAuthorizationCallbacks({authorizationResults:o,callback:r,challenges:c.signal.challenges,ctx:i,pending:s,run:a})}finally{await disposeHook(r)}}}async function invokeAuthorizedStep(e){let{args:t,authorizationResults:n,callbackToken:r,ctx:i,execute:a,receiver:o}=e,s={callId:i.callId,toolName:i.toolName,session:i.session,abortSignal:i.abortSignal,baseUrl:getWorkflowMetadata().url,token:r,authorizationResults:n},c={args:t.map(e=>e===i?null:e),context:s,contextIndexes:t.flatMap((e,t)=>e===i?[t]:[])};return await a.call(o,c)}async function reconcileCompletedAuthorizations(e,t,n,r,i){let a=new Set(i);for(let r of a){let i=n.get(r);i!==void 0&&await reportAuthorization(e,t,i,`authorized`),n.delete(r)}for(let e=r.length-1;e>=0;e--){let t=r[e];t!==void 0&&a.has(t.attemptId)&&r.splice(e,1)}}async function collectAuthorizationCallbacks(e){let{authorizationResults:t,callback:n,challenges:r,ctx:i,pending:a,run:o}=e;for(let e of r){let r=requireAttemptId(e);a.set(r.attemptId,r),await reportAuthorization(o,i.abortSignal,r);try{let e=await waitForCallback(n,r,i.abortSignal);t.push({name:r.name,instanceId:r.instanceId,attemptId:r.attemptId,hookUrl:r.hookUrl,principal:r.principal,resume:r.resume,callback:e})}catch(e){throw i.abortSignal.aborted||await reportAuthorization(o,i.abortSignal,r,`failed`),e}}}function requireAttemptId(e){if(e.attemptId===void 0)throw Error(`Workflow authorization challenge "${e.name}" has no attempt id.`);return e}async function reportPendingAsFailed(e,t,n){for(let r of n.values())await reportAuthorization(e,t,r,`failed`)}async function reportAuthorization(e,t,n,r){let i={attemptId:n.attemptId,name:n.name,sequence:e.from.sequence,stepIndex:e.from.stepIndex,turnId:e.from.turnId,authorization:n.challenge},a=r===void 0?createAuthorizationRequiredEvent({...i,description:`Sign in to ${n.name} to continue.`,webhookUrl:n.hookUrl}):createAuthorizationCompletedEvent({...i,outcome:r}),o=createHook();try{await withAbort(resumeHookStep(e.owner.inbox,{kind:`request`,from:e.from,replyTo:o.token,request:{kind:`authorization-request`,event:{kind:`subagent-authorization-event`,callId:e.from.callId,childSessionId:e.from.runId,subagentName:e.from.toolName,event:a}}}),t),await withAbort(o,t)}finally{await disposeHook(o)}}async function waitForCallback(e,t,n){let r=e[Symbol.asyncIterator]();for(;;){let e=await withAbort(r.next(),n);if(e.done)throw Error(`Authorization callback closed before sign-in completed.`);let i=readCallback(e.value,t);if(i!==void 0)return i}}async function withAbort(e,t){let abort,n=new Promise((e,n)=>{abort=()=>n(t.reason??Error(`Workflow authorization cancelled.`)),t.addEventListener(`abort`,abort,{once:!0}),t.aborted&&abort()});try{return await Promise.race([e,n])}finally{t.removeEventListener(`abort`,abort)}}function readCallback(e,t){if(typeof e==`object`&&e&&`payloads`in e&&Array.isArray(e.payloads))for(let n of e.payloads){let e=n?.authorizationCallback;if(e?.attemptId!==t.attemptId||e?.connectionName!==t.name)continue;let r=e.callback;if(!(typeof r?.method!=`string`||typeof r.params!=`object`||r.params===null||Array.isArray(r.params))&&Object.values(r.params).every(e=>typeof e==`string`)&&(r.body===void 0||typeof r.body==`string`))return r}}export{workflowToolStep};
+import{createAuthorizationCompletedEvent,createAuthorizationRequiredEvent}from"#protocol/message.js";import{createHook,getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{disposeHook}from"#execution/hook-ownership.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{findWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";function workflowToolStep(e,t){return new Proxy(e,{apply(e,n,r){let i=findWorkflowContextArgument(r);return i===void 0?Reflect.apply(e,n,r):executeAuthorizedStep(t,n,r,i)}})}function findWorkflowContextArgument(e){for(let t of e){let e=findWorkflowToolRunContext(t);if(e!==void 0)return{ctx:t,run:e}}}async function executeAuthorizedStep(e,t,n,r){let{ctx:i,run:a}=r,o=[],s=new Map;for(;;){let r=createHook();try{let c;try{c=await invokeAuthorizedStep({args:n,authorizationResults:o,callbackToken:r.token,ctx:i,execute:e,receiver:t})}catch(e){throw i.abortSignal.aborted||await reportPendingAsFailed(a,i.abortSignal,s),e}if(await reconcileCompletedAuthorizations(a,i.abortSignal,s,o,c.authorized),c.kind===`result`)return await reportPendingAsFailed(a,i.abortSignal,s),c.output;await collectAuthorizationCallbacks({authorizationResults:o,callback:r,challenges:c.signal.challenges,ctx:i,pending:s,run:a})}finally{await disposeHook(r)}}}async function invokeAuthorizedStep(e){let{args:t,authorizationResults:n,callbackToken:r,ctx:i,execute:a,receiver:o}=e,s={callId:i.callId,toolName:i.toolName,session:i.session,abortSignal:i.abortSignal,baseUrl:getWorkflowMetadata().url,token:r,authorizationResults:n},c={args:t.map(e=>e===i?null:e),context:s,contextIndexes:t.flatMap((e,t)=>e===i?[t]:[])};return await a.call(o,c)}async function reconcileCompletedAuthorizations(e,t,n,r,i){let a=new Set(i);for(let r of a){let i=n.get(r);i!==void 0&&await reportAuthorization(e,t,i,`authorized`),n.delete(r)}for(let e=r.length-1;e>=0;e--){let t=r[e];t!==void 0&&a.has(t.attemptId)&&r.splice(e,1)}}async function collectAuthorizationCallbacks(e){let{authorizationResults:t,callback:n,challenges:r,ctx:i,pending:a,run:o}=e;for(let e of r){let r=requireAttemptId(e);a.set(r.attemptId,r),await reportAuthorization(o,i.abortSignal,r);try{let e=await waitForCallback(n,r,i.abortSignal);t.push({name:r.name,instanceId:r.instanceId,attemptId:r.attemptId,hookUrl:r.hookUrl,principal:r.principal,resume:r.resume,callback:e})}catch(e){throw i.abortSignal.aborted||await reportAuthorization(o,i.abortSignal,r,`failed`),e}}}function requireAttemptId(e){if(e.attemptId===void 0)throw Error(`Workflow authorization challenge "${e.name}" has no attempt id.`);return e}async function reportPendingAsFailed(e,t,n){for(let r of n.values())await reportAuthorization(e,t,r,`failed`)}async function reportAuthorization(e,t,n,r){let i={...authorizationEventFields(n),sequence:e.from.sequence,stepIndex:e.from.stepIndex,taskId:e.from.taskId,turnId:e.from.turnId},a=r===void 0?createAuthorizationRequiredEvent({...i,description:`Sign in to ${n.name} to continue.`,webhookUrl:n.hookUrl}):createAuthorizationCompletedEvent({...i,outcome:r}),o=createHook();try{await withAbort(e.owner.send({kind:`request`,from:e.from,replyTo:o.token,request:{kind:`authorization-request`,event:{kind:`subagent-authorization-event`,callId:e.from.callId,childSessionId:e.from.runId,subagentName:e.from.toolName,event:a}}}),t),await withAbort(o,t)}finally{await disposeHook(o)}}async function waitForCallback(e,t,n){let r=e[Symbol.asyncIterator]();for(;;){let e=await withAbort(r.next(),n);if(e.done)throw Error(`Authorization callback closed before sign-in completed.`);let i=readCallback(e.value,t);if(i!==void 0)return i}}async function withAbort(e,t){let abort,n=new Promise((e,n)=>{abort=()=>n(t.reason??Error(`Workflow authorization cancelled.`)),t.addEventListener(`abort`,abort,{once:!0}),t.aborted&&abort()});try{return await Promise.race([e,n])}finally{t.removeEventListener(`abort`,abort)}}function readCallback(e,t){if(typeof e==`object`&&e&&`payloads`in e&&Array.isArray(e.payloads))for(let n of e.payloads){let e=n?.authorizationCallback;if(e?.attemptId!==t.attemptId||e?.connectionName!==t.name)continue;let r=e.callback;if(!(typeof r?.method!=`string`||typeof r.params!=`object`||r.params===null||Array.isArray(r.params))&&Object.values(r.params).every(e=>typeof e==`string`)&&(r.body===void 0||typeof r.body==`string`))return r}}export{workflowToolStep};

package/dist/src/execution/tools/workflow/types.d.ts

@@ -1,9 +1,6 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import type { TaskView } from "#tasks/types.js";
 import type { WorkflowBodyDefinition } from "#execution/tools/workflow/body.js";
 import type { WorkflowToolRunOwner } from "#execution/tools/workflow/messages.js";
 export interface WorkflowToolRunInput extends WorkflowBodyDefinition {
-    readonly execution?: "background" | "blocking";
     readonly hookToken: string;
     readonly owner: WorkflowToolRunOwner;
 }
@@ -11,10 +8,3 @@ export interface WorkflowToolRunAddress {
     readonly hookToken: string;
     readonly runId: string;
 }
-export interface BackgroundWorkflowToolRunInput {
-    readonly activityObserver?: ActivityObserverConfig;
-    readonly initialView: TaskView;
-    readonly parentContinuationToken: string;
-    readonly taskInboxToken: string;
-    readonly workflow: WorkflowBodyDefinition;
-}

package/dist/src/execution/tools/workflow/withdraw-step.d.ts

@@ -0,0 +1,31 @@
+import { type PublishedSessionEvents, type SessionStepState } from "#execution/publish-session-events.js";
+import { type SessionStateTransition } from "#execution/session/state-delta.js";
+import { type ProxyInputRequest } from "#harness/proxy-input-requests.js";
+/**
+ * Decides a run's request to withdraw a question. A question the session
+ * still offers is retired and relayed `cancelled`, so channels stop offering
+ * it. One it no longer offers was already answered or withdrawn when its turn
+ * was cancelled. Either way the run hears `withdrawn`, after any answer the
+ * session sent it first, so the question resolves from the session's first
+ * decision.
+ */
+export declare function withdrawWorkflowToolRunQuestionStep(input: WithdrawQuestionInput): Promise<SessionStateTransition>;
+type WithdrawQuestionInput = SessionStepState & {
+    readonly control: string;
+    readonly requestId: string;
+    readonly runId: string;
+};
+/**
+ * Withdraws the requests a finished run left open: its own questions and those
+ * of the sessions it opened, which ended with it. Nobody can answer them now,
+ * so each is relayed `cancelled`.
+ */
+export declare function withdrawFinishedRunQuestionsStep(input: SessionStepState & {
+    readonly runId: string;
+}): Promise<SessionStateTransition>;
+/**
+ * Retires the relayed requests `select` picks and relays the `input.resolved`
+ * that reports each one `cancelled`, for a step that owns the session.
+ */
+export declare function relayWithdrawnRequests(input: SessionStepState, select: (requestId: string, route: ProxyInputRequest) => boolean): Promise<PublishedSessionEvents>;
+export {};

package/dist/src/execution/tools/workflow/withdraw-step.js

@@ -0,0 +1 @@
+import{readDurableSession,replaceDurableSessionSnapshot}from"#execution/durable-session-store.js";import{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{ignoreGoneTarget}from"#execution/tasks/workflow-target.js";async function withdrawWorkflowToolRunQuestionStep(e){"use step";return await withSessionStateDelta(e,withdrawWorkflowToolRunQuestion)}async function withdrawWorkflowToolRunQuestion(e){let t={kind:`withdrawn`,requestId:e.requestId};return await ignoreGoneTarget(resumeHook(e.control,t)),await relayWithdrawnRequests(e,(t,n)=>t===e.requestId&&n.workflowAsk!==void 0&&n.runId===e.runId)}async function withdrawFinishedRunQuestionsStep(e){"use step";return await withSessionStateDelta(e,e=>relayWithdrawnRequests(e,(t,n)=>n.runId===e.runId))}async function relayWithdrawnRequests(e,t){let n=withdrawProxyInputRequests(readDurableSession(e.sessionState),t);return await relaySessionEvents({serializedContext:e.serializedContext,sessionState:replaceDurableSessionSnapshot({session:n.session,state:e.sessionState}),sessionWritable:e.sessionWritable},n.events)}export{relayWithdrawnRequests,withdrawFinishedRunQuestionsStep,withdrawWorkflowToolRunQuestionStep};

package/dist/src/execution/tools/workflow/workflow-owner-blocking.d.ts

@@ -1,12 +1,10 @@
 import { type ChannelReader } from "#execution/tools/workflow/owner-channels.js";
-import { type WorkflowToolRunMessage, type WorkflowToolRunControlMessage } from "#execution/tools/workflow/messages.js";
+import type { WorkflowToolRunMessage, WorkflowToolRunControlMessage } from "#execution/tools/workflow/messages.js";
 import type { WorkflowToolRunInput } from "#execution/tools/workflow/types.js";
 export interface BlockingWorkflowOwner {
-    readonly kind: "turn";
+    /** The session's commands, from the run's control hook. */
     readonly commands: ChannelReader<"control", WorkflowToolRunControlMessage>;
-    readonly signal: AbortSignal;
-    handleCommand(message: WorkflowToolRunControlMessage): void;
     handleMessage(message: WorkflowToolRunMessage): Promise<void>;
 }
-/** Routes invocation messages to the waiting turn and accepts cancellation. */
+/** The run's link to its session: commands arrive on its control hook, and its messages go to the session's inbox. */
 export declare function createBlockingWorkflow(input: WorkflowToolRunInput): BlockingWorkflowOwner;

package/dist/src/execution/tools/workflow/workflow-owner-blocking.js

@@ -1 +1 @@
-import{createHook}from"#compiled/@workflow/core/index.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{isWorkflowToolRunControlMessage}from"#execution/tools/workflow/messages.js";import{createChannelReader}from"#execution/tools/workflow/owner-channels.js";function createBlockingWorkflow(e){let t=new AbortController,n=createHook({token:e.hookToken});return{kind:`turn`,commands:createChannelReader(`control`,n),signal:t.signal,handleCommand(e){isWorkflowToolRunControlMessage(e)&&t.abort(new WorkflowToolRunCancelledError(e.reason))},handleMessage(t){return resumeHookStep(e.owner.inbox,t,{ifPresent:t.kind===`outcome`&&t.result.status===`cancelled`})}}}var WorkflowToolRunCancelledError=class extends Error{constructor(e){super(e),this.name=`WorkflowToolRunCancelledError`}};export{createBlockingWorkflow};
+import{createHook}from"#compiled/@workflow/core/index.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{createChannelReader}from"#execution/tools/workflow/owner-channels.js";function createBlockingWorkflow(e){let t=createHook({token:e.hookToken});return{commands:createChannelReader(`control`,t),handleMessage(t){return resumeHookStep(e.owner.inbox,t,{ifPresent:t.kind===`outcome`&&t.result.status===`cancelled`})}}}export{createBlockingWorkflow};

package/dist/src/execution/tools/workflow/workflow.d.ts

@@ -1,3 +1,3 @@
-import type { BackgroundWorkflowToolRunInput, WorkflowToolRunInput } from "#execution/tools/workflow/types.js";
-/** Owns admission, command intake, body execution, and settlement for either lifetime. */
-export declare function workflowToolRunWorkflow(input: WorkflowToolRunInput | BackgroundWorkflowToolRunInput): Promise<void>;
+import type { WorkflowToolRunInput } from "#execution/tools/workflow/types.js";
+/** Owns command intake, body execution, and settlement for one workflow tool call. */
+export declare function workflowToolRunWorkflow(input: WorkflowToolRunInput): Promise<void>;

package/dist/src/execution/tools/workflow/workflow.js

@@ -1 +1 @@
-import{sleep}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{openWorkflowToolRunOwnerInbox}from"#execution/tools/workflow/owner.js";import{WORKFLOW_CANCELLATION_CLEANUP_MS}from"#execution/tools/workflow/cancellation-policy.js";import{createChannelReader,raceChannelReads}from"#execution/tools/workflow/owner-channels.js";import{createWorkflowBodyRef,executeWorkflowBody}from"#execution/tools/workflow/body.js";import{createBackgroundWorkflowOwner}from"#execution/tools/workflow/workflow-owner-background.js";import{createBlockingWorkflow}from"#execution/tools/workflow/workflow-owner-blocking.js";async function workflowToolRunWorkflow(e){"use workflow";let t=`workflow`in e?await createBackgroundWorkflowOwner(e):createBlockingWorkflow(e);if(t===void 0)return;let n=`workflow`in e?{...e.workflow,execution:`background`}:{...e,execution:e.execution??`blocking`},{signal:r}=t,i=t.kind===`turn`,a=!0,o,s=0,c,l,u;for(;;){if(i&&r.aborted){if(o===void 0)break;l??=sleep(WORKFLOW_CANCELLATION_CLEANUP_MS).then(()=>`cancel`)}if(c!==void 0&&s>=c.reportCount&&t.commands.landed.length===0&&t.commands.failure===void 0){u=c.outcome;break}let e;try{if(i&&o===void 0){let e=openWorkflowToolRunOwnerInbox();o={inbox:e,reader:createChannelReader(`body`,awaitBodyResult(executeWorkflowBody({...n,owner:e.owner},r)))}}let s=[];a&&s.push(t.commands),o!==void 0&&(s.push(o.inbox.reader),c===void 0&&s.push(o.reader)),e=await raceChannelReads(s,l)}catch(e){if(t.commands.failure!==void 0)throw e;u={status:`failed`,error:normalizeSerializableError(e)};break}if(e===`cancel`)break;if(e.next.done){if(e.channel===`control`){a=!1;continue}if(e.channel===`body`){u={status:`failed`,error:`Workflow body ended without an outcome.`};break}if(i&&r.aborted)break;return}if(e.channel===`control`){if(t.kind!==`turn`)throw Error(`Session-owned workflow run received a turn command.`);t.handleCommand(e.next.value);continue}if(e.channel===`commands`){if(t.kind!==`session`)throw Error(`Turn-owned workflow run received a task command.`);let n=e.next.value;if(i&&n.kind===`task-command`&&(n.command.kind===`ready`||n.command.kind===`reject-dispatch`))continue;let r=await t.handleCommand(n);if(r===`stop`)return;r===`start`&&(i=!0);continue}if(e.channel===`body`){c=e.next.value;continue}e.next.value.kind!==`outcome`&&(e.next.value.kind===`report`&&(s+=1),await t.handleMessage(e.next.value))}r.aborted&&(u={status:`cancelled`,reason:r.reason instanceof Error?r.reason.message:String(r.reason??``)}),u!==void 0&&await t.handleMessage({from:createWorkflowBodyRef(n),kind:`outcome`,result:u})}async function*awaitBodyResult(e){yield await e}workflowToolRunWorkflow.workflowId=`workflow//eve//workflowToolRunWorkflow`;export{workflowToolRunWorkflow};
+import{sleep}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{openWorkflowToolRunOwnerInbox}from"#execution/tools/workflow/owner.js";import{WORKFLOW_CANCELLATION_CLEANUP_MS}from"#execution/tools/workflow/cancellation-policy.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{createChannelReader,raceChannelReads}from"#execution/tools/workflow/owner-channels.js";import{createWorkflowBodyRef,startCallBody}from"#execution/tools/workflow/body.js";import{isWorkflowToolRunAskDecision,isWorkflowToolRunControlMessage}from"#execution/tools/workflow/messages.js";import{createBlockingWorkflow}from"#execution/tools/workflow/workflow-owner-blocking.js";import{startServeBody}from"#execution/tools/workflow/serve.js";async function workflowToolRunWorkflow(e){"use workflow";let t=createBlockingWorkflow(e),n=openWorkflowToolRunOwnerInbox();e.entry.entryPoint!==`execute`&&await reportTaskStarted(e);let r=startWorkflowBody({...e,owner:n.owner}),i=r.control.runSignal,a=createChannelReader(`body`,awaitBodyOutcome(r.outcome)),o=!0,s=0,c,l,u;try{for(;;){if(r.control.unwinding&&(l??=sleep(WORKFLOW_CANCELLATION_CLEANUP_MS).then(()=>`cancel`)),c!==void 0&&s>=n.owner.sent&&t.commands.landed.length===0&&t.commands.failure===void 0){u=c;break}let e;try{let r=[];o&&r.push(t.commands),r.push(n.reader),c===void 0&&r.push(a),e=await raceChannelReads(r,l)}catch(e){if(t.commands.failure!==void 0)throw e;u={status:`failed`,error:normalizeSerializableError(e)};break}if(e===`cancel`){if(!r.control.unwinding){l=void 0;continue}i.aborted||r.control.apply({kind:`end`,reason:`The task was cancelled and its serve body didn't return to receive() within 30 seconds.`});break}if(e.next.done){if(e.channel===`control`){o=!1;continue}if(e.channel===`body`){u={status:`failed`,error:`Workflow body ended without an outcome.`};break}if(i.aborted)break;return}if(e.channel===`control`){r.control.unwinding||(l=void 0),applyControlMessage(r,e.next.value);continue}if(e.channel===`body`){c=e.next.value;continue}let d=e.next.value;d.kind!==`outcome`&&(s+=1,await t.handleMessage(d))}}finally{await r.close()}if(i.aborted&&(u={status:`cancelled`,reason:i.reason instanceof Error?i.reason.message:String(i.reason??``)}),u!==void 0){let n=r.usage.total();await t.handleMessage({from:createWorkflowBodyRef(e),kind:`outcome`,result:u,...n!==void 0&&{usage:n}})}}async function reportTaskStarted(e){await resumeHookStep(e.owner.inbox,{from:createWorkflowBodyRef(e),kind:`started`},{ifPresent:!0})}function applyControlMessage(e,t){if(isWorkflowToolRunControlMessage(t)){if(isWorkflowToolRunAskDecision(t)){e.asks.settle(t);return}e.control.apply(t)}}function startWorkflowBody(e){switch(e.entry.entryPoint){case`execute`:case`task`:return startCallBody(e);case`serve`:return startServeBody(e)}}async function*awaitBodyOutcome(e){yield await e}workflowToolRunWorkflow.workflowId=`workflow//eve//workflowToolRunWorkflow`;export{workflowToolRunWorkflow};

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

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

package/dist/src/execution/workflow-callback-url.d.ts

@@ -28,8 +28,3 @@ export declare function resolveWorkflowCallbackBaseUrl(metadataUrl: string): str
  * `new URL(path, base)` would drop for absolute paths.
  */
 export declare function createWorkflowCallbackUrl(baseUrl: string, callbackPath: string): string;
-/**
- * Builds a callback to a remote task child without disclosing this deployment's
- * protection bypass secret to an authored external origin.
- */
-export declare function createRemoteTaskInputCallbackUrl(baseUrl: string, callbackPath: string): string;

package/dist/src/execution/workflow-callback-url.js

@@ -1 +1 @@
-import{joinEveRoutePath}from"#shared/eve-route-path.js";import{EVE_PUBLIC_ROUTE_PREFIX_ENV,normalizePublicRoutePrefix}from"#shared/public-route-prefix.js";const VERCEL_PROTECTION_BYPASS_QUERY=`x-vercel-protection-bypass`,VERCEL_CALLBACK_HOST_ENVS=[`VERCEL_URL`,`VERCEL_BRANCH_URL`,`VERCEL_PROJECT_PRODUCTION_URL`];function resolveVercelProductionCallbackBaseUrl(){return process.env.VERCEL_ENV===`production`&&process.env.VERCEL_PROJECT_PRODUCTION_URL?`https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`:null}function resolveWorkflowCallbackBaseUrl(e){let t=process.env.WORKFLOW_LOCAL_BASE_URL?.trim()||void 0,n=(resolveVercelProductionCallbackBaseUrl()??t??e).replace(/\/$/,``),r=normalizePublicRoutePrefix(process.env[EVE_PUBLIC_ROUTE_PREFIX_ENV]);return r===void 0?n:`${n}${r}`}function createWorkflowCallbackUrl(e,t){let n=new URL(t,`http://eve.local`),r=new URL(e);r.pathname=joinEveRoutePath(r.pathname,n.pathname),r.search=n.search;let i=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return i&&r.searchParams.set(VERCEL_PROTECTION_BYPASS_QUERY,i),r.toString()}function createRemoteTaskInputCallbackUrl(e,t){let n=new URL(t,`http://eve.local`),r=new URL(e);r.pathname=joinEveRoutePath(r.pathname,n.pathname),r.search=n.search;let i=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim(),a=VERCEL_CALLBACK_HOST_ENVS.some(e=>process.env[e]?.trim().toLowerCase()===r.hostname.toLowerCase());return i&&r.protocol===`https:`&&a&&r.searchParams.set(VERCEL_PROTECTION_BYPASS_QUERY,i),r.toString()}export{createRemoteTaskInputCallbackUrl,createWorkflowCallbackUrl,resolveVercelProductionCallbackBaseUrl,resolveWorkflowCallbackBaseUrl};
+import{joinEveRoutePath}from"#shared/eve-route-path.js";import{EVE_PUBLIC_ROUTE_PREFIX_ENV,normalizePublicRoutePrefix}from"#shared/public-route-prefix.js";function resolveVercelProductionCallbackBaseUrl(){return process.env.VERCEL_ENV===`production`&&process.env.VERCEL_PROJECT_PRODUCTION_URL?`https://${process.env.VERCEL_PROJECT_PRODUCTION_URL}`:null}function resolveWorkflowCallbackBaseUrl(e){let t=process.env.WORKFLOW_LOCAL_BASE_URL?.trim()||void 0,n=(resolveVercelProductionCallbackBaseUrl()??t??e).replace(/\/$/,``),r=normalizePublicRoutePrefix(process.env[EVE_PUBLIC_ROUTE_PREFIX_ENV]);return r===void 0?n:`${n}${r}`}function createWorkflowCallbackUrl(e,t){let n=new URL(t,`http://eve.local`),r=new URL(e);r.pathname=joinEveRoutePath(r.pathname,n.pathname),r.search=n.search;let i=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return i&&r.searchParams.set(`x-vercel-protection-bypass`,i),r.toString()}export{createWorkflowCallbackUrl,resolveVercelProductionCallbackBaseUrl,resolveWorkflowCallbackBaseUrl};

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

@@ -1,4 +1,4 @@
-import type { CancelTurnInput, CancelTurnResult, DeliverHookPayload, Runtime } from "#channel/types.js";
+import type { CancelTurnInput, CancelTurnResult, DeliverHookPayload, DispatchSessionInput, Runtime, SessionCommand, SessionCommandResult } from "#channel/types.js";
 import { type Run, type StartOptionsWithoutDeploymentId, type WorkflowFunction, type WorkflowMetadata } from "#internal/workflow/runtime.js";
 import type { RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
 import type { SessionCheckpoint } from "#execution/session/handoff.js";
@@ -19,10 +19,6 @@ export declare const workflowEntryReference: {
 export declare const sessionTimeoutWorkflowReference: {
     workflowId: string;
 };
-/** Stable workflow reference for root-session activity collectors. */
-export declare const activityCollectorWorkflowReference: {
-    workflowId: string;
-};
 /** Stable workflow reference for authored workflow tool runs. */
 export declare const workflowToolRunWorkflowReference: {
     workflowId: string;
@@ -46,6 +42,8 @@ export interface SessionOwnerStartInput {
 }
 /** Starts a successor owner and binds its output to the original session stream. */
 export declare function startSessionOwnerStep(input: SessionOwnerStartInput): Promise<void>;
+/** Sends one command to a session through its stable command inbox. */
+export declare function dispatchWorkflowSessionCommand<TCommand extends SessionCommand>(input: DispatchSessionInput<TCommand>): Promise<SessionCommandResult<TCommand>>;
 /** Requests cancellation through a session's stable command inbox. */
 export declare function requestWorkflowTurnCancellation(input: CancelTurnInput): Promise<CancelTurnResult>;
 /**