eve 0.71.3 → 0.72.0

package/dist/src/harness/emission.js

@@ -1 +1 @@
-import{createActionInputAppendedEvent,createActionPartialEvent,createActionResultEvent,createActionsRequestedEvent,createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent}from"#protocol/message.js";import{getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission-state.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{emitNestedToolActions}from"#harness/nested-actions.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.js";import{collectActionPresentation,createPresentedRuntimeActionRequestFromToolCall}from"#harness/action-presentation.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{createProviderStreamActionBatch}from"#harness/stream-actions.js";import{normalizeModelStreamError}from"#harness/model-call-error.js";import{createOrderedStreamEmitter}from"#harness/ordered-stream-emitter.js";import{interruptStreamOnFailure}from"#harness/interruptible-stream.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{normalizeAssistantStepFinishReason}from"#harness/finish-reason.js";async function emitTurnPreamble(e,t,n,r,i,a){let o=n.turnId!==``,s=o?n.turnId:`turn_${n.sequence}`;n.sessionStarted||await e(createSessionStartedEvent({runtime:i,trace:a})),o||await e(createTurnStartedEvent({sequence:n.sequence,trace:a,turnId:s}),r),t.message!==void 0&&await e(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:s}));let c={sessionStarted:!0,sequence:n.sequence,stepIndex:o?n.stepIndex:0,turnId:s};return o&&n.assistantOutputStarted?{...c,assistantOutputStarted:!0}:c}async function emitStepStarted(e,t,n,r){await e(createStepStartedEvent({modelId:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}),r)}async function emitStepAndTurnFailed(e,t,n){await e(createStepFailedEvent({...n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),await e(createTurnFailedEvent({...n,sequence:t.sequence,turnId:t.turnId}))}async function emitFailedStep(e,t,n){await emitStepAndTurnFailed(e,t,n),await e(createSessionFailedEvent(n))}async function emitRecoverableFailedTurn(e,t,n){return await emitStepAndTurnFailed(e,t,n),await e(createSessionWaitingEvent(n.usage)),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function advanceStep(e){return{...e,stepIndex:e.stepIndex+1}}async function emitTurnEpilogue(e,t,n,r){return await e(createTurnCompletedEvent({sequence:t.sequence,turnId:t.turnId}),n),await e(createSessionWaitingEvent(r)),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}async function emitStreamContent(e,t,n,r){let i=createOrderedStreamEmitter(e),a=createProviderStreamActionBatch({emitFn:i.emit,state:t});try{return await consumeStreamContent(i.emit,t,interruptStreamOnFailure(n,i.failureSignal),a,r)}finally{try{await a.cancel()}finally{await i.closeAndDrain()}}}function reportedFinishReason(e,t){return t&&e===`stop`?`tool-calls`:e}async function consumeStreamContent(e,t,n,r,i){let a=``,o=``,s=`stop`,c,l=new Set,u=new Set,d=new Set,f=new Set,p=new Set,m=new Set,h=[],g=[],_=new Map,v=new Map,flushCurrentMessage=async()=>{o.length!==0&&(await e(createMessageCompletedEvent({finishReason:`tool-calls`,message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),o=``)},emitActionInput=async(n,r,i)=>e(createActionInputAppendedEvent({callId:n,inputTextDelta:i,sequence:t.sequence,stepIndex:t.stepIndex,toolName:r,turnId:t.turnId})),emitActionRequest=async n=>{let{action:r}=n;u.has(r.callId)||(o.trim().length>0&&await flushCurrentMessage(),u.add(r.callId),_.set(r.callId,r.input),await e(createActionsRequestedEvent({actions:[r],presentation:collectActionPresentation([n]),sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})))},collectProviderToolCall=async e=>{if(f.has(e.toolCallId)||(f.add(e.toolCallId),u.has(e.toolCallId)))return;u.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage();let t=resolveProviderToolCallRequest(e,i?.tools??new Map);if(t.toolError!==void 0){m.add(e.toolCallId),await emitActionResult(createRuntimeToolResultFromToolError(t.toolError)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(t.toolError));return}_.set(t.request.action.callId,t.request.action.input),r.observe(t.request)},emitActionResult=async n=>{if(d.has(n.callId))return;d.add(n.callId),await emitNestedToolActions(e,t,n.callId);let r=n.isError===!0?void 0:projectResultPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionResultEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitActionPartial=async n=>{let r=projectDeltaPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionPartialEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitToolCall=async e=>{if(isInvalidToolCall(e)){m.add(e.toolCallId);return}if(!(i===void 0||i.excludedActionToolNames.has(e.toolName)))try{await emitActionRequest(createPresentedRuntimeActionRequestFromToolCall({toolCall:e,tools:i.tools}))}catch(t){if(t instanceof TypeError){let n=createInvalidToolCallInputError({error:t,toolCall:e});m.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage(),await emitActionResult(createRuntimeToolResultFromToolError(n)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(n));return}throw t}};for await(let d of n)if(c===void 0)switch(d.type){case`reasoning-delta`:await r.flush(),a+=d.text,await e(createReasoningAppendedEvent({reasoningDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`text-delta`:await r.flush(),a.trim().length>0&&(await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),a=``),o+=d.text,await e(createMessageAppendedEvent({messageDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`tool-input-start`:if(i===void 0||d.providerExecuted===!0||i.excludedActionToolNames.has(d.toolName)){v.delete(d.id);break}await r.flush(),o.trim().length>0&&await flushCurrentMessage(),v.set(d.id,{toolName:d.toolName});break;case`tool-input-delta`:{let e=v.get(d.id);if(e===void 0)break;await r.flush(),await emitActionInput(d.id,e.toolName,d.delta);break}case`tool-input-end`:v.delete(d.id);break;case`tool-call`:{let e=d;v.delete(e.toolCallId),l.add(e.toolCallId),e.providerExecuted===!0?await collectProviderToolCall(e):(await r.flush(),await emitToolCall(e));break}case`tool-result`:{let e=d;if(e.preliminary===!0){e.providerExecuted!==!0&&await emitActionPartial(createRuntimeToolResultFromStepResult(e));break}if(e.providerExecuted===!0){await collectProviderToolCall({input:`input`in e?e.input:void 0,toolCallId:e.toolCallId,toolName:e.toolName}),await r.flush(),await emitActionResult(createRuntimeToolResultFromStepResult(e));break}if(l.has(d.toolCallId)){if(isInlineAuthorizationToolResult(e))break;u.has(d.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId));break}if(await r.flush(),await flushCurrentMessage(),isInlineAuthorizationToolResult(e)){p.add(d.toolCallId),h.push(e);break}await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId);break}case`tool-error`:{let e=d;e.providerExecuted===!0?(await collectProviderToolCall(e),await r.flush(),await emitActionResult(createRuntimeToolResultFromToolError(e))):u.has(e.toolCallId)?(await emitActionResult(createRuntimeToolResultFromToolError(e)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(e))):l.has(e.toolCallId)||(await emitActionResult(createRuntimeToolResultFromToolError(e)),p.add(e.toolCallId));break}case`finish-step`:s=normalizeAssistantStepFinishReason(d.finishReason),await r.flush();break;case`error`:c=normalizeModelStreamError(d.error);break;case`abort`:throw new DOMException(d.reason??`The model stream was aborted.`,`AbortError`)}if(await r.flush(),c!==void 0)throw c;return a.trim().length>0&&await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),s!==`content-filter`&&o.trim().length>0&&await e(createMessageCompletedEvent({finishReason:reportedFinishReason(s,i?.hidesHeldText===!0),message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),{emittedActionCallIds:u,handledInlineToolResultCallIds:p,invalidInputToolCallIds:m,inlineAuthorizationResults:h,trailingInlineToolResultParts:g}}export{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState};
+import{createActionInputAppendedEvent,createActionPartialEvent,createActionResultEvent,createActionsRequestedEvent,createMessageAppendedEvent,createMessageCompletedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent}from"#protocol/message.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{emitNestedToolActions}from"#harness/nested-actions.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.js";import{collectActionPresentation,createPresentedRuntimeActionRequestFromToolCall}from"#harness/action-presentation.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{createProviderStreamActionBatch}from"#harness/stream-actions.js";import{normalizeModelStreamError}from"#harness/model-call/errors.js";import{createOrderedStreamEmitter}from"#harness/ordered-stream-emitter.js";import{interruptStreamOnFailure}from"#harness/interruptible-stream.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{normalizeAssistantStepFinishReason}from"#harness/finish-reason.js";async function emitStreamContent(e,t,n,r){let i=createOrderedStreamEmitter(e),a=createProviderStreamActionBatch({emitFn:i.emit,state:t});try{return await consumeStreamContent(i.emit,t,interruptStreamOnFailure(n,i.failureSignal),a,r)}finally{try{await a.cancel()}finally{await i.closeAndDrain()}}}function reportedFinishReason(e,t){return t&&e===`stop`?`tool-calls`:e}async function consumeStreamContent(e,t,n,r,i){let a=``,o=``,s=`stop`,c,l=new Set,u=new Set,d=new Set,f=new Set,p=new Set,m=new Set,h=[],g=[],_=new Map,v=new Map,flushCurrentMessage=async()=>{o.length!==0&&(await e(createMessageCompletedEvent({finishReason:`tool-calls`,message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),o=``)},emitActionInput=async(n,r,i)=>e(createActionInputAppendedEvent({callId:n,inputTextDelta:i,sequence:t.sequence,stepIndex:t.stepIndex,toolName:r,turnId:t.turnId})),emitActionRequest=async n=>{let{action:r}=n;u.has(r.callId)||(o.trim().length>0&&await flushCurrentMessage(),u.add(r.callId),_.set(r.callId,r.input),await e(createActionsRequestedEvent({actions:[r],presentation:collectActionPresentation([n]),sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})))},collectProviderToolCall=async e=>{if(f.has(e.toolCallId)||(f.add(e.toolCallId),u.has(e.toolCallId)))return;u.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage();let t=resolveProviderToolCallRequest(e,i?.tools??new Map);if(t.toolError!==void 0){m.add(e.toolCallId),await emitActionResult(createRuntimeToolResultFromToolError(t.toolError)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(t.toolError));return}_.set(t.request.action.callId,t.request.action.input),r.observe(t.request)},emitActionResult=async n=>{if(d.has(n.callId))return;d.add(n.callId),await emitNestedToolActions(e,t,n.callId);let r=n.isError===!0?void 0:projectResultPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionResultEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitActionPartial=async n=>{let r=projectDeltaPresentation(i?.tools.get(n.toolName),n.callId,_.get(n.callId),n.output);await e(createActionPartialEvent({presentation:r,result:n,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}))},emitToolCall=async e=>{if(isInvalidToolCall(e)){m.add(e.toolCallId);return}if(!(i===void 0||i.excludedActionToolNames.has(e.toolName)))try{await emitActionRequest(createPresentedRuntimeActionRequestFromToolCall({toolCall:e,tools:i.tools}))}catch(t){if(t instanceof TypeError){let n=createInvalidToolCallInputError({error:t,toolCall:e});m.add(e.toolCallId),o.trim().length>0&&await flushCurrentMessage(),await emitActionResult(createRuntimeToolResultFromToolError(n)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(n));return}throw t}};for await(let d of n)if(c===void 0)switch(d.type){case`reasoning-delta`:await r.flush(),a+=d.text,await e(createReasoningAppendedEvent({reasoningDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`text-delta`:await r.flush(),a.trim().length>0&&(await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),a=``),o+=d.text,await e(createMessageAppendedEvent({messageDelta:d.text,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId}));break;case`tool-input-start`:if(i===void 0||d.providerExecuted===!0||i.excludedActionToolNames.has(d.toolName)){v.delete(d.id);break}await r.flush(),o.trim().length>0&&await flushCurrentMessage(),v.set(d.id,{toolName:d.toolName});break;case`tool-input-delta`:{let e=v.get(d.id);if(e===void 0)break;await r.flush(),await emitActionInput(d.id,e.toolName,d.delta);break}case`tool-input-end`:v.delete(d.id);break;case`tool-call`:{let e=d;v.delete(e.toolCallId),l.add(e.toolCallId),e.providerExecuted===!0?await collectProviderToolCall(e):(await r.flush(),await emitToolCall(e));break}case`tool-result`:{let e=d;if(e.preliminary===!0){e.providerExecuted!==!0&&await emitActionPartial(createRuntimeToolResultFromStepResult(e));break}if(e.providerExecuted===!0){await collectProviderToolCall({input:`input`in e?e.input:void 0,toolCallId:e.toolCallId,toolName:e.toolName}),await r.flush(),await emitActionResult(createRuntimeToolResultFromStepResult(e));break}if(l.has(d.toolCallId)){if(isInlineAuthorizationToolResult(e))break;u.has(d.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId));break}if(await r.flush(),await flushCurrentMessage(),isInlineAuthorizationToolResult(e)){p.add(d.toolCallId),h.push(e);break}await emitActionResult(createRuntimeToolResultFromStepResult(e)),p.add(d.toolCallId);break}case`tool-error`:{let e=d;e.providerExecuted===!0?(await collectProviderToolCall(e),await r.flush(),await emitActionResult(createRuntimeToolResultFromToolError(e))):u.has(e.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromToolError(e)),p.add(e.toolCallId),g.push(createToolResultMessagePartFromToolError(e)));break}case`finish-step`:s=normalizeAssistantStepFinishReason(d.finishReason),await r.flush();break;case`error`:c=normalizeModelStreamError(d.error);break;case`abort`:throw new DOMException(d.reason??`The model stream was aborted.`,`AbortError`)}if(await r.flush(),c!==void 0)throw c;return a.trim().length>0&&await e(createReasoningCompletedEvent({reasoning:a,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),s!==`content-filter`&&o.trim().length>0&&await e(createMessageCompletedEvent({finishReason:reportedFinishReason(s,i?.hidesHeldText===!0),message:o,sequence:t.sequence,stepIndex:t.stepIndex,turnId:t.turnId})),{emittedActionCallIds:u,handledInlineToolResultCallIds:p,invalidInputToolCallIds:m,inlineAuthorizationResults:h,trailingInlineToolResultParts:g}}export{emitStreamContent};

package/dist/src/harness/execute-tool.d.ts

@@ -17,6 +17,7 @@ export interface HarnessToolDefinition {
     readonly execute?: (input: any, options: ToolExecuteOptions) => any;
     /** Optional JSON input substituted when this tool starts its workflow body. */
     readonly executeInput?: (input: unknown) => JsonValue;
+    readonly frameworkTool?: boolean;
     readonly frameworkAction?: "load-skill" | "task-cancel" | "task-wait";
     readonly inputSchema: FlexibleSchema;
     readonly name: string;

package/dist/src/harness/final-output.d.ts

@@ -4,6 +4,11 @@ import type { JsonObject } from "#shared/json.js";
  * Stable model-visible name for the kernel structured-output interception.
  */
 export declare const FINAL_OUTPUT_TOOL_NAME = "final_output";
+/**
+ * What the model reads when it gives its final output beside calls whose results it hasn't seen:
+ * the turn can't end on an answer written before them, so it answers again once they arrive.
+ */
+export declare const FINAL_OUTPUT_BESIDE_PENDING_CALLS = "Your final output wasn't delivered because other calls in this response were still running. Use their results, then call final_output again.";
 /**
  * Builds the model-facing `final_output` tool from a lowered output schema.
  *

package/dist/src/harness/final-output.js

@@ -1 +1 @@
-import{defineJsonSchema,toModelSchema}from"#tools/schema.js";const FINAL_OUTPUT_TOOL_NAME=`final_output`;function buildFinalOutputTool(e){let t=toModelSchema(defineJsonSchema(e),`input`);return{description:`Deliver your final answer in the required structure by calling this tool. Call it exactly once, when you are done; do not answer in prose.`,inputSchema:t,outputSchema:t}}export{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool};
+import{defineJsonSchema,toModelSchema}from"#tools/schema.js";const FINAL_OUTPUT_TOOL_NAME=`final_output`,FINAL_OUTPUT_BESIDE_PENDING_CALLS=`Your final output wasn't delivered because other calls in this response were still running. Use their results, then call final_output again.`;function buildFinalOutputTool(e){let t=toModelSchema(defineJsonSchema(e),`input`);return{description:`Deliver your final answer in the required structure by calling this tool. Call it exactly once, when you are done; do not answer in prose.`,inputSchema:t,outputSchema:t}}export{FINAL_OUTPUT_BESIDE_PENDING_CALLS,FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool};

package/dist/src/harness/hitl/approvals.d.ts

@@ -0,0 +1,115 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { ModelMessage } from "ai";
+import type { getApprovalAuditState } from "#harness/hitl/candidates.js";
+import { type AuthorizationChallenge } from "#harness/authorization.js";
+import { type ResolvedInputBatch } from "#harness/input-request-resolution.js";
+import type { StepInput } from "#harness/types.js";
+import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { Transition } from "#harness/session-machine/commit.js";
+import { type ResolvedStepInput } from "./delivery.js";
+import type { StepCoordinates, SuspendedStep } from "#harness/session-machine/view.js";
+import { type SessionView } from "#harness/session-machine/view.js";
+/**
+ * A model response made calls that need a person's approval. The response waits in a suspended
+ * step, beside any runtime calls it made, and the turn holds until the answers arrive.
+ */
+export declare function parkOnApprovals(view: SessionView, input: {
+    readonly event: StepCoordinates;
+    readonly messages: readonly ModelMessage[];
+    readonly requests: readonly InputRequest[];
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    readonly responseAuthRequiredRequestIds?: readonly string[];
+    readonly requester?: SuspendedStep["requester"];
+}): Transition;
+/** Approved workflow and agent calls join the runs their steps wait on, as their approvers. */
+export declare function dispatch(view: SessionView, input: {
+    readonly approvers: Readonly<Record<string, SessionAuthContext>>;
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+}): Transition;
+/**
+ * Approved calls run before the delivery's own input, as the AI SDK ran them: the model reads
+ * their results first. The input waits in the queue, unreceived, for the step after.
+ */
+export declare function deferInput(view: SessionView, input: StepInput): Transition;
+/** What the approval-response policies did with a delivery, before `answer` reads it. */
+export interface ResponsePolicyPass {
+    readonly kind: "continue" | "continue-coordination" | "authorization-required" | "responses-completed" | "park";
+    readonly challenges: readonly AuthorizationChallenge[];
+    readonly feedback: readonly string[];
+    /** The delivery minus the answers the policies took, plus the settlements they reached. */
+    readonly stepInput?: StepInput;
+    readonly audit: ReturnType<typeof getApprovalAuditState>;
+    /** Responder sign-ins pending when the pass began. */
+    readonly challengesAtStart: readonly AuthorizationChallenge[];
+}
+/** What `answer` concluded, beyond the events and state it changed. */
+export interface Answered extends Transition {
+    /**
+     * `continue`: the step goes on. `park`: nothing can run until more input arrives.
+     * `repeat`: a policy pass committed, so the next pass runs in a fresh step. `sign-in`: a
+     * responder must sign in first. `defer-message`: a message arrived while the session-limit
+     * prompt is open; it waits in its turn for the prompt.
+     */
+    readonly next: "continue" | "park" | "repeat" | "sign-in" | "defer-message";
+    /** The turn's input, without the answers `answer` consumed. */
+    readonly input?: StepInput;
+    /** Whether a plain-text answer consumed the message. */
+    readonly consumedMessage?: boolean;
+    /** The batches the delivery resolved, in order. */
+    readonly resolved: readonly ResolvedInputBatch[];
+    /** A decision on the session-limit prompt. */
+    readonly limit?: {
+        readonly granted: boolean;
+    };
+}
+/**
+ * A delivery answers what the session asked. An approval batch resolves once every request in it
+ * has a decision: approved calls become ready to run, denied ones get their denial as a result,
+ * and `once()` approvals grant their key. A message steers the held turn instead: the first
+ * pending batch resolves with the answers it has, and the rest are ignored. A session-limit
+ * answer grants or declines a fresh budget. A partial answer waits, queued, for the rest.
+ */
+export declare function answer(view: SessionView, input: {
+    readonly delivery: ResolvedStepInput | undefined;
+    readonly policy: ResponsePolicyPass;
+    /** The delivery merged the queue in, so the queue empties. */
+    readonly takeQueued: boolean;
+    readonly approvalKey: (request: InputRequest) => string | undefined;
+}): Answered;
+/** Queued input that can run now, rather than wait for more answers. */
+export declare function hasRunnableQueue(view: SessionView): boolean;
+/** Keys `once()` approvals granted, except those a pending approval still asks about. */
+export declare function grantedApprovalKeys(view: SessionView, approvalKey: (request: InputRequest) => string | undefined): ReadonlySet<string>;
+/**
+ * The steps a delivery approves calls of, whose tools the calls run with: those it answers in
+ * full, approving at least one call, or the only pending step a plain-text answer approves.
+ */
+export declare function approvingSteps(view: SessionView, stepInput: StepInput | undefined): readonly SuspendedStep[];
+/** The suspended step that holds `requestId`. */
+export declare function stepForRequest(view: SessionView, requestId: string): SuspendedStep | undefined;
+/**
+ * The held turn moves on, steered or cancelled: the sign-ins it waits on end, declined, including
+ * a responder's for one of its approvals.
+ */
+export declare function withdrawSignIns(view: SessionView, reason: string): Transition;
+/**
+ * The session spent its budget: it asks whether to continue instead of calling the model, and
+ * the turn ends. The prompt is the projection's open request; `answer` grants a
+ * fresh budget or declines it.
+ */
+export declare function requestLimit(view: SessionView, input: {
+    readonly request: InputRequest;
+}): Transition;
+/**
+ * Work needs a sign-in. The calls that need it stop, settling `cancelled` until it completes;
+ * an attempt it replaces fails; and each sign-in is asked for and recorded. The turn holds until
+ * every sign-in calls back. Input that waited on a responder's sign-in stays queued for it. An
+ * approved call that needs the sign-in leaves its step, so the model calls it again once the
+ * sign-in completes.
+ */
+export declare function requireSignIn(view: SessionView, input: {
+    readonly challenges: readonly AuthorizationChallenge[];
+    readonly callIdsByName?: ReadonlyMap<string, readonly string[]>;
+    readonly queued?: StepInput;
+}): Transition;

package/dist/src/harness/hitl/approvals.js

@@ -0,0 +1 @@
+import{canonicalize,compactInput,hasInput,isEmptyInput,resolveTextInput,withoutResponses,withoutTurnInput}from"./delivery.js";import{openInputs,turnCoordinates}from"#protocol/session-projection.js";import{readClientContext}from"#internal/client-context.js";import{createActionResultEvent,createApprovalCandidateEvent,createApprovalSettledEvent,createAuthorizationCompletedEvent,createAuthorizationRequiredEvent,createInputRequestedEvent,createInputResolvedEvent,createMessageCompletedEvent}from"#protocol/message.js";import{coalesceTurnInputs,createFrameworkUserMessage}from"#harness/messages.js";import{turnPosition}from"#harness/session-machine/view.js";import{renderPendingApprovalsSnippet}from"#harness/hitl/approval-prompt.js";import{finishTurn,hold,ownOpenRequestIds,settle,stepCallIds,suspend,withResult,withoutApproved}from"#harness/session-machine/transitions.js";import{supersededChallenges,withSignIns}from"#harness/authorization.js";import{withoutCalls}from"#harness/inline-tool-authorization.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{TOOL_EXECUTION_DENIED_MESSAGE,resolveApprovalOutcome,resolveInputOutcome}from"#harness/input-request-resolution.js";import{resolveSessionLimitContinuation}from"#harness/hitl/budget-request.js";import{signInWithdrawn}from"#harness/session-machine/events.js";function parkOnApprovals(e,t){let n=t.requester?.principalType===`anonymous`?null:t.requester,r=t.messages.findIndex(e=>e.role!==`tool`),i=r===-1?t.messages:t.messages.slice(0,r),a=renderPendingApprovalsSnippet(t.requests),o=suspend(e.turn,{event:t.event,messages:t.messages.slice(i.length),requester:n,requests:t.requests,responseAuthRequiredRequestIds:t.responseAuthRequiredRequestIds,tasks:t.tasks});return{commit:[...i,...a===void 0?[]:[createFrameworkUserMessage(`context.state`,a)]],events:[createInputRequestedEvent({requests:t.requests,...t.event})],turn:o}}function dispatch(e,t){let n=e.turn.suspended.map(e=>{let n=stepCallIds(e),r=t.tasks.filter(e=>n.has(e.callId));if(r.length===0)return e;let i=withoutApproved(e,new Set(r.map(e=>e.callId))),a={...e.approvers};for(let{callId:e}of r){let n=t.approvers[e];n!==void 0&&(a[e]=n)}return{...i,tasks:[...e.tasks,...r],...Object.keys(a).length>0&&{approvers:a}}});return{events:[],turn:{...e.turn,suspended:n}}}function deferInput(e,t){return{events:[],turn:withQueued(e.turn,t)}}function withQueued(e,t){return t===void 0||isEmptyInput(t)?e:{...e,queued:e.queued===void 0?t:coalesceTurnInputs(e.queued,t)}}function answer(e,t){let{policy:n}=t,{projection:r}=e,i=turnPosition(r),a=[...n.feedback.map(e=>createMessageCompletedEvent({message:e,sequence:i.sequence,stepIndex:i.stepIndex,turnId:i.turnId})),...reportApprovalProgress(r,n.audit,n.challengesAtStart)],o=t.takeQueued?{...e.turn,queued:void 0}:e.turn,done=e=>({events:a,resolved:[],turn:o,...e}),queue=e=>{o=withQueued(o,e)};if(n.kind===`park`)return done({next:`park`});if(n.kind===`continue-coordination`)return queue(n.stepInput),done({next:`repeat`});if(n.challenges.length>0)return done({next:`sign-in`});let s=t.delivery,c=openInputs(r).find(t=>t.request.kind===`session-limit`&&ownOpenRequestIds(e).has(t.request.requestId)),l=o.suspended.filter(e=>e.requests.length>0);if(c===void 0&&l.length===0)return done({input:s,next:`continue`});let u=c===void 0?l.length===1?l[0]:void 0:{requests:[c.request]},d=u===void 0?s:resolveTextInput(u,s),f=canonicalize(d?.inputResponses??[]),p=new Map(f.map(e=>[e.requestId,e])),m=l.filter(e=>e.requests.every(e=>p.has(e.requestId))),leftoverFor=e=>f.filter(t=>e.some(e=>e.requests.some(e=>e.requestId===t.requestId))),park=()=>(queue(compactInput(d)),done({next:`park`}));if(f.length===0&&d?.message===void 0)return park();if(c!==void 0){let e=p.get(c.request.requestId);if(e===void 0)return hasInput(s)?(queue(withoutTurnInput(d)),done({input:d,next:`defer-message`})):(queue(compactInput(d)),done({next:`park`}));let t={event:{sequence:c.sequence,stepIndex:c.stepIndex,turnId:c.turnId},inputs:[{outcome:resolveInputOutcome(c.request.kind,e),request:c.request,response:e}]};a.push(resolvedEvent(t));let n=leftoverFor(l);return n.length>0&&queue({inputResponses:n}),done({consumedMessage:d?.messageConsumed,input:withoutResponses(d),limit:resolveSessionLimitContinuation({requests:[c.request],responses:f}),next:`continue`,resolved:[t]})}if(m.length===0&&d?.message===void 0)return park();m.length===0&&m.push(l[0]);let h=leftoverFor(l.filter(e=>!m.includes(e)));h.length>0&&queue({inputResponses:h});let g=new Set(o.grants),_=[],v=[],y=o.suspended.map(e=>{if(!m.includes(e))return e;let n=e.messages,r=[];for(let i of e.requests){let{approved:a,reason:o,status:s}=resolveApprovalOutcome(p.get(i.requestId));if(a){g.add(t.approvalKey(i)??i.action.toolName),r.push(i);continue}n=withResult(n,{output:{reason:o,type:`execution-denied`},toolCallId:i.action.callId,toolName:i.action.toolName,type:`tool-result`}),v.push(createActionResultEvent({rejected:!0,result:{callId:i.action.callId,isError:!0,kind:`tool-result`,output:{approval:{requestId:i.requestId,status:s},code:`TOOL_EXECUTION_DENIED`,message:o??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:i.action.toolName},...e.event}))}_.push({event:e.event,inputs:e.requests.map(e=>{let t=p.get(e.requestId);return{outcome:resolveInputOutcome(e.kind,t),request:e,response:t}})});let i=[...e.approved??[],...r];return{...e,messages:n,requests:[],...i.length>0&&{approved:i}}});return a.push(..._.map(resolvedEvent),...v),o={...o,grants:[...g],suspended:y},done({consumedMessage:d?.messageConsumed,input:withoutResponses(d),next:`continue`,resolved:_})}function resolvedEvent(e){return createInputResolvedEvent({resolutions:e.inputs.map(e=>{let t={kind:e.request.kind,outcome:e.outcome,requestId:e.request.requestId};return e.response===void 0?t:{...t,response:e.response}}),...e.event})}function reportApprovalProgress(e,t,n){let r=turnCoordinates(e),isOpen=t=>{let n=e.inputs[t];return n!==void 0&&n.status!==`settled`},i=[];for(let a of n){let n=t.candidateHistory.some(e=>e.candidateId===a.candidateId&&e.status===`timed-out`),o=e.authorizations[a.attemptId??a.name];n&&o?.status===`required`&&i.push(createAuthorizationCompletedEvent({...authorizationEventFields(a),outcome:`failed`,reason:`The approval response expired. Please submit a new response.`,...r}))}for(let n of t.activeCandidates)e.candidates[n.candidateId]===void 0&&isOpen(n.requestId)&&i.push(createApprovalCandidateEvent({candidateId:n.candidateId,outcome:`pending`,requestId:n.requestId,responderPrincipalId:n.responder.principalId,...r}));for(let n of t.candidateHistory)n.status!==`allowed`&&n.status!==`authorization-required`&&e.inputs[n.requestId]!==void 0&&e.candidates[n.candidateId]?.outcome!==n.status&&i.push(createApprovalCandidateEvent({candidateId:n.candidateId,outcome:n.status,requestId:n.requestId,responderPrincipalId:n.responder.principalId,reason:n.reason,...r}));for(let e of t.settlements)isOpen(e.requestId)&&i.push(createApprovalSettledEvent({outcome:e.outcome===`allowed`?`approved`:`cancelled`,requestId:e.requestId,responderPrincipalId:e.actor.principalId,...r}));return i}function hasRunnableQueue(e){let t=e.turn.queued;if(t===void 0)return!1;if(t.message!==void 0||(t.context?.length??0)>0||readClientContext(t)!==void 0||t.outputSchema!==void 0||(t.runtimeActionResults?.length??0)>0)return!0;let n=[...t.inputResponses??[],...(t.attributedInputResponses??[]).map(({response:e})=>e)];if(n.length===0)return!1;let r=new Set(n.map(e=>e.requestId)),i=openInputs(e.projection).find(e=>e.request.kind===`session-limit`);return i===void 0?e.turn.suspended.some(e=>e.requests.length>0&&e.requests.every(e=>r.has(e.requestId))):r.has(i.request.requestId)}function grantedApprovalKeys(e,t){let n=new Set(e.turn.grants);for(let r of e.turn.suspended)for(let e of r.requests)isApprovalRequest(e)&&n.delete(t(e)??e.action.toolName);return n}function approvingSteps(e,t){let n=e.turn.suspended.filter(e=>e.requests.length>0),r=n.length===1?resolveTextInput(n[0],t):t,i=new Map((r?.inputResponses??[]).map(e=>[e.requestId,e.optionId]));return n.filter(e=>e.requests.every(e=>i.has(e.requestId))&&e.requests.some(e=>isApprovalRequest(e)&&i.get(e.requestId)===`approve`))}function stepForRequest(e,t){return e.turn.suspended.find(e=>e.requests.some(e=>e.requestId===t))}function withdrawSignIns(e,t){return{events:e.signIns.flatMap(n=>{let r=e.projection.authorizations[n.attemptId??n.name];return r?.status===`required`?[signInWithdrawn(r,t)]:[]}),signIns:[],turn:e.turn}}function requestLimit(e,t){let n=turnPosition(e.projection);return{events:[createInputRequestedEvent({requests:[t.request],sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId}),...finishTurn(e).events],turn:e.turn}}function requireSignIn(e,t){let n=turnPosition(e.projection),r={sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId},i=[...supersededChallenges(e.signIns,t.challenges).map(e=>createAuthorizationCompletedEvent({...authorizationEventFields(e),outcome:`failed`,reason:`Superseded by a newer authorization attempt.`,...r})),...t.challenges.map(e=>createAuthorizationRequiredEvent({...authorizationEventFields(e),description:e.challenge.instructions??`Authorization required for ${e.name}`,webhookUrl:e.hookUrl,...r}))];i.push(...hold(e,{on:`input`}).events);let a=t.queued===void 0?e.turn.queued:e.turn.queued===void 0?t.queued:coalesceTurnInputs(e.turn.queued,t.queued),o=withSignIns(e.signIns,t.challenges),s=new Set([...t.callIdsByName?.values()??[]].flat()),c=e.turn.suspended.map(e=>[...stepCallIds(e)].some(e=>s.has(e))?{...e,messages:withoutCalls(e.messages,s)}:e);if(c.every((t,n)=>t===e.turn.suspended[n]))return{events:i,signIns:o,turn:{...e.turn,queued:a}};let l=settle({...e,turn:{...e.turn,queued:a,suspended:c}},{results:[]});return{commit:l.commit,events:i,signIns:o,turn:l.turn}}export{answer,approvingSteps,deferInput,dispatch,grantedApprovalKeys,hasRunnableQueue,parkOnApprovals,requestLimit,requireSignIn,stepForRequest,withdrawSignIns};

package/dist/src/harness/hitl/approved-call-callers.d.ts

@@ -0,0 +1,14 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { SessionStateMap } from "#harness/types.js";
+/** Who approved each of the `approved` calls, by call id. */
+export declare function approversOf(approved: readonly InputRequest[], state: SessionStateMap | undefined): Readonly<Record<string, SessionAuthContext>>;
+/**
+ * Records who approved each of the `approved` calls, so each runs as its approver while the rest
+ * of the turn keeps the turn's own caller.
+ */
+export declare function setApprovedCallCallers(approved: readonly InputRequest[], state: SessionStateMap | undefined): void;
+/** Runs `fn` as the call's approver when `callId` is an approved call; otherwise as is. */
+export declare function runAsApprover<T>(callId: string | undefined, fn: () => T): T;
+/** A streaming call's body runs on each `next()`, so each one runs as the approver too. */
+export declare function iterateAsApprover<T>(callId: string | undefined, iterable: AsyncIterable<T>): AsyncIterable<T>;

package/dist/src/harness/hitl/approved-call-callers.js

@@ -0,0 +1 @@
+import{approverOfRequest}from"./candidates.js";import{contextStorage}from"#context/container.js";import{ContextKey}from"#context/key.js";import{runAsCaller}from"#context/caller-scope.js";const ApprovedCallCallersKey=new ContextKey(`eve.approvedCallCallers`);function approversOf(e,t){let n={};for(let r of e){if(r.action===void 0)continue;let e=approverOfRequest(t,r.requestId);e!==void 0&&(n[r.action.callId]=e)}return n}function setApprovedCallCallers(e,t){let n=contextStorage.getStore();n!==void 0&&n.setVirtualContext(ApprovedCallCallersKey,new Map(Object.entries(approversOf(e,t))))}function runAsApprover(e,t){let n=e===void 0?void 0:contextStorage.getStore()?.get(ApprovedCallCallersKey)?.get(e);return n===void 0?t():runAsCaller(n,t)}async function*iterateAsApprover(e,t){let n=t[Symbol.asyncIterator]();try{for(;;){let t=await runAsApprover(e,()=>n.next());if(t.done===!0)return;yield t.value}}finally{await n.return?.()}}export{approversOf,iterateAsApprover,runAsApprover,setApprovedCallCallers};

package/dist/src/harness/hitl/approved-calls.d.ts

@@ -0,0 +1,37 @@
+import { type ModelMessage, type TelemetryOptions, type ToolSet, type TypedToolResult } from "ai";
+import type { HarnessToolMap } from "#harness/types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { HandleEventFn } from "#harness/types.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+export interface ApprovedCallResult {
+    readonly part: Extract<ToolResponsePart, {
+        type: "tool-result";
+    }>;
+}
+/**
+ * Runs approved local calls before the model reads their results. Like the calls a model step
+ * runs inline, each streams its progress and result as it goes. The lifecycle owner places the
+ * results in the steps that made the calls.
+ */
+export declare function runApprovedCalls(input: {
+    readonly requests: readonly InputRequest[];
+    readonly tools: HarnessToolMap;
+    readonly approvedTools?: ReadonlySet<string>;
+    /** The conversation the tools read as `ctx.messages`. */
+    readonly messages: readonly ModelMessage[];
+    readonly position: {
+        readonly sequence: number;
+        readonly stepIndex: number;
+        readonly turnId: string;
+    };
+    readonly publish: HandleEventFn;
+    readonly abortSignal: AbortSignal | undefined;
+    /** The step attempt's telemetry, which hears each execution as the AI SDK reports it. */
+    readonly telemetry?: TelemetryOptions;
+}): Promise<{
+    readonly settled: readonly ApprovedCallResult[];
+    readonly toolResults: readonly TypedToolResult<ToolSet>[];
+}>;
+export {};

package/dist/src/harness/hitl/approved-calls.js

@@ -0,0 +1 @@
+import{asSchema}from"ai";import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{createActionPartialEvent,createActionResultEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{isAsyncIterable}from"#shared/async-iterable.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";import{emitNestedToolActions}from"#harness/nested-actions.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{TOOL_EXECUTION_DENIED_MESSAGE}from"#harness/input-request-resolution.js";import{buildToolSet,recheckApprovedCall}from"#harness/tools.js";const log=createLogger(`harness.tool-loop`);async function runApprovedCalls(e){let t=buildToolSet({tools:e.tools,approvedTools:e.approvedTools}),n=e.requests.map(n=>{let r=e.tools.get(n.action.toolName),i=t[n.action.toolName];if(r?.execute===void 0||i?.execute===void 0||i.toModelOutput===void 0)throw Error(`The approved tool is no longer available. Request a new tool call and approval.`);return{request:n,definition:r,tool:i}}),r={sequence:e.position.sequence,stepIndex:e.position.stepIndex,turnId:e.position.turnId},i=await Promise.allSettled(n.map(async({request:t,definition:n,tool:i})=>{let a=[],o=[],{callId:s,toolName:c,input:l}=t.action;try{if(throwIfTurnAborted(e.abortSignal),(await asSchema(i.inputSchema).validate?.(l))?.success===!1){let t=`The approved input is no longer valid for tool "${c}". Request a new tool call and approval.`;return await e.publish(createActionResultEvent({...r,result:createRuntimeToolResultFromValue({callId:s,isError:!0,output:t,toolName:c})})),{settled:[{part:{type:`tool-result`,toolCallId:s,toolName:c,output:{type:`error-text`,value:t}}}],toolResults:o}}let t=await recheckApprovedCall(n,{abortSignal:e.abortSignal,callId:s,input:l,approvedTools:e.approvedTools});if(t.denied)return await e.publish(createActionResultEvent({...r,rejected:!0,result:{callId:s,isError:!0,kind:`tool-result`,output:{code:`TOOL_EXECUTION_DENIED`,message:t.reason??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:c}})),a.push({part:{output:{reason:t.reason,type:`execution-denied`},toolCallId:s,toolName:c,type:`tool-result`}}),{settled:a,toolResults:o};let u,d=!1,f=toolTelemetry(e.telemetry,{messages:[...e.messages],toolCall:{input:l,toolCallId:s,toolName:c,type:`tool-call`}});await f.started();let p=0;try{await f.execute(async()=>{let t=performance.now();try{let t=i.execute(l,{abortSignal:e.abortSignal,context:void 0,messages:[...e.messages],toolCallId:s});if(isAsyncIterable(t))for await(let i of t)u=i,await e.publish(createActionPartialEvent({...r,presentation:projectDeltaPresentation(n,s,parseJsonObject(l),i),result:createRuntimeToolResultFromValue({callId:s,output:i,toolName:c})}));else u=await t}finally{p=performance.now()-t}})}catch(t){await f.ended({error:t,input:l,toolCallId:s,toolName:c,type:`tool-error`},p),throwIfTurnAborted(e.abortSignal),logError(log,`tool execution failed`,t,{toolName:c,toolCallId:s}),d=!0,u=toError(t).message}d||await f.ended({input:l,output:u,toolCallId:s,toolName:c,type:`tool-result`},p);let m={input:l,output:u,toolCallId:s,toolName:c,type:`tool-result`};return o.push(m),isInlineAuthorizationToolResult(m)?{settled:a,toolResults:o}:(await emitNestedToolActions(e.publish,e.position,s),a.push({part:{output:d?{type:`error-text`,value:String(u)}:await i.toModelOutput({input:l,output:u,toolCallId:s}),toolCallId:s,toolName:c,type:`tool-result`}}),await e.publish(createActionResultEvent({...r,presentation:d?void 0:projectResultPresentation(n,s,parseJsonObject(l),u),result:createRuntimeToolResultFromValue({callId:s,isError:d,output:u,toolName:c})})),{settled:a,toolResults:o})}catch(t){throwIfTurnAborted(e.abortSignal);let n=toError(t).message;return logError(log,`approved tool failed`,t,{toolName:c,toolCallId:s}),await e.publish(createActionResultEvent({...r,result:createRuntimeToolResultFromValue({callId:s,isError:!0,output:n,toolName:c})})),{settled:[{part:{type:`tool-result`,toolCallId:s,toolName:c,output:{type:`error-text`,value:n}}}],toolResults:o}}})),a=i.find(e=>e.status===`rejected`);if(a?.status===`rejected`)throw a.reason;let o=i.flatMap(e=>e.status===`fulfilled`?[e.value]:[]);return{settled:o.flatMap(e=>e.settled),toolResults:o.flatMap(e=>e.toolResults)}}function toolTelemetry(e,t){let n=e===void 0||e.isEnabled===!1?[]:[e.integrations??[]].flat(),r={...t,callId:`approved:${t.toolCall.toolCallId}`,functionId:e?.functionId,recordInputs:e?.recordInputs,recordOutputs:e?.recordOutputs,toolContext:void 0},notify=async e=>{await Promise.allSettled(n.map(async t=>await e(t)))};return{started:()=>notify(e=>e.onToolExecutionStart?.(r)),execute:async e=>{let wrapped=e;for(let e of n){if(e.executeTool===void 0)continue;let n=wrapped;wrapped=()=>e.executeTool({...r,execute:n,toolCallId:t.toolCall.toolCallId})}await wrapped()},ended:(e,t)=>notify(n=>n.onToolExecutionEnd?.({...r,toolExecutionMs:t,toolOutput:e}))}}export{runApprovedCalls};

package/dist/src/harness/hitl/budget.d.ts

@@ -0,0 +1,21 @@
+import type { HarnessSession } from "#harness/types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { JsonObject } from "#shared/json.js";
+export { bumpSessionRuntimeUsageLimits } from "#harness/turn-tag-state.js";
+export type SessionUsageLimitCheck = {
+    readonly kind: "within";
+} | {
+    readonly kind: "ask";
+    readonly request: InputRequest;
+} | {
+    readonly kind: "fail";
+    readonly code: string;
+    readonly details: JsonObject;
+    readonly message: string;
+};
+/** Whether the session may call the model, may ask to continue, or must fail. */
+export declare function checkSessionUsageLimit(input: {
+    readonly canAsk: boolean;
+    readonly session: HarnessSession;
+    readonly turnSequence: number;
+}): SessionUsageLimitCheck;

package/dist/src/harness/hitl/budget.js

@@ -0,0 +1 @@
+import{bumpSessionRuntimeUsageLimits,getSessionTokenUsage,getSessionUsageLimitViolation}from"#harness/turn-tag-state.js";import{createSessionLimitContinuationRequest}from"#harness/hitl/budget-request.js";function checkSessionUsageLimit(e){let t=getSessionUsageLimitViolation(e.session);if(t===null)return{kind:`within`};if(violationWindow(t)>0&&e.canAsk)return{kind:`ask`,request:createSessionLimitContinuationRequest({sessionId:e.session.sessionId,turnSequence:e.turnSequence,violation:t})};let n=getSessionTokenUsage(e.session);return{code:t.kind===`token-cost`?`SESSION_TOKEN_COST_LIMIT_REACHED`:`SESSION_TOKEN_LIMIT_REACHED`,details:t.kind===`token-cost`?{costUsd:n.costUsd,kind:t.kind,limitUsd:t.limitUsd,usedCostUsd:t.usedCostUsd}:{inputTokens:n.inputTokens,kind:t.kind,limit:t.limit,outputTokens:n.outputTokens,usedTokens:t.usedTokens},kind:`fail`,message:formatSessionLimitMessage(t.kind)}}function violationWindow(e){return e.kind===`token-cost`?e.limitUsd:e.limit}function formatSessionLimitMessage(e){return e===`token-cost`?`The session reached its configured model token-cost limit.`:`The session reached its configured ${e} token limit.`}export{bumpSessionRuntimeUsageLimits,checkSessionUsageLimit};

package/dist/src/harness/{approval-candidates.d.ts → hitl/candidates.d.ts}

@@ -12,7 +12,6 @@ interface ApprovalCandidateAuditRecord {
     readonly status: ApprovalCandidateStatus;
     readonly createdAt: number;
     readonly completedAt?: number;
-    readonly eventEmitted?: boolean;
     readonly expiresAt?: number;
     readonly reason?: string;
 }
@@ -30,7 +29,6 @@ export interface ApprovalSettlementAuditRecord {
     readonly requestId: string;
     readonly settledAt: number;
     readonly candidateId?: string;
-    readonly eventEmitted?: boolean;
 }
 export interface ActiveApprovalCandidate {
     readonly candidateId: string;
@@ -41,7 +39,6 @@ export interface ActiveApprovalCandidate {
     readonly createdAt: number;
     readonly expiresAt: number;
     readonly authorizationChallenges?: readonly AuthorizationChallenge[];
-    readonly pendingEventEmitted?: boolean;
 }
 interface ApprovalStateTransition {
     readonly changed: boolean;
@@ -57,21 +54,6 @@ export declare function createApprovalCandidate(input: {
     readonly responder: SessionAuthContext;
     readonly state: SessionStateMap | undefined;
 }): ApprovalStateTransition;
-/** Marks the pending candidate event as emitted. */
-export declare function markApprovalCandidatePendingEventEmitted(input: {
-    readonly candidateId: string;
-    readonly state: SessionStateMap | undefined;
-}): SessionStateMap | undefined;
-/** Marks a terminal candidate history event as emitted. */
-export declare function markApprovalCandidateHistoryEventEmitted(input: {
-    readonly candidateId: string;
-    readonly state: SessionStateMap | undefined;
-}): SessionStateMap | undefined;
-/** Marks a terminal settlement event as emitted. */
-export declare function markApprovalSettlementEventEmitted(input: {
-    readonly requestId: string;
-    readonly state: SessionStateMap | undefined;
-}): SessionStateMap | undefined;
 /** Marks a candidate as waiting on a private authorization challenge. */
 export declare function markApprovalCandidateAuthorizationRequired(input: {
     readonly authorizationChallenges: readonly AuthorizationChallenge[];
@@ -117,6 +99,15 @@ export declare function getApprovalAuditState(state: SessionStateMap | undefined
     readonly candidateHistory: readonly ApprovalCandidateAuditRecord[];
     readonly settlements: readonly ApprovalSettlementAuditRecord[];
 };
+export declare function sameResponder(a: Pick<SessionAuthContext, "authenticator" | "issuer" | "principalId" | "principalType">, b: Pick<SessionAuthContext, "authenticator" | "issuer" | "principalId" | "principalType">): boolean;
+/**
+ * The held turn moved on, steered or cancelled: the responders still checking one of its
+ * approvals stop, their candidates stale.
+ */
+export declare function retireActiveCandidates(state: SessionStateMap | undefined, input: {
+    readonly completedAt: number;
+    readonly reason: string;
+}): SessionStateMap | undefined;
 /** The full auth of whoever approved `requestId`, when it was allowed. */
 export declare function approverOfRequest(state: SessionStateMap | undefined, requestId: string): SessionAuthContext | undefined;
 export {};

package/dist/src/harness/hitl/candidates.js

@@ -0,0 +1 @@
+const APPROVAL_STATE_KEY=`eve.runtime.hitl.approvalState`;function createApprovalCandidate(e){let t=expireApprovalCandidates({now:e.createdAt,state:e.state}),n=readApprovalState(t);if(n.settlements[e.requestId]!==void 0)return{changed:!1,state:t};let r=e.responder;if(Object.values(n.activeCandidates).find(t=>t.requestId===e.requestId&&t.decision===e.decision&&sameResponder(t.responder,r))!==void 0)return{changed:!1,state:t};let i=n.activeCandidates[e.candidateIdPrefix]!==void 0||n.candidateHistory.some(t=>t.candidateId===e.candidateIdPrefix)?`${e.candidateIdPrefix}.${n.nextCandidateSequence.toString(36)}`:e.candidateIdPrefix;if(n.activeCandidates[i]!==void 0||n.candidateHistory.some(e=>e.candidateId===i))throw Error(`Approval candidate id collision: "${i}".`);let a={candidateId:i,createdAt:e.createdAt,decision:e.decision,expiresAt:e.expiresAt,requestId:e.requestId,responder:r,status:`pending`};return{changed:!0,state:writeApprovalState(t,{...n,activeCandidates:{...n.activeCandidates,[a.candidateId]:a},nextCandidateSequence:n.nextCandidateSequence+1})}}function markApprovalCandidateAuthorizationRequired(e){let t=readApprovalState(e.state),n=t.activeCandidates[e.candidateId];if(n===void 0)return e.state;let r={...n,authorizationChallenges:e.authorizationChallenges,expiresAt:e.expiresAt??n.expiresAt,status:`authorization-required`};return writeApprovalState(e.state,{...t,activeCandidates:{...t.activeCandidates,[e.candidateId]:r}})}function finishApprovalCandidate(e){let t=readApprovalState(e.state),n=t.activeCandidates[e.candidateId];if(n===void 0)return e.state;let r={...t.activeCandidates};return delete r[e.candidateId],writeApprovalState(e.state,{...t,activeCandidates:r,candidateHistory:[...t.candidateHistory,toCandidateAuditRecord({candidate:n,completedAt:e.completedAt,reason:e.reason,status:e.status})]})}function expireApprovalCandidates(e){let t=e.state,n=Object.values(readApprovalState(t).activeCandidates);for(let r of n)r.expiresAt>e.now||(t=finishApprovalCandidate({candidateId:r.candidateId,completedAt:e.now,state:t,status:`timed-out`}));return t}function settleAllowedCandidate(e){let t=expireApprovalCandidates({now:e.settledAt,state:e.state}),n=readApprovalState(t),r=n.activeCandidates[e.candidateId];if(r===void 0){let r=n.candidateHistory.find(t=>t.candidateId===e.candidateId);if((r&&n.settlements[r.requestId])!==void 0)return{changed:!1,state:t};throw Error(`Unknown approval candidate "${e.candidateId}".`)}return settleRequest({candidateId:r.candidateId,outcome:r.decision===`cancel`?`cancelled`:`allowed`,requestId:r.requestId,responder:r.responder,settledAt:e.settledAt,state:t})}function settleDirectApprovalResponse(e){let t=expireApprovalCandidates({now:e.settledAt,state:e.state});return settleRequest({outcome:e.outcome,requestId:e.requestId,responder:e.actor,settledAt:e.settledAt,state:t})}function getActiveApprovalCandidate(e,t){return readApprovalState(e).activeCandidates[t]}function getApprovalAuditState(e){let t=readApprovalState(e);return{activeCandidates:Object.values(t.activeCandidates),candidateHistory:t.candidateHistory,settlements:Object.values(t.settlements)}}function settleRequest(e){let t=readApprovalState(e.state);if(t.settlements[e.requestId]!==void 0)return{changed:!1,state:e.state};let n={actor:projectResponder(e.responder),...e.outcome===`allowed`&&{approver:e.responder},candidateId:e.candidateId,outcome:e.outcome,requestId:e.requestId,settledAt:e.settledAt},r={},i=[...t.candidateHistory];for(let n of Object.values(t.activeCandidates)){if(n.requestId!==e.requestId){r[n.candidateId]=n;continue}i.push(toCandidateAuditRecord({candidate:n,completedAt:e.settledAt,status:n.candidateId===e.candidateId?`allowed`:`stale`}))}let a={activeCandidates:r,candidateHistory:i,nextCandidateSequence:t.nextCandidateSequence,settlements:{...t.settlements,[e.requestId]:n}};return{changed:!0,state:writeApprovalState(e.state,a)}}function toCandidateAuditRecord(e){let{authorizationChallenges:t,responder:n,...r}=e.candidate;return{...r,completedAt:e.completedAt,responder:projectResponder(n),reason:e.reason,status:e.status}}function projectResponder(e){return{authenticator:e.authenticator,issuer:e.issuer,principalId:e.principalId,principalType:e.principalType}}function sameResponder(e,t){return e.authenticator===t.authenticator&&e.issuer===t.issuer&&e.principalId===t.principalId&&e.principalType===t.principalType}function readActiveCandidates(e){return Object.fromEntries(Object.entries(e).map(([e,t])=>[e,{...t,decision:t.decision===`cancel`?`cancel`:`approve`}]))}function readApprovalState(e){let t=e?.[APPROVAL_STATE_KEY];if(typeof t!=`object`||!t)return{activeCandidates:{},candidateHistory:[],nextCandidateSequence:0,settlements:{}};let n=t;return{activeCandidates:typeof n.activeCandidates==`object`&&n.activeCandidates!==null?readActiveCandidates(n.activeCandidates):{},candidateHistory:Array.isArray(n.candidateHistory)?n.candidateHistory:[],nextCandidateSequence:typeof n.nextCandidateSequence==`number`&&Number.isSafeInteger(n.nextCandidateSequence)&&n.nextCandidateSequence>=0?n.nextCandidateSequence:deriveNextCandidateSequence(n),settlements:typeof n.settlements==`object`&&n.settlements!==null?n.settlements:{}}}function deriveNextCandidateSequence(e){return Object.keys(e.activeCandidates??{}).length+(Array.isArray(e.candidateHistory)?e.candidateHistory.length:0)}function writeApprovalState(e,t){return{...e,[APPROVAL_STATE_KEY]:t}}function retireActiveCandidates(e,t){let n=e;for(let e of getApprovalAuditState(n).activeCandidates)n=finishApprovalCandidate({candidateId:e.candidateId,completedAt:t.completedAt,reason:t.reason,state:n,status:`stale`});return n}function approverOfRequest(e,t){return readApprovalState(e).settlements[t]?.approver}export{approverOfRequest,createApprovalCandidate,expireApprovalCandidates,finishApprovalCandidate,getActiveApprovalCandidate,getApprovalAuditState,markApprovalCandidateAuthorizationRequired,retireActiveCandidates,sameResponder,settleAllowedCandidate,settleDirectApprovalResponse};

package/dist/src/harness/hitl/coordinator.js

@@ -0,0 +1 @@
+import{contextStorage}from"#context/container.js";import{AuthKey,SessionKey}from"#context/keys.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{buildApprovalResponseAuth,handleApprovalResponsePolicyError}from"#execution/tool-auth.js";import{suspendedSteps}from"#harness/session-machine/view.js";import{clearPendingAuthorization,getAuthorizationResult,getPendingAuthorization,isAuthorizationSignal}from"#harness/authorization.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{createApprovalCandidate,expireApprovalCandidates,finishApprovalCandidate,getActiveApprovalCandidate,getApprovalAuditState,markApprovalCandidateAuthorizationRequired,sameResponder,settleAllowedCandidate,settleDirectApprovalResponse}from"#harness/hitl/candidates.js";async function coordinateApprovalDelivery(e){let t=e.now??Date.now(),n=getApprovalAuditState(e.session.state).activeCandidates.filter(e=>e.expiresAt<=t),r=n.flatMap(e=>e.authorizationChallenges?.map(e=>e.attemptId??e.candidateId??e.name)??[]),i=expireApprovalCandidates({now:t,state:e.session.state}),a={...e.session,state:clearPendingAuthorization(i,r)},o=getApprovalAuditState(a.state),s=suspendedSteps(a.state).filter(e=>e.requests.length>0),c=new Set(s.flatMap(e=>e.requests.map(e=>e.requestId))),l=o.settlements.filter(e=>c.has(e.requestId)),u=new Set(o.settlements.map(e=>e.requestId)),d=new Set([...u].filter(e=>!c.has(e))),f=hasResponseForRequest(e.stepInput,d),p=f?removeConsumedResponses(e.stepInput,d):e.stepInput;if(f&&l.length===0&&!hasMeaningfulInput(p))return deliveryResult(a,p,`park`);if(s.length===0)return deliveryResult(a,p);let m=p,h=new Set(s.flatMap(e=>e.responseAuthRequiredRequestIds??[])),g=s.flatMap(e=>e.requests),_=new Map(g.map(e=>[e.requestId,e])),v=[],y=[],b=new Set,x=!1,S=getApprovalAuditState(a.state).activeCandidates,C=[...m?.attributedInputResponses??[],...(m?.inputResponses??[]).map(e=>({auth:void 0,response:e}))];for(let{auth:e,response:n}of C){let r=_.get(n.requestId);if(r===void 0||!isApprovalRequest(r))continue;if(!h.has(n.requestId)){let r=contextStorage.getStore(),i=e===void 0?r?.get(AuthKey)??r?.get(SessionKey)?.auth.current??null:e,o=toCandidateDecision(n.optionId),s=suspendedSteps(a.state).find(e=>e.requests.some(e=>e.requestId===n.requestId))?.requester??null;if(i!==null&&o!==void 0&&s!==null&&!sameResponder(s,i)){b.add(n.requestId),y.push(`Only the person who requested this action can respond to this approval.`);continue}if(i!==null&&o!==void 0){let e=settleDirectApprovalResponse({actor:i,outcome:o===`approve`?`allowed`:`cancelled`,requestId:n.requestId,settledAt:t,state:a.state});a={...a,state:e.state},x||=e.changed}continue}b.add(n.requestId);let i=toCandidateDecision(n.optionId);if(i===void 0)continue;let o=e===void 0?buildCallbackContext().session.auth.current:e;if(o===null){y.push(`Authentication is required to respond to this approval.`);continue}let s=createApprovalCandidate({candidateIdPrefix:approvalCandidateIdPrefix(r.requestId,o,i),createdAt:t,decision:i,expiresAt:t+6e5,requestId:r.requestId,responder:o,state:a.state});a={...a,state:s.state},x||=s.changed}let w=removeConsumedResponses(m,b);if(b.size>0)return deliveryResult(a,w,x?`continue-coordination`:`continue`,[],y);if(x)return deliveryResult(a,w,`continue`,[],y);let T=new Set(getPendingAuthorization(a.state)?.challenges.map(e=>e.name)??[]);for(let n of S){if(n.status===`authorization-required`){let e=n.authorizationChallenges??[];if(!e.some(e=>getAuthorizationResult(e.name)!==void 0)){v.push(...e.filter(e=>!T.has(e.name)));continue}}let r=_.get(n.requestId);if(r===void 0||getActiveApprovalCandidate(a.state,n.candidateId)===void 0)continue;let i=await authorizeCandidate({candidateId:n.candidateId,decision:n.decision,now:t,request:r,responder:n.responder,session:a,tools:await e.prepareTools?.(r)??e.tools});a=i.session,x||=i.didCommit,v.push(...i.challenges);let o=getApprovalAuditState(a.state).settlements.find(e=>e.requestId===n.requestId);o!==void 0&&l.push(o)}let E=appendSettledResponses(w,l);return(x||n.length>0)&&getApprovalAuditState(a.state).activeCandidates.length===0?deliveryResult(a,E,`responses-completed`):l.length>0?deliveryResult(a,E,`continue`):x?deliveryResult(a,E,`continue-coordination`):deliveryResult(a,E,v.length>0?`authorization-required`:`continue`,v)}async function authorizeCandidate(e){let t={...e.session,state:expireApprovalCandidates({now:e.now,state:e.session.state})};if(getActiveApprovalCandidate(t.state,e.candidateId)===void 0)return{challenges:[],didCommit:!1,session:t};let n=e.tools.get(e.request.action.toolName)?.approval,r=n!==void 0&&typeof n!=`function`?n.response:void 0;if(r===void 0)return failCandidate({...e,reason:`Approval authorization is temporarily unavailable. Please try again.`,session:t});try{let n=buildCallbackContext(),i=await withAuthorizerTimeout(r({auth:buildApprovalResponseAuth({responder:e.responder,scope:e.candidateId}),request:{callId:e.request.action.callId,requestId:e.request.requestId,principal:suspendedSteps(t.state).find(t=>t.requests.some(t=>t.requestId===e.request.requestId))?.requester??null,toolInput:e.request.action.input,toolName:e.request.action.toolName},response:{decision:e.decision,principal:e.responder},session:{id:n.session.id,initiator:n.session.auth.initiator,parent:n.session.parent,turn:n.session.turn}}));if(i.status===`rejected`)return t={...t,state:finishApprovalCandidate({candidateId:e.candidateId,completedAt:e.now,reason:i.reason,state:t.state,status:`rejected`})},{challenges:[],didCommit:!0,session:t};if(i.status!==`allowed`)return failCandidate({...e,session:t});let a=settleAllowedCandidate({candidateId:e.candidateId,settledAt:e.now,state:t.state});return{challenges:[],didCommit:a.changed,session:{...t,state:a.state}}}catch(n){let r=await handleApprovalResponsePolicyError(n).catch(()=>void 0);if(isAuthorizationSignal(r)){let n=r.challenges.map(e=>Date.parse(e.challenge.expiresAt??``)).filter(Number.isFinite).sort((e,t)=>e-t)[0];return t={...t,state:markApprovalCandidateAuthorizationRequired({authorizationChallenges:r.challenges.map(t=>({...t,candidateId:e.candidateId})),candidateId:e.candidateId,expiresAt:n,state:t.state})},{challenges:r.challenges.map(t=>({...t,candidateId:e.candidateId})),didCommit:!0,session:t}}return failCandidate({...e,session:t})}}function failCandidate(e){let t=e.reason??`We couldn’t verify your response. Please try again.`;return{challenges:[],didCommit:!0,session:{...e.session,state:finishApprovalCandidate({candidateId:e.candidateId,completedAt:e.now,reason:t,state:e.session.state,status:`failed`})}}}function hasResponseForRequest(e,t){return e?.attributedInputResponses?.some(({response:e})=>t.has(e.requestId))===!0||e?.inputResponses?.some(e=>t.has(e.requestId))===!0}function hasMeaningfulInput(e){return e?.message!==void 0||(e?.attributedInputResponses?.length??0)>0||(e?.inputResponses?.length??0)>0||(e?.runtimeActionResults?.length??0)>0}function appendSettledResponses(e,t){if(t.length===0)return e;let n=new Set([...(e?.inputResponses??[]).map(e=>e.requestId),...(e?.attributedInputResponses??[]).map(({response:e})=>e.requestId)]),r=t.filter(e=>!n.has(e.requestId));return r.length===0?e:{...e,inputResponses:[...e?.inputResponses??[],...r.map(e=>({optionId:e.outcome===`allowed`?`approve`:`cancel`,requestId:e.requestId}))]}}function removeConsumedResponses(e,t){if(e===void 0)return;let n=(e.attributedInputResponses??[]).filter(({response:e})=>!t.has(e.requestId)),r=[...(e.inputResponses??[]).filter(e=>!t.has(e.requestId)),...n.map(({response:e})=>e)];return{...e,attributedInputResponses:void 0,inputResponses:r}}function deliveryResult(e,t,n=`continue`,r=[],i=[]){return{challenges:r,feedback:i,kind:n,session:e,stepInput:t}}function toCandidateDecision(e){if(e===`approve`)return`approve`;if(e===`cancel`||e===`deny`)return`cancel`}function approvalCandidateIdPrefix(e,t,n){let r=[t.authenticator,t.issuer??``,t.principalType,t.principalId].join(`:`),i=`${encodeCandidateIdPart(e)}.${encodeCandidateIdPart(r)}`;return n===`approve`?i:`${i}.${encodeCandidateIdPart(n)}`}function encodeCandidateIdPart(e){return Array.from(e,e=>e.codePointAt(0).toString(36)).join(`-`)}async function withAuthorizerTimeout(e){let t;try{return await Promise.race([Promise.resolve(e),new Promise((e,n)=>{t=setTimeout(()=>n(Error(`Approval response authorizer timed out.`)),1e4)})])}finally{t!==void 0&&clearTimeout(t)}}export{coordinateApprovalDelivery};

package/dist/src/harness/hitl/delivery.d.ts

@@ -0,0 +1,37 @@
+import type { UserContent } from "ai";
+import type { StepInput } from "#harness/types.js";
+import type { InputResponse } from "#shared/input.js";
+import type { SuspendedStep } from "#harness/session-machine/state.js";
+import type { SessionView } from "#harness/session-machine/view.js";
+/**
+ * The delivery a step answers with: input queued behind earlier work joins it, unless the
+ * runtime still runs calls (queued input waits for them). A stale answer, to a request that
+ * already closed, never authorizes anything: a stale session-limit answer is dropped, and
+ * any other becomes plain text the model reads.
+ */
+export declare function deliver(view: SessionView, input: StepInput | undefined, options: {
+    readonly takeQueued: boolean;
+}): {
+    readonly input?: StepInput;
+    readonly displayMessage?: string | UserContent;
+    readonly takeQueued: boolean;
+};
+export type ResolvedStepInput = StepInput & {
+    readonly messageConsumed?: boolean;
+};
+/**
+ * Plain text answers the only pending batch, unless a response policy must decide it. A channel
+ * that wraps the typed text in an envelope for the model attaches the text itself to answer with.
+ * The answer consumes the message and the context the channel sent about it: the model reads
+ * neither.
+ */
+export declare function resolveTextInput(batch: Pick<SuspendedStep, "requests" | "responseAuthRequiredRequestIds">, stepInput: StepInput | undefined): ResolvedStepInput | undefined;
+export declare function canonicalize(responses: readonly InputResponse[]): readonly InputResponse[];
+export declare function hasInput(input: StepInput | undefined): boolean;
+export declare function isEmptyInput(input: StepInput): boolean;
+export declare function withoutResponses(input: ResolvedStepInput | undefined): StepInput | undefined;
+/** The turn's own input: the message a plain-text answer didn't consume, and its context. */
+export declare function turnInputOnly(input: ResolvedStepInput | undefined): StepInput | undefined;
+/** What of the input isn't the turn's: answers, and the output the session asks for. */
+export declare function withoutTurnInput(input: ResolvedStepInput | undefined): ResolvedStepInput;
+export declare function compactInput(input: ResolvedStepInput | undefined): ResolvedStepInput;

package/dist/src/harness/hitl/delivery.js

@@ -0,0 +1 @@
+import{attachClientContext,readClientContext}from"#internal/client-context.js";import{readAnswerText}from"#internal/input-text.js";import{resolveTextToResponses}from"#channel/resolve-text.js";import{coalesceTurnInputs}from"#harness/messages.js";import{ownOpenRequestIds}from"#harness/session-machine/transitions.js";import{convertStaleResponsesToUserMessage,dropStaleSessionLimitContinuationResponses}from"#harness/hitl/stale-responses.js";function deliver(e,t,n){let r=n.takeQueued?e.turn.queued:void 0,i=r===void 0?t:t===void 0?r:coalesceTurnInputs(r,t),a=new Set([...ownOpenRequestIds(e),...e.turn.suspended.flatMap(e=>e.requests.map(e=>e.requestId))]),o=new Map(Object.values(e.projection.inputs).map(e=>[e.request.requestId,e.request])),s=convertStaleResponsesToUserMessage({pendingRequestIds:a,requests:o,stepInput:dropStaleSessionLimitContinuationResponses({pendingRequestIds:a,stepInput:i})});return s.kind===`converted`?{displayMessage:s.displayMessage,input:s.stepInput,takeQueued:n.takeQueued}:{input:s.stepInput,takeQueued:n.takeQueued}}function resolveTextInput(e,t){let n=readAnswerText(t);if(t===void 0||n===void 0)return t;let r=new Set(e.requests.map(e=>e.requestId));if(t.inputResponses?.some(e=>r.has(e.requestId)))return t;let i=new Set(e.responseAuthRequiredRequestIds??[]),a=resolveTextToResponses(n,e.requests.filter(e=>!i.has(e.requestId)));return a.length===0?t:compactInput({...t,context:void 0,inputResponses:[...t.inputResponses??[],...a],message:void 0,messageConsumed:!0})}function canonicalize(e){let t=new Map;for(let n of e)t.set(n.requestId,n);return[...t.values()]}function hasInput(e){return e?.message!==void 0||(e?.inputResponses?.length??0)>0}function isEmptyInput(e){return Object.keys(compactInput(e)).length===0}function withoutResponses(e){if(e===void 0)return;let{attributedInputResponses:t,inputResponses:n,messageConsumed:r,...i}=e;return i}function turnInputOnly(e){if(e===void 0)return;let t={};(e.context?.length??0)>0&&(t.context=e.context),e.message!==void 0&&e.messageConsumed!==!0&&(t.message=e.message);let n=attachClientContext(t,readClientContext(e));return isEmptyInput(n)?void 0:n}function withoutTurnInput(e){let t={};return(e?.inputResponses?.length??0)>0&&(t.inputResponses=e.inputResponses),e?.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),t}function compactInput(e){if(e===void 0)return{};let t={};return(e.context?.length??0)>0&&(t.context=e.context),(e.inputResponses?.length??0)>0&&(t.inputResponses=e.inputResponses),e.message!==void 0&&(t.message=e.message),e.messageConsumed===!0&&(t.messageConsumed=!0),e.outputSchema!==void 0&&(t.outputSchema=e.outputSchema),attachClientContext(t,readClientContext(e))}export{canonicalize,compactInput,deliver,hasInput,isEmptyInput,resolveTextInput,turnInputOnly,withoutResponses,withoutTurnInput};

package/dist/src/harness/hitl/index.d.ts

@@ -0,0 +1,49 @@
+import type { ModelMessage } from "ai";
+import type { resolveInlineAuthorizationInterrupt } from "#harness/inline-tool-authorization.js";
+import type { StepCoordinates } from "#harness/session-machine/view.js";
+import type { Step } from "#harness/step/context.js";
+import type { HarnessSessionBase, StepResult } from "#harness/types.js";
+import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { InputRequest } from "#shared/input.js";
+export { acceptHumanInput, admitApprovedWork, dispatchApprovedWorkflows, hasApprovedWork, runApprovedLocalCalls, type ApprovedWork, type HumanInputIntake, } from "./intake.js";
+export { extractToolApprovalInputRequests } from "#harness/input-extraction.js";
+export { hasRunnableQueue } from "./approvals.js";
+/**
+ * A model step made calls that need a person's approval: the step parks on them beside any
+ * runtime calls it made. The turn holds for the answers, unless the runtime runs calls for it
+ * meanwhile, or queued input can already run.
+ */
+export declare function parkOnApprovals(step: Step, input: {
+    readonly event: StepCoordinates;
+    readonly messages: readonly ModelMessage[];
+    readonly requests: readonly InputRequest[];
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    /** The step made calls the runtime runs, so the turn waits on them instead. */
+    readonly waitsOnRuntime: boolean;
+}): Promise<StepResult>;
+/**
+ * A call the model step ran needs a sign-in: the calls that need it stop, and the model calls
+ * them again once it completes.
+ */
+export declare function stopForToolSignIn(step: Step, interrupt: NonNullable<ReturnType<typeof resolveInlineAuthorizationInterrupt>>): Promise<StepResult>;
+/**
+ * The gate before each model call. A spent budget asks whether to continue when someone can
+ * answer, and fails the session otherwise. `messages` are the step's: they park with the prompt,
+ * so the input that triggered it survives into the turn that resumes.
+ */
+export declare function enforceBudget(step: Step, messages: readonly ModelMessage[]): Promise<StepResult | undefined>;
+/**
+ * What a model call needs from the approvals: the keys `once()` approvals granted, and a note on
+ * the calls still awaiting approval, which a message may revise.
+ */
+export declare function humanInputContext(step: Step): {
+    readonly approvedTools: ReadonlySet<string>;
+    readonly pendingApprovalsNote?: string;
+};
+/**
+ * Drops what a cleared context owned: sign-in attempts and responders' approval progress. `clear`
+ * reported each close; relay routes for live tasks stay.
+ */
+export declare function discardClearedHumanInput<T extends HarnessSessionBase>(session: T): T;
+/** The cancelled turn's responders stop checking its approvals: their candidates stale. */
+export declare function retireCancelledCandidates<T extends HarnessSessionBase>(session: T): T;

package/dist/src/harness/hitl/index.js

@@ -0,0 +1 @@
+import{renderPendingApprovalsInstruction}from"./approval-prompt.js";import{grantedApprovalKeys,hasRunnableQueue,parkOnApprovals as parkOnApprovals$1,requestLimit,requireSignIn}from"./approvals.js";import{retireActiveCandidates}from"./candidates.js";import{checkSessionUsageLimit}from"./budget.js";import{acceptHumanInput,admitApprovedWork,dispatchApprovedWorkflows,hasApprovedWork,holdForInput,runApprovedLocalCalls}from"./intake.js";import{AuthKey,SessionKey}from"#context/keys.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{fail}from"#harness/session-machine/transitions.js";import{clearPendingAuthorization}from"#harness/authorization.js";import{buildResponseAuthorizationTools}from"#context/build-dynamic-tools.js";import{extractToolApprovalInputRequests}from"#harness/input-extraction.js";async function parkOnApprovals(e,t){let n=parkOnApprovals$1(e.view(),{event:t.event,messages:t.messages,requests:t.requests,tasks:t.tasks,requester:currentRequester(e),responseAuthRequiredRequestIds:responsePolicyRequestIds(e,t.requests)});return await e.apply(n,[...e.session.history,...n.commit??[]]),t.waitsOnRuntime?{next:null,session:e.session}:hasRunnableQueue(e.view())?{next:e.runStep,session:e.session}:holdForInput(e)}async function stopForToolSignIn(e,t){return e.session={...e.session,history:validateHarnessModelMessages(t.history)},await e.apply(requireSignIn(e.view(),{callIdsByName:t.callIdsByName,challenges:t.challenges}),e.session.history),{held:{kind:`request`},next:null,session:e.session}}async function enforceBudget(e,t){let n=checkSessionUsageLimit({canAsk:e.emit!==void 0&&e.config.capabilities?.requestInput===!0,session:e.session,turnSequence:e.position().sequence});if(n.kind!==`within`)return n.kind===`ask`?(e.session={...e.session,history:validateHarnessModelMessages([...t])},await e.apply(requestLimit(e.view(),{request:n.request}),e.session.history),{next:null,session:e.session}):(await e.apply(fail(e.view(),{code:n.code,details:n.details,message:n.message,terminal:{sessionId:e.session.sessionId}})),{next:{done:!0,output:``},session:e.session})}function humanInputContext(e){let t=e.view(),n=responseTools(e);return{approvedTools:grantedApprovalKeys(t,e=>n.get(e.action.toolName)?.approvalKey?.(e.action.input)),pendingApprovalsNote:renderPendingApprovalsInstruction(t.turn.suspended.flatMap(e=>e.requests))}}function discardClearedHumanInput(e){let{"eve.runtime.hitl.approvalState":t,...n}=clearPendingAuthorization(e.state)??{};return{...e,state:Object.keys(n).length>0?n:void 0}}function responseTools(e){return buildResponseAuthorizationTools({authoredTools:e.config.tools,context:e.ctx})}function responsePolicyRequestIds(e,t){let n=responseTools(e);return t.filter(e=>{let t=n.get(e.action.toolName)?.approval;return t!==void 0&&typeof t!=`function`&&t.response!==void 0}).map(e=>e.requestId)}function currentRequester(e){return e.ctx?.get(AuthKey)??e.ctx?.get(SessionKey)?.auth.current??null}function retireCancelledCandidates(e){return{...e,state:retireActiveCandidates(e.state,{completedAt:Date.now(),reason:`Cancelled.`})}}export{acceptHumanInput,admitApprovedWork,discardClearedHumanInput,dispatchApprovedWorkflows,enforceBudget,extractToolApprovalInputRequests,hasApprovedWork,hasRunnableQueue,humanInputContext,parkOnApprovals,retireCancelledCandidates,runApprovedLocalCalls,stopForToolSignIn};

package/dist/src/harness/hitl/intake.d.ts

@@ -0,0 +1,67 @@
+import type { SuspendedStep } from "#harness/session-machine/view.js";
+import { type Step } from "#harness/step/context.js";
+import type { HarnessToolMap, StepInput, StepResult } from "#harness/types.js";
+import type { InstrumentationAttempt } from "#instrumentation/runtime.js";
+/**
+ * What a delivery does before its turn runs. `stop` ends the step: the answers left nothing to
+ * run yet, so the turn holds, or a responder must sign in first. `run` carries the turn's input,
+ * without the answers the session took, and the approved work that runs once the turn opens.
+ */
+export type HumanInputIntake = {
+    readonly kind: "stop";
+    readonly result: StepResult;
+} | {
+    readonly kind: "run";
+    readonly input: StepInput | undefined;
+    /** The message the turn receives, as the stream shows it. */
+    readonly message?: StepInput["message"];
+    /** A plain-text answer consumed the message, so the model never reads it. */
+    readonly consumedMessage: boolean;
+    /** The delivery carries input for a turn. */
+    readonly opensTurn: boolean;
+    readonly approved: ApprovedWork;
+};
+/**
+ * What the delivery decided: the session-limit answer, and the tools approved calls run with.
+ * The calls themselves wait in their suspended steps until the turn's next model step.
+ */
+export interface ApprovedWork {
+    readonly limit?: {
+        readonly granted: boolean;
+    };
+    /** The tools a parked step's calls run with: those of the step that asked. */
+    readonly toolsOf: (step: SuspendedStep | undefined) => HarnessToolMap;
+}
+/**
+ * Answers what the session asked: approval answers pass the response policies, and the session
+ * decides which parked steps they resolve. Runs before the delivery joins its turn, so approved
+ * calls get the tools of the step that asked.
+ */
+export declare function acceptHumanInput(step: Step, input: StepInput | undefined, options: {
+    readonly takeQueued: boolean;
+}): Promise<HumanInputIntake>;
+/**
+ * Admits what a delivery decided before its turn calls the model: a session-limit answer grants a
+ * fresh budget or ends the turn tree, and a step its answers completed, as denials do, commits.
+ */
+export declare function admitApprovedWork(step: Step, work: ApprovedWork): Promise<void>;
+/** Whether a suspended step holds approved calls that haven't run. */
+export declare function hasApprovedWork(step: Step): boolean;
+/**
+ * Approved workflow and agent calls join the runs their steps wait on, once the step has started
+ * and before its budget check. Returns whether any did: the turn then waits on the runtime, and
+ * approved local calls run after their results arrive.
+ */
+export declare function dispatchApprovedWorkflows(step: Step, work: ApprovedWork): Promise<boolean>;
+/**
+ * Runs approved local calls once the step has started and its budget allows it, as the AI SDK ran
+ * them before the model read their results: each with the tools of the step that asked, as
+ * whoever approved it, and in the step's first attempt. A call that needs a sign-in holds the
+ * turn.
+ */
+export declare function runApprovedLocalCalls(step: Step, work: ApprovedWork, setAttemptScope: (scope: InstrumentationAttempt | undefined) => void): Promise<StepResult | undefined>;
+/**
+ * The held turn holds on, for a person to act on its sign-in, approval, or the session-limit
+ * prompt; the session resumes it when they do.
+ */
+export declare function holdForInput(step: Step): Promise<StepResult>;

package/dist/src/harness/hitl/intake.js

@@ -0,0 +1 @@
+import{deliver,turnInputOnly,withoutTurnInput}from"./delivery.js";import{answer,approvingSteps,deferInput,dispatch,grantedApprovalKeys,requireSignIn,stepForRequest,withdrawSignIns}from"./approvals.js";import{getApprovalAuditState,retireActiveCandidates}from"./candidates.js";import{approversOf,setApprovedCallCallers}from"./approved-call-callers.js";import{runApprovedCalls}from"./approved-calls.js";import{coordinateApprovalDelivery}from"./coordinator.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{activeTurnId}from"#harness/session-machine/view.js";import{bumpSessionRuntimeUsageLimits}from"#harness/turn-tag-state.js";import{collectDeferredCalls}from"#harness/coordination.js";import{approvedCalls,completeSignIn,hold,settle}from"#harness/session-machine/transitions.js";import{stepStartedForResolvers}from"#harness/session-machine/resolver-events.js";import{SessionLimitDeclinedError}from"#harness/turn-cancellation.js";import{resolveInlineAuthorizationInterrupt}from"#harness/inline-tool-authorization.js";import{buildResponseAuthorizationTools}from"#context/build-dynamic-tools.js";import{openTurn}from"#harness/step/context.js";import{prepareTurnInput}from"#harness/step/intake.js";import{placeTurnInput}from"#harness/step/prompt.js";async function acceptHumanInput(e,t,n){let{config:r,ctx:i}=e,a=r.signInCompletions??[];a.length>0&&await e.apply(completeSignIn(e.view(),{completions:a}));let o=deliver(e.view(),t,n),s=t?.message!==void 0||o.displayMessage!==void 0?await withdrawSteeredSignIns(e,o.input):o.input,c=new Map,l,restoreTools=async t=>{let n=t?.event??e.position(),a=`${n.turnId}:${n.stepIndex}`,o=c.get(a);if(o!==void 0&&l===a)return o;t!==void 0&&await r.prepareApprovalTurn?.(t.event),i!==void 0&&await r.resolveStepDynamicTools?.({ctx:i,event:stepStartedForResolvers({modelId:e.session.agent.modelReference?.id??`dynamic`,sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId}),messages:e.projectHistory(e.session.history)});let s=buildResponseAuthorizationTools({authoredTools:r.tools,context:i});return c.set(a,s),l=a,s},toolsOf=e=>(e&&c.get(`${e.event.turnId}:${e.event.stepIndex}`))??r.tools,u=e.view().signIns,d=await coordinateApprovalDelivery({session:e.session,stepInput:s,tools:r.tools,prepareTools:t=>restoreTools(stepForRequest(e.view(),t.requestId))});e.session=d.session;for(let t of approvingSteps(e.view(),d.stepInput))await restoreTools(t);let f=answer(e.view(),{approvalKey:t=>toolsOf(stepForRequest(e.view(),t.requestId)).get(t.action.toolName)?.approvalKey?.(t.action.input),delivery:d.stepInput,policy:{...d,audit:getApprovalAuditState(e.session.state),challengesAtStart:u},takeQueued:o.takeQueued});for(let t of f.resolved)await e.instrumentation?.publishInputResolutions({batch:t,sessionId:e.session.sessionId});await e.apply(f);let stop=e=>({kind:`stop`,result:e});switch(f.next){case`park`:return e.view().projection.activeTurnId===void 0?stop({next:null,session:e.session}):stop(await holdForInput(e));case`repeat`:return stop({next:e.runStep,session:e.session});case`sign-in`:return await e.apply(requireSignIn(e.view(),{challenges:d.challenges,queued:d.stepInput})),stop(held(e));case`defer-message`:{if(approvedCalls(e.view().turn).length>0){let t=turnInputOnly(f.input);return t!==void 0&&await e.apply(deferInput(e.view(),t)),stop({next:null,session:e.session})}let t=await prepareTurnInput(e,f.input,{consumedMessage:!1}),n=await openTurn(e,{input:[...t.ephemeral,...t.messages],message:o.displayMessage??f.input?.message});return n===void 0?(e.session={...e.session,history:validateHarnessModelMessages(placeTurnInput(e,e.session.history,t))},stop(await holdForInput(e))):stop(n)}}for(let t of e.view().turn.suspended)(t.approved?.length??0)>0&&await restoreTools(t);let p=f.resolved.some(e=>e.inputs.some(e=>e.request.kind===`tool-approval`)&&e.inputs.every(e=>e.response!==void 0))||approvedCalls(e.view().turn).length>0?turnInputOnly(f.input):void 0;return p!==void 0&&await e.apply(deferInput(e.view(),p)),{approved:{limit:f.limit,toolsOf},consumedMessage:f.consumedMessage===!0,input:p===void 0?f.input:withoutTurnInput(f.input),message:f.consumedMessage===!0||p!==void 0?void 0:o.displayMessage??o.input?.message,kind:`run`,opensTurn:hasTurnInput(o.input)||hasTurnInput(d.stepInput)}}async function admitApprovedWork(e,t){if(t.limit!==void 0){if(!t.limit.granted)throw new SessionLimitDeclinedError;e.session=bumpSessionRuntimeUsageLimits(e.session)}await e.apply(settle(e.view(),{results:[]}))}function hasApprovedWork(e){return approvedCalls(e.view().turn).length>0}async function dispatchApprovedWorkflows(e,t){let n=[],r=[];for(let i of e.view().turn.suspended){let a=t.toolsOf(i),o=(i.approved??[]).filter(e=>a.get(e.action.toolName)?.workflowId!==void 0);if(o.length===0)continue;r.push(...o);let s=collectDeferredCalls({session:e.session,toolCalls:o.map(({action:e})=>({input:e.input,toolCallId:e.callId,toolName:e.toolName})),tools:a,turnId:i.event.turnId});e.session=s.session,n.push(...s.workflowRequests)}return n.length!==0&&(await e.apply(dispatch(e.view(),{approvers:approversOf(r,e.session.state),tasks:n})),!0)}async function runApprovedLocalCalls(e,t,n){let r=e.view().turn.suspended.map(e=>{let n=t.toolsOf(e);return{requests:(e.approved??[]).filter(e=>n.get(e.action.toolName)?.workflowId===void 0),tools:n}}),i=r.flatMap(({requests:e})=>e);e.frameworkToolNames=new Set(r.flatMap(({tools:e})=>[...e].filter(([,e])=>e.frameworkTool===!0).map(([e])=>e))),setApprovedCallCallers(i,e.session.state);let a=e.position(),o=i.length===0?void 0:e.instrumentation?.prepareAttempt({isFrameworkTool:t=>e.frameworkToolNames.has(t),attemptIndex:0,stepIndex:a.stepIndex,turnId:activeTurnId(a)});o!==void 0&&n(o.scope);let s=await Promise.all(r.map(async({requests:t,tools:n})=>t.length===0?{settled:[],toolResults:[]}:await runApprovedCalls({abortSignal:e.config.abortSignal,approvedTools:grantedApprovalKeys(e.view(),e=>n.get(e.action.toolName)?.approvalKey?.(e.action.input)),messages:e.projectHistory(e.session.history),position:e.position(),publish:e.publish,requests:t,telemetry:o?.telemetry,tools:n})));await e.apply(settle(e.view(),{results:s.flatMap(e=>e.settled)}));let c=resolveInlineAuthorizationInterrupt({messages:[],toolResults:s.flatMap(e=>e.toolResults)});if(c!==void 0)return await e.apply(requireSignIn(e.view(),{callIdsByName:c.callIdsByName,challenges:c.challenges}),e.session.history),held(e)}const STEERED_SIGN_IN_REASON=`Cancelled because a new message arrived.`;async function holdForInput(e){return await e.apply(hold(e.view(),{on:`input`})),held(e)}function held(e){return{held:{kind:`request`},next:null,session:e.session}}async function withdrawSteeredSignIns(e,t){let n=[...new Set(e.view().signIns.map(e=>e.name))];return e.session={...e.session,state:retireActiveCandidates(e.session.state,{completedAt:Date.now(),reason:STEERED_SIGN_IN_REASON})},n.length===0?t:(await e.apply(withdrawSignIns(e.view(),STEERED_SIGN_IN_REASON)),{...t,context:[...t?.context??[],`Sign-in to ${n.join(`, `)} was cancelled because the user sent a new message instead. Ask to sign in again only if the new message still needs it.`]})}function hasTurnInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}export{acceptHumanInput,admitApprovedWork,dispatchApprovedWorkflows,hasApprovedWork,holdForInput,runApprovedLocalCalls};