eve 0.50.0 → 0.51.1

package/dist/src/harness/advertised-tools.d.ts

@@ -1,22 +1,16 @@
 import type { ToolSet } from "ai";
 import type { HarnessToolDefinition } from "#harness/execute-tool.js";
 import type { HarnessSession, HarnessToolMap } from "#harness/types.js";
-type AdvertisedToolSession = Pick<HarnessSession, "rootSessionId" | "subagentDepth">;
+type AdvertisedToolSession = Pick<HarnessSession, "rootSessionId" | "taskId">;
 type AdvertisedToolMapInput = {
-    readonly canRequestInput?: boolean;
-    readonly delegatedCaller?: boolean;
     readonly session: AdvertisedToolSession;
     readonly tools: HarnessToolMap;
 };
 type AdvertisedToolDefinitionsInput = {
-    readonly canRequestInput?: boolean;
-    readonly delegatedCaller?: boolean;
     readonly session: AdvertisedToolSession;
     readonly tools: readonly HarnessToolDefinition[];
 };
 type AdvertisedModelToolsInput = {
-    readonly canRequestInput?: boolean;
-    readonly delegatedCaller?: boolean;
     readonly modelTools: ToolSet;
     readonly session: HarnessSession;
     readonly tools: HarnessToolMap;

package/dist/src/harness/advertised-tools.js

@@ -1 +1 @@
-import{resolveSubagentDepth}from"#harness/subagent-depth.js";import{ensureWorkflowContinuationSecurity,getWorkflowContinuationSecurity}from"#harness/workflow-continuation-security.js";import{applyWorkflowTool}from"#harness/workflow-sandbox.js";function getAdvertisedTools(e){return`modelTools`in e?getAdvertisedModelTools(e):isToolDefinitionList(e.tools)?filterUnavailableDelegationToolDefinitions(e.tools,e.session,e):filterUnavailableToolMap(e.tools,e.session,e)}async function getAdvertisedModelTools(e){let i=filterUnavailableToolMap(e.tools,e.session,e);if(e.workflow===void 0)return{harnessTools:i,modelTools:e.modelTools,session:e.session};let a=filterWorkflowHostToolsForRootSession(i,e.session);if(a.size===0)return{harnessTools:i,modelTools:e.modelTools,session:e.session};let o=ensureWorkflowContinuationSecurity(e.session),{modelTools:s}=await applyWorkflowTool({continuationSecurity:getWorkflowContinuationSecurity(o),harnessTools:a,maxSubagents:e.workflow.maxSubagents,tools:e.modelTools});return{harnessTools:i,modelTools:s,session:o}}function filterUnavailableDelegationToolDefinitions(e,t,n){let r=[];for(let i of e)isToolAvailable(i,t,n)&&r.push(i);return r}function filterUnavailableToolMap(e,t,n){let r=new Map;for(let[i,a]of e)isToolAvailable(a,t,n)&&r.set(i,a);return r}function filterWorkflowHostToolsForRootSession(t,n){let r=new Map,i=resolveSubagentDepth(n);if(n.rootSessionId!==void 0||i.currentDepth>0)return r;for(let[e,n]of t){let t=n.behavior?.handling?.kind===`dispatch`?n.behavior.handling.target:void 0;(t?.kind===`self-agent-call`||t?.kind===`subagent-call`||t?.kind===`remote-agent-call`)&&r.set(e,n)}return r}function isToolAvailable(t,n,r){for(let i of t.behavior?.availability??[])switch(i){case`delegated-task-child`:if(r.delegatedCaller!==!0)return!1;break;case`requires-request-input`:if(r.canRequestInput!==!0)return!1;break;case`root-session`:if(n.rootSessionId!==void 0||resolveSubagentDepth(n).currentDepth>0)return!1;break;default:return i}return!0}function isToolDefinitionList(e){return Array.isArray(e)}export{getAdvertisedTools};
+import{ensureWorkflowContinuationSecurity,getWorkflowContinuationSecurity}from"#harness/workflow-continuation-security.js";import{applyWorkflowTool}from"#harness/workflow-sandbox.js";function getAdvertisedTools(e){return`modelTools`in e?getAdvertisedModelTools(e):isToolDefinitionList(e.tools)?filterUnavailableToolDefinitions(e.tools,e.session):filterUnavailableToolMap(e.tools,e.session)}async function getAdvertisedModelTools(r){let i=filterUnavailableToolMap(r.tools,r.session);if(r.workflow===void 0)return{harnessTools:i,modelTools:r.modelTools,session:r.session};let a=filterWorkflowHostToolsForRootSession(i,r.session);if(a.size===0)return{harnessTools:i,modelTools:r.modelTools,session:r.session};let o=ensureWorkflowContinuationSecurity(r.session),{modelTools:s}=await applyWorkflowTool({continuationSecurity:getWorkflowContinuationSecurity(o),harnessTools:a,maxSubagents:r.workflow.maxSubagents,tools:r.modelTools});return{harnessTools:i,modelTools:s,session:o}}function filterUnavailableToolDefinitions(e,t){let n=[];for(let r of e)shouldHideTool(r,t)||n.push(r);return n}function filterUnavailableToolMap(e,t){let n=new Map;for(let[r,i]of e)shouldHideTool(i,t)||n.set(r,i);return n}function filterWorkflowHostToolsForRootSession(e,t){let n=new Map;if(t.rootSessionId!==void 0)return n;for(let[t,r]of e)r.resultKind===`subagent`&&n.set(t,r);return n}function shouldHideTool(e,t){let n=t.rootSessionId!==void 0;return e.rootOnly===!0||e.behavior?.availability.includes(`root-session`)===!0?n:e.behavior?.availability.includes(`delegated-task-child`)===!0&&t.taskId===void 0}function isToolDefinitionList(e){return Array.isArray(e)}export{getAdvertisedTools};

package/dist/src/harness/background-tools.d.ts

@@ -1,11 +1,16 @@
 import { ContextKey } from "#context/key.js";
 import type { ToolExecuteOptions } from "#tools/definition.js";
 import type { TaskExec } from "#tools/task.js";
-import type { PreparedToolBehavior } from "#tools/behavior.js";
+import type { AgentView } from "#subagents/handles/prompt.js";
+import type { JsonValue } from "#shared/json.js";
 export interface BackgroundExecutableTool {
-    readonly behavior?: PreparedToolBehavior;
     readonly execute: (input: unknown, options: ToolExecuteOptions, task: TaskExec) => unknown;
+    readonly executeInput?: (input: unknown) => JsonValue;
     readonly name: string;
+    readonly nodeId?: string;
+    readonly resultKind?: "subagent" | "tool";
+    /** Present when the execute body runs in the task-owned durable workflow. */
+    readonly workflowId?: string;
 }
 export interface BackgroundToolCall {
     readonly callId: string;
@@ -22,6 +27,7 @@ export interface BackgroundToolCallBatch {
     setTool(name: string, definition?: BackgroundExecutableTool): void;
 }
 export interface BackgroundToolExecutor {
+    readAgentViews?(): Promise<readonly AgentView[]>;
     execute(input: {
         readonly batch: BackgroundToolCallBatch;
         readonly definition: BackgroundExecutableTool;

package/dist/src/harness/{runtime-actions.d.ts → coordination.d.ts}

@@ -1,72 +1,79 @@
 import type { ModelMessage, ToolSet, TypedToolCall } from "ai";
-import type { RuntimeActionRequest } from "#shared/action-types.js";
-import type { PendingDispatchAction } from "#shared/dispatch-action.js";
+import type { RuntimeActionRequest, RuntimeToolCallActionRequest, RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
 import { type JsonObject } from "#shared/json.js";
 import type { HarnessEmitFn, HarnessSession, HarnessToolMap, SessionStateMap, StepInput } from "#harness/types.js";
 /**
- * Serializable event coordinates for one pending runtime-action batch.
+ * Serializable event coordinates for one pending coordination batch.
  *
  * Runtime action results are projected back onto the parent stream using the
  * same turn and step identity as the originating `actions.requested` batch.
  */
-interface PendingRuntimeActionEventMetadata {
+interface PendingCoordinationEventMetadata {
     readonly sequence: number;
     readonly stepIndex: number;
     readonly turnId: string;
 }
 /**
- * Serializable pending runtime-action batch stored on `session.state`.
+ * Serializable pending coordination batch stored on `session.state`.
  *
  * Child ownership does not live here: the agent handle store records every
  * dispatched child (from before its start side effect) and is the sole
  * authority for continuing, settling, and cancelling children.
  */
-export interface PendingRuntimeActionBatch {
-    readonly actions: readonly PendingDispatchAction[];
-    readonly event: PendingRuntimeActionEventMetadata;
+export interface PendingCoordinationBatch {
+    /** Framework task controls deferred to the turn owner. */
+    readonly runtimeActions: readonly RuntimeToolCallActionRequest[];
+    /** Authored-tool and subagent workflow tasks pending coordination. */
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    readonly event: PendingCoordinationEventMetadata;
+    readonly localFanoutSize?: number;
     readonly responseMessages: readonly ModelMessage[];
 }
 /**
- * Outcome of resolving a pending runtime-action batch.
+ * Outcome of resolving a pending coordination batch.
  */
-interface ResolvePendingRuntimeActionsResult {
+interface ResolvePendingCoordinationResult {
     readonly messages: ModelMessage[];
     readonly outcome: "continue" | "resolved" | "unresolved";
     readonly session: HarnessSession;
 }
-/** Returns the pending runtime-action batch stored on the session, if any. */
-export declare function getPendingRuntimeActionBatch(state: SessionStateMap | undefined): PendingRuntimeActionBatch | undefined;
+/** Returns the pending coordination batch stored on the session, if any. */
+export declare function getPendingCoordinationBatch(state: SessionStateMap | undefined): PendingCoordinationBatch | undefined;
 /**
- * Returns true when the session is parked on a pending runtime-action batch.
+ * Returns true when the session is parked on pending task/control coordination.
  */
-export declare function hasPendingRuntimeActionBatch(state: SessionStateMap | undefined): boolean;
-export declare function clearPendingRuntimeActionBatch(session: HarnessSession): HarnessSession;
+export declare function hasPendingCoordinationBatch(state: SessionStateMap | undefined): boolean;
+export declare function clearPendingCoordinationBatch(session: HarnessSession): HarnessSession;
 /**
- * Stores one pending runtime-action batch on the session.
+ * Stores one pending coordination batch on the session.
  */
-export declare function setPendingRuntimeActionBatch(input: {
-    readonly actions: readonly PendingDispatchAction[];
-    readonly event: PendingRuntimeActionEventMetadata;
+export declare function setPendingCoordinationBatch(input: {
+    readonly runtimeActions: readonly RuntimeToolCallActionRequest[];
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    readonly event: PendingCoordinationEventMetadata;
+    readonly localFanoutSize?: number;
     readonly responseMessages: readonly ModelMessage[];
     readonly session: HarnessSession;
 }): HarnessSession;
-/** Rejects an ambiguous action batch before any result or side effect can bind by call id. */
-export declare function assertUniqueRuntimeActionCallIds(actions: readonly PendingDispatchAction[]): void;
+/** Rejects a batch before any result or side effect can bind ambiguously by call id. */
+export declare function assertUniqueCoordinationCallIds(requests: readonly {
+    readonly callId: string;
+}[]): void;
 /**
- * Resolves one pending runtime-action batch back into model history.
+ * Resolves one pending coordination batch back into model history.
  *
  * When all expected runtime action results are present, this appends the
  * stored assistant tool-call messages plus synthesized tool-result messages to
  * history, clears the pending batch, and emits `subagent.completed` and
  * `action.result` events back onto the parent stream.
  */
-export declare function resolvePendingRuntimeActions(input: {
+export declare function resolvePendingCoordination(input: {
     readonly emit?: HarnessEmitFn;
     readonly session: HarnessSession;
     readonly stepInput?: StepInput;
     /** Definitions whose `toModelOutput` projects a workflow tool's result for the model. */
     readonly tools?: HarnessToolMap;
-}): Promise<ResolvePendingRuntimeActionsResult>;
+}): Promise<ResolvePendingCoordinationResult>;
 /**
  * Projects one AI SDK tool call into the eve runtime-action contract.
  */
@@ -74,11 +81,17 @@ export declare function createRuntimeActionRequestFromToolCall(input: {
     readonly toolCall: TypedToolCall<ToolSet>;
     readonly tools: HarnessToolMap;
 }): RuntimeActionRequest;
-/** Projects one execute-less dispatch tool call into the durable pending contract. */
-export declare function createPendingDispatchActionFromToolCall(input: {
+/** Projects one deferred harness tool call into task/control coordination. */
+export declare function createCoordinationRequestFromToolCall(input: {
     readonly toolCall: TypedToolCall<ToolSet>;
     readonly tools: HarnessToolMap;
-}): PendingDispatchAction;
+}): {
+    readonly kind: "runtime-action";
+    readonly request: RuntimeToolCallActionRequest;
+} | {
+    readonly kind: "task";
+    readonly request: RuntimeWorkflowTaskRequest;
+};
 /**
  * Coerces an AI SDK tool-call `input` into the runtime-action `JsonObject`
  * contract, throwing a `TypeError` (with the original as `cause`) that names

package/dist/src/harness/coordination.js

@@ -0,0 +1 @@
+import{createActionResultEvent}from"#protocol/message.js";import{parseJsonObject}from"#shared/json.js";import{findWorkflowToolRun,isInboxSubagentResultFromRecordedWorkflowToolRun,removeWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{clearProxyInputRequestsForChild,clearProxyInputRequestsWhere}from"#harness/proxy-input-requests.js";import{settleAgentTurn}from"#subagents/handles/transitions.js";import{accumulateSessionUsage,getTurnUsageState,setTurnUsageState}from"#harness/turn-tag-state.js";import{findRunningAgentHandle,isResultBoundToRunningHandle}from"#subagents/handles/query.js";import{resolveRuntimeActionResultsForCallIds}from"#runtime/actions/results.js";import{normalizeToolModelOutput}from"#harness/tool-model-output.js";const PENDING_COORDINATION_BATCH_KEY=`eve.runtime.pendingCoordinationBatch`;function readSubagentResultOutcome(e){return e.origin===`child`?e.outcome:void 0}function getPendingCoordinationBatch(e){let t=e?.[PENDING_COORDINATION_BATCH_KEY];if(typeof t!=`object`||!t)return;let n=t;if(!(!Array.isArray(n.runtimeActions)||!Array.isArray(n.tasks)||!Array.isArray(n.responseMessages)||typeof n.event!=`object`||n.event===null))return n}function hasPendingCoordinationBatch(e){return getPendingCoordinationBatch(e)!==void 0}function clearPendingCoordinationBatch(e){if(e.state?.[PENDING_COORDINATION_BATCH_KEY]===void 0)return e;let t={...e.state};return delete t[PENDING_COORDINATION_BATCH_KEY],{...e,state:Object.keys(t).length>0?t:void 0}}function setPendingCoordinationBatch(e){assertUniqueCoordinationCallIds([...e.runtimeActions,...e.tasks]);let t={...e.session.state};return t[PENDING_COORDINATION_BATCH_KEY]={runtimeActions:[...e.runtimeActions],tasks:[...e.tasks],event:e.event,localFanoutSize:e.localFanoutSize,responseMessages:[...e.responseMessages]},{...e.session,state:t}}function assertUniqueCoordinationCallIds(e){let t=new Set;for(let n of e){if(t.has(n.callId))throw Error(`Coordination batch contains duplicate callId "${n.callId}".`);t.add(n.callId)}}function resolveReadyCoordinationResults(e){let t=getPendingCoordinationBatch(e.session.state);if(t!==void 0)return resolveResultsForCoordinationBatch({batch:t,results:e.results,state:e.session.state})}function resolveResultsForCoordinationBatch(e){return resolveRuntimeActionResultsForCallIds({pendingCallIds:[...e.batch.runtimeActions,...e.batch.tasks].map(e=>e.callId),results:e.results.filter(t=>isResultBoundToRunningHandle(e.state,t)||t.kind===`subagent-result`&&isInboxSubagentResultFromRecordedWorkflowToolRun(e.state,t))})}async function resolvePendingCoordination(t){let r=getPendingCoordinationBatch(t.session.state);if(r===void 0)return{messages:[...t.session.history],outcome:`continue`,session:t.session};let i=resolveReadyCoordinationResults({results:t.stepInput?.runtimeActionResults??[],session:t.session});if(i===void 0)return{messages:[...t.session.history],outcome:`unresolved`,session:t.session};if(t.emit!==void 0)for(let n of i){if(n.kind===`subagent-result`&&n.isError!==!0){let e=readBackgroundTaskReceipt(n),r={callId:n.callId,output:typeof n.output==`string`?n.output:JSON.stringify(n.output),subagentName:n.subagentName};await t.emit({data:e===void 0?r:{...r,backgroundTask:e},type:`subagent.completed`})}await t.emit(createActionResultEvent({result:n,sequence:r.event.sequence,stepIndex:r.event.stepIndex,turnId:r.event.turnId}))}let a=t.session;for(let e of i){if(e.kind!==`subagent-result`||e.origin!==`child`||readBackgroundTaskReceipt(e)!==void 0)continue;let t=findRunningAgentHandle(a.state,{callId:e.callId});if(t===void 0)continue;let n=readSubagentResultOutcome(e);if(n===void 0)continue;n.kind===`terminal`&&`continuationToken`in t.address&&(a=clearProxyInputRequestsForChild(a,t.address.continuationToken));let r=settleAgentTurn(a,{operationId:t.operation.id,outcome:n});r.kind===`settled`&&(a=r.session)}for(let e of i){if(e.kind!==`tool-result`)continue;let t=findWorkflowToolRun(a.state,e.callId);t!==void 0&&(a=removeWorkflowToolRun(clearProxyInputRequestsWhere(a,e=>e.answerHook?.runId===t.runId),t.callId))}for(let e of i){if(e.kind!==`subagent-result`)continue;let t=findWorkflowToolRun(a.state,e.callId);t?.resultKind===`subagent`&&(a=removeWorkflowToolRun(clearProxyInputRequestsForChild(a,t.hookToken),t.callId))}let o={...a.state};delete o[PENDING_COORDINATION_BATCH_KEY],a={...a,state:Object.keys(o).length>0?o:void 0};for(let e of i){if(e.kind!==`subagent-result`)continue;let t=readSubagentResultOutcome(e);t!==void 0&&(a=setTurnUsageState(a,accumulateSessionUsage({previous:getTurnUsageState(a.state),usage:t.usageDelta})))}let s=[];for(let e of i){switch(e.kind){case`load-skill-result`:s.push({output:toToolResultOutput(e),toolCallId:e.callId,toolName:`load_skill`,type:`tool-result`});continue;case`subagent-result`:s.push({output:toToolResultOutput(e),toolCallId:e.callId,toolName:e.subagentName,type:`tool-result`});continue;case`tool-result`:s.push({output:await projectToolResultOutput(e,t.tools?.get(e.toolName)),toolCallId:e.callId,toolName:e.toolName,type:`tool-result`});continue}throw Error(`Unsupported runtime action result kind "${String(e)}".`)}let c=[...a.history,...r.responseMessages];return s.length>0&&c.push({content:s,role:`tool`}),{messages:c,outcome:`resolved`,session:a}}function readBackgroundTaskReceipt(e){return`backgroundTask`in e?e.backgroundTask:void 0}function createRuntimeActionRequestFromToolCall(e){return e.tools.get(e.toolCall.toolName)?.frameworkAction===`load-skill`?{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName}),kind:`load-skill`}:{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName}),kind:`tool-call`,toolName:e.toolCall.toolName}}function createCoordinationRequestFromToolCall(e){let t=e.tools.get(e.toolCall.toolName),n=resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName});if(t?.runtimeAction?.kind===`task-control`)return{kind:`runtime-action`,request:{callId:e.toolCall.toolCallId,input:n,kind:`tool-call`,toolName:e.toolCall.toolName}};if(t?.workflowId!==void 0)return{kind:`task`,request:{callId:e.toolCall.toolCallId,executeInput:t.executeInput?.(n),input:n,kind:`workflow-task`,resultKind:t.resultKind,toolName:e.toolCall.toolName,workflowId:t.workflowId}};throw Error(`Deferred tool "${e.toolCall.toolName}" has no task or runtime action.`)}function resolveToolCallInputObject(e,n){if(e==null||typeof e==`string`&&e.trim()===``)return{};try{return parseJsonObject(typeof e==`string`?parseJsonStringInput(e):e)}catch(e){let t=e instanceof Error?e.message:String(e);throw TypeError(`Failed to parse tool-call arguments for "${n.toolName}" (${n.callId}): ${t}`,{cause:e})}}function parseJsonStringInput(e){return JSON.parse(e)}async function projectToolResultOutput(e,t){return e.isError===!0||t?.toModelOutput===void 0?toToolResultOutput(e):normalizeToolModelOutput({output:await t.toModelOutput(e.output),toolCallId:e.callId,toolName:e.toolName})}function toToolResultOutput(e){return typeof e.output==`string`?e.isError===!0?{type:`error-text`,value:e.output}:{type:`text`,value:e.output}:e.isError===!0?{type:`error-json`,value:toMutableJsonValue(e.output)}:{type:`json`,value:toMutableJsonValue(e.output)}}function toMutableJsonValue(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(e=>toMutableJsonValue(e));let t={};for(let[n,r]of Object.entries(e))t[n]=toMutableJsonValue(r);return t}export{assertUniqueCoordinationCallIds,clearPendingCoordinationBatch,createCoordinationRequestFromToolCall,createRuntimeActionRequestFromToolCall,getPendingCoordinationBatch,hasPendingCoordinationBatch,resolvePendingCoordination,resolveToolCallInputObject,setPendingCoordinationBatch};

package/dist/src/harness/emission.d.ts

@@ -53,7 +53,7 @@ export declare function advanceStep(state: HarnessEmissionState): HarnessEmissio
  * Emits `turn.completed` and either `session.waiting` or `session.completed`.
  * Returns updated emission state with an incremented sequence.
  */
-export declare function emitTurnEpilogue(emitFn: HarnessEmitFn, state: HarnessEmissionState, mode: RunMode, messages?: readonly import("ai").ModelMessage[]): Promise<HarnessEmissionState>;
+export declare function emitTurnEpilogue(emitFn: HarnessEmitFn, state: HarnessEmissionState, mode: RunMode): Promise<HarnessEmissionState>;
 /**
  * Maps an AI SDK finish reason string to the eve-owned
  * {@link AssistantStepFinishReason} union. Unknown values become `"other"`.
@@ -76,5 +76,12 @@ interface StreamActionEmissionOptions {
     readonly excludedActionToolNames: ReadonlySet<string>;
     readonly tools: HarnessToolMap;
 }
-/** Consumes `fullStream` in source order, batching provider calls before their first result. */
+/**
+ * Consumes the AI SDK `fullStream` and emits real-time text and reasoning
+ * events.
+ *
+ * Emits local tool events in source order. Provider calls that arrive in one
+ * stream batch into one request event before their first result. A result
+ * without a streamed call resumes a call from an earlier step.
+ */
 export declare function emitStreamContent(emitFn: HarnessEmitFn, state: HarnessEmissionState, fullStream: AsyncIterable<TextStreamPart<ToolSet>>, options?: StreamActionEmissionOptions): Promise<EmittedStreamContent>;

package/dist/src/harness/emission.js

@@ -1 +1 @@
-import{createActionInputAppendedEvent,createActionPartialEvent,createActionResultEvent,createActionsRequestedEvent,createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent,createSessionCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent}from"#protocol/message.js";import{createRuntimeActionRequestFromToolCall}from"#harness/runtime-actions.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{hasEmptyDeliverySentinel}from"#shared/empty-delivery.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.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{getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission-state.js";async function emitTurnPreamble(e,t,n,r,i){let a=`turn_${n.sequence}`;return n.sessionStarted||await e(createSessionStartedEvent({runtime:r,trace:i})),await e(createTurnStartedEvent({sequence:n.sequence,trace:i,turnId:a})),t.message!==void 0&&await e(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:a})),{sessionStarted:!0,sequence:n.sequence,stepIndex:0,turnId:a}}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()),{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}),r),n===`conversation`?await e(createSessionWaitingEvent()):await e(createSessionCompletedEvent()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function normalizeAssistantStepFinishReason(e){switch(e){case`content-filter`:case`error`:case`length`:case`stop`:case`tool-calls`:return e;default:return`other`}}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()}}}async function consumeStreamContent(o,s,c,l,u){let d=``,f=``,p=`stop`,m,h=new Set,g=new Set,_=new Set,v=new Set,y=new Set,b=new Set,x=[],S=[],C=new Map,flushCurrentMessage=async()=>{f.length!==0&&(await o(createMessageCompletedEvent({finishReason:`tool-calls`,message:f,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),f=``)},emitActionInput=async(t,n,r)=>o(createActionInputAppendedEvent({callId:t,inputTextDelta:r,sequence:s.sequence,stepIndex:s.stepIndex,toolName:n,turnId:s.turnId})),emitActionRequest=async e=>{g.has(e.callId)||(f.trim().length>0&&await flushCurrentMessage(),g.add(e.callId),await o(createActionsRequestedEvent({actions:[e],sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})))},collectProviderToolCall=async e=>{if(v.has(e.toolCallId)||(v.add(e.toolCallId),g.has(e.toolCallId)))return;g.add(e.toolCallId),f.trim().length>0&&await flushCurrentMessage();let t=resolveProviderToolCallRequest(e);if(t.toolError!==void 0){b.add(e.toolCallId),await emitActionResult(createRuntimeToolResultFromToolError(t.toolError)),y.add(e.toolCallId),S.push(createToolResultMessagePartFromToolError(t.toolError));return}l.observe(t.request)},emitActionResult=async e=>{_.has(e.callId)||(_.add(e.callId),await o(createActionResultEvent({result:e,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})))},emitActionPartial=async e=>{await o(createActionPartialEvent({result:e,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}))},emitToolCall=async e=>{if(isInvalidToolCall(e)){b.add(e.toolCallId);return}if(!(u===void 0||u.excludedActionToolNames.has(e.toolName)))try{await emitActionRequest(createRuntimeActionRequestFromToolCall({toolCall:e,tools:u.tools}))}catch(t){if(t instanceof TypeError){let n=createInvalidToolCallInputError({error:t,toolCall:e});b.add(e.toolCallId),f.trim().length>0&&await flushCurrentMessage(),await emitActionResult(createRuntimeToolResultFromToolError(n)),y.add(e.toolCallId),S.push(createToolResultMessagePartFromToolError(n));return}throw t}};for await(let e of c)if(m===void 0)switch(e.type){case`reasoning-delta`:await l.flush(),d+=e.text,await o(createReasoningAppendedEvent({reasoningDelta:e.text,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}));break;case`text-delta`:await l.flush(),d.trim().length>0&&(await o(createReasoningCompletedEvent({reasoning:d,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),d=``),f+=e.text,await o(createMessageAppendedEvent({messageDelta:e.text,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}));break;case`tool-input-start`:if(u===void 0||e.providerExecuted===!0||u.excludedActionToolNames.has(e.toolName)){C.delete(e.id);break}await l.flush(),f.trim().length>0&&await flushCurrentMessage(),C.set(e.id,{toolName:e.toolName});break;case`tool-input-delta`:{let t=C.get(e.id);if(t===void 0)break;await l.flush(),await emitActionInput(e.id,t.toolName,e.delta);break}case`tool-input-end`:C.delete(e.id);break;case`tool-call`:{let t=e;C.delete(t.toolCallId),h.add(t.toolCallId),t.providerExecuted===!0?await collectProviderToolCall(t):(await l.flush(),await emitToolCall(t));break}case`tool-result`:{let t=e;if(t.preliminary===!0){t.providerExecuted!==!0&&await emitActionPartial(createRuntimeToolResultFromStepResult(t));break}if(t.providerExecuted===!0){await collectProviderToolCall({input:`input`in t?t.input:void 0,toolCallId:t.toolCallId,toolName:t.toolName}),await l.flush(),await emitActionResult(createRuntimeToolResultFromStepResult(t));break}if(h.has(e.toolCallId)){if(isInlineAuthorizationToolResult(t))break;g.has(e.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromStepResult(t)),y.add(e.toolCallId));break}if(await l.flush(),await flushCurrentMessage(),isInlineAuthorizationToolResult(t)){y.add(e.toolCallId),x.push(t);break}await emitActionResult(createRuntimeToolResultFromStepResult(t)),y.add(e.toolCallId);break}case`tool-error`:{let t=e;t.providerExecuted===!0?(await collectProviderToolCall(t),await l.flush(),await emitActionResult(createRuntimeToolResultFromToolError(t))):g.has(t.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromToolError(t)),y.add(t.toolCallId),S.push(createToolResultMessagePartFromToolError(t)));break}case`finish-step`:p=normalizeAssistantStepFinishReason(e.finishReason),await l.flush();break;case`error`:m=normalizeModelStreamError(e.error);break;case`abort`:throw new DOMException(e.reason??`The model stream was aborted.`,`AbortError`);default:break}if(await l.flush(),m!==void 0)throw m;return d.trim().length>0&&await o(createReasoningCompletedEvent({reasoning:d,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),p!==`tool-calls`&&hasEmptyDeliverySentinel(f)?await o(createMessageCompletedEvent({finishReason:p,message:null,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})):f.trim().length>0&&await o(createMessageCompletedEvent({finishReason:p,message:f,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),{emittedActionCallIds:g,handledInlineToolResultCallIds:y,invalidInputToolCallIds:b,inlineAuthorizationResults:x,trailingInlineToolResultParts:S}}export{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,normalizeAssistantStepFinishReason,setHarnessEmissionState};
+import{createActionInputAppendedEvent,createActionPartialEvent,createActionResultEvent,createActionsRequestedEvent,createMessageAppendedEvent,createMessageCompletedEvent,createMessageReceivedEvent,createReasoningAppendedEvent,createReasoningCompletedEvent,createSessionCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent}from"#protocol/message.js";import{createRuntimeActionRequestFromToolCall}from"#harness/coordination.js";import{createRuntimeToolResultFromStepResult,createRuntimeToolResultFromToolError,createToolResultMessagePartFromToolError}from"#harness/action-result-helpers.js";import{hasEmptyDeliverySentinel}from"#shared/empty-delivery.js";import{createInvalidToolCallInputError,isInvalidToolCall,resolveProviderToolCallRequest}from"#harness/tool-call-input-errors.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{getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission-state.js";async function emitTurnPreamble(e,t,n,r,i){let a=`turn_${n.sequence}`;return n.sessionStarted||await e(createSessionStartedEvent({runtime:r,trace:i})),await e(createTurnStartedEvent({sequence:n.sequence,trace:i,turnId:a})),t.message!==void 0&&await e(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:a})),{sessionStarted:!0,sequence:n.sequence,stepIndex:0,turnId:a}}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()),{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){return await e(createTurnCompletedEvent({sequence:t.sequence,turnId:t.turnId})),n===`conversation`?await e(createSessionWaitingEvent()):await e(createSessionCompletedEvent()),{sessionStarted:t.sessionStarted,sequence:t.sequence+1,stepIndex:0,turnId:``}}function normalizeAssistantStepFinishReason(e){switch(e){case`content-filter`:case`error`:case`length`:case`stop`:case`tool-calls`:return e;default:return`other`}}function readSubagentBackgroundTaskReceipt(e,t){if(e.isError===!0||t?.get(e.toolName)?.resultKind!==`subagent`||typeof e.output!=`object`||e.output===null||Array.isArray(e.output))return;let n=Reflect.get(e.output,`status`),r=Reflect.get(e.output,`taskId`);return n===`working`&&typeof r==`string`?{status:n,taskId:r}:void 0}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()}}}async function consumeStreamContent(o,s,c,l,u){let d=``,f=``,p=`stop`,m,h=new Set,g=new Set,_=new Set,v=new Set,y=new Set,b=new Set,x=[],S=[],C=new Map,flushCurrentMessage=async()=>{f.length!==0&&(await o(createMessageCompletedEvent({finishReason:`tool-calls`,message:f,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),f=``)},emitActionInput=async(t,n,r)=>o(createActionInputAppendedEvent({callId:t,inputTextDelta:r,sequence:s.sequence,stepIndex:s.stepIndex,toolName:n,turnId:s.turnId})),emitActionRequest=async e=>{g.has(e.callId)||(f.trim().length>0&&await flushCurrentMessage(),g.add(e.callId),await o(createActionsRequestedEvent({actions:[e],sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})))},collectProviderToolCall=async e=>{if(v.has(e.toolCallId)||(v.add(e.toolCallId),g.has(e.toolCallId)))return;g.add(e.toolCallId),f.trim().length>0&&await flushCurrentMessage();let t=resolveProviderToolCallRequest(e);if(t.toolError!==void 0){b.add(e.toolCallId),await emitActionResult(createRuntimeToolResultFromToolError(t.toolError)),y.add(e.toolCallId),S.push(createToolResultMessagePartFromToolError(t.toolError));return}l.observe(t.request)},emitActionResult=async e=>{if(_.has(e.callId))return;_.add(e.callId);let t=readSubagentBackgroundTaskReceipt(e,u?.tools);t!==void 0&&await o({data:{backgroundTask:t,callId:e.callId,output:typeof e.output==`string`?e.output:JSON.stringify(e.output),subagentName:e.toolName},type:`subagent.completed`}),await o(createActionResultEvent({result:e,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}))},emitActionPartial=async e=>{await o(createActionPartialEvent({result:e,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}))},emitToolCall=async e=>{if(isInvalidToolCall(e)){b.add(e.toolCallId);return}if(!(u===void 0||u.excludedActionToolNames.has(e.toolName)))try{await emitActionRequest(createRuntimeActionRequestFromToolCall({toolCall:e,tools:u.tools}))}catch(t){if(t instanceof TypeError){let n=createInvalidToolCallInputError({error:t,toolCall:e});b.add(e.toolCallId),f.trim().length>0&&await flushCurrentMessage(),await emitActionResult(createRuntimeToolResultFromToolError(n)),y.add(e.toolCallId),S.push(createToolResultMessagePartFromToolError(n));return}throw t}};for await(let e of c)if(m===void 0)switch(e.type){case`reasoning-delta`:await l.flush(),d+=e.text,await o(createReasoningAppendedEvent({reasoningDelta:e.text,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}));break;case`text-delta`:await l.flush(),d.trim().length>0&&(await o(createReasoningCompletedEvent({reasoning:d,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),d=``),f+=e.text,await o(createMessageAppendedEvent({messageDelta:e.text,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId}));break;case`tool-input-start`:if(u===void 0||e.providerExecuted===!0||u.excludedActionToolNames.has(e.toolName)){C.delete(e.id);break}await l.flush(),f.trim().length>0&&await flushCurrentMessage(),C.set(e.id,{toolName:e.toolName});break;case`tool-input-delta`:{let t=C.get(e.id);if(t===void 0)break;await l.flush(),await emitActionInput(e.id,t.toolName,e.delta);break}case`tool-input-end`:C.delete(e.id);break;case`tool-call`:{let t=e;C.delete(t.toolCallId),h.add(t.toolCallId),t.providerExecuted===!0?await collectProviderToolCall(t):(await l.flush(),await emitToolCall(t));break}case`tool-result`:{let t=e;if(t.preliminary===!0){t.providerExecuted!==!0&&await emitActionPartial(createRuntimeToolResultFromStepResult(t));break}if(t.providerExecuted===!0){await collectProviderToolCall({input:`input`in t?t.input:void 0,toolCallId:t.toolCallId,toolName:t.toolName}),await l.flush(),await emitActionResult(createRuntimeToolResultFromStepResult(t));break}if(h.has(e.toolCallId)){if(isInlineAuthorizationToolResult(t))break;g.has(e.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromStepResult(t)),y.add(e.toolCallId));break}if(await l.flush(),await flushCurrentMessage(),isInlineAuthorizationToolResult(t)){y.add(e.toolCallId),x.push(t);break}await emitActionResult(createRuntimeToolResultFromStepResult(t)),y.add(e.toolCallId);break}case`tool-error`:{let t=e;t.providerExecuted===!0?(await collectProviderToolCall(t),await l.flush(),await emitActionResult(createRuntimeToolResultFromToolError(t))):g.has(t.toolCallId)&&(await emitActionResult(createRuntimeToolResultFromToolError(t)),y.add(t.toolCallId),S.push(createToolResultMessagePartFromToolError(t)));break}case`finish-step`:p=normalizeAssistantStepFinishReason(e.finishReason),await l.flush();break;case`error`:m=normalizeModelStreamError(e.error);break;case`abort`:throw new DOMException(e.reason??`The model stream was aborted.`,`AbortError`);default:break}if(await l.flush(),m!==void 0)throw m;return d.trim().length>0&&await o(createReasoningCompletedEvent({reasoning:d,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),p!==`tool-calls`&&hasEmptyDeliverySentinel(f)?await o(createMessageCompletedEvent({finishReason:p,message:null,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})):f.trim().length>0&&await o(createMessageCompletedEvent({finishReason:p,message:f,sequence:s.sequence,stepIndex:s.stepIndex,turnId:s.turnId})),{emittedActionCallIds:g,handledInlineToolResultCallIds:y,invalidInputToolCallIds:b,inlineAuthorizationResults:x,trailingInlineToolResultParts:S}}export{advanceStep,emitFailedStep,emitRecoverableFailedTurn,emitStepStarted,emitStreamContent,emitTurnEpilogue,emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,normalizeAssistantStepFinishReason,setHarnessEmissionState};

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

@@ -2,7 +2,19 @@ import type { FlexibleSchema } from "ai";
 import type { Approval } from "#approval/definition.js";
 import type { ToolExecuteOptions } from "#tools/definition.js";
 import type { TaskExec } from "#tools/task.js";
+import type { JsonValue } from "#shared/json.js";
 import type { PreparedToolBehavior } from "#tools/behavior.js";
+/**
+ * Runtime-owned action metadata attached to one harness-visible tool.
+ *
+ * `task-control` marks the parent-side background task tools
+ * (`task_cancel`, `task_update`): they carry no child
+ * address of their own — the dispatch step resolves targets through the
+ * session task index by tool name.
+ */
+export type HarnessRuntimeActionDefinition = {
+    readonly kind: "task-control";
+};
 /**
  * Unified harness-owned tool definition.
  */
@@ -11,10 +23,50 @@ export interface HarnessToolDefinition {
     readonly behavior?: PreparedToolBehavior;
     readonly description: string;
     readonly execute?: (input: any, options: ToolExecuteOptions, task?: TaskExec) => any;
+    /** Optional JSON input substituted when this tool starts its workflow body. */
+    readonly executeInput?: (input: unknown) => JsonValue;
     readonly execution?: "background";
+    readonly frameworkAction?: "load-skill";
     readonly inputSchema: FlexibleSchema;
     readonly name: string;
+    /** Runtime graph node for a framework subagent workflow body. */
+    readonly nodeId?: string;
     readonly approval?: Approval;
     readonly outputSchema?: FlexibleSchema;
+    /**
+     * How the result of this workflow-backed tool is settled: as a
+     * `subagent-result` (delegation tools — `behavior.handling.target.kind` is
+     * `subagent-call`, `remote-agent-call`, or `self-agent-call`) or as an
+     * ordinary `tool-result` (authored workflow tools). Absent means `"tool"`.
+     *
+     * On the definition itself this duplicates the dispatch target kind; it
+     * exists because the value must survive past the tool map. `buildToolSet`,
+     * `createCoordinationRequestFromToolCall`, and the workflow sandbox host
+     * tool copy it into the `RuntimeWorkflowTaskRequest`, which `startWorkflowTask`
+     * persists on the `WorkflowToolRunRecord` in session state and the run echoes
+     * back on every `WorkflowToolRunRef` inbox message. The owner turn then routes
+     * outcomes, counts the workflow subagent budget, and decides whether child
+     * usage accrues without access to a `HarnessToolMap`. Harness-side readers
+     * (`advertised-tools`, `emission`, the background tool executor) use it to
+     * expose only delegation tools inside workflow sandboxes, emit task receipts,
+     * and reserve/claim agent handles for subagent starts.
+     *
+     * The persisted copy is dropped by `removeWorkflowToolRun` when the run
+     * settles, or `clearWorkflowToolRuns` at turn end.
+     *
+     * TODO: once subagent starts no longer need harness-specific handling,
+     * derive this from `behavior.handling.target.kind` at the projection points
+     * above and remove the field.
+     */
+    readonly resultKind?: "subagent" | "tool";
+    /**
+     * Advertise this tool only to the root session, hiding it from subagent
+     * sessions. Set on the injected `agent` self-delegation tool so children
+     * cannot delegate recursively. Absent means visible everywhere.
+     */
+    readonly rootOnly?: boolean;
+    readonly runtimeAction?: HarnessRuntimeActionDefinition;
     readonly toModelOutput?: (output: unknown) => unknown;
+    /** Present when this tool starts an associated durable workflow. */
+    readonly workflowId?: string;
 }

package/dist/src/harness/hitl/session-limit-input-requests.js

@@ -1 +1 @@
-import{isSessionLimitContinuationRequest,resolveSessionLimitContinuation}from"#harness/session-limit-continuation.js";import{getPendingInputBatches,queueDeferredStepInput,removePendingInputBatches}from"#harness/pending-input-batches.js";import{buildResolvedInputBatch}from"#harness/input-request-resolution.js";import{appendResolvedBatchTranscript,compactStepInput,finishResolvedInput,responsesForBatches}from"#harness/hitl/pending-input-resolution.js";function isSessionLimitInputBatch(e){let t=e.requests.some(e=>e.kind===`session-limit`);if(t&&e.requests.some(e=>e.kind!==`session-limit`))throw TypeError(`Session-limit pending input batches must contain only session-limit requests.`);return t}function resolveSessionLimitInput(n){let i=new Set(n.responses.map(e=>e.requestId));if(!(n.pendingBatch.requests.some(e=>i.has(e.requestId))&&n.pendingBatch.requests.every(e=>i.has(e.requestId))))return{deferredMessage:!0,outcome:`unresolved`,messages:[...n.baseHistory],session:queueDeferredStepInput(n.session,compactStepInput(n.resolvedStepInput))};let a=n.batches.filter(e=>e!==n.pendingBatch),o=responsesForBatches(n.responses,a),s=a.some(t=>t.requests.some(t=>isSessionLimitContinuationRequest(t))),c=[...n.baseHistory];appendResolvedBatchTranscript(c,n.pendingBatch,[]);let l=removePendingInputBatches(n.session,[n.pendingBatch]),u=resolveSessionLimitContinuation({requests:n.pendingBatch.requests,responses:n.responses});return finishResolvedInput({deferTurnInput:n.deferTurnInput||s,leftoverResponses:o,limitContinuation:u,messages:c,resolvedInputs:[buildResolvedInputBatch(n.pendingBatch,n.responses)].filter(e=>e!==void 0),resolvedStepInput:n.resolvedStepInput,session:l})}function clearPendingSessionLimitPrompt(t){let r=getPendingInputBatches(t.state).filter(t=>t.requests.length>0&&t.requests.every(t=>isSessionLimitContinuationRequest(t)));return r.length===0?t:removePendingInputBatches(t,r)}export{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput};
+import{getPendingInputBatches,queueDeferredStepInput,removePendingInputBatches}from"#harness/pending-input-batches.js";import{buildResolvedInputBatch}from"#harness/input-request-resolution.js";import{appendResolvedBatchTranscript,compactStepInput,finishResolvedInput,responsesForBatches}from"#harness/hitl/pending-input-resolution.js";import{isSessionLimitContinuationRequest,resolveSessionLimitContinuation}from"#harness/session-limit-continuation.js";function isSessionLimitInputBatch(e){let t=e.requests.some(e=>e.kind===`session-limit`);if(t&&e.requests.some(e=>e.kind!==`session-limit`))throw TypeError(`Session-limit pending input batches must contain only session-limit requests.`);return t}function resolveSessionLimitInput(e){let r=new Set(e.responses.map(e=>e.requestId));if(!(e.pendingBatch.requests.some(e=>r.has(e.requestId))&&e.pendingBatch.requests.every(e=>r.has(e.requestId))))return{deferredMessage:!0,outcome:`unresolved`,messages:[...e.baseHistory],session:queueDeferredStepInput(e.session,compactStepInput(e.resolvedStepInput))};let i=e.batches.filter(t=>t!==e.pendingBatch),a=responsesForBatches(e.responses,i),o=i.some(e=>e.requests.some(e=>isSessionLimitContinuationRequest(e))),s=[...e.baseHistory];appendResolvedBatchTranscript(s,e.pendingBatch,[]);let c=removePendingInputBatches(e.session,[e.pendingBatch]),l=resolveSessionLimitContinuation({requests:e.pendingBatch.requests,responses:e.responses});return finishResolvedInput({deferTurnInput:e.deferTurnInput||o,leftoverResponses:a,limitContinuation:l,messages:s,resolvedInputs:[buildResolvedInputBatch(e.pendingBatch,e.responses)].filter(e=>e!==void 0),resolvedStepInput:e.resolvedStepInput,session:c})}function clearPendingSessionLimitPrompt(t){let n=getPendingInputBatches(t.state).filter(e=>e.requests.length>0&&e.requests.every(e=>isSessionLimitContinuationRequest(e)));return n.length===0?t:removePendingInputBatches(t,n)}export{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput};

package/dist/src/harness/input-requests.js

@@ -1 +1 @@
-import{readClientContext}from"#internal/client-context.js";import{resolveTextToResponses}from"#channel/resolve-text.js";import{resolveToolCallInputObject}from"#harness/runtime-actions.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{appendPendingInputBatch,consumeDeferredStepInput,getPendingInputBatches,getPendingInputRequestIds,hasDeferredStepInput,hasPendingInputBatch,queueDeferredStepInput}from"#harness/pending-input-batches.js";import{compactStepInput}from"#harness/hitl/pending-input-resolution.js";import{resolveQuestionOnlyInputBatches}from"#harness/hitl/question-input-requests.js";import{hasTailApprovalResponse}from"#harness/current-messages.js";import{getApprovedTools,hasAnsweredApprovalBatch,resolveApprovalInputBatches}from"#harness/hitl/approval-input-requests.js";import{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput}from"#harness/hitl/session-limit-input-requests.js";function hasStepInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}function hasPendingApprovalBatch(e){return getPendingInputBatches(e.state).some(e=>e.requests.some(e=>isApprovalRequest(e)))}function resolvePendingInput(t){let n=[...t.history??t.session.history],r=getPendingInputBatches(t.session.state);if(r.length===0)return{outcome:`continue`,messages:n,session:t.session};let i=routePendingInput(r),a=hasTailApprovalResponse(n),s=i.kind===`session-limit`?i.batch:r.length===1?r[0]:void 0,c=s===void 0?t.stepInput:resolveTextMessageInput(s,t.stepInput),l=canonicalizeInputResponses(c?.inputResponses??[]);if(i.kind===`approval`&&t.deferMessagesWhileApprovalsPending===!0&&c?.message!==void 0&&!hasAnsweredApprovalBatch(i.approvalBatches,l))return{deferredMessage:!0,outcome:`unresolved`,messages:n,session:queueDeferredStepInput(t.session,compactStepInput(c))};if(l.length===0&&c?.message===void 0){let r=compactStepInput(c);return{outcome:`unresolved`,messages:n,session:r.context!==void 0||readClientContext(r)!==void 0||r.outputSchema!==void 0?queueDeferredStepInput(t.session,r):t.session}}let u={baseHistory:n,batches:r,deferTurnInput:a,resolvedStepInput:c,responses:l,session:t.session};switch(i.kind){case`session-limit`:return resolveSessionLimitInput({...u,pendingBatch:i.batch});case`approval`:return resolveApprovalInputBatches({...u,approvalBatches:i.approvalBatches,questionBatches:i.questionBatches,resolveApprovalKey:t.resolveApprovalKey});case`question`:return resolveQuestionOnlyInputBatches(u)}}function routePendingInput(e){let t=e.map(e=>({batch:e,domain:classifyPendingInputBatch(e)})),n=t.find(({domain:e})=>e===`session-limit`)?.batch;if(n!==void 0)return{batch:n,kind:`session-limit`};let r=t.filter(({domain:e})=>e===`approval`).map(({batch:e})=>e);if(r.length>0){let t=new Set(r);return{approvalBatches:r,kind:`approval`,questionBatches:e.filter(e=>!t.has(e))}}return{kind:`question`}}function classifyPendingInputBatch(e){for(let t of e.requests)switch(t.kind){case`question`:case`session-limit`:case`tool-approval`:break;default:{let e=t.kind;throw TypeError(`Unhandled pending input request kind: ${String(e)}`)}}return isSessionLimitInputBatch(e)?`session-limit`:e.requests.some(e=>isApprovalRequest(e))?`approval`:`question`}function canonicalizeInputResponses(e){let t=new Map;for(let n of e)t.set(n.requestId,n);return[...t.values()]}function resolveTextMessageInput(e,n){if(typeof n?.message!=`string`)return n;let r=new Set(e.requests.map(e=>e.requestId));if(n.inputResponses?.some(e=>r.has(e.requestId)))return n;let i=new Set(e.responseAuthRequiredRequestIds??[]),a=e.requests.filter(e=>!i.has(e.requestId)),o=resolveTextToResponses(n.message,a);return o.length===0?n:compactStepInput({...n,inputResponses:[...n.inputResponses??[],...o],messageConsumed:!0,message:void 0})}function createRuntimeToolCallActionFromToolCall(e){return{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName}),kind:`tool-call`,toolName:e.toolCall.toolName}}export{appendPendingInputBatch,clearPendingSessionLimitPrompt,consumeDeferredStepInput,createRuntimeToolCallActionFromToolCall,getApprovedTools,getPendingInputRequestIds,hasDeferredStepInput,hasPendingApprovalBatch,hasPendingInputBatch,hasStepInput,resolvePendingInput};
+import{readClientContext}from"#internal/client-context.js";import{resolveTextToResponses}from"#channel/resolve-text.js";import{resolveToolCallInputObject}from"#harness/coordination.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{appendPendingInputBatch,consumeDeferredStepInput,getPendingInputBatches,getPendingInputRequestIds,hasDeferredStepInput,hasPendingInputBatch,queueDeferredStepInput}from"#harness/pending-input-batches.js";import{compactStepInput}from"#harness/hitl/pending-input-resolution.js";import{resolveQuestionOnlyInputBatches}from"#harness/hitl/question-input-requests.js";import{hasTailApprovalResponse}from"#harness/current-messages.js";import{getApprovedTools,hasAnsweredApprovalBatch,resolveApprovalInputBatches}from"#harness/hitl/approval-input-requests.js";import{clearPendingSessionLimitPrompt,isSessionLimitInputBatch,resolveSessionLimitInput}from"#harness/hitl/session-limit-input-requests.js";function hasStepInput(e){return e===void 0?!1:e.message!==void 0||(e.inputResponses?.length??0)>0}function hasPendingApprovalBatch(e){return getPendingInputBatches(e.state).some(e=>e.requests.some(e=>isApprovalRequest(e)))}function resolvePendingInput(t){let n=[...t.history??t.session.history],r=getPendingInputBatches(t.session.state);if(r.length===0)return{outcome:`continue`,messages:n,session:t.session};let i=routePendingInput(r),a=hasTailApprovalResponse(n),s=i.kind===`session-limit`?i.batch:r.length===1?r[0]:void 0,c=s===void 0?t.stepInput:resolveTextMessageInput(s,t.stepInput),l=canonicalizeInputResponses(c?.inputResponses??[]);if(i.kind===`approval`&&t.deferMessagesWhileApprovalsPending===!0&&c?.message!==void 0&&!hasAnsweredApprovalBatch(i.approvalBatches,l))return{deferredMessage:!0,outcome:`unresolved`,messages:n,session:queueDeferredStepInput(t.session,compactStepInput(c))};if(l.length===0&&c?.message===void 0){let r=compactStepInput(c);return{outcome:`unresolved`,messages:n,session:r.context!==void 0||readClientContext(r)!==void 0||r.outputSchema!==void 0?queueDeferredStepInput(t.session,r):t.session}}let u={baseHistory:n,batches:r,deferTurnInput:a,resolvedStepInput:c,responses:l,session:t.session};switch(i.kind){case`session-limit`:return resolveSessionLimitInput({...u,pendingBatch:i.batch});case`approval`:return resolveApprovalInputBatches({...u,approvalBatches:i.approvalBatches,questionBatches:i.questionBatches,resolveApprovalKey:t.resolveApprovalKey});case`question`:return resolveQuestionOnlyInputBatches(u)}}function routePendingInput(e){let t=e.map(e=>({batch:e,domain:classifyPendingInputBatch(e)})),n=t.find(({domain:e})=>e===`session-limit`)?.batch;if(n!==void 0)return{batch:n,kind:`session-limit`};let r=t.filter(({domain:e})=>e===`approval`).map(({batch:e})=>e);if(r.length>0){let t=new Set(r);return{approvalBatches:r,kind:`approval`,questionBatches:e.filter(e=>!t.has(e))}}return{kind:`question`}}function classifyPendingInputBatch(e){for(let t of e.requests)switch(t.kind){case`question`:case`session-limit`:case`tool-approval`:break;default:{let e=t.kind;throw TypeError(`Unhandled pending input request kind: ${String(e)}`)}}return isSessionLimitInputBatch(e)?`session-limit`:e.requests.some(e=>isApprovalRequest(e))?`approval`:`question`}function canonicalizeInputResponses(e){let t=new Map;for(let n of e)t.set(n.requestId,n);return[...t.values()]}function resolveTextMessageInput(e,n){if(typeof n?.message!=`string`)return n;let r=new Set(e.requests.map(e=>e.requestId));if(n.inputResponses?.some(e=>r.has(e.requestId)))return n;let i=new Set(e.responseAuthRequiredRequestIds??[]),a=e.requests.filter(e=>!i.has(e.requestId)),o=resolveTextToResponses(n.message,a);return o.length===0?n:compactStepInput({...n,inputResponses:[...n.inputResponses??[],...o],messageConsumed:!0,message:void 0})}function createRuntimeToolCallActionFromToolCall(e){return{callId:e.toolCall.toolCallId,input:resolveToolCallInputObject(e.toolCall.input,{callId:e.toolCall.toolCallId,toolName:e.toolCall.toolName}),kind:`tool-call`,toolName:e.toolCall.toolName}}export{appendPendingInputBatch,clearPendingSessionLimitPrompt,consumeDeferredStepInput,createRuntimeToolCallActionFromToolCall,getApprovedTools,getPendingInputRequestIds,hasDeferredStepInput,hasPendingApprovalBatch,hasPendingInputBatch,hasStepInput,resolvePendingInput};

package/dist/src/harness/proxy-input-requests.d.ts

@@ -61,13 +61,17 @@ export declare function upsertProxyInputRequestState(input: {
  */
 export declare function clearProxyInputRequestsForChild(session: HarnessSession, childContinuationToken: string): HarnessSession;
 /** Removes every proxy route the predicate selects. */
-export declare function clearProxyInputRequestsWhere(session: HarnessSession, select: (route: ProxyInputRequest) => boolean): HarnessSession;
+export declare function clearProxyInputRequestsWhere<T extends {
+    readonly state?: SessionStateMap;
+}>(session: T, select: (route: ProxyInputRequest) => boolean): T;
 /** Removes only the request IDs whose responses were successfully forwarded. */
 export declare function retireProxyInputRequests<T extends {
     readonly state?: SessionStateMap;
 }>(session: T, requestIds: readonly string[]): T;
 /** Removes every proxy route owned by one durable task. */
-export declare function clearProxyInputRequestsForTask(session: HarnessSession, taskId: string): HarnessSession;
+export declare function clearProxyInputRequestsForTask<T extends {
+    readonly state?: SessionStateMap;
+}>(session: T, taskId: string): T;
 /**
  * Removes every proxy entry. Called when a cancelled turn orphans its
  * descendants so stale HITL responses no longer route to them.

package/dist/src/harness/session-limit-continuation.d.ts

@@ -1,14 +1,14 @@
 /**
- * Deterministic HITL continuation prompt for session token limits.
+ * Deterministic HITL continuation prompt for session usage limits.
  *
- * When a durable session reaches its configured token budget, the harness
+ * When a durable session reaches its configured token or token-cost budget, the harness
  * parks on a harness-authored input request instead of failing the session.
  * The request is derived only from the session identity and violation, so
  * identical session state always produces an identical prompt — no model call
  * is involved.
  */
 import type { InputRequest, InputResponse } from "#shared/input.js";
-import type { SessionTokenLimitViolation } from "#harness/turn-tag-state.js";
+import type { SessionUsageLimitViolation } from "#harness/turn-tag-state.js";
 /** Synthetic action tool name carried by session-limit continuation requests. */
 export declare const SESSION_LIMIT_CONTINUATION_TOOL_NAME = "session_limit_continuation";
 /** Option id that grants a fresh token budget window. */
@@ -16,12 +16,12 @@ export declare const SESSION_LIMIT_CONTINUE_OPTION_ID = "continue";
 /** Option id that declines continuation and ends the session. */
 export declare const SESSION_LIMIT_STOP_OPTION_ID = "stop";
 /**
- * Builds the deterministic continuation prompt for one session token limit
+ * Builds the deterministic continuation prompt for one session usage-limit
  * violation.
  */
 export declare function createSessionLimitContinuationRequest(input: {
     readonly sessionId: string;
-    readonly violation: SessionTokenLimitViolation;
+    readonly violation: SessionUsageLimitViolation;
 }): InputRequest;
 /**
  * Returns true when a request is a harness-authored session-limit

package/dist/src/harness/session-limit-continuation.js

@@ -1 +1 @@
-const SESSION_LIMIT_CONTINUATION_TOOL_NAME=`session_limit_continuation`,SESSION_LIMIT_CONTINUE_OPTION_ID=`continue`,SESSION_LIMIT_STOP_OPTION_ID=`stop`;function createSessionLimitContinuationRequest(r){let{sessionId:i,violation:a}=r,o=`${i}:limit:${a.kind}:${String(a.usedTokens)}`;return{action:{callId:o,input:{kind:a.kind,limit:a.limit,usedTokens:a.usedTokens},kind:`tool-call`,toolName:SESSION_LIMIT_CONTINUATION_TOOL_NAME},allowFreeform:!1,display:`confirmation`,kind:`session-limit`,options:[{description:`Grant a fresh token budget`,id:SESSION_LIMIT_CONTINUE_OPTION_ID,label:`Approve`,style:`primary`},{description:`Stop now`,id:SESSION_LIMIT_STOP_OPTION_ID,label:`Stop`,style:`danger`}],prompt:`This session has hit the ${a.kind}-token limit (${formatCompactTokenCount(a.limit)}) per session. This is a guardrail against defective long-running sessions. If session activity looks fine, just approve to keep going.`,requestId:o}}function formatCompactTokenCount(e){return e>=1e6?`${trimTrailingZero(e/1e6)}M`:e>=1e3?`${trimTrailingZero(e/1e3)}K`:String(e)}function trimTrailingZero(e){let t=e.toFixed(1);return t.endsWith(`.0`)?t.slice(0,-2):t}function isSessionLimitContinuationRequest(e){return e.kind===`session-limit`}function isSessionLimitContinuationRequestId(e){return/:limit:(?:input|output):\d+$/u.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===`continue`)return{granted:!0};if(n.optionId===`stop`)return{granted:!1}}}export{SESSION_LIMIT_CONTINUATION_TOOL_NAME,SESSION_LIMIT_CONTINUE_OPTION_ID,SESSION_LIMIT_STOP_OPTION_ID,createSessionLimitContinuationRequest,isSessionLimitContinuationRequest,isSessionLimitContinuationRequestId,resolveSessionLimitContinuation};
+const SESSION_LIMIT_CONTINUATION_TOOL_NAME=`session_limit_continuation`,SESSION_LIMIT_CONTINUE_OPTION_ID=`continue`,SESSION_LIMIT_STOP_OPTION_ID=`stop`;function createSessionLimitContinuationRequest(r){let{sessionId:i,violation:a}=r,o=a.kind===`token-cost`?a.usedCostUsd:a.usedTokens,s=`${i}:limit:${a.kind}:${String(o)}`;return{action:{callId:s,input:a.kind===`token-cost`?{kind:a.kind,limitUsd:a.limitUsd,usedCostUsd:a.usedCostUsd}:{kind:a.kind,limit:a.limit,usedTokens:a.usedTokens},kind:`tool-call`,toolName:SESSION_LIMIT_CONTINUATION_TOOL_NAME},allowFreeform:!1,display:`confirmation`,kind:`session-limit`,options:[{description:a.kind===`token-cost`?`Grant a fresh model token-cost budget`:`Grant a fresh token budget`,id:SESSION_LIMIT_CONTINUE_OPTION_ID,label:`Approve`,style:`primary`},{description:`Stop now`,id:SESSION_LIMIT_STOP_OPTION_ID,label:`Stop`,style:`danger`}],prompt:formatSessionLimitPrompt(a),requestId:s}}function formatCompactTokenCount(e){return e>=1e6?`${trimTrailingZero(e/1e6)}M`:e>=1e3?`${trimTrailingZero(e/1e3)}K`:String(e)}function trimTrailingZero(e){let t=e.toFixed(1);return t.endsWith(`.0`)?t.slice(0,-2):t}function formatSessionLimitPrompt(e){return`This session has hit the ${e.kind===`token-cost`?`${formatUsd(e.limitUsd)} model token-cost limit per session`:`${e.kind}-token limit (${formatCompactTokenCount(e.limit)}) per session`}. This is a guardrail against defective long-running sessions. If session activity looks fine, just approve to keep going.`}function formatUsd(e){return`$${(e<1e-6?String(e):e.toFixed(6)).replace(/0+$/u,``).replace(/\.$/u,``)}`}function isSessionLimitContinuationRequest(e){return e.kind===`session-limit`}function isSessionLimitContinuationRequestId(e){return/:limit:(?: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===`continue`)return{granted:!0};if(n.optionId===`stop`)return{granted:!1}}}export{SESSION_LIMIT_CONTINUATION_TOOL_NAME,SESSION_LIMIT_CONTINUE_OPTION_ID,SESSION_LIMIT_STOP_OPTION_ID,createSessionLimitContinuationRequest,isSessionLimitContinuationRequest,isSessionLimitContinuationRequestId,resolveSessionLimitContinuation};

package/dist/src/harness/session-limit-enforcement.d.ts

@@ -1,12 +1,12 @@
 /**
- * Session token limit policy for the tool-loop harness.
+ * Session token and token-cost limit policy for the tool-loop harness.
  *
  * Two seams into the harness step:
  *
  * 1. {@link applySessionLimitContinuation} runs after pending-input
  *    resolution and acts on the user's answer to a continuation prompt —
  *    grant a fresh budget window, or cancel the in-flight turn tree.
- * 2. {@link enforceSessionTokenLimit} runs before each model call and, when
+ * 2. {@link enforceSessionUsageLimit} runs before each model call and, when
  *    the session is over budget, parks it on the deterministic continuation
  *    prompt (sessions that can reach a human) or fails it (task-mode sessions
  *    without HITL — nobody can answer the prompt).
@@ -24,7 +24,7 @@ interface SessionLimitPolicyInput {
  * Acts on a resolved session-limit continuation answer.
  *
  * Granted: bumps the runtime token limits via
- * {@link bumpSessionRuntimeTokenLimits} and lets the step continue
+ * {@link bumpSessionRuntimeUsageLimits} and lets the step continue
  * transparently.
  * Declined: a user decision, not an error — the decline cancels the
  * in-flight turn tree through the standard cancellation path, settling as
@@ -53,7 +53,7 @@ export declare function applySessionLimitContinuation(input: SessionLimitPolicyI
  * task-mode sessions without HITL fail fast with
  * `SESSION_TOKEN_LIMIT_REACHED`.
  */
-export declare function enforceSessionTokenLimit(input: SessionLimitPolicyInput & {
+export declare function enforceSessionUsageLimit(input: SessionLimitPolicyInput & {
     readonly messages: readonly ModelMessage[];
 }): Promise<StepResult | null>;
 export {};

package/dist/src/harness/session-limit-enforcement.js

@@ -1 +1 @@
-import{createInputRequestedEvent}from"#protocol/message.js";import{emitFailedStep,emitTurnEpilogue,setHarnessEmissionState}from"#harness/emission.js";import{SessionLimitDeclinedError}from"#harness/turn-cancellation.js";import{appendPendingInputBatch}from"#harness/input-requests.js";import{bumpSessionRuntimeTokenLimits,getSessionTokenLimitViolation,getSessionTokenUsage}from"#harness/turn-tag-state.js";import{createSessionLimitContinuationRequest}from"#harness/session-limit-continuation.js";async function applySessionLimitContinuation(e){if(e.limitContinuation===void 0)return{result:null,session:e.session};if(e.limitContinuation.granted)return{result:null,session:bumpSessionRuntimeTokenLimits(e.session)};if(!(e.config.mode===`conversation`||e.session.continuationToken!==``)){let t=getSessionTokenLimitViolation(e.session);return{result:t===null?{next:{done:!0,output:``},session:e.session}:await failSessionTokenLimit({...e,violation:t}),session:e.session}}throw new SessionLimitDeclinedError}async function enforceSessionTokenLimit(e){let t=getSessionTokenLimitViolation(e.session);if(t===null)return null;let{emit:n}=e;return t.limit>0&&n!==void 0&&(e.config.mode===`conversation`||e.config.capabilities?.requestInput===!0)?parkOnSessionTokenLimit({...e,emit:n,violation:t}):failSessionTokenLimit({...e,violation:t})}async function parkOnSessionTokenLimit(t){let i=createSessionLimitContinuationRequest({sessionId:t.session.sessionId,violation:t.violation}),a=t.emissionState,o=appendPendingInputBatch({event:{sequence:a.sequence,stepIndex:a.stepIndex,turnId:a.turnId},requests:[i],responseMessages:[],session:{...t.session,history:[...t.messages]}});return await t.emit(createInputRequestedEvent({requests:[i],sequence:a.sequence,stepIndex:a.stepIndex,turnId:a.turnId})),t.config.mode===`conversation`&&(a=await emitTurnEpilogue(t.emit,a,t.config.mode)),{next:null,session:setHarnessEmissionState(o,a)}}function formatSessionTokenLimitMessage(e){return`The session reached its configured ${e} token limit.`}async function failSessionTokenLimit(e){let n=getSessionTokenUsage(e.session),r=formatSessionTokenLimitMessage(e.violation.kind),i={inputTokens:n.inputTokens,kind:e.violation.kind,limit:e.violation.limit,outputTokens:n.outputTokens,usedTokens:e.violation.usedTokens};return e.emit&&await emitFailedStep(e.emit,e.emissionState,{code:`SESSION_TOKEN_LIMIT_REACHED`,details:i,message:r,sessionId:e.session.sessionId}),{next:{done:!0,isError:e.config.mode===`task`||void 0,output:e.config.mode===`task`?r:``},session:e.session}}export{applySessionLimitContinuation,enforceSessionTokenLimit};
+import{createInputRequestedEvent}from"#protocol/message.js";import{emitFailedStep,emitTurnEpilogue,setHarnessEmissionState}from"#harness/emission.js";import{SessionLimitDeclinedError}from"#harness/turn-cancellation.js";import{appendPendingInputBatch}from"#harness/input-requests.js";import{bumpSessionRuntimeUsageLimits,getSessionTokenUsage,getSessionUsageLimitViolation}from"#harness/turn-tag-state.js";import{createSessionLimitContinuationRequest}from"#harness/session-limit-continuation.js";async function applySessionLimitContinuation(e){if(e.limitContinuation===void 0)return{result:null,session:e.session};if(e.limitContinuation.granted)return{result:null,session:bumpSessionRuntimeUsageLimits(e.session)};if(!(e.config.mode===`conversation`||e.session.continuationToken!==``)){let t=getSessionUsageLimitViolation(e.session);return{result:t===null?{next:{done:!0,output:``},session:e.session}:await failSessionUsageLimit({...e,violation:t}),session:e.session}}throw new SessionLimitDeclinedError}async function enforceSessionUsageLimit(e){let t=getSessionUsageLimitViolation(e.session);if(t===null)return null;let{emit:n}=e;return violationWindow(t)>0&&n!==void 0&&(e.config.mode===`conversation`||e.config.capabilities?.requestInput===!0)?parkOnSessionUsageLimit({...e,emit:n,violation:t}):failSessionUsageLimit({...e,violation:t})}async function parkOnSessionUsageLimit(t){let i=createSessionLimitContinuationRequest({sessionId:t.session.sessionId,violation:t.violation}),a=t.emissionState,o=appendPendingInputBatch({event:{sequence:a.sequence,stepIndex:a.stepIndex,turnId:a.turnId},requests:[i],responseMessages:[],session:{...t.session,history:[...t.messages]}});return await t.emit(createInputRequestedEvent({requests:[i],sequence:a.sequence,stepIndex:a.stepIndex,turnId:a.turnId})),t.config.mode===`conversation`&&(a=await emitTurnEpilogue(t.emit,a,t.config.mode)),{next:null,session:setHarnessEmissionState(o,a)}}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.`}async function failSessionUsageLimit(e){let n=getSessionTokenUsage(e.session),r=formatSessionLimitMessage(e.violation.kind),i=e.violation.kind===`token-cost`?{costUsd:n.costUsd,kind:e.violation.kind,limitUsd:e.violation.limitUsd,usedCostUsd:e.violation.usedCostUsd}:{inputTokens:n.inputTokens,kind:e.violation.kind,limit:e.violation.limit,outputTokens:n.outputTokens,usedTokens:e.violation.usedTokens};return e.emit&&await emitFailedStep(e.emit,e.emissionState,{code:e.violation.kind===`token-cost`?`SESSION_TOKEN_COST_LIMIT_REACHED`:`SESSION_TOKEN_LIMIT_REACHED`,details:i,message:r,sessionId:e.session.sessionId}),{next:{done:!0,isError:e.config.mode===`task`||void 0,output:e.config.mode===`task`?r:``},session:e.session}}export{applySessionLimitContinuation,enforceSessionUsageLimit};

package/dist/src/harness/session-usage-limits.d.ts

@@ -0,0 +1,48 @@
+export interface SessionUsageAmounts {
+    readonly costUsd?: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+export interface SessionRuntimeUsageLimits {
+    readonly costUsd?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+}
+export type SessionUsageLimitViolation = {
+    readonly kind: "input";
+    readonly limit: number;
+    readonly usedTokens: number;
+} | {
+    readonly kind: "output";
+    readonly limit: number;
+    readonly usedTokens: number;
+} | {
+    readonly kind: "token-cost";
+    readonly limitUsd: number;
+    readonly usedCostUsd: number;
+};
+/** Resolves per-axis lifetime ceilings, preferring a previously granted ceiling. */
+export declare function resolveRuntimeUsageLimits(input: {
+    readonly configured: SessionRuntimeUsageLimits;
+    readonly stored?: SessionRuntimeUsageLimits;
+}): SessionRuntimeUsageLimits;
+/** Grants one full configured window from the current lifetime usage. */
+export declare function grantRuntimeUsageLimits(input: {
+    readonly configured: SessionRuntimeUsageLimits;
+    readonly usage: SessionUsageAmounts;
+}): SessionRuntimeUsageLimits;
+/** Returns the unspent quota for each capped axis. */
+export declare function remainingRuntimeUsageQuota(input: {
+    readonly runtime: SessionRuntimeUsageLimits;
+    readonly usage: SessionUsageAmounts;
+}): {
+    readonly costUsd: number | false;
+    readonly inputTokens: number | false;
+    readonly outputTokens: number | false;
+};
+/** Returns the first exhausted axis: input tokens, output tokens, then token cost. */
+export declare function findRuntimeUsageLimitViolation(input: {
+    readonly configured: SessionRuntimeUsageLimits;
+    readonly runtime: SessionRuntimeUsageLimits;
+    readonly usage: SessionUsageAmounts;
+}): SessionUsageLimitViolation | null;

package/dist/src/harness/session-usage-limits.js

@@ -0,0 +1 @@
+function resolveRuntimeUsageLimits(e){let t={},n=e.stored?.inputTokens??e.configured.inputTokens;n!==void 0&&(t.inputTokens=n);let r=e.stored?.outputTokens??e.configured.outputTokens;r!==void 0&&(t.outputTokens=r);let i=e.stored?.costUsd??e.configured.costUsd;return i!==void 0&&(t.costUsd=i),t}function grantRuntimeUsageLimits(e){let t={};return e.configured.inputTokens!==void 0&&(t.inputTokens=e.usage.inputTokens+e.configured.inputTokens),e.configured.outputTokens!==void 0&&(t.outputTokens=e.usage.outputTokens+e.configured.outputTokens),e.configured.costUsd!==void 0&&(t.costUsd=(e.usage.costUsd??0)+e.configured.costUsd),t}function remainingRuntimeUsageQuota(e){return{costUsd:e.runtime.costUsd!==void 0&&Math.max(0,e.runtime.costUsd-(e.usage.costUsd??0)),inputTokens:e.runtime.inputTokens!==void 0&&Math.max(0,e.runtime.inputTokens-e.usage.inputTokens),outputTokens:e.runtime.outputTokens!==void 0&&Math.max(0,e.runtime.outputTokens-e.usage.outputTokens)}}function findRuntimeUsageLimitViolation(e){return e.runtime.inputTokens!==void 0&&e.configured.inputTokens!==void 0&&e.usage.inputTokens>=e.runtime.inputTokens?{kind:`input`,limit:e.configured.inputTokens,usedTokens:e.usage.inputTokens}:e.runtime.outputTokens!==void 0&&e.configured.outputTokens!==void 0&&e.usage.outputTokens>=e.runtime.outputTokens?{kind:`output`,limit:e.configured.outputTokens,usedTokens:e.usage.outputTokens}:e.runtime.costUsd!==void 0&&e.configured.costUsd!==void 0&&(e.usage.costUsd??0)>=e.runtime.costUsd?{kind:`token-cost`,limitUsd:e.configured.costUsd,usedCostUsd:e.usage.costUsd??0}:null}export{findRuntimeUsageLimitViolation,grantRuntimeUsageLimits,remainingRuntimeUsageQuota,resolveRuntimeUsageLimits};

package/dist/src/harness/stale-input-responses.js

@@ -1,3 +1,3 @@
-import{appendUserContent,normalizeUserContent}from"#harness/messages.js";import{isSessionLimitContinuationRequestId}from"#harness/session-limit-continuation.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{extractHistoricalInputRequests}from"#harness/input-extraction.js";function dropStaleSessionLimitContinuationResponses(e){if(e.stepInput===void 0)return;let t=e.stepInput.inputResponses??[],r=e.stepInput.attributedInputResponses??[],keep=t=>e.pendingRequestIds.has(t)||!isSessionLimitContinuationRequestId(t),i=t.filter(e=>keep(e.requestId)),a=r.filter(({response:e})=>keep(e.requestId));if(i.length===t.length&&a.length===r.length)return e.stepInput;let{attributedInputResponses:o,inputResponses:s,...c}=e.stepInput,l=c;return i.length>0&&(l.inputResponses=i),a.length>0&&(l.attributedInputResponses=a),l}function convertStaleResponsesToUserMessage(e){if(e.stepInput===void 0)return{kind:`unchanged`};let t=e.stepInput.inputResponses??[],n=e.stepInput.attributedInputResponses??[];if(t.length===0&&n.length===0)return{kind:`unchanged`,stepInput:e.stepInput};let r=[],a=[],o=[];for(let n of t)(e.pendingRequestIds.has(n.requestId)?r:o).push(n);for(let t of n)e.pendingRequestIds.has(t.response.requestId)?a.push(t):o.push(t.response);if(o.length===0)return{kind:`unchanged`,stepInput:e.stepInput};let s=extractHistoricalInputRequests({history:e.history,requestIds:new Set(o.map(e=>e.requestId)),tools:e.tools}),c=appendOptionalUserContent(e.stepInput.message,formatModelMessage(o,s)),l=appendOptionalUserContent(e.stepInput.message,formatDisplayMessage(o,s)),{attributedInputResponses:u,inputResponses:d,...f}=e.stepInput,p={...f,message:c};return r.length>0&&(p.inputResponses=r),a.length>0&&(p.attributedInputResponses=a),{displayMessage:l,kind:`converted`,stepInput:p}}function formatModelMessage(e,t){let n=e.map(e=>{let n=t.get(e.requestId),i=n?.options?.find(t=>t.id===e.optionId),a={};if(e.optionId!==void 0&&(a.optionId=e.optionId),i!==void 0){let e={id:i.id,label:i.label};i.description!==void 0&&(e.description=i.description),a.selectedOption=e}e.text!==void 0&&(a.text=e.text);let o={requestId:e.requestId,response:a};return n!==void 0&&(o.prompt=n.prompt,o.requestType=isApprovalRequest(n)?`approval`:`question`),o});return[`The user submitted the following response to an earlier interactive prompt.`,`Treat it as new input at the current point in the conversation and decide whether it is still relevant.${e.some(e=>{let n=t.get(e.requestId);return n===void 0||isApprovalRequest(n)})?` This does not authorize an earlier action; request approval again if that action is still needed.`:``}`,JSON.stringify(n,null,2)].join(`
+import{appendUserContent,normalizeUserContent}from"#harness/messages.js";import{isApprovalRequest}from"#harness/input-request-class.js";import{isSessionLimitContinuationRequestId}from"#harness/session-limit-continuation.js";import{extractHistoricalInputRequests}from"#harness/input-extraction.js";function dropStaleSessionLimitContinuationResponses(e){if(e.stepInput===void 0)return;let t=e.stepInput.inputResponses??[],n=e.stepInput.attributedInputResponses??[],keep=t=>e.pendingRequestIds.has(t)||!isSessionLimitContinuationRequestId(t),i=t.filter(e=>keep(e.requestId)),a=n.filter(({response:e})=>keep(e.requestId));if(i.length===t.length&&a.length===n.length)return e.stepInput;let{attributedInputResponses:o,inputResponses:s,...c}=e.stepInput,l=c;return i.length>0&&(l.inputResponses=i),a.length>0&&(l.attributedInputResponses=a),l}function convertStaleResponsesToUserMessage(e){if(e.stepInput===void 0)return{kind:`unchanged`};let t=e.stepInput.inputResponses??[],n=e.stepInput.attributedInputResponses??[];if(t.length===0&&n.length===0)return{kind:`unchanged`,stepInput:e.stepInput};let r=[],a=[],o=[];for(let n of t)(e.pendingRequestIds.has(n.requestId)?r:o).push(n);for(let t of n)e.pendingRequestIds.has(t.response.requestId)?a.push(t):o.push(t.response);if(o.length===0)return{kind:`unchanged`,stepInput:e.stepInput};let s=extractHistoricalInputRequests({history:e.history,requestIds:new Set(o.map(e=>e.requestId)),tools:e.tools}),c=appendOptionalUserContent(e.stepInput.message,formatModelMessage(o,s)),l=appendOptionalUserContent(e.stepInput.message,formatDisplayMessage(o,s)),{attributedInputResponses:u,inputResponses:d,...f}=e.stepInput,p={...f,message:c};return r.length>0&&(p.inputResponses=r),a.length>0&&(p.attributedInputResponses=a),{displayMessage:l,kind:`converted`,stepInput:p}}function formatModelMessage(e,t){let r=e.map(e=>{let r=t.get(e.requestId),i=r?.options?.find(t=>t.id===e.optionId),a={};if(e.optionId!==void 0&&(a.optionId=e.optionId),i!==void 0){let e={id:i.id,label:i.label};i.description!==void 0&&(e.description=i.description),a.selectedOption=e}e.text!==void 0&&(a.text=e.text);let o={requestId:e.requestId,response:a};return r!==void 0&&(o.prompt=r.prompt,o.requestType=isApprovalRequest(r)?`approval`:`question`),o});return[`The user submitted the following response to an earlier interactive prompt.`,`Treat it as new input at the current point in the conversation and decide whether it is still relevant.${e.some(e=>{let r=t.get(e.requestId);return r===void 0||isApprovalRequest(r)})?` This does not authorize an earlier action; request approval again if that action is still needed.`:``}`,JSON.stringify(r,null,2)].join(`
 `)}function formatDisplayMessage(e,t){return e.map(e=>e.text!==void 0&&e.text.length>0?e.text:t.get(e.requestId)?.options?.find(t=>t.id===e.optionId)?.label??e.optionId??`Response to an earlier interactive prompt`).join(`
 `)}function appendOptionalUserContent(n,r){let i=normalizeUserContent(n);return i===void 0?r:appendUserContent({appended:r,existing:i})}export{convertStaleResponsesToUserMessage,dropStaleSessionLimitContinuationResponses};

package/dist/src/harness/step-hooks.d.ts

@@ -1,5 +1,4 @@
 import type { PrepareStepFunction, StepResult, ToolSet } from "ai";
-import type { SessionAuthContext } from "#channel/types.js";
 import type { HarnessEmissionState } from "#harness/emission.js";
 import { type AnthropicCacheMarker, type PromptCachePath } from "#harness/prompt-cache.js";
 import { type HarnessEmitFn, type HarnessSession, type ToolLoopHarnessConfig } from "#harness/types.js";
@@ -16,7 +15,7 @@ export type HarnessStepResult = Pick<StepResult<ToolSet>, "content" | "finishRea
  * Input for {@link buildStepHooks}.
  */
 interface StepHooksInput {
-    readonly auth: SessionAuthContext | null;
+    readonly auth?: import("#channel/types.js").SessionAuthContext | null;
     readonly cachePath: PromptCachePath;
     readonly emit?: HarnessEmitFn;
     readonly emissionState: HarnessEmissionState;