eve 0.83.2 → 0.84.0

package/dist/src/harness/facts.js

@@ -0,0 +1 @@
+import{activeTurn}from"#protocol/session-projection/selectors.js";function defined(e){return Object.fromEntries(Object.entries(e).filter(([,e])=>e!==void 0))}function fact(e,t){return{data:defined(t),type:e}}function usageOf(e){return defined({cacheReadTokens:e.cacheReadTokens??0,cacheWriteTokens:e.cacheWriteTokens??0,costUsd:e.costUsd,inputTokens:e.inputTokens??0,outputTokens:e.outputTokens??0})}function errorInfoOf(e){let{errorId:t,hint:n}=e.details??{};return defined({code:e.code,hint:typeof n==`string`&&n.trim().length>0?n.trim():void 0,id:typeof t==`string`?t:void 0,message:e.message})}function sessionEndedFacts(e,t){let n=[];e!==void 0&&e.view.session.status===`new`&&n.push(fact(`session.started`,{}));for(let e of t.settles??[])n.push(...controlSettled(e));let{control:r}=t;r!==void 0&&n.push(controlAdmitted(r,`reset`),deliveryApplied(r.deliveryId));let i=r===void 0?t.cause:{deliveryId:r.deliveryId};return n.push(fact(`session.ended`,{cause:i,error:t.error,outcome:t.outcome})),n}function turnSettled(e,t,n=activeTurn(e.view)?.turnId){if(n===void 0)return[];let r=e.view.turns[n]?.reply;return[fact(`turn.settled`,{...t,reply:r!==void 0&&r.length>0?r:void 0,turnId:n})]}function runRequested(e,t){return fact(`model.requested`,{owner:e,runId:t})}function runStarted(e){let{attempt:t,modelId:n,runId:r}=e;return fact(`model.started`,{attempt:t,modelId:n,runId:r})}function runSettledFacts(e){let{usage:t,...n}=e,r=[fact(`model.settled`,n)];return t!==void 0&&r.push(fact(`usage.recorded`,{kind:`model`,owner:{runId:e.runId},usage:t})),r}function delegatedUsageFact(e,t){let n=usageOf(t);return e===void 0?fact(`usage.recorded`,{kind:`delegated-late`,usage:n}):fact(`usage.recorded`,{kind:`model`,owner:{callId:e},usage:n})}function contextStarted(e){return fact(`context.started`,e)}function controlAdmitted(e,t){return fact(`delivery.admitted`,{deliveryId:e.deliveryId,principal:e.principal,source:{control:t}})}function controlSettled(e){let{control:t,outcome:n,source:r}=e;return[controlAdmitted(t,r),fact(`delivery.settled`,{deliveryId:t.deliveryId,outcome:n})]}function deliveryApplied(e){return fact(`delivery.settled`,{deliveryId:e,outcome:`applied`})}export{contextStarted,controlAdmitted,controlSettled,defined,delegatedUsageFact,deliveryApplied,errorInfoOf,fact,runRequested,runSettledFacts,runStarted,sessionEndedFacts,turnSettled,usageOf};

package/dist/src/harness/finish-reason.d.ts

@@ -1,3 +1,8 @@
-import type { AssistantStepFinishReason } from "#protocol/message.js";
+/**
+ * Why one model run ended. `tool-calls` is the only one the turn continues after, unless
+ * steering superseded the run, which ends `other` and continues with the next run. The wire
+ * carries it as an open string on `model.settled`.
+ */
+export type AssistantStepFinishReason = "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls";
 /** Maps an AI SDK finish reason to the eve-owned union. */
 export declare function normalizeAssistantStepFinishReason(value: string | undefined): AssistantStepFinishReason;

package/dist/src/harness/generation-steering.d.ts

@@ -1,4 +1,4 @@
-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { SessionEvent } from "#protocol/session-event.js";
 /** Interrupts generation without cancelling the turn or replaying local effects. */
 export declare class GenerationSteering {
     private readonly controller;
@@ -14,8 +14,10 @@ export declare class GenerationSteering {
     });
     get interrupted(): boolean;
     begin(): void;
+    /** Steering cut the generation; what the step still publishes settles it, so nothing stops it. */
+    end(): void;
     protectToolExecution(): void;
-    beforeEvent(event: UnstampedMessageStreamEvent): void;
+    beforeEvent(event: SessionEvent): void;
     check(): void;
     dispose(): void;
     private readonly onSteering;

package/dist/src/harness/generation-steering.js

@@ -1 +1 @@
-var GenerationSteeredError=class extends Error{constructor(){super(`Model generation superseded by steering.`),this.name=`GenerationSteeredError`}},GenerationSteering=class{controller=new AbortController;active=!1;effectsStarted=!1;steeringSignal;signal;outputStarted;constructor(e){this.steeringSignal=e.steeringSignal,this.outputStarted=e.outputStarted===!0,this.signal=e.steeringSignal===void 0&&e.abortSignal!==void 0?e.abortSignal:e.abortSignal===void 0?this.controller.signal:AbortSignal.any([e.abortSignal,this.controller.signal]),this.steeringSignal?.addEventListener(`abort`,this.onSteering)}get interrupted(){return this.controller.signal.aborted}begin(){this.active=!0,this.onSteering(),this.check()}protectToolExecution(){this.check(),this.effectsStarted=!0}beforeEvent(e){this.active&&(this.check(),(e.type===`input.requested`||e.type===`step.failed`||e.type===`turn.completed`)&&(this.effectsStarted=!0),(e.type===`message.appended`&&e.data.messageDelta.length>0||e.type===`message.completed`&&(e.data.message?.length??0)>0||e.type===`result.completed`)&&(this.outputStarted=!0))}check(){if(this.interrupted)throw this.controller.signal.reason}dispose(){this.steeringSignal?.removeEventListener(`abort`,this.onSteering)}onSteering=()=>{this.active&&!this.effectsStarted&&!this.outputStarted&&this.steeringSignal?.aborted&&this.controller.abort(new GenerationSteeredError)}};export{GenerationSteering};
+var GenerationSteeredError=class extends Error{constructor(){super(`Model generation superseded by steering.`),this.name=`GenerationSteeredError`}},GenerationSteering=class{controller=new AbortController;active=!1;effectsStarted=!1;steeringSignal;signal;outputStarted;constructor(e){this.steeringSignal=e.steeringSignal,this.outputStarted=e.outputStarted===!0,this.signal=e.steeringSignal===void 0&&e.abortSignal!==void 0?e.abortSignal:e.abortSignal===void 0?this.controller.signal:AbortSignal.any([e.abortSignal,this.controller.signal]),this.steeringSignal?.addEventListener(`abort`,this.onSteering)}get interrupted(){return this.controller.signal.aborted}begin(){this.active=!0,this.onSteering(),this.check()}end(){this.active=!1}protectToolExecution(){this.check(),this.effectsStarted=!0}beforeEvent(e){this.active&&(this.check(),(e.type===`interaction.opened`||e.type===`model.settled`&&e.data.outcome===`failed`||e.type===`turn.settled`)&&(this.effectsStarted=!0),(e.type===`content.delta`&&e.data.kind===`text`&&e.data.delta.length>0||e.type===`content.completed`&&(e.data.kind===`result`||e.data.kind===`text`&&typeof e.data.value==`string`&&e.data.value.length>0))&&(this.outputStarted=!0))}check(){if(this.interrupted)throw this.controller.signal.reason}dispose(){this.steeringSignal?.removeEventListener(`abort`,this.onSteering)}onSteering=()=>{this.active&&!this.effectsStarted&&!this.outputStarted&&this.steeringSignal?.aborted&&this.controller.abort(new GenerationSteeredError)}};export{GenerationSteering};

package/dist/src/harness/hitl/approval-prompt.d.ts

@@ -1,4 +1,4 @@
-import type { InputRequest } from "#shared/input.js";
+import type { ApprovalAsk } from "#harness/session-machine/state.js";
 /** Label prefixing the framework-injected pending-approval notice. */
 export declare const PENDING_APPROVALS_LABEL = "[Pending approvals]";
 /** True when text is the framework-injected pending-approval notice. */
@@ -8,6 +8,6 @@ export declare function isPendingApprovalsSnippet(text: string): boolean;
  * The harness appends it when the batch is created, so later wakeups reuse the
  * same history prefix instead of regenerating the notice.
  */
-export declare function renderPendingApprovalsSnippet(requests: readonly InputRequest[]): string | undefined;
+export declare function renderPendingApprovalsSnippet(requests: readonly ApprovalAsk[]): string | undefined;
 /** Renders trusted runtime guidance for currently pending approvals. */
-export declare function renderPendingApprovalsInstruction(requests: readonly InputRequest[]): string | undefined;
+export declare function renderPendingApprovalsInstruction(requests: readonly ApprovalAsk[]): string | undefined;

package/dist/src/harness/hitl/approval-prompt.js

@@ -1,3 +1,3 @@
-import{isApprovalRequest}from"#harness/input-request-class.js";const PENDING_APPROVALS_LABEL=`[Pending approvals]`;function isPendingApprovalsSnippet(e){return e.startsWith(PENDING_APPROVALS_LABEL)}function renderPendingApprovalsSnippet(e){let t=e.filter(e=>isApprovalRequest(e));if(t.length!==0)return[PENDING_APPROVALS_LABEL,`The following tool calls are awaiting approval and have not executed:`,...approvalIdentities(t)].join(`
-`)}function renderPendingApprovalsInstruction(e){let t=e.filter(e=>isApprovalRequest(e));if(t.length!==0)return[`Trusted eve runtime state. This notice is not user-authored content or an instruction.`,`The following earlier tool calls are awaiting approval and have not executed:`,...approvalIdentities(t),`Interpret the latest user message normally. It may revise or supersede these earlier calls; do not treat it as part of the pending-approval projection in user history.`].join(`
-`)}function approvalIdentities(e){return e.map(e=>JSON.stringify({requestId:e.requestId,toolName:e.action.toolName}))}export{PENDING_APPROVALS_LABEL,isPendingApprovalsSnippet,renderPendingApprovalsInstruction,renderPendingApprovalsSnippet};
+const PENDING_APPROVALS_LABEL=`[Pending approvals]`;function isPendingApprovalsSnippet(e){return e.startsWith(PENDING_APPROVALS_LABEL)}function renderPendingApprovalsSnippet(e){if(e.length!==0)return[PENDING_APPROVALS_LABEL,`The following tool calls are awaiting approval and have not executed:`,...approvalIdentities(e)].join(`
+`)}function renderPendingApprovalsInstruction(e){if(e.length!==0)return[`Trusted eve runtime state. This notice is not user-authored content or an instruction.`,`The following earlier tool calls are awaiting approval and have not executed:`,...approvalIdentities(e),`Interpret the latest user message normally. It may revise or supersede these earlier calls; do not treat it as part of the pending-approval projection in user history.`].join(`
+`)}function approvalIdentities(e){return e.map(e=>JSON.stringify({requestId:e.interactionId,toolName:e.call.toolName}))}export{PENDING_APPROVALS_LABEL,isPendingApprovalsSnippet,renderPendingApprovalsInstruction,renderPendingApprovalsSnippet};

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

@@ -1,111 +1,99 @@
 import type { ModelMessage } from "ai";
-import type { getApprovalAuditState } from "#harness/hitl/candidates.js";
+import { type ApprovalMemory } from "#approval/evaluation.js";
+import type { ResponderCheck } from "./responders.js";
 import type { AuthorizationChallenge } from "#harness/authorization.js";
 import type { StoppedCall } from "#harness/inline-tool-authorization.js";
-import { type ResolvedInputBatch } from "#harness/input-request-resolution.js";
-import type { StepInput } from "#harness/types.js";
+import { type LimitAsk } from "#harness/hitl/budget-request.js";
+import type { HarnessStepInput } from "#harness/types.js";
+import type { InteractionRow } from "#protocol/session-projection/tables.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 { ApprovalAsk, ApprovedCall, 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.
+ * step, beside any runtime calls it made. The approvals are asked now, or once the step's tasks
+ * finish (`openDeferredApprovals`).
  */
-export declare function parkOnApprovals(view: SessionView, input: {
+export declare function askApprovals(view: SessionView, input: {
     readonly event: StepCoordinates;
     readonly messages: readonly ModelMessage[];
-    readonly requests: readonly InputRequest[];
+    readonly requests: readonly ApprovalAsk[];
     readonly tasks: readonly RuntimeWorkflowTaskRequest[];
     readonly responseAuthRequiredRequestIds?: readonly string[];
     readonly requester?: SuspendedStep["requester"];
 }): Transition;
+/** A step that parked approvals beside its tasks asks for them once the tasks finish. */
+export declare function openDeferredApprovals(view: SessionView): Transition;
+/** The step's approvals nobody has settled: open, or not asked yet. */
+export declare function pendingApprovals(view: SessionView, step: SuspendedStep): readonly ApprovalAsk[];
 /** Approved workflow and agent calls join the runs their requesting steps wait on. */
 export declare function dispatch(view: SessionView, input: {
     readonly tasks: readonly RuntimeWorkflowTaskRequest[];
 }): Transition;
+/** Turn input the turn can't take yet waits, unreceived, for a later step. */
+export declare function queueInput(view: SessionView, input: HarnessStepInput | undefined): 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.
+ * A delivery's answers reach the session: each is submitted once, and stands, admitted, once
+ * its responder may answer. An answer a response policy still weighs stays submitted. What a
+ * responder may not do refuses their delivery, with why.
  */
-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";
-    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.
-     */
-    readonly next: "continue" | "park" | "repeat" | "sign-in";
-    /** 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;
-    };
+export declare function admitAnswers(view: SessionView, input: {
+    readonly delivery: ResolvedStepInput | undefined;
+    readonly check: ResponderCheck;
+}): Transition;
+/** A call cleared to run now, with the step that asked, whose tools it runs with. */
+export interface RunnableCall {
+    readonly approval: ApprovedCall;
+    readonly step: SuspendedStep;
 }
 /**
- * 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.
+ * A step's approvals settle together, once each has a standing answer. A message steers past
+ * them instead: the answers given stand, and the approvals nobody answered are withdrawn.
+ * Approved calls are returned to run; denied ones get their denial as a result.
+ * A request that asked to be remembered records the decision. `answered` says a step settled on
+ * its answers rather than a message.
  */
-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;
-    /** False when no message answers by text; see `ToolLoopHarnessConfig.typedAnswers`. */
-    readonly typedAnswers?: boolean;
-    readonly approvalKey: (request: InputRequest) => string | undefined;
-    /**
-     * Whether the request's restored step has `eve__search`, which a call whose
-     * tool is gone can use to find another.
-     */
-    readonly searchable: (request: InputRequest) => boolean;
-}): 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>;
+export declare function settleApprovals(view: SessionView, input: {
+    readonly steer: boolean;
+}): Transition & {
+    readonly approved: readonly RunnableCall[];
+    readonly answered: boolean;
+};
 /**
- * The steps a delivery approves calls of, whose tools the calls run with: those it answers in
- * full, approving at least one call.
+ * Approvals whose tool went away: no answer can run their calls, so nobody needs them anymore.
+ * Each call fails, and the model reads why.
  */
-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;
+export declare function withdrawUnavailable(view: SessionView, input: {
+    readonly interactionIds: readonly string[];
+    readonly searchable: (request: ApprovalAsk) => boolean;
+}): Transition;
+export declare function approvalMemory(view: SessionView): ApprovalMemory;
+/** The budget prompt the session waits on, with the turn it asked in, if any. */
+export declare function openLimit(view: SessionView): {
+    readonly row: InteractionRow;
+    readonly turnId?: string;
+} | undefined;
 /**
- * The held turn moves on, steered: the sign-ins it waits on end, declined, including a
- * responder's for one of its approvals, and the calls that waited for them fail with `reason`.
+ * The session spent its budget: it asks whether to continue instead of calling the model.
+ * `settleLimit` grants a fresh budget or declines it.
  */
-export declare function withdrawSignIns(view: SessionView, reason: string): Transition;
+export declare function requestLimit(view: SessionView, ask: LimitAsk): Transition;
 /**
- * The session spent its budget: it asks whether to continue instead of calling the model, and
- * the turn holds for input. The prompt is the projection's open request; `answer` grants a
- * fresh budget or declines it.
+ * The budget prompt settles on its standing answer: Continue grants a fresh budget, and Stop
+ * declines it. Any other answer is refused, and the prompt stays open for another.
  */
-export declare function requestLimit(view: SessionView, input: {
-    readonly request: InputRequest;
-}): Transition;
+export declare function settleLimit(view: SessionView): Transition & {
+    readonly limit?: {
+        readonly granted: boolean;
+    };
+};
+/**
+ * The held turn moves on, steered: the sign-ins it waits on are withdrawn, including a
+ * responder's for one of its approvals, and the calls that waited for them fail with `reason`.
+ */
+export declare function withdrawSignIns(view: SessionView, reason: string): Transition;
 /**
  * Work needs a sign-in. The calls that need it stop and wait in their steps; an attempt it
  * replaces fails; and each sign-in is asked for and recorded. The turn holds until every sign-in
@@ -115,5 +103,5 @@ export declare function requestLimit(view: SessionView, input: {
 export declare function requireSignIn(view: SessionView, input: {
     readonly challenges: readonly AuthorizationChallenge[];
     readonly calls?: readonly StoppedCall[];
-    readonly queued?: StepInput;
+    readonly queued?: HarnessStepInput;
 }): Transition;

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

@@ -1 +1,2 @@
-import{signInAttemptKey,supersededChallenges,withSignIns}from"./sign-ins.js";import{canonicalize,compactInput,isEmptyInput,resolveTextInput,withoutResponses}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{awaitSignIns,hold,ownOpenRequestIds,runnableCalls,settle,stepCallIds,suspend,withResult,withoutApproved}from"#harness/session-machine/transitions.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{TOOL_EXECUTION_DENIED_MESSAGE,failedCall,resolveApprovalOutcome,resolveInputOutcome,unavailableToolMessage}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:t.tasks.length>0?[]:[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));return r.length===0?e:{...withoutApproved(e,new Set(r.map(e=>e.callId))),tasks:[...e.tasks,...r]}});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===`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||t.typedAnswers===!1?s:resolveTextInput({requests:[c.request]},s),d=canonicalize(u?.inputResponses??[]),f=new Map(d.map(e=>[e.requestId,e])),p=l.filter(e=>e.requests.every(e=>f.has(e.requestId))),leftoverFor=e=>d.filter(t=>e.some(e=>e.requests.some(e=>e.requestId===t.requestId))),park=()=>(queue(compactInput(u)),done({next:`park`}));if(d.length===0&&u?.message===void 0)return park();if(c!==void 0){let e=f.get(c.request.requestId);if(e===void 0)return 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:u?.messageConsumed,input:withoutResponses(u),limit:resolveSessionLimitContinuation({requests:[c.request],responses:d}),next:`continue`,resolved:[t]})}if(p.length===0&&u?.message===void 0)return park();p.length===0&&p.push(l[0]);let m=leftoverFor(l.filter(e=>!p.includes(e)));m.length>0&&queue({inputResponses:m});let h=new Set(o.grants),g=[],_=[],v=new Set(n.audit.settlements.filter(e=>e.outcome===`unavailable`).map(e=>e.requestId)),y=o.suspended.map(e=>{if(!p.includes(e))return e;let n=e.messages,r=[];for(let i of e.requests){let{callId:a,toolName:o}=i.action;if(v.has(i.requestId)){let r=failedCall({callId:a,failure:unavailableToolMessage(o,t.searchable(i)),toolName:o});n=withResult(n,r.part),_.push(createActionResultEvent({result:r.result,...e.event}));continue}let{approved:s,reason:c,status:l}=resolveApprovalOutcome(f.get(i.requestId));if(s){h.add(t.approvalKey(i)??o),r.push(i);continue}n=withResult(n,{output:{reason:c,type:`execution-denied`},toolCallId:a,toolName:o,type:`tool-result`}),_.push(createActionResultEvent({rejected:!0,result:{callId:a,isError:!0,kind:`tool-result`,output:{approval:{requestId:i.requestId,status:l},code:`TOOL_EXECUTION_DENIED`,message:c??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:o},...e.event}))}g.push({event:e.event,inputs:e.requests.map(e=>{let t=f.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(...g.map(resolvedEvent),..._),o={...o,grants:[...h],suspended:y},done({consumedMessage:u?.messageConsumed,input:withoutResponses(u),next:`continue`,resolved:g})}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)&&e.outcome!==`unavailable`&&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;let n=[...t.inputResponses??[],...(t.attributedInputResponses??[]).map(({response:e})=>e)],r=new Set(n.map(e=>e.requestId)),i=openInputs(e.projection).find(e=>e.request.kind===`session-limit`);return i===void 0?t.message!==void 0||(t.context?.length??0)>0||(t.history?.length??0)>0||readClientContext(t)!==void 0||t.outputSchema!==void 0||(t.runtimeActionResults?.length??0)>0||n.length!==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=new Map((t?.inputResponses??[]).map(e=>[e.requestId,e.optionId]));return n.filter(e=>e.requests.every(e=>r.has(e.requestId))&&e.requests.some(e=>isApprovalRequest(e)&&r.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){let n=e.turn.suspended.flatMap(t=>(t.approved??[]).filter(n=>!runnableCalls(e,t).includes(n))),r=[...e.signIns,...n.flatMap(e=>e.signIns??[])],i=[...new Map(r.map(e=>[signInAttemptKey(e),e]))].map(([,t])=>e.projection.authorizations[t.attemptId??t.name]).flatMap(e=>e?.status===`required`?[signInWithdrawn(e,t)]:[]),a=settle(e,{results:n.map(({action:e})=>failedCall({callId:e.callId,failure:t,toolName:e.toolName}))});return{...a,events:[...i,...a.events],signIns:[]}}function requestLimit(e,t){let n=turnPosition(e.projection);return{events:[createInputRequestedEvent({requests:[t.request],sequence:n.sequence,stepIndex:n.stepIndex,turnId:n.turnId}),...hold(e,{on:`input`}).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),{calls:s}=t,c=s===void 0?e.turn.suspended:e.turn.suspended.map(e=>awaitSignIns(e,{challenges:t.challenges,stopped:s}));return{events:i,signIns:o,turn:{...e.turn,queued:a,suspended:c}}}export{answer,approvingSteps,deferInput,dispatch,grantedApprovalKeys,hasRunnableQueue,parkOnApprovals,requestLimit,requireSignIn,stepForRequest,withdrawSignIns};
+import{signInAttemptKey,supersededChallenges,withSignIns}from"./sign-ins.js";import{isEmptyInput}from"./delivery.js";import{SUPERSEDED_BY_MESSAGE,openRequests}from"#protocol/session-projection/reader.js";import{interactionOwner}from"#protocol/session-projection/selectors.js";import{ownOpenRequestIds,runningTasks,turnPosition}from"#harness/session-machine/view.js";import{rememberDecision}from"#approval/evaluation.js";import{renderPendingApprovalsSnippet}from"#harness/hitl/approval-prompt.js";import{coalesceTurnInputs,createFrameworkUserMessage}from"#harness/messages.js";import{awaitSignIns,runnableCalls,settle,withoutApproved}from"#harness/session-machine/transitions.js";import{callSettledFrom}from"#harness/call-facts.js";import{approvalOpened,interactionOpened,interactionSettled,responseAdmitted,responseSettled,responseSubmitted,signInInteractionId,signInOpened}from"#harness/interaction-facts.js";import{TOOL_EXECUTION_DENIED_MESSAGE,failedCall,resolveApprovalOutcome,unavailableToolMessage}from"#harness/approval-outcome.js";import{limitDecision}from"#harness/hitl/budget-request.js";import{stepCallIds,suspend,withResult}from"#harness/session-machine/suspended-steps.js";function askApprovals(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:t.tasks.length>0?[]:t.requests.map(e=>approvalOpened(e)),turn:o}}function openDeferredApprovals(e){let t=e.projection.view;return{events:e.turn.suspended.flatMap(e=>e.tasks.length===0||runningTasks(e).length>0||e.requests.some(e=>t.interactions[e.interactionId]!==void 0)?[]:e.requests.map(e=>approvalOpened(e))),turn:e.turn}}function pendingApprovals(e,t){let n=e.projection.view;return t.requests.filter(e=>{let t=n.interactions[e.interactionId];return t===void 0||t.status===`open`})}function dispatch(e,t){let n=e.turn.suspended.map(e=>{let n=stepCallIds(e),r=t.tasks.filter(e=>n.has(e.callId));return r.length===0?e:{...withoutApproved(e,new Set(r.map(e=>e.callId))),tasks:[...e.tasks,...r]}});return{events:[],turn:{...e.turn,suspended:n}}}function queueInput(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 admitAnswers(e,t){let{check:n,delivery:r}=t,i=e.projection.view,a=responseLedger(i);a.submit(r?.answers??[]);for(let{reason:e,responseId:t}of n.refused)t!==void 0&&a.settle(t,`refused`,e);for(let e of n.admit)a.admit(e);let o=n.refused.map(({reason:e})=>e).join(`
+`),s=new Set(n.refused.map(({responseId:e})=>e)),c=(r?.answers??[]).filter(({responseId:e})=>s.has(e)).map(({deliveryId:e})=>e),l=c.length===n.refused.length&&c.every(e=>e!==void 0),u=[...new Set(l?c:(r?.deliveries??[]).map(({deliveryId:e})=>e))].filter(e=>i.deliveries[e]?.status!==`settled`).map(e=>({data:{deliveryId:e,outcome:`refused`,reason:o},type:`delivery.settled`}));return{events:[...a.facts(),...u],responders:n.weigh,turn:e.turn}}function standingAnswers(e){let t=new Map,n=Object.values(e.responses).sort((e,t)=>e.introducedAt-t.introducedAt);for(let e of n)e.status===`admitted`&&t.set(e.interactionId,e);return t}function responseOf(e,t){if(t?.value===void 0)return;let n={interactionId:e};return t.value.optionId!==void 0&&(n.optionId=t.value.optionId),t.value.text!==void 0&&(n.text=t.value.text),n}function settleApprovals(e,t){let n=e.projection.view,r=standingAnswers(n),answerOf=e=>responseOf(e.interactionId,r.get(e.interactionId)),i=responseLedger(n),a=[],o=!1,s=[],c=[],decide=(e,t,n)=>{let a=t===`withdrawn`?void 0:r.get(e.interactionId);a!==void 0&&i.settle(a.responseId,`applied`),a!==void 0&&(t===`accepted`||t===`declined`)&&c.push({at:a.introducedAt,outcome:t,request:e}),i.closeOthers(e.interactionId,a?.responseId),s.push(interactionSettled(e.interactionId,t,{cause:a===void 0?void 0:{responseId:a.responseId},reason:n,response:t===`withdrawn`?void 0:answerOf(e)}))},l=e.turn.suspended.map(i=>{let c=pendingApprovals(e,i).filter(e=>n.interactions[e.interactionId]!==void 0);if(c.length===0)return i;let l=c.every(e=>answerOf(e)!==void 0);if(!t.steer&&!l)return i;o||=l;let u=i.messages;for(let t of c){let{callId:n,toolName:o}=t.call,{approved:c,reason:l,status:d}=resolveApprovalOutcome(answerOf(t));if(c){let n=e.responders[r.get(t.interactionId)?.responseId??``];a.push({approval:{call:t.call,interactionId:t.interactionId,...n!==void 0&&{responder:n.responder}},step:i}),decide(t,`accepted`);continue}d===`ignored`?decide(t,`withdrawn`,SUPERSEDED_BY_MESSAGE):decide(t,d===`invalid`?`invalid`:`declined`),u=withResult(u,{output:{reason:l,type:`execution-denied`},toolCallId:n,toolName:o,type:`tool-result`});let f=callSettledFrom({callId:n,isError:!0,kind:`tool-result`,output:{approval:{interactionId:t.interactionId,status:d},code:`TOOL_EXECUTION_DENIED`,message:l??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}},toolName:o},{rejected:!0});s.push({...f,data:{...f.data,cause:{interactionId:t.interactionId}}})}return{...i,messages:u}}),declinedLast=e=>+(e.outcome===`declined`),u=c.sort((e,t)=>e.at-t.at||declinedLast(e)-declinedLast(t)).reduce((e,t)=>rememberDecision(e,t.request,t.outcome),e.turn.remembered);return{answered:o,approved:a,events:[...i.facts(),...s],turn:{...e.turn,remembered:u,suspended:l}}}function withdrawUnavailable(e,t){let n=e.projection.view,r=responseLedger(n),i=new Set(t.interactionIds),a=[],o=e.turn.suspended.map(n=>{let o=n.messages;for(let s of pendingApprovals(e,n)){if(!i.has(s.interactionId))continue;let{callId:e,toolName:n}=s.call,c=unavailableToolMessage(n,t.searchable(s)),l=failedCall({callId:e,message:c,toolName:n});o=withResult(o,l.part),r.closeOthers(s.interactionId,void 0),a.push(interactionSettled(s.interactionId,`withdrawn`,{reason:c}),callSettledFrom(l.result))}return o===n.messages?n:{...n,messages:o}});return{events:[...r.facts(),...a],turn:{...e.turn,suspended:o}}}function approvalMemory(e){return{pending:e.turn.suspended.flatMap(t=>pendingApprovals(e,t).flatMap(e=>e.remember===void 0?[]:[e.remember.key])),remembered:e.turn.remembered}}function openLimit(e){let t=ownOpenRequestIds(e),n=e.projection.view,r=openRequests(n).find(e=>e.request.kind===`budget`&&t.has(e.interactionId));return r===void 0?void 0:{row:r,turnId:interactionOwner(n,r).turnId}}function requestLimit(e,t){let{turnId:n}=turnPosition(e.projection);return{events:[interactionOpened({...t,subject:{turnId:n}})],turn:e.turn}}function settleLimit(e){let t=openLimit(e),n=e.projection.view,r=t?.row.interactionId,i=r===void 0?void 0:standingAnswers(n).get(r),a=r===void 0?void 0:responseOf(r,i);if(t===void 0||r===void 0||i===void 0||a===void 0)return{events:[],turn:e.turn};let o=responseLedger(n),s=limitDecision(a);return s===void 0?(o.settle(i.responseId,`refused`,`The budget prompt takes Continue or Stop.`),{events:o.facts(),turn:e.turn}):(o.settle(i.responseId,`applied`),o.closeOthers(r,i.responseId),{events:[...o.facts(),interactionSettled(r,s.granted?`accepted`:`declined`,{cause:{responseId:i.responseId},response:a})],limit:s,turn:e.turn})}function withdrawSignIns(e,t){let n=e.projection.view,r=e.turn.suspended.flatMap(t=>(t.approved??[]).filter(n=>!runnableCalls(e,t).includes(n))),i=[...e.signIns,...r.flatMap(e=>e.signIns??[])],a=[...new Map(i.map(e=>[signInAttemptKey(e),e])).values()].flatMap(e=>{let r=signInInteractionId(e);return n.interactions[r]?.status===`open`?[interactionSettled(r,`withdrawn`,{reason:t})]:[]}),o=settle(e,{results:r.map(({call:e})=>failedCall({callId:e.callId,message:t,toolName:e.toolName}))});return{...o,events:[...a,...o.events],signIns:[]}}function requireSignIn(e,t){let{turnId:n}=turnPosition(e.projection),r=e.projection.view,i=t.challenges.filter(e=>r.interactions[signInInteractionId(e)]===void 0),a=[...supersededChallenges(e.signIns,t.challenges).flatMap(e=>{let t=signInInteractionId(e);return r.interactions[t]?.status===`open`?[interactionSettled(t,`abandoned`,{reason:`Superseded by a newer authorization attempt.`})]:[]}),...i.map(e=>signInOpened(e,{subject:e.candidateId!==void 0&&r.responses[e.candidateId]!==void 0?{responseId:e.candidateId}:{turnId:n}}))],o=withQueued(e.turn,t.queued),s=withSignIns(e.signIns,t.challenges),{calls:c}=t,l=c===void 0?o.suspended:o.suspended.map(e=>awaitSignIns(e,{challenges:t.challenges,stopped:c}));return{events:a,signIns:s,turn:{...o,suspended:l}}}function responseLedger(e){let t=[],n=new Map,r=new Map;for(let t of Object.values(e.responses))r.set(t.responseId,t.status);let submit=i=>{for(let a of i){let{deliveryId:i,interactionId:o,optionId:s,responseId:c,text:l}=a;if(r.has(c)||e.interactions[o]?.status!==`open`)continue;n.set(c,a),r.set(c,`submitted`);let u={};s!==void 0&&(u.optionId=s),l!==void 0&&(u.text=l),t.push(responseSubmitted({deliveryId:i,interactionId:o,responseId:c,value:u}))}},interactionOf=t=>n.get(t)?.interactionId??e.responses[t]?.interactionId,order=t=>e.responses[t]?.introducedAt??2**53-1,openFor=e=>[...r].filter(([t,n])=>n!==`settled`&&interactionOf(t)===e).map(([e])=>e).sort((e,t)=>order(e)-order(t)),settle=(e,n,i)=>{let a=r.get(e);a!==void 0&&a!==`settled`&&(r.set(e,`settled`),t.push(responseSettled(e,n,i)))};return{admit(e){if(r.get(e)!==`submitted`)return;let n=interactionOf(e);if(n!==void 0)for(let t of openFor(n))t!==e&&r.get(t)===`admitted`&&settle(t,`abandoned`,`revised`);r.set(e,`admitted`),t.push(responseAdmitted(e))},closeOthers(e,t){for(let n of openFor(e))n!==t&&settle(n,r.get(n)===`admitted`?`abandoned`:`withdrawn`)},facts:()=>t,submit,settle}}export{admitAnswers,approvalMemory,askApprovals,dispatch,openDeferredApprovals,openLimit,pendingApprovals,queueInput,requestLimit,requireSignIn,settleApprovals,settleLimit,withdrawSignIns,withdrawUnavailable};

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

@@ -1,54 +1,32 @@
-import { type ModelMessage, type TelemetryOptions, type ToolSet, type TypedToolResult } from "ai";
+import type { ApprovalMemory } from "#approval/evaluation.js";
+import type { ModelMessage, TelemetryOptions } from "ai";
 import type { SessionAuthContext } from "#channel/types.js";
-import type { HarnessToolLookup } from "#harness/types.js";
+import { type CallResult, type ToolSignIn } from "#harness/call-executor.js";
+import type { HandleEventFn, HarnessToolLookup } from "#harness/types.js";
 import type { ApprovedCall } from "#harness/session-machine/state.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";
-    }>;
-}
-/** What the model reads for an approved call the turn's cancellation cut short. */
-export declare const APPROVED_CALL_INTERRUPTED_MESSAGE = "The turn was cancelled while this approved tool call was running. It may have partially run; it was not retried.";
+import type { SessionView } from "#harness/session-machine/view.js";
+export { APPROVED_CALL_INTERRUPTED_MESSAGE } from "#harness/call-executor.js";
 /**
  * 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 ApprovedCall[];
+    readonly approvals: readonly ApprovedCall[];
     /** The entries of the step that asked, which the approved calls run. */
     readonly tools: HarnessToolLookup;
-    readonly approvedTools?: ReadonlySet<string>;
+    readonly approvalMemory?: ApprovalMemory;
     /** 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;
-    /** Who approved each request, which the call reads as `ctx.approval`; it still runs as the requester. */
-    readonly responderOf: (request: ApprovedCall) => SessionAuthContext | undefined;
+    /** Who approved each call, which it reads as `ctx.approval`; it still runs as the requester. */
+    readonly responderOf?: (approval: ApprovedCall) => SessionAuthContext | undefined;
+    /** The session as of the latest publish, which says whether a call's sign-ins are still open. */
+    readonly view: () => Pick<SessionView, "projection">;
 }): Promise<{
-    readonly settled: readonly ApprovedCallResult[];
-    readonly toolResults: readonly TypedToolResult<ToolSet>[];
+    readonly settled: readonly CallResult[];
+    readonly signIns: readonly ToolSignIn[];
 }>;
-/** Records an approved call refused by its final request-policy check. */
-export declare function rejectApprovedCall(input: {
-    readonly request: ApprovedCall;
-    readonly reason?: string;
-    readonly position: {
-        readonly sequence: number;
-        readonly stepIndex: number;
-        readonly turnId: string;
-    };
-    readonly publish: HandleEventFn;
-}): Promise<ApprovedCallResult>;
-export {};

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

@@ -1 +1 @@
-import{asSchema}from"ai";import{createLogger,logError}from"#internal/logging.js";import{toError}from"#shared/errors.js";import{createActionPartialEvent,createActionResultEvent,createAuthorizationCompletedEvent}from"#protocol/message.js";import{SEARCH_TOOL_NAME}from"#protocol/catalog-tools.js";import{toModelSchema}from"#tools/schema.js";import{parseJsonObject}from"#shared/json.js";import{isConnectionAuthorizationFailedError}from"#connections/errors.js";import{toolCallModelOutput}from"#harness/tool-call-io.js";import{isAsyncIterable}from"#shared/async-iterable.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{createRuntimeToolResultFromValue}from"#harness/action-result-helpers.js";import{projectDeltaPresentation,projectResultPresentation}from"#harness/tool-presentation.js";import{isInlineAuthorizationToolResult}from"#harness/inline-tool-authorization.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{TOOL_EXECUTION_DENIED_MESSAGE,failedCall,unavailableToolMessage}from"#harness/input-request-resolution.js";import{recheckApprovedCall,wrapToolExecute}from"#harness/tools.js";const log=createLogger(`harness.tool-loop`),APPROVED_CALL_INTERRUPTED_MESSAGE=`The turn was cancelled while this approved tool call was running. It may have partially run; it was not retried.`;async function runApprovedCalls(e){let t={sequence:e.position.sequence,stepIndex:e.position.stepIndex,turnId:e.position.turnId},reportSignIns=async(n,r)=>{let i=isConnectionAuthorizationFailedError(r)?r.reason??r.message:r===void 0||typeof r==`string`?r:r.message;for(let a of n.signIns??[])await e.publish(createAuthorizationCompletedEvent({...authorizationEventFields(a),...t,outcome:i===void 0?`authorized`:`failed`,...i!==void 0&&{reason:i},...isConnectionAuthorizationFailedError(r)&&{retryable:r.retryable}}))},settleFailure=async(n,r)=>{let{callId:i,toolName:a}=n.action,o=failedCall({callId:i,failure:r,toolName:a});return await reportSignIns(n,r),await e.publish(createActionResultEvent({...t,result:o.result})),{part:o.part}},n=await Promise.allSettled(e.requests.map(async n=>{let r=[],i=[],{callId:a,toolName:o,input:s}=n.action,c=e.tools.get(o),l=c===void 0?void 0:wrapToolExecute(c),u=!1,d;try{if(throwIfTurnAborted(e.abortSignal),c===void 0||l===void 0)return{settled:[await settleFailure(n,unavailableToolMessage(o,e.tools.get(SEARCH_TOOL_NAME)!==void 0))],toolResults:i};if((await asSchema(toModelSchema(c.inputSchema,`input`)).validate?.(s))?.success===!1){let e=`The approved input is no longer valid for tool "${o}". Request a new tool call and approval.`;return{settled:[await settleFailure(n,e)],toolResults:i}}let f=await recheckApprovedCall(c,{abortSignal:e.abortSignal,callId:a,input:s,approvedTools:e.approvedTools});if(f.denied)return await reportSignIns(n,f.reason??TOOL_EXECUTION_DENIED_MESSAGE),r.push(await rejectApprovedCall({request:n,reason:f.reason,position:t,publish:e.publish})),{settled:r,toolResults:i};let p,m,h=toolTelemetry(e.telemetry,{messages:[...e.messages],toolCall:{input:s,toolCallId:a,toolName:o,type:`tool-call`}});await h.started();let g=0;try{await h.execute(async()=>{let r=performance.now();try{u=!0;let r=e.responderOf(n),i=l(s,{...r!==void 0&&{approval:{responder:r}},abortSignal:e.abortSignal,messages:[...e.messages],toolCallId:a});if(isAsyncIterable(i))for await(let n of i)p=n,await e.publish(createActionPartialEvent({...t,presentation:projectDeltaPresentation(c,a,parseJsonObject(s),n),result:createRuntimeToolResultFromValue({callId:a,output:n,toolName:o})}));else p=await i}finally{g=performance.now()-r}})}catch(t){await h.ended({error:t,input:s,toolCallId:a,toolName:o,type:`tool-error`},g),throwIfTurnAborted(e.abortSignal),logError(log,`tool execution failed`,t,{toolName:o,toolCallId:a}),m=toError(t),p=m.message}m===void 0&&await h.ended({input:s,output:p,toolCallId:a,toolName:o,type:`tool-result`},g);let _={input:s,output:p,toolCallId:a,toolName:o,type:`tool-result`};return i.push(_),isInlineAuthorizationToolResult(_)?{settled:r,toolResults:i}:(d={part:{output:m===void 0?await toolCallModelOutput(c,p,a):{type:`error-text`,value:m.message},toolCallId:a,toolName:o,type:`tool-result`}},r.push(d),await reportSignIns(n,m),await e.publish(createActionResultEvent({...t,presentation:m===void 0?projectResultPresentation(c,a,parseJsonObject(s),p):void 0,result:createRuntimeToolResultFromValue({callId:a,isError:m!==void 0,output:m??p,toolName:o})})),{settled:r,toolResults:i})}catch(t){return e.abortSignal?.aborted===!0?(u||throwIfTurnAborted(e.abortSignal),d===void 0?{settled:[interruptedResult(a,o)],toolResults:i}:{settled:[d],toolResults:i}):(logError(log,`approved tool failed`,t,{toolName:o,toolCallId:a}),{settled:[await settleFailure(n,toError(t))],toolResults:i})}})),r=n.find(e=>e.status===`rejected`);if(r?.status===`rejected`&&e.abortSignal?.aborted!==!0)throw r.reason;let i=n.flatMap(e=>e.status===`fulfilled`?[e.value]:[]);return{settled:i.flatMap(e=>e.settled),toolResults:i.flatMap(e=>e.toolResults)}}function interruptedResult(e,t){return{part:{output:{type:`error-text`,value:APPROVED_CALL_INTERRUPTED_MESSAGE},toolCallId:e,toolName:t,type:`tool-result`}}}async function rejectApprovedCall(e){let{callId:t,toolName:n}=e.request.action;return await e.publish(createActionResultEvent({...e.position,rejected:!0,result:{callId:t,isError:!0,kind:`tool-result`,toolName:n,output:{code:`TOOL_EXECUTION_DENIED`,message:e.reason??TOOL_EXECUTION_DENIED_MESSAGE,tool:{result:`not_run`}}}})),{part:{output:{reason:e.reason,type:`execution-denied`},toolCallId:t,toolName:n,type:`tool-result`}}}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{APPROVED_CALL_INTERRUPTED_MESSAGE,rejectApprovedCall,runApprovedCalls};
+import{toErrorMessage}from"#shared/errors.js";import{SEARCH_TOOL_NAME}from"#protocol/catalog-tools.js";import{isConnectionAuthorizationFailedError}from"#connections/errors.js";import{callSignInsSettled}from"#harness/session-machine/transitions.js";import{callSettledFrom}from"#harness/call-facts.js";import{isRunnableTool}from"#harness/tools.js";import{changedSinceOffered,changedToolMessage,failedCall,unavailableToolMessage}from"#harness/approval-outcome.js";import{APPROVED_CALL_INTERRUPTED_MESSAGE,executeToolCall}from"#harness/call-executor.js";async function runApprovedCalls(e){let reportSignIns=async(t,n)=>{if((t.signIns?.length??0)===0)return;let r=isConnectionAuthorizationFailedError(n)?n:void 0,i=callSignInsSettled(e.view(),t,n===void 0?void 0:{reason:r===void 0?toErrorMessage(n):r.reason??r.message,...r!==void 0&&{retryable:r.retryable}});i.length>0&&await e.publish(i)},t=await Promise.allSettled(e.approvals.map(async t=>{let{call:n,interactionId:r}=t,{callId:i,toolName:a}=n,o=e.tools.get(a);if(changedSinceOffered(n,o)){let n=changedToolMessage(a),r=failedCall({callId:i,message:n,toolName:a});return await reportSignIns(t,n),await e.publish(callSettledFrom(r.result)),{settled:[{part:r.part}],toolResults:[]}}if(isRunnableTool(o)){let i=e.responderOf?.(t);return await executeToolCall(n,{...e,...r!==void 0&&{clearedBy:{interactionId:r}},definition:o,...i!==void 0&&{responder:i},beforeResult:e=>reportSignIns(t,e)},`recheck`)}let s=e.tools.get(SEARCH_TOOL_NAME)!==void 0,c=unavailableToolMessage(a,s),l=failedCall({callId:i,message:c,toolName:a});return await reportSignIns(t,c),await e.publish(callSettledFrom(l.result)),{settled:[{part:l.part}],toolResults:[]}})),n=t.find(e=>e.status===`rejected`);if(n?.status===`rejected`&&e.abortSignal?.aborted!==!0)throw n.reason;let r=t.flatMap(e=>e.status===`fulfilled`?[e.value]:[]);return{settled:r.flatMap(e=>e.settled),signIns:r.flatMap(e=>e.signIn===void 0?[]:[e.signIn])}}export{APPROVED_CALL_INTERRUPTED_MESSAGE,runApprovedCalls};

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

@@ -1,56 +1,18 @@
-/**
- * Deterministic HITL continuation prompt for session usage limits.
- *
- * When a durable session reaches its usage limit, the harness
- * parks on a harness-authored input request instead of failing the session.
- * The request is derived only from the session, turn, and usage, so
- * identical session state always produces an identical prompt — no model call
- * is involved.
- */
-import type { InputRequest, InputResponse } from "#shared/input.js";
+import type { InteractionRequest } from "#protocol/session-events/families/interaction.js";
+import type { ResponseValue } from "#protocol/session-events/families/response.js";
 import type { JsonObject } from "#shared/json.js";
 import type { TokenUsage } from "#shared/token-usage.js";
-/** Option id that declines continuation and ends the session. */
-export declare const SESSION_LIMIT_STOP_OPTION_ID = "stop";
-/**
- * Builds the deterministic continuation prompt for a session that reached its
- * usage limit.
- */
+export interface LimitAsk {
+    readonly interactionId: string;
+    readonly request: InteractionRequest;
+}
 export declare function createSessionLimitContinuationRequest(input: {
     readonly sessionId: string;
-    readonly total: TokenUsage;
-    /** The turn's `sequence`, which tells its prompt apart from another turn's at the same usage. */
     readonly turnSequence: number;
-    readonly window: TokenUsage;
-    /** Which usage window the prompt is for; approving starts the next one. */
     readonly windowIndex: number;
-}): InputRequest;
-/** `usage` as JSON: an unreported cost is left out. */
+}): LimitAsk;
 export declare function toJsonUsage(usage: TokenUsage): JsonObject;
-/**
- * Returns true when a request is a harness-authored session-limit
- * continuation prompt.
- */
-export declare function isSessionLimitContinuationRequest(request: InputRequest): boolean;
-/**
- * Matches request ids minted by {@link createSessionLimitContinuationRequest}.
- *
- * Continuation requests never enter model history (no matching tool call
- * exists), so the id shape is the only durable marker for recognizing a
- * stale continuation answer after its request left the pending batch.
- */
 export declare function isSessionLimitContinuationRequestId(requestId: string): boolean;
-/**
- * Resolves the user's answer to a session-limit continuation prompt.
- *
- * Returns `{ granted: true }` for "continue", `{ granted: false }` for
- * "stop", and `undefined` when the batch carries no continuation request or
- * the user has not answered it — an unanswered prompt is re-raised on the
- * next step because the violation still holds.
- */
-export declare function resolveSessionLimitContinuation(input: {
-    readonly requests: readonly InputRequest[];
-    readonly responses: readonly InputResponse[];
-}): {
+export declare function limitDecision(answer: ResponseValue): {
     readonly granted: boolean;
 } | undefined;

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

@@ -1 +1 @@
-const SESSION_LIMIT_CONTINUE_OPTION_ID=`continue`,SESSION_LIMIT_STOP_OPTION_ID=`stop`;function createSessionLimitContinuationRequest(e){let{sessionId:t,total:n,turnSequence:r,window:i,windowIndex:a}=e,o=`${t}:${String(r)}:limit:usage:${String(a)}`;return{action:{callId:o,input:{total:toJsonUsage(n),window:toJsonUsage(i)},kind:`tool-call`,toolName:`session_limit_continuation`},allowFreeform:!1,display:`confirmation`,kind:`session-limit`,options:[{description:`Start a new usage window`,id:SESSION_LIMIT_CONTINUE_OPTION_ID,label:`Approve`,style:`primary`},{description:`Stop now`,id:SESSION_LIMIT_STOP_OPTION_ID,label:`Stop`,style:`danger`}],prompt:SESSION_LIMIT_PROMPT,requestId:o}}function toJsonUsage(e){let{costUsd:t,...n}=e;return t===void 0?n:{...n,costUsd:t}}const SESSION_LIMIT_PROMPT=`This session has hit its usage limit. This is a guardrail against defective long-running sessions. If session activity looks fine, just approve to keep going.`;function isSessionLimitContinuationRequest(e){return e.kind===`session-limit`}function isSessionLimitContinuationRequestId(e){return/:limit:(?:usage|input|output):\d+$/u.test(e)||/:limit:token-cost:\d+(?:\.\d+)?(?:e[+-]?\d+)?$/iu.test(e)}function resolveSessionLimitContinuation(e){let t=e.requests.find(isSessionLimitContinuationRequest);if(t===void 0)return;let n=e.responses.find(e=>e.requestId===t.requestId);if(n!==void 0){if(n.optionId===SESSION_LIMIT_CONTINUE_OPTION_ID)return{granted:!0};if(n.optionId===`stop`)return{granted:!1}}}export{SESSION_LIMIT_STOP_OPTION_ID,createSessionLimitContinuationRequest,isSessionLimitContinuationRequest,isSessionLimitContinuationRequestId,resolveSessionLimitContinuation,toJsonUsage};
+import{APPROVE_OPTION_ID,DENY_OPTION_ID}from"#shared/input.js";function createSessionLimitContinuationRequest(e){let{sessionId:t,turnSequence:n,windowIndex:r}=e;return{interactionId:`${t}:${n}:limit:usage:${r}`,request:{allowFreeform:!1,display:`confirmation`,kind:`budget`,options:[{description:`Start a new usage window`,id:APPROVE_OPTION_ID,label:`Approve`,style:`primary`},{description:`Stop now`,id:DENY_OPTION_ID,label:`Stop`,style:`danger`}],prompt:`This session has hit its usage limit. This is a guardrail against defective long-running sessions. If session activity looks fine, just approve to keep going.`}}}function toJsonUsage(e){let{costUsd:t,...n}=e;return t===void 0?n:{...n,costUsd:t}}function isSessionLimitContinuationRequestId(e){return/:limit:(?:usage|input|output):\d+$/u.test(e)||/:limit:token-cost:\d+(?:\.\d+)?(?:e[+-]?\d+)?$/iu.test(e)}function limitDecision(e){if(e.optionId===APPROVE_OPTION_ID)return{granted:!0};if(e.optionId===DENY_OPTION_ID)return{granted:!1}}export{createSessionLimitContinuationRequest,isSessionLimitContinuationRequestId,limitDecision,toJsonUsage};

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

@@ -1,27 +1,28 @@
+import { type LimitAsk } from "#harness/hitl/budget-request.js";
+import type { SessionProjection } from "#protocol/session-projection.js";
 import type { HarnessSession } from "#harness/types.js";
 import type { SessionUsageLimit } from "#shared/agent-definition.js";
-import type { InputRequest } from "#shared/input.js";
 import type { JsonObject } from "#shared/json.js";
-/**
- * The limit for agents that author none: 40M new input tokens per window. Cache reads are
- * replayed history, not new work, so only uncached input and cache writes count.
- */
+import type { TokenUsage } from "#shared/token-usage.js";
+/** Cache reads replay history rather than spending new input. Cache writes still count. */
 export declare const DEFAULT_SESSION_USAGE_LIMIT: SessionUsageLimit;
 export type SessionUsageLimitCheck = {
     readonly kind: "within";
 } | {
     readonly kind: "ask";
-    readonly request: InputRequest;
+    readonly ask: LimitAsk;
 } | {
     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 limit: SessionUsageLimit;
-    readonly session: HarnessSession;
+    readonly session: Pick<HarnessSession, "sessionId" | "state">;
     readonly turnSequence: number;
+    readonly usage: TokenUsage;
+    /** The window the last accepted budget prompt started; the stored one by default. */
+    readonly window?: SessionProjection["usageWindow"];
 }): SessionUsageLimitCheck;

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

@@ -1 +1 @@
-import{getSessionUsage,getSessionUsageWindow,getSessionUsageWindowIndex}from"#harness/turn-tag-state.js";import{createSessionLimitContinuationRequest,toJsonUsage}from"#harness/hitl/budget-request.js";const DEFAULT_SESSION_USAGE_LIMIT=({window:e})=>e.inputTokens-e.cacheReadTokens>=4e7;function checkSessionUsageLimit(e){let t=getSessionUsage(e.session),n=getSessionUsageWindow(e.session);return isEmptyUsage(n)||!e.limit({total:t,window:n})?{kind:`within`}:e.canAsk?{kind:`ask`,request:createSessionLimitContinuationRequest({sessionId:e.session.sessionId,total:t,turnSequence:e.turnSequence,window:n,windowIndex:getSessionUsageWindowIndex(e.session)})}:{code:`SESSION_USAGE_LIMIT_REACHED`,details:{total:toJsonUsage(t),window:toJsonUsage(n)},kind:`fail`,message:`The session reached its usage limit.`}}function isEmptyUsage(e){return e.inputTokens===0&&e.outputTokens===0&&!e.costUsd}export{DEFAULT_SESSION_USAGE_LIMIT,checkSessionUsageLimit};
+import{storedProjection}from"#harness/session-machine/view.js";import{usageSince}from"#shared/token-usage-math.js";import{createSessionLimitContinuationRequest,toJsonUsage}from"#harness/hitl/budget-request.js";const DEFAULT_SESSION_USAGE_LIMIT=({window:e})=>e.inputTokens-e.cacheReadTokens>=4e7;function checkSessionUsageLimit(e){let t=e.usage,n=e.window??storedProjection(e.session.state).usageWindow,r=usageSince(t,n?.start);return r.inputTokens===0&&r.outputTokens===0&&!r.costUsd||!e.limit({total:{...t},window:{...r}})?{kind:`within`}:e.canAsk?{kind:`ask`,ask:createSessionLimitContinuationRequest({sessionId:e.session.sessionId,turnSequence:e.turnSequence,windowIndex:n?.index??0})}:{kind:`fail`,code:`SESSION_USAGE_LIMIT_REACHED`,details:{total:toJsonUsage(t),window:toJsonUsage(r)},message:`The session reached its usage limit.`}}export{DEFAULT_SESSION_USAGE_LIMIT,checkSessionUsageLimit};

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

@@ -1,7 +1,6 @@
-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 { MessageContent } from "#shared/message-content.js";
+import type { HarnessStepInput } from "#harness/types.js";
+import type { SessionView as SessionTables } from "#protocol/session-projection/tables.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
@@ -9,36 +8,36 @@ import type { SessionView } from "#harness/session-machine/view.js";
  * 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: {
+export declare function deliver(view: SessionView, input: HarnessStepInput | undefined, options: {
     readonly takeQueued: boolean;
     readonly typedAnswers?: boolean;
 }): {
-    readonly input?: StepInput;
-    readonly displayMessage?: string | UserContent;
+    readonly input?: HarnessStepInput;
+    readonly displayMessage?: MessageContent;
     readonly takeQueued: boolean;
 };
-export type ResolvedStepInput = StepInput & {
+export type ResolvedStepInput = HarnessStepInput & {
     readonly messageConsumed?: boolean;
 };
 /**
  * Plain text answers a budget prompt; `resolveTypedApproval` answers approvals. 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.
+ * The answer consumes the message, with the context and history the channel sent with it: the
+ * model reads none of them.
  */
-export declare function resolveTextInput(batch: Pick<SuspendedStep, "requests">, stepInput: StepInput | undefined): ResolvedStepInput | undefined;
+export declare function resolveTextInput(view: SessionTables, stepInput: HarnessStepInput | undefined): ResolvedStepInput | undefined;
 /**
  * Turns a typed reply into a response to the first open request when that request is one of
  * this turn's approvals. The approval coordinator then settles it, or asks its response policy
  * about the person who typed, as it does for a press. A batch's other approvals stay open for
  * later replies.
  */
-export declare function resolveTypedApproval(view: Pick<SessionView, "projection" | "turn">, stepInput: StepInput | undefined): ResolvedStepInput | undefined;
-export declare function canonicalize(responses: readonly InputResponse[]): readonly InputResponse[];
-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, its history and context. */
-export declare function turnInputOnly(input: ResolvedStepInput | undefined): StepInput | undefined;
+export declare function resolveTypedApproval(view: Pick<SessionView, "projection" | "turn">, stepInput: HarnessStepInput | undefined): ResolvedStepInput | undefined;
+export declare function typedResponseId(deliveryId: string, index: number): string;
+export declare function isEmptyInput(input: HarnessStepInput): boolean;
+export declare function withoutResponses(input: ResolvedStepInput | undefined): HarnessStepInput | 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): HarnessStepInput | 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;