eve 0.83.2 → 0.84.0

package/dist/src/harness/model-call/recovery.js

@@ -1 +1 @@
-import{createLogger}from"#internal/logging.js";import{resolveAssistantStepText}from"#harness/messages.js";import{EmptyModelResponseError,extractUnsupportedProviderToolTypes,isNoOutputGeneratedError}from"#harness/model-call/errors.js";import{resolveFrameworkToolFromUpstreamType}from"#harness/provider-tools.js";const log=createLogger(`harness.tool-loop`);async function recoverModelCall(e){let{error:t}=e,n={sessionId:e.sessionId,turnId:e.turnId},r={},i=extractUnsupportedProviderToolTypes(t),a=[...new Set(i.flatMap(e=>resolveFrameworkToolFromUpstreamType(e)??[]))];if(a.length>0){log.warn(`disabling unsupported provider tool(s); retrying step once`,{...n,disabled:a,upstreamTypes:i}),r={disabledProviderTools:new Set(a),extraSystemNote:buildDisabledToolNote(a)};try{return{result:await e.call({...r,suppressStepStartedEmission:!0})}}catch(e){t=e}}if(t instanceof EmptyModelResponseError){log.warn(`empty model response; reissuing the model call once`,n);try{return{result:await e.call({...r,retryReason:`empty-response`,suppressStepStartedEmission:!0,trailingUserNote:EMPTY_RESPONSE_NUDGE})}}catch(e){t=e}}return{error:t}}function buildDisabledToolNote(e){let t=e.join(`, `);return`The following ${e.length===1?`tool is`:`tools are`} not available with the current model and has been removed: ${t}. Proceed using the remaining tools or your training knowledge.`}function isEmptyModelResponse(e){return e.toolCalls.length===0&&e.toolResults.length===0&&resolveAssistantStepText(e.response.messages,e.text)===null}function rethrowNoOutputAsEmptyResponse(e){throw isNoOutputGeneratedError(e)?new EmptyModelResponseError({cause:e}):e}const EMPTY_RESPONSE_NUDGE=`Your previous reply was empty and was not delivered. Continue the current user request. Reuse completed results when they satisfy the request. If existing results are stale or insufficient, use the appropriate read tools to get fresh results. Do not repeat writes or other side effects that already completed. Do not mention this notice.`;export{isEmptyModelResponse,recoverModelCall,rethrowNoOutputAsEmptyResponse};
+import{createLogger}from"#internal/logging.js";import{resolveAssistantStepText}from"#harness/messages.js";import{EmptyModelResponseError,extractUnsupportedProviderToolTypes,isNoOutputGeneratedError}from"#harness/model-call/errors.js";import{resolveFrameworkToolFromUpstreamType}from"#harness/provider-tools.js";const log=createLogger(`harness.tool-loop`);function recoverModelCall(e,t,n){if(t.retryReason===void 0){if(t.disabledProviderTools===void 0){let t=extractUnsupportedProviderToolTypes(e),r=[...new Set(t.flatMap(e=>resolveFrameworkToolFromUpstreamType(e)??[]))];if(r.length>0)return log.warn(`disabling unsupported provider tool(s); retrying step once`,{...n,disabled:r,upstreamTypes:t}),{disabledProviderTools:new Set(r),extraSystemNote:buildDisabledToolNote(r)}}if(e instanceof EmptyModelResponseError)return log.warn(`empty model response; reissuing the model call once`,n),{...t,retryReason:`empty-response`,trailingUserNote:EMPTY_RESPONSE_NUDGE}}}function buildDisabledToolNote(e){let t=e.join(`, `);return`The following ${e.length===1?`tool is`:`tools are`} not available with the current model and has been removed: ${t}. Proceed using the remaining tools or your training knowledge.`}function isEmptyModelResponse(e){return e.toolCalls.length===0&&e.toolResults.length===0&&resolveAssistantStepText(e.response.messages,e.text)===null}function rethrowNoOutputAsEmptyResponse(e){throw isNoOutputGeneratedError(e)?new EmptyModelResponseError({cause:e}):e}const EMPTY_RESPONSE_NUDGE=`Your previous reply was empty and was not delivered. Continue the current user request. Reuse completed results when they satisfy the request. If existing results are stale or insufficient, use the appropriate read tools to get fresh results. Do not repeat writes or other side effects that already completed. Do not mention this notice.`;export{isEmptyModelResponse,recoverModelCall,rethrowNoOutputAsEmptyResponse};

package/dist/src/harness/model-call/request.d.ts

@@ -17,7 +17,6 @@ export declare function requestMessages(step: Step, input: {
     readonly projectedMessages: readonly HarnessModelMessage[];
     readonly turnMessages: readonly HarnessModelMessage[];
     readonly catalog: StepCatalog;
-    readonly hidesHeldText: boolean;
     readonly pendingApprovalsNote: string | undefined;
 }): RequestMessages;
 /** The call's system instructions: a retry's note, the agent's system prompt, then the step's. */

package/dist/src/harness/model-call/request.js

@@ -1,3 +1,3 @@
-import{DynamicSkillManifestKey,HistoryStateKey}from"#context/keys.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{dynamicSkillAnnouncements}from"#execution/skills/instructions.js";import{taskSystemMessages}from"#execution/tasks/model-step.js";import{buildDynamicInstructionMessages}from"#context/dynamic-instruction-lifecycle.js";import{catalogAnnouncements}from"#execution/catalog/listing.js";import{createCurrentMessages}from"#harness/current-messages.js";import{applySystemCacheBreakpoint}from"#harness/prompt-cache.js";function requestMessages(e,t){let{ctx:n}=e,r=createCurrentMessages(t.messages,{historyState:n?.get(HistoryStateKey),currentTurnMessages:t.turnMessages,projectedMessages:t.projectedMessages});n!==void 0&&r.addSystem(buildDynamicInstructionMessages(n)),r.addSystem(taskSystemMessages(t.catalog.offersTasks,{finalReplyOnly:t.hidesHeldText}));let i=n?.get(HistoryStateKey)?.announcements;return r.addAnnouncements({...catalogAnnouncements(t.catalog,i),...dynamicSkillAnnouncements(n?.get(DynamicSkillManifestKey),i)}),t.pendingApprovalsNote!==void 0&&r.add(t.pendingApprovalsNote,`context.state`,{cacheFriendly:!1}),r}function modelInstructions(e){let{session:t}=e,n=e.extraSystemNote?[{role:`system`,content:e.extraSystemNote}]:[];if(e.systemMessages.length===0&&n.length===0)return t.agent.system??void 0;let r=t.agent.system?[{role:`system`,content:t.agent.system}]:[],i=[...n,...r,...e.systemMessages];return mergeSystemInstructions(e.anthropicCache?applySystemCacheBreakpoint(i,e.anthropicCache):i)}function withTrailingUserNote(e,t){return t?[...e,createFrameworkUserMessage(`execution.retry`,t)]:[...e]}function mergeSystemInstructions(e){if(e.length===0)return;if(e.length===1)return{...e[0]};let t;for(let n of e)n.providerOptions!==void 0&&(t={...t,...n.providerOptions});let n={role:`system`,content:e.map(e=>e.content).join(`
+import{HistoryStateKey}from"#context/keys.js";import{memoryRecallContents}from"#reactions/kinds/memory.js";import{createFrameworkUserMessage}from"#harness/messages.js";import{dynamicSkillAnnouncements}from"#execution/skills/instructions.js";import{dynamicSkillManifest}from"#reactions/kinds/skill.js";import{taskSystemMessages}from"#execution/tasks/model-step.js";import{dynamicInstructionMessages}from"#reactions/kinds/instructions.js";import{catalogAnnouncements}from"#execution/catalog/listing.js";import{createCurrentMessages}from"#harness/current-messages.js";import{applySystemCacheBreakpoint}from"#harness/prompt-cache.js";function requestMessages(e,t){let{ctx:n}=e,r=createCurrentMessages(t.messages,{historyState:n?.get(HistoryStateKey),currentTurnMessages:t.turnMessages,projectedMessages:t.projectedMessages});r.addSystem(dynamicInstructionMessages(n)),r.addSystem(taskSystemMessages(t.catalog.offersTasks,e.finalReplyOnly));let i=n?.get(HistoryStateKey)?.announcements;return r.addAnnouncements({...catalogAnnouncements(t.catalog,i),...dynamicSkillAnnouncements(dynamicSkillManifest(n),i)}),t.pendingApprovalsNote!==void 0&&r.add(t.pendingApprovalsNote,`context.state`,{cacheFriendly:!1}),r.addAnchored(memoryRecallContents(n),`memory.load`),r}function modelInstructions(e){let{session:t}=e,n=e.extraSystemNote?[{role:`system`,content:e.extraSystemNote}]:[];if(e.systemMessages.length===0&&n.length===0)return t.agent.system??void 0;let r=t.agent.system?[{role:`system`,content:t.agent.system}]:[],i=[...n,...r,...e.systemMessages];return mergeSystemInstructions(e.anthropicCache?applySystemCacheBreakpoint(i,e.anthropicCache):i)}function withTrailingUserNote(e,t){return t?[...e,createFrameworkUserMessage(`execution.retry`,t)]:[...e]}function mergeSystemInstructions(e){if(e.length===0)return;if(e.length===1)return{...e[0]};let t;for(let n of e)n.providerOptions!==void 0&&(t={...t,...n.providerOptions});let n={role:`system`,content:e.map(e=>e.content).join(`
 
 `)};return t!==void 0&&(n.providerOptions=t),n}export{mergeSystemInstructions,modelInstructions,requestMessages,withTrailingUserNote};

package/dist/src/harness/model-call/response.d.ts

@@ -1,4 +1,5 @@
-import type { ModelMessage, ToolSet, TypedToolResult } from "ai";
+import type { ModelMessage } from "ai";
+import type { InlineCallResults } from "#harness/call-executor.js";
 import type { HarnessStepResult } from "#harness/step-hooks.js";
 import type { HarnessToolLookup } from "#harness/types.js";
 type StepResponseMessage = HarnessStepResult["response"]["messages"][number];
@@ -8,21 +9,29 @@ type ToolResponsePart = Extract<ModelMessage, {
 type ToolResultPart = Extract<ToolResponsePart, {
     type: "tool-result";
 }>;
-export declare function withAccumulatedResponseMessages(input: {
-    readonly invalidInputToolCallIds?: ReadonlySet<string>;
-    readonly responseMessages: readonly StepResponseMessage[];
+/**
+ * The step as the harness reads it: the AI SDK's result, with the results of the calls eve ran or
+ * answered appended to the response, and what the calls wait on.
+ */
+export declare function withCallResults(input: {
     readonly stepResult: HarnessStepResult;
-    readonly toolResults?: readonly TypedToolResult<ToolSet>[];
+    readonly responseMessages: readonly StepResponseMessage[];
+    readonly calls: InlineCallResults;
+    /** Results for calls that didn't run. */
+    readonly answers: readonly ToolResultPart[];
+    readonly invalidInputToolCallIds?: ReadonlySet<string>;
 }): HarnessStepResult;
 /** True when provider history still owes a result for any assistant tool call. */
 export declare function hasUnansweredToolCall(messages: readonly ModelMessage[]): boolean;
 /**
- * Appends synthesized tool results for calls that have no result anywhere in
- * the step's response messages. Exported for its dedupe contract: a call
- * already answered — including provider-executed results the SDK keeps
- * inline in the assistant message — must never receive a second
- * `tool-result`, or the next Anthropic call rejects the history with
- * "each tool_use must have a single result".
+ * Appends tool results for calls that have no result anywhere in the step's response messages.
+ * The response's results share one tool message, in the order the model made its calls: the AI
+ * SDK answers an invalid call as it streams, and eve's calls run once the response ends.
+ *
+ * Exported for its dedupe contract: a call already answered — including provider-executed
+ * results the SDK keeps inline in the assistant message — must never receive a second
+ * `tool-result`, or the next Anthropic call rejects the history with "each tool_use must have a
+ * single result".
  */
 export declare function appendMissingToolResultMessages(input: {
     readonly append: readonly ToolResultPart[];
@@ -36,5 +45,6 @@ export declare function appendMissingToolResultMessages(input: {
  * tool-message-only scan would let a synthesized result duplicate them.
  */
 export declare function extractToolResultCallIds(messages: readonly ModelMessage[]): ReadonlySet<string>;
-export declare function answerSkippedToolCalls(step: HarnessStepResult, tools: HarnessToolLookup): ToolResultPart[];
+/** Answers the local calls of a response that ended early: eve doesn't run them. */
+export declare function answerSkippedToolCalls(step: HarnessStepResult, tools: HarnessToolLookup, excludedCallIds: ReadonlySet<string>): ToolResultPart[];
 export {};

package/dist/src/harness/model-call/response.js

@@ -1 +1 @@
-import{historyCallNames}from"#harness/execute-call.js";import{getInvalidToolCallInputError,isInvalidToolCall}from"#harness/tool-call-input-errors.js";function withAccumulatedResponseMessages(e){let{stepResult:t}=e;return{content:t.content,finishReason:t.finishReason,...e.invalidInputToolCallIds===void 0?{}:{invalidInputToolCallIds:e.invalidInputToolCallIds},providerMetadata:t.providerMetadata,response:{...t.response,messages:[...e.responseMessages]},text:t.text,toolCalls:t.toolCalls,toolResults:e.toolResults===void 0?t.toolResults:[...e.toolResults],usage:t.usage}}function hasUnansweredToolCall(e){let t=new Set,n=new Set;for(let r of e)if(Array.isArray(r.content))for(let e of r.content)typeof e==`object`&&e&&(e.type===`tool-call`&&t.add(e.toolCallId),e.type===`tool-result`&&n.add(e.toolCallId));for(let e of t)if(!n.has(e))return!0;return!1}function appendMissingToolResultMessages(e){let t=extractToolResultCallIds(e.responseMessages),n=historyCallNames(e.responseMessages),r=e.append.filter(e=>!t.has(e.toolCallId)).map(e=>({...e,toolName:n.get(e.toolCallId)??e.toolName}));return[...e.responseMessages,...r.length>0?[{role:`tool`,content:[...r]}]:[]]}function extractToolResultCallIds(e){let t=new Set;for(let n of e)if(Array.isArray(n.content))for(let e of n.content)typeof e==`object`&&e&&e.type===`tool-result`&&t.add(e.toolCallId);return t}function answerSkippedToolCalls(e,t){let{finishReason:n}=e;if(n===`stop`||n===`tool-calls`)return[];let r=extractToolResultCallIds(e.response.messages),i=new Set((e.content??[]).flatMap(e=>e.type===`tool-approval-request`&&e.isAutomatic!==!0?[e.toolCall.toolCallId]:[])),a=`The tool did not run because the model response ended early (finish reason: ${n}). Call the tool again if you still need its result.`;return(e.toolCalls??[]).filter(e=>t.get(e.toolName)?.execute!==void 0&&e.providerExecuted!==!0&&!isInvalidToolCall(e)&&getInvalidToolCallInputError({toolCall:e})===void 0&&!r.has(e.toolCallId)&&!i.has(e.toolCallId)).map(e=>({output:{type:`error-text`,value:a},toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-result`}))}export{answerSkippedToolCalls,appendMissingToolResultMessages,extractToolResultCallIds,hasUnansweredToolCall,withAccumulatedResponseMessages};
+import{historyCallNames}from"#harness/execute-call.js";import{isRunnableTool}from"#harness/tools.js";import{getInvalidToolCallInputError,isInvalidToolCall}from"#harness/tool-call-input-errors.js";function withCallResults(e){let{calls:t,stepResult:n}=e;return{approvalRequests:t.approvals,policyApprovals:t.policyApprovals,content:n.content,finishReason:n.finishReason,...e.invalidInputToolCallIds===void 0?{}:{invalidInputToolCallIds:e.invalidInputToolCallIds},providerMetadata:n.providerMetadata,response:{...n.response,messages:appendMissingToolResultMessages({append:[...t.parts,...e.answers],responseMessages:e.responseMessages})},signIns:t.signIns,text:n.text,toolCalls:n.toolCalls,toolResults:[...n.toolResults??[],...t.toolResults],usage:n.usage}}function hasUnansweredToolCall(e){let t=new Set,n=new Set;for(let r of e)if(Array.isArray(r.content))for(let e of r.content)typeof e==`object`&&e&&(e.type===`tool-call`&&t.add(e.toolCallId),e.type===`tool-result`&&n.add(e.toolCallId));for(let e of t)if(!n.has(e))return!0;return!1}function appendMissingToolResultMessages(e){let t=extractToolResultCallIds(e.responseMessages),n=historyCallNames(e.responseMessages),r=e.append.filter(e=>!t.has(e.toolCallId)).map(e=>({...e,toolName:n.get(e.toolCallId)??e.toolName}));if(r.length===0)return[...e.responseMessages];let i=e.responseMessages.at(-1),a=i?.role===`tool`?i:void 0,o=new Map;for(let t of e.responseMessages)if(t.role===`assistant`&&Array.isArray(t.content))for(let e of t.content)e.type===`tool-call`&&!o.has(e.toolCallId)&&o.set(e.toolCallId,o.size);let position=e=>(e.type===`tool-result`?o.get(e.toolCallId):void 0)??o.size,s=[...a?.content??[],...r].sort((e,t)=>position(e)-position(t));return[...a===void 0?e.responseMessages:e.responseMessages.slice(0,-1),{role:`tool`,content:s}]}function extractToolResultCallIds(e){let t=new Set;for(let n of e)if(Array.isArray(n.content))for(let e of n.content)typeof e==`object`&&e&&e.type===`tool-result`&&t.add(e.toolCallId);return t}function answerSkippedToolCalls(e,t,n){let{finishReason:r}=e;if(r===`stop`||r===`tool-calls`)return[];let i=`The tool did not run because the model response ended early (finish reason: ${r}). Call the tool again if you still need its result.`;return(e.toolCalls??[]).filter(e=>isRunnableTool(t.get(e.toolName))&&e.providerExecuted!==!0&&!isInvalidToolCall(e)&&getInvalidToolCallInputError({toolCall:e})===void 0&&!n.has(e.toolCallId)).map(e=>({output:{type:`error-text`,value:i},toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-result`}))}export{answerSkippedToolCalls,appendMissingToolResultMessages,extractToolResultCallIds,hasUnansweredToolCall,withCallResults};

package/dist/src/harness/model-call/retry.d.ts

@@ -1,11 +1,28 @@
+import { type Policy } from "#reactions/policy.js";
+/** Whether a failed model call is tried again, and how long to wait first. */
+export type RetryDecision = {
+    readonly retry: false;
+} | {
+    readonly retry: true;
+    readonly delayMs: number;
+};
+/** A failed attempt: which one it was, and what it threw. */
+export interface RetryQuestion {
+    readonly attempt: number;
+    readonly error: unknown;
+}
+export type RetryPolicy = Policy<RetryQuestion, RetryDecision>;
+/** A policy's answer when it has no objection to a retry, or when it stops one. */
+export declare const ALLOW_RETRY: RetryDecision;
+export declare const STOP_RETRY: RetryDecision;
 /**
- * Retries `fn` with exponential backoff while the thrown error is
- * classified as `"retry"`. Rethrows the last error once attempts are
- * exhausted or the error is classified as something other than
- * transient.
+ * Retries `fn` while eve's retry policies and the caller's `policies` all allow it, waiting the
+ * longest any asks for. Rethrows the last error once one stops it. `onRetry` hears each decision
+ * to retry, before the wait.
  */
-export declare function runModelCallWithRetries<T>(fn: (attempt: number) => Promise<T>, diag: {
+export declare function runModelCallWithRetries<T>(fn: () => Promise<T>, diag: {
     readonly sessionId: string;
     readonly turnId: string;
-    readonly canRetry?: () => boolean;
+    readonly policies?: readonly RetryPolicy[];
+    readonly onRetry?: (error: unknown) => Promise<void>;
 }, signal?: AbortSignal): Promise<T>;

package/dist/src/harness/model-call/retry.js

@@ -1 +1 @@
-import{createLogger}from"#internal/logging.js";import{setTimeout}from"node:timers/promises";import{classifyModelCallError}from"#harness/model-call/errors.js";const log=createLogger(`harness.tool-loop`);async function runModelCallWithRetries(e,t,n){for(let r=1;;r++){n?.throwIfAborted();try{return await e(r)}catch(e){if(n?.throwIfAborted(),t.canRetry?.()===!1||r===3||classifyModelCallError(e)!==`retry`)throw e;let i=500*2**(r-1)+Math.floor(Math.random()*250);log.warn(`model call failed transiently — retrying`,{attempt:r,delayMs:i,sessionId:t.sessionId,turnId:t.turnId,error:e}),await setTimeout(i,void 0,{signal:n})}}}export{runModelCallWithRetries};
+import{createLogger}from"#internal/logging.js";import{setTimeout}from"node:timers/promises";import{classifyModelCallError}from"#harness/model-call/errors.js";import{decide}from"#reactions/policy.js";const log=createLogger(`harness.tool-loop`),ALLOW_RETRY={delayMs:0,retry:!0},STOP_RETRY={retry:!1},retryLaw={meet:(e,t)=>e.retry?t.retry?{delayMs:Math.max(e.delayMs,t.delayMs),retry:!0}:t:e,open:ALLOW_RETRY},BUILT_IN=[({error:e})=>classifyModelCallError(e)===`retry`?ALLOW_RETRY:STOP_RETRY,({attempt:e})=>e<3?ALLOW_RETRY:STOP_RETRY,({attempt:e})=>({delayMs:500*2**(e-1)+Math.floor(Math.random()*250),retry:!0})];async function runModelCallWithRetries(e,t,n){let r=[...BUILT_IN,...t.policies??[]];for(let i=1;;i++){n?.throwIfAborted();try{return await e()}catch(e){n?.throwIfAborted();let a=decide(retryLaw,r,{attempt:i,error:e});if(!a.retry)throw e;let{delayMs:o}=a;log.warn(`model call failed transiently — retrying`,{attempt:i,delayMs:o,sessionId:t.sessionId,turnId:t.turnId,error:e}),await t.onRetry?.(e),await setTimeout(o,void 0,{signal:n})}}}export{ALLOW_RETRY,STOP_RETRY,runModelCallWithRetries};

package/dist/src/harness/model-call/run.d.ts

@@ -1,12 +1,10 @@
 import { type StepCatalog } from "#execution/catalog/step-catalog.js";
 import type { GenerationSteering } from "#harness/generation-steering.js";
 import { type HarnessModelMessage } from "#harness/messages.js";
-import { type ApprovedWork } from "#harness/hitl/index.js";
 import { type Step } from "#harness/step/context.js";
 import type { TurnInput } from "#harness/step/intake.js";
 import type { HarnessStepResult } from "#harness/step-hooks.js";
 import { type StepResult } from "#harness/types.js";
-import type { InstrumentationAttempt } from "#instrumentation/runtime.js";
 import { type EndsTurnTools } from "./tools.js";
 /** A model step's response, for the session to act on. */
 export interface ModelResponse {
@@ -22,19 +20,13 @@ export interface ModelResponse {
 }
 /**
  * One model step of the open turn: the prompt it reads, the model that serves it, and the call
- * with its retries and recoveries. `onResponse` decides what the session does with the response.
+ * with its retries and recoveries. The response handler applies what it returned.
  *
- * Approved work runs where the AI SDK ran it, between the step's start and the model call:
- * approved workflow calls join their runs, the budget gate passes, then approved local calls run
- * and the model reads their results.
+ * The budget gate passes first, after the session's dynamic values are evaluated with the
+ * conversation the call reads, which fixes its model, tools, and context. Then the turn requests
+ * a model run, and the run starts as its provider call begins.
  */
 export declare function runModelStep(step: Step, input: {
-    readonly onResponse: (response: ModelResponse) => Promise<StepResult>;
     readonly turn: TurnInput;
-    readonly approved: ApprovedWork;
     readonly generation: GenerationSteering;
-    /** A child's caller and a schedule hear only the turn's real end. */
-    readonly hidesHeldText: boolean;
-    /** The attempt the step's events belong to, for instrumentation. */
-    readonly setAttemptScope: (scope: InstrumentationAttempt | undefined) => void;
 }): Promise<StepResult>;

package/dist/src/harness/model-call/run.js

@@ -1 +1 @@
-import{resolveEffectiveRuntimeModel}from"./model.js";import{recoverModelCall}from"./recovery.js";import{endsTurnTools,frameworkToolNames}from"./tools.js";import{recordModelUsage}from"./usage.js";import{ModelCaller}from"./call.js";import{reportModelCallFailure}from"./failure.js";import{HistoryStateKey}from"#context/keys.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{activeTurnId,nextStepIndex}from"#harness/session-machine/view.js";import{dispatchApprovedWorkflows,enforceBudget,hasApprovedWork,humanInputContext,runApprovedLocalCalls}from"#harness/hitl/index.js";import{startStep}from"#harness/session-machine/transitions.js";import{stepStartedForResolvers}from"#harness/session-machine/resolver-events.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{requireSessionModelReference}from"#harness/types.js";import{buildStepCatalog,recordOfferedCatalogTools}from"#execution/catalog/step-catalog.js";import{buildPrompt,previewPrompt,projectPrompt,withClientContext}from"#harness/step/prompt.js";import{failBoundaryEvent,failModelSelection}from"#harness/step/context.js";async function runModelStep(e,t){let{generation:n}=t,r=hasApprovedWork(e),i=r?previewPrompt(e,t.turn):await buildPrompt(e,t.turn),a=await selectModel(e,i);if(!(`model`in a))return a.failed;let start=t=>e.apply(startStep(e.view(),{modelId:requireSessionModelReference(e.session).id}),t),o=projectPrompt(e,i);try{await start(o)}catch(t){return failBoundaryEvent(e,t)}if(r&&await dispatchApprovedWorkflows(e,t.approved))return{next:null,session:e.session};let s=await enforceBudget(e,i.messages);if(s!==void 0)return s;if(r){let n=await runApprovedLocalCalls(e,t.approved,t.setAttemptScope);if(n!==void 0)return n;i=await buildPrompt(e,t.turn),o=projectPrompt(e,i)}let c=!e.hasDelegatedCaller&&e.session.outputSchema===void 0,l=buildStepCatalog({agentTools:e.config.tools,ctx:e.ctx,endsTurn:c,session:e.session});recordOfferedCatalogTools(e.ctx,l),e.frameworkToolNames=frameworkToolNames(l);let{approvedTools:u,pendingApprovalsNote:d}=humanInputContext(e,l),f=new ModelCaller(e,i,{approvedTools:u,catalog:l,generation:n,hidesHeldText:t.hidesHeldText,model:a.model,pendingApprovalsNote:d,projectedMessages:o,setAttemptScope:t.setAttemptScope,startStep:start,turnMessages:t.turn.messages}),p;try{p=await f.call({suppressStepStartedEmission:!0})}catch(t){if(f.throwIfCompactionFailed(),throwIfTurnAborted(e.config.abortSignal),n.interrupted)return f.steered();let r=await recoverModelCall({call:e=>f.call(e),error:t,sessionId:e.session.sessionId,turnId:e.position().turnId});if(f.throwIfCompactionFailed(),throwIfTurnAborted(e.config.abortSignal),n.interrupted)return f.steered();if(!(`result`in r))return reportModelCallFailure(e,r.error);p=r.result}await recordModelUsage(e,{model:a.model,result:p}),f.clearInterruptedUsage();let m;try{n.check(),m=await t.onResponse({catalog:l,durableModelPromptMessageCount:i.clientContext===void 0||i.clientContext.messages.length===0?f.modelMessages.length:void 0,endsTurnTools:endsTurnTools(l,c),promptMessages:f.request.history,requestEnvelopeTokens:f.requestEnvelopeTokens,result:p})}catch(t){if(throwIfTurnAborted(e.config.abortSignal),n.interrupted)return f.steered();throw t}return e.ctx?.set(HistoryStateKey,f.request.historyState),m}async function selectModel(e,t){let{config:n,ctx:r}=e;try{if(r!==void 0&&n.dispatchDynamicModelEvent!==void 0){let i=e.position();await n.dispatchDynamicModelEvent({ctx:r,event:stepStartedForResolvers({modelId:e.session.agent.modelReference?.id??`dynamic`,sequence:i.sequence,stepIndex:nextStepIndex(e.view().projection),turnId:activeTurnId(i)}),messages:validateHarnessModelMessages(e.projectHistory(withClientContext(t)))})}let i=await resolveEffectiveRuntimeModel({config:n,ctx:r,session:e.session});return e.session=i.session,{model:i.model}}catch(t){return{failed:await failModelSelection(e,t)}}}export{runModelStep};
+import{reportModelCallFailure}from"./failure.js";import{resolveEffectiveRuntimeModel}from"./model.js";import{endsTurnTools,frameworkToolNames}from"./tools.js";import{recordModelUsage}from"./usage.js";import{ModelCaller}from"./call.js";import{HistoryStateKey}from"#context/keys.js";import{activeTurnId}from"#harness/session-machine/view.js";import{enforceBudget,humanInputContext}from"#harness/hitl/index.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{runRequested,runStarted}from"#harness/facts.js";import{nextRunId}from"#protocol/session-projection.js";import{throwIfTurnAborted}from"#harness/turn-cancellation.js";import{requireSessionModelReference}from"#harness/types.js";import{buildStepCatalog,recordOfferedCatalogTools}from"#execution/catalog/step-catalog.js";import{buildPrompt,previewPrompt,projectPrompt,withClientContext}from"#harness/step/prompt.js";import{handleStepResult}from"#harness/step/after-model.js";import{failBoundaryEvent,failModelSelection,prepareModelCall}from"#harness/step/context.js";async function runModelStep(e,t){let{generation:n}=t,r=await prepareModelCall(e,previewPrompt(e,t.turn));if(r!==void 0)return r;let i=await buildPrompt(e,t.turn),a=await enforceBudget(e,i.messages);if(a!==void 0)return a;let o=await requestRun(e,i);if(`failed`in o)return o.failed;let s=projectPrompt(i),c=!e.hasDelegatedCaller&&e.session.outputSchema===void 0,l=buildStepCatalog({agentTools:e.config.tools,ctx:e.ctx,endsTurn:c,session:e.session});recordOfferedCatalogTools(e.ctx,l),e.frameworkToolNames=frameworkToolNames(l);let{approvalMemory:u,pendingApprovalsNote:d}=humanInputContext(e),f=new ModelCaller(e,i,{approvalMemory:u,catalog:l,generation:n,model:o.model,newRun:async()=>{if(`failed`in await requestRun(e,i))throw Error(`The model run's replacement found no model.`)},startRun:async t=>await startRun(e,t),pendingApprovalsNote:d,projectedMessages:s,turnMessages:t.turn.messages}),p;try{p=await f.call()}catch(t){let r=await f.failIfCompactionFailed();return r===void 0?(throwIfTurnAborted(e.config.abortSignal),n.interrupted?f.steered():reportModelCallFailure(e,t)):r}await recordModelUsage(e,{model:o.model}),f.clearInterruptedUsage();let m;try{n.check(),m=await handleStepResult(e,{catalog:l,durableModelPromptMessageCount:i.clientContext===void 0||i.clientContext.messages.length===0?f.modelMessages.length:void 0,endsTurnTools:endsTurnTools(l,c),promptMessages:f.request.history,requestEnvelopeTokens:f.requestEnvelopeTokens,result:p})}catch(t){if(throwIfTurnAborted(e.config.abortSignal),n.interrupted)return f.steered();throw t}return e.ctx?.set(HistoryStateKey,f.request.historyState),m}async function requestRun(e,t){let{config:n,ctx:r}=e;try{await e.apply([runRequested({turnId:activeTurnId(e.position())},nextRunId(e.view().projection))],validateHarnessModelMessages(withClientContext(t)))}catch(t){return{failed:await failBoundaryEvent(e,t)}}try{let t=await resolveEffectiveRuntimeModel({config:n,ctx:r,session:e.session});return e.session=t.session,{model:t.model}}catch(t){return{failed:await failModelSelection(e,t)}}}async function startRun(e,t){let n=e.position().runId;if(n===void 0)return;let r=requireSessionModelReference(e.session).id;await e.apply([runStarted({attempt:t,modelId:r,runId:n})])}export{runModelStep};

package/dist/src/harness/model-call/tools.d.ts

@@ -1,10 +1,8 @@
 import type { ToolSet } from "ai";
 import type { StepCatalog } from "#execution/catalog/step-catalog.js";
 import type { HarnessToolDefinition } from "#harness/execute-tool.js";
-import type { GenerationSteering } from "#harness/generation-steering.js";
 import type { ModelProfile } from "#harness/model-profile.js";
 import type { Step } from "#harness/step/context.js";
-import type { CallResolver } from "#harness/types.js";
 /**
  * Assembles the tools one model call offers: the catalog's listed entries with provider tools in
  * place, and `eve__reply` when the turn asks for a structured result.
@@ -12,27 +10,10 @@ import type { CallResolver } from "#harness/types.js";
 export declare function prepareModelTools(step: Step, input: {
     readonly catalog: StepCatalog;
     readonly disabledProviderTools?: ReadonlySet<string>;
-    readonly generation: GenerationSteering;
     readonly profile: ModelProfile;
 }): Promise<ToolSet>;
 /** The entries that can end the turn, with their `endsTurn` option, when `endsTurn` applies. */
 export declare function endsTurnTools(catalog: StepCatalog, applies: boolean): EndsTurnTools;
 /** The names of the entries eve provides, which tracing marks as framework tools. */
 export declare function frameworkToolNames(catalog: StepCatalog): ReadonlySet<string>;
-/**
- * Wired as the agent's `onToolExecutionEnd`. On the `tool-error` branch
- * the `error` is still the original throwable (stack/cause intact),
- * unlike the message-only `tool-error` part the model later sees.
- */
-export declare function logToolExecutionError(event: {
-    readonly toolCall: {
-        readonly input: unknown;
-        readonly toolName: string;
-        readonly toolCallId: string;
-    };
-    readonly toolOutput: {
-        readonly type: string;
-        readonly error?: unknown;
-    };
-}, resolve: CallResolver): void;
 export type EndsTurnTools = ReadonlyMap<string, NonNullable<HarnessToolDefinition["endsTurn"]>>;

package/dist/src/harness/model-call/tools.js

@@ -1 +1 @@
-import{createLogger,logError}from"#internal/logging.js";import{REPLY_TOOL_NAME}from"#protocol/reply-tool.js";import{SKILL_ENTRY_NAME}from"#protocol/catalog-tools.js";import{toModelSchema}from"#tools/schema.js";import{dispatchesAfterStep}from"#harness/execute-call.js";import{isTurnCancellation}from"#harness/turn-cancellation.js";import{buildToolSetWithProviderTools}from"#harness/tools.js";import{applyLastToolCacheBreakpoint}from"#harness/prompt-cache.js";import{buildFinalOutputTool}from"#harness/final-output.js";const log=createLogger(`harness.tool-loop`);async function prepareModelTools(e,t){let{catalog:n,profile:r}=t,i=await buildToolSetWithProviderTools({describe:n.describe,disabledProviderTools:t.disabledProviderTools,profile:r,resolve:n.resolve,tools:n.advertised});e.session.outputSchema!==void 0&&(i[REPLY_TOOL_NAME]=buildFinalOutputTool(e.session.outputSchema));let a=r.anthropicCache?applyLastToolCacheBreakpoint(i,r.anthropicCache):i;for(let[e,r]of Object.entries(a)){r.inputSchema=toModelSchema(r.inputSchema,`input`),r.outputSchema!==void 0&&(r.outputSchema=toModelSchema(r.outputSchema,`output`));let i=r.execute;i!==void 0&&(r.execute=(...r)=>(dispatchesAfterStep(n.resolve({input:r[0],toolName:e}))||t.generation.protectToolExecution(),i(...r)))}return a}function endsTurnTools(e,t){return t?new Map([...e.entries].flatMap(([e,t])=>t.endsTurn===void 0||t.endsTurn===!1?[]:[[e,t.endsTurn]])):new Map}function frameworkToolNames(e){return new Set([...e.advertised.values(),...e.entries.values(),e.get(SKILL_ENTRY_NAME)].flatMap(e=>e?.frameworkTool===!0?[e.name]:[]))}function logToolExecutionError(e,t){e.toolOutput.type!==`tool-error`||isTurnCancellation(e.toolOutput.error)||logError(log,`tool execution failed`,e.toolOutput.error,{toolName:t(e.toolCall)?.definition.name??e.toolCall.toolName,toolCallId:e.toolCall.toolCallId})}export{endsTurnTools,frameworkToolNames,logToolExecutionError,prepareModelTools};
+import{REPLY_TOOL_NAME}from"#protocol/reply-tool.js";import{toModelSchema}from"#tools/schema.js";import{SKILL_ENTRY_NAME}from"#protocol/catalog-tools.js";import{buildToolSetWithProviderTools}from"#harness/tools.js";import{applyLastToolCacheBreakpoint}from"#harness/prompt-cache.js";import{buildFinalOutputTool}from"#harness/final-output.js";async function prepareModelTools(e,t){let{catalog:n,profile:r}=t,i=await buildToolSetWithProviderTools({describe:n.describe,disabledProviderTools:t.disabledProviderTools,profile:r,tools:n.advertised});e.session.outputSchema!==void 0&&(i[REPLY_TOOL_NAME]=buildFinalOutputTool(e.session.outputSchema));let a=r.anthropicCache?applyLastToolCacheBreakpoint(i,r.anthropicCache):i;for(let e of Object.values(a))e.inputSchema=toModelSchema(e.inputSchema,`input`),e.outputSchema!==void 0&&(e.outputSchema=toModelSchema(e.outputSchema,`output`));return a}function endsTurnTools(e,t){return t?new Map([...e.entries].flatMap(([e,t])=>t.endsTurn===void 0||t.endsTurn===!1?[]:[[e,t.endsTurn]])):new Map}function frameworkToolNames(e){return new Set([...e.advertised.values(),...e.entries.values(),e.get(SKILL_ENTRY_NAME)].flatMap(e=>e?.frameworkTool===!0?[e.name]:[]))}export{endsTurnTools,frameworkToolNames,prepareModelTools};

package/dist/src/harness/model-call/unique-call-ids.d.ts

@@ -0,0 +1,13 @@
+import { type LanguageModel } from "ai";
+/**
+ * Serves `model` so every call it starts gets an id no call in `taken` holds.
+ *
+ * Calls are keyed by the provider's tool call id, from the session's tables to the prompt's
+ * tool results. Some providers number calls per response, so a later turn can repeat an id
+ * the session already introduced; that call is renamed, with every part that refers to it, as
+ * the stream arrives, so the model, the tables and readers all see the same new id. `taken`
+ * holds the ids the session still holds: the calls in its view and the prompt's tool calls.
+ * A call that left both, by retention and then a clear or compaction, can see its id again; the
+ * session's own view no longer has it, and a reader of the whole stream keeps the earlier call.
+ */
+export declare function withUniqueCallIds(model: LanguageModel, taken: Iterable<string>): LanguageModel;

package/dist/src/harness/model-call/unique-call-ids.js

@@ -0,0 +1 @@
+import{gateway,wrapLanguageModel}from"ai";function withUniqueCallIds(e,t){return wrapLanguageModel({model:resolved(e),middleware:uniqueCallIds(new Set(t))})}function resolved(e){return typeof e==`string`?(Reflect.get(globalThis,`AI_SDK_DEFAULT_PROVIDER`)??gateway).languageModel(e):e}function uniqueCallIds(e){return{specificationVersion:`v4`,wrapStream:async({doStream:t})=>{let{stream:n,...r}=await t();return{...r,stream:n.pipeThrough(renameRepeatedCalls(e))}}}}function renameRepeatedCalls(e){let t=new Map,n=new Set,introduce=n=>{let r=n;for(let t=2;e.has(r);t++)r=`${n}_${t}`;return e.add(r),r===n?t.delete(n):t.set(n,r),r},current=e=>t.get(e)??e;return new TransformStream({transform(e,t){switch(e.type){case`tool-input-start`:n.add(e.id),t.enqueue({...e,id:introduce(e.id)});return;case`tool-input-delta`:case`tool-input-end`:t.enqueue({...e,id:current(e.id)});return;case`tool-call`:{let r=n.delete(e.toolCallId)?current(e.toolCallId):introduce(e.toolCallId);t.enqueue({...e,toolCallId:r});return}case`tool-result`:case`tool-approval-request`:t.enqueue({...e,toolCallId:current(e.toolCallId)});return;default:t.enqueue(e)}}})}export{withUniqueCallIds};

package/dist/src/harness/model-call/usage.d.ts

@@ -1,7 +1,9 @@
 import type { LanguageModel, ProviderMetadata } from "ai";
 import type { HarnessStepResult } from "#harness/step-hooks.js";
-import { type TokenUsageDelta } from "#harness/turn-tag-state.js";
 import type { Step } from "#harness/step/context.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+/** What one model call reported spending; a field it didn't report is absent. */
+export type TokenUsageDelta = Partial<TokenUsage>;
 /**
  * The model's gateway id, or `undefined` for a model without a string `provider`, such as a
  * test double, so a missing field never throws into the tool loop.
@@ -13,11 +15,11 @@ export declare function extractTokenUsageDelta(input: {
 }): TokenUsageDelta | undefined;
 export declare function extractGatewayCostUsd(providerMetadata: ProviderMetadata | undefined): number | undefined;
 /**
- * Tags the turn's workflow run with the model and the turn's running token totals. Each model
- * step is its own workflow step and attributes are last-write-wins, so the running total, kept in
- * session state, is what reaches the dashboard. Best-effort: tagging never breaks the loop.
+ * Tags the turn's workflow run with the model and what the turn's runs have spent, which their
+ * `usage.recorded` facts record. Each model step is its own workflow step and attributes are
+ * last-write-wins, so the latest total is what reaches the dashboard. Best-effort: tagging never
+ * breaks the loop.
  */
 export declare function recordModelUsage(step: Step, input: {
     readonly model: LanguageModel;
-    readonly result: HarnessStepResult;
 }): Promise<void>;

package/dist/src/harness/model-call/usage.js

@@ -1 +1 @@
-import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{addTurnUsage,getTurnUsageState}from"#harness/turn-tag-state.js";import{setEveAttributes}from"#runtime/attributes/emit.js";function gatewayModelId(e){try{return formatLanguageModelGatewayId(e)}catch{return}}function extractTokenUsageDelta(e){let t=e.usage;if(t!==void 0||e.costUsd!==void 0)return{cacheReadTokens:t?.inputTokenDetails?.cacheReadTokens,cacheWriteTokens:t?.inputTokenDetails?.cacheWriteTokens,costUsd:e.costUsd,inputTokens:t?.inputTokens,outputTokens:t?.outputTokens}}function extractGatewayCostUsd(e){let t=readGatewayMetadata(e)?.cost;if(typeof t==`number`&&Number.isFinite(t))return t;if(typeof t==`string`){let e=Number(t);return Number.isFinite(e)?e:void 0}}function readGatewayMetadata(e){let t=e?.gateway;return t&&typeof t==`object`&&!Array.isArray(t)?t:void 0}async function recordModelUsage(e,t){e.session=addTurnUsage(e.session,e.position().turnId,extractTokenUsageDelta({costUsd:extractGatewayCostUsd(t.result.providerMetadata),usage:t.result.usage}));let n=getTurnUsageState(e.session.state),r={"$eve.model":gatewayModelId(t.model),"$eve.input_tokens":n?.inputTokens,"$eve.output_tokens":n?.outputTokens,"$eve.cache_read_tokens":n?.cacheReadTokens,"$eve.cache_write_tokens":n?.cacheWriteTokens,"$eve.cost_usd":n?.sawCost?n.costUsd:void 0,"$eve.tool_count":e.config.tools.size};await e.config.titleAttributeWrite,await setEveAttributes(r)}export{extractGatewayCostUsd,extractTokenUsageDelta,gatewayModelId,recordModelUsage};
+import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{turnUsage}from"#harness/session-usage.js";import{setEveAttributes}from"#runtime/attributes/emit.js";function gatewayModelId(e){try{return formatLanguageModelGatewayId(e)}catch{return}}function extractTokenUsageDelta(e){let t=e.usage;if(t!==void 0||e.costUsd!==void 0)return{cacheReadTokens:t?.inputTokenDetails?.cacheReadTokens,cacheWriteTokens:t?.inputTokenDetails?.cacheWriteTokens,costUsd:e.costUsd,inputTokens:t?.inputTokens,outputTokens:t?.outputTokens}}function extractGatewayCostUsd(e){let t=readGatewayMetadata(e)?.cost;if(typeof t==`number`&&Number.isFinite(t))return t;if(typeof t==`string`){let e=Number(t);return Number.isFinite(e)?e:void 0}}function readGatewayMetadata(e){let t=e?.gateway;return t&&typeof t==`object`&&!Array.isArray(t)?t:void 0}async function recordModelUsage(e,t){let n=turnUsage(e.view().projection.view,e.position().turnId),r={"$eve.model":gatewayModelId(t.model),"$eve.input_tokens":n.inputTokens,"$eve.output_tokens":n.outputTokens,"$eve.cache_read_tokens":n.cacheReadTokens,"$eve.cache_write_tokens":n.cacheWriteTokens,"$eve.cost_usd":n.costUsd,"$eve.tool_count":e.config.tools.size};await e.config.titleAttributeWrite,await setEveAttributes(r)}export{extractGatewayCostUsd,extractTokenUsageDelta,gatewayModelId,recordModelUsage};

package/dist/src/harness/ordered-stream-emitter.d.ts

@@ -1,6 +1,7 @@
 import type { HarnessEmitFn } from "#harness/types.js";
 interface OrderedStreamEmitter {
     closeAndDrain(): Promise<void>;
+    /** Emits one streamed event, merged with adjacent deltas, or one commit, which is a barrier. */
     emit: HarnessEmitFn;
     readonly failureSignal: AbortSignal;
 }

package/dist/src/harness/ordered-stream-emitter.js

@@ -1 +1 @@
-const MAX_PENDING_DELTA_CHARACTERS=65536;function createOrderedStreamEmitter(e,t={}){let n=t.maxPendingEvents??64;if(!Number.isInteger(n)||n<1)throw RangeError(`maxPendingEvents must be a positive integer.`);let r=[],i=new Set,a=new Set,o=!1,s=0,c=0,l,u=!1,d=!1,f=new AbortController,throwIfFailed=()=>{if(u)throw l},settleIdleWaiters=()=>{for(let e of a)e();a.clear()},hasCapacity=()=>c<n&&s<MAX_PENDING_DELTA_CHARACTERS,settleCapacityWaiters=()=>{if(hasCapacity()){for(let e of i)e();i.clear()}},pump=async()=>{if(!(d||u)){for(d=!0;r.length>0;){let t=r.shift();if(t===void 0)break;s-=t.deltaCharacters,c-=t.sourceEvents,settleCapacityWaiters();try{await e(materializeEvent(t),t.messages)}catch(e){u||(l=e,u=!0,f.abort(e)),r.length=0,s=0,c=0,settleCapacityWaiters();break}}d=!1,settleIdleWaiters()}},waitForIdle=async()=>{if(!d&&r.length===0){throwIfFailed();return}await new Promise(e=>{a.add(e)}),throwIfFailed()},waitForCapacity=async()=>{hasCapacity()||(await new Promise(e=>{i.add(e)}),throwIfFailed())};return{async closeAndDrain(){o=!0,pump(),await waitForIdle()},async emit(e,t){if(throwIfFailed(),o)throw TypeError(`Cannot emit after the ordered stream emitter has closed.`);let i=r.length-1,a=r[i],l=appendDelta(e);a===void 0||!mergeAdjacentEmissions(a,e,t)?r.push({deltaCharacters:l?.length??0,event:e,messages:t,sourceEvents:1}):(a.deltaCharacters+=l?.length??0,a.sourceEvents+=1),s+=l?.length??0,c+=1,pump(),(c>=n||s>=MAX_PENDING_DELTA_CHARACTERS)&&await waitForCapacity(),throwIfFailed()},failureSignal:f.signal}}function mergeAdjacentEmissions(e,t,n){let r=appendKey(e.event),i=appendKey(t);return r!==void 0||i!==void 0?r===void 0||r!==i||!isAppendEvent(e.event)||!isAppendEvent(t)||!sameCoordinates(e.event,t)?!1:(e.deltaParts??=[appendDelta(e.event)],e.deltaParts.push(appendDelta(t)),e.event=t,e.messages=n,!0):e.event.type===`action.partial`&&t.type===`action.partial`&&e.event.data.result.callId===t.data.result.callId&&(e.event=t,e.messages=n,!0)}function appendKey(e){switch(e.type){case`message.appended`:case`reasoning.appended`:return e.type;case`action.input.appended`:return`${e.type}:${e.data.callId}`;default:return}}function isAppendEvent(e){return appendKey(e)!==void 0}function appendDelta(e){switch(e.type){case`message.appended`:return e.data.messageDelta;case`reasoning.appended`:return e.data.reasoningDelta;case`action.input.appended`:return e.data.inputTextDelta;default:return}}function materializeEvent(e){return e.deltaParts===void 0?e.event:e.event.type===`message.appended`?{...e.event,data:{...e.event.data,messageDelta:e.deltaParts.join(``)}}:e.event.type===`reasoning.appended`?{...e.event,data:{...e.event.data,reasoningDelta:e.deltaParts.join(``)}}:e.event.type===`action.input.appended`?{...e.event,data:{...e.event.data,inputTextDelta:e.deltaParts.join(``)}}:e.event}function sameCoordinates(e,t){return e.data.sequence===t.data.sequence&&e.data.stepIndex===t.data.stepIndex&&e.data.turnId===t.data.turnId}export{createOrderedStreamEmitter};
+import{eventsOf}from"#harness/publication.js";const MAX_PENDING_DELTA_CHARACTERS=65536;function createOrderedStreamEmitter(e,t={}){let n=t.maxPendingEvents??64;if(!Number.isInteger(n)||n<1)throw RangeError(`maxPendingEvents must be a positive integer.`);let r=[],i=new Set,a=new Set,o=!1,s=0,c=0,l,u=!1,d=!1,f=new AbortController,throwIfFailed=()=>{if(u)throw l},settleIdleWaiters=()=>{for(let e of a)e();a.clear()},hasCapacity=()=>c<n&&s<MAX_PENDING_DELTA_CHARACTERS,settleCapacityWaiters=()=>{if(hasCapacity()){for(let e of i)e();i.clear()}},pump=async()=>{if(!(d||u)){for(d=!0;r.length>0;){let t=r.shift();if(t===void 0)break;s-=t.deltaCharacters,c-=t.sourceEvents,settleCapacityWaiters();try{await e(t.commit??materializeEvent(t),t.messages)}catch(e){u||(l=e,u=!0,f.abort(e)),r.length=0,s=0,c=0,settleCapacityWaiters();break}}d=!1,settleIdleWaiters()}},waitForIdle=async()=>{if(!d&&r.length===0){throwIfFailed();return}await new Promise(e=>{a.add(e)}),throwIfFailed()},waitForCapacity=async()=>{hasCapacity()||(await new Promise(e=>{i.add(e)}),throwIfFailed())};return{async closeAndDrain(){o=!0,pump(),await waitForIdle()},async emit(e,t){if(throwIfFailed(),o)throw TypeError(`Cannot emit after the ordered stream emitter has closed.`);let i=eventsOf(e),a=i[0];if(a===void 0)return;if(i.length>1){r.push({commit:i,deltaCharacters:0,event:a,messages:t,sourceEvents:i.length}),c+=i.length,pump(),c>=n&&await waitForCapacity(),throwIfFailed();return}let l=r.length-1,u=r[l],d=appendDelta(a);u===void 0||u.commit!==void 0||!mergeAdjacentEmissions(u,a,t)?r.push({deltaCharacters:d?.length??0,event:a,messages:t,sourceEvents:1}):(u.deltaCharacters+=d?.length??0,u.sourceEvents+=1),s+=d?.length??0,c+=1,pump(),(c>=n||s>=MAX_PENDING_DELTA_CHARACTERS)&&await waitForCapacity(),throwIfFailed()},failureSignal:f.signal}}function mergeAdjacentEmissions(e,t,n){let r=appendKey(e.event),i=appendKey(t);return r!==void 0||i!==void 0?r===void 0||r!==i||!isAppendEvent(e.event)||!isAppendEvent(t)?!1:(e.deltaParts??=[appendDelta(e.event)],e.deltaParts.push(appendDelta(t)),e.messages=n,!0):e.event.type===`call.progress`&&t.type===`call.progress`&&e.event.data.callId===t.data.callId&&(e.event=t,e.messages=n,!0)}function appendKey(e){switch(e.type){case`content.delta`:return`${e.type}:${e.data.partId}`;case`call.input`:return`${e.type}:${e.data.callId}`;default:return}}function isAppendEvent(e){return appendKey(e)!==void 0}function appendDelta(e){switch(e.type){case`content.delta`:case`call.input`:return e.data.delta;default:return}}function materializeEvent(e){if(e.deltaParts===void 0)return e.event;let{event:t}=e;return t.type===`content.delta`||t.type===`call.input`?{...t,data:{...t.data,delta:e.deltaParts.join(``)}}:t}export{createOrderedStreamEmitter};

package/dist/src/harness/provider-tool-history.js

@@ -1 +1 @@
-function normalizeProviderToolHistory(e){let t=findProviderToolCallsToNormalize(e);if(e.providerExecutedOutcomeIds.size===0)return{messages:[...e.messages],outcomeEndsResponse:!1};let n=[],r=-1,i=-1,a=0;for(let o of e.messages){if(o.role!==`assistant`||!Array.isArray(o.content)){n.push(o),o.role===`assistant`&&typeof o.content==`string`&&o.content.trim().length>0&&(i=a),a+=1;continue}let s=[],c=[],l=!1,u=[],d=new Set,f=o.content.some(e=>e.type===`tool-result`&&t.has(e.toolCallId)),flushAssistant=()=>{s.length!==0&&(n.push({...o,content:s}),s=[])},flushTool=()=>{c.length!==0&&(n.push({role:`tool`,content:c}),c=[])};for(let n of o.content)n.type===`tool-result`&&t.has(n.toolCallId)?(flushAssistant(),c.push(n)):f&&n.type===`tool-call`&&n.providerExecuted!==!0&&!t.has(n.toolCallId)?(d.add(n.toolCallId),u.push(n)):n.type===`tool-approval-request`&&d.has(n.toolCallId)?u.push(n):(flushTool(),l&&n.type!==`tool-result`&&flushAssistant(),l=n.type===`tool-result`,s.push(n.type===`tool-call`&&t.has(n.toolCallId)?{...n,providerExecuted:!1}:n)),n.type===`tool-result`&&e.providerExecutedOutcomeIds.has(n.toolCallId)?r=a:n.type===`text`&&n.text.trim().length>0&&(i=a),a+=1;flushTool(),s.push(...u),flushAssistant()}return{messages:n,outcomeEndsResponse:r>=0&&r>i}}function findProviderToolCallsToNormalize(e){let t=new Set;for(let n of e.messages){if(n.role!==`assistant`||!Array.isArray(n.content))continue;let r=n.content.some(t=>t.type===`tool-call`&&t.providerExecuted!==!0&&!e.providerExecutedOutcomeIds.has(t.toolCallId));for(let i of n.content)i.type===`tool-call`&&e.providerExecutedOutcomeIds.has(i.toolCallId)&&(i.providerExecuted!==!0||r)&&t.add(i.toolCallId)}return t}export{normalizeProviderToolHistory};
+function normalizeProviderToolHistory(e){let t=findProviderToolCallsToNormalize(e);if(e.providerExecutedOutcomeIds.size===0)return{messages:[...e.messages],outcomeEndsResponse:!1};let n=[],r=-1,i=-1,a=0;for(let o of e.messages){if(o.role!==`assistant`||!Array.isArray(o.content)){n.push(o),o.role===`assistant`&&typeof o.content==`string`&&o.content.trim().length>0&&(i=a),a+=1;continue}let s=[],c=[],l=!1,u=[],d=o.content.some(e=>e.type===`tool-result`&&t.has(e.toolCallId)),flushAssistant=()=>{s.length!==0&&(n.push({...o,content:s}),s=[])},flushTool=()=>{c.length!==0&&(n.push({role:`tool`,content:c}),c=[])};for(let n of o.content)n.type===`tool-result`&&t.has(n.toolCallId)?(flushAssistant(),c.push(n)):d&&n.type===`tool-call`&&n.providerExecuted!==!0&&!t.has(n.toolCallId)?u.push(n):(flushTool(),l&&n.type!==`tool-result`&&flushAssistant(),l=n.type===`tool-result`,s.push(n.type===`tool-call`&&t.has(n.toolCallId)?{...n,providerExecuted:!1}:n)),n.type===`tool-result`&&e.providerExecutedOutcomeIds.has(n.toolCallId)?r=a:n.type===`text`&&n.text.trim().length>0&&(i=a),a+=1;flushTool(),s.push(...u),flushAssistant()}return{messages:n,outcomeEndsResponse:r>=0&&r>i}}function findProviderToolCallsToNormalize(e){let t=new Set;for(let n of e.messages){if(n.role!==`assistant`||!Array.isArray(n.content))continue;let r=n.content.some(t=>t.type===`tool-call`&&t.providerExecuted!==!0&&!e.providerExecutedOutcomeIds.has(t.toolCallId));for(let i of n.content)i.type===`tool-call`&&e.providerExecutedOutcomeIds.has(i.toolCallId)&&(i.providerExecuted!==!0||r)&&t.add(i.toolCallId)}return t}export{normalizeProviderToolHistory};

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

@@ -0,0 +1,4 @@
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { SessionPublication } from "#harness/types.js";
+/** The events of one publication, in order. */
+export declare function eventsOf(publication: SessionPublication): readonly SessionEvent[];

package/dist/src/harness/publication.js

@@ -0,0 +1 @@
+function eventsOf(e){return Array.isArray(e)?e:[e]}export{eventsOf};

package/dist/src/harness/request-envelope.d.ts

@@ -1,5 +1,4 @@
 import type { ModelMessage, ToolSet } from "ai";
-import type { HarnessSession } from "#harness/types.js";
 /** Count only request content outside the durable model-visible history. */
 export declare function estimateRequestEnvelope(input: {
     readonly history: readonly ModelMessage[];
@@ -7,5 +6,3 @@ export declare function estimateRequestEnvelope(input: {
     readonly messages: readonly ModelMessage[];
     readonly tools: ToolSet;
 }): Promise<number>;
-export declare function getRequestEnvelopeTokens(session: HarnessSession): number | undefined;
-export declare function setRequestEnvelopeTokens(session: HarnessSession, tokens: number | undefined): HarnessSession;

package/dist/src/harness/request-envelope.js

@@ -1 +1 @@
-import{serializeInputSchema}from"#tools/schema.js";import{estimateTokens}from"#harness/token-estimate.js";async function estimateRequestEnvelope(e){let t=await Promise.all(Object.entries(e.tools).map(async([e,t])=>{let n=typeof t.inputSchema==`function`?t.inputSchema():t.inputSchema,r=n===void 0?void 0:`jsonSchema`in n?await n.jsonSchema:serializeInputSchema(n);return{name:e,description:t.description,inputSchema:r,id:t.type===`provider`?t.id:void 0,args:t.type===`provider`?t.args:void 0}}));return Math.max(0,estimateTokens({instructions:e.instructions,messages:e.messages,tools:t})-estimateTokens(e.history))}const REQUEST_ENVELOPE_STATE_KEY=`eve.harness.requestEnvelopeTokens`;function getRequestEnvelopeTokens(e){let t=e.state?.[REQUEST_ENVELOPE_STATE_KEY];return typeof t==`number`&&Number.isFinite(t)&&t>=0?t:void 0}function setRequestEnvelopeTokens(e,t){if(t===void 0&&e.state?.[REQUEST_ENVELOPE_STATE_KEY]===void 0)return e;let n={...e.state};return t===void 0?delete n[REQUEST_ENVELOPE_STATE_KEY]:n[REQUEST_ENVELOPE_STATE_KEY]=t,{...e,state:n}}export{estimateRequestEnvelope,getRequestEnvelopeTokens,setRequestEnvelopeTokens};
+import{serializeInputSchema}from"#tools/schema.js";import{estimateTokens}from"#harness/token-estimate.js";async function estimateRequestEnvelope(e){let t=await Promise.all(Object.entries(e.tools).map(async([e,t])=>{let n=typeof t.inputSchema==`function`?t.inputSchema():t.inputSchema,r=n===void 0?void 0:`jsonSchema`in n?await n.jsonSchema:serializeInputSchema(n);return{name:e,description:t.description,inputSchema:r,id:t.type===`provider`?t.id:void 0,args:t.type===`provider`?t.args:void 0}}));return Math.max(0,estimateTokens({instructions:e.instructions,messages:e.messages,tools:t})-estimateTokens(e.history))}export{estimateRequestEnvelope};

package/dist/src/harness/running-work.d.ts

@@ -0,0 +1,10 @@
+import type { SessionStateMap } from "#harness/types.js";
+export interface RunningWork {
+    /** Workflow runs a turn waits on, as `workflow-tool-runs.ts` encodes them. */
+    readonly calls: readonly unknown[];
+    /** Tasks, as `execution/tasks/table.ts` encodes them. */
+    readonly tasks: readonly unknown[];
+}
+export declare function readRunningWork(state: SessionStateMap | undefined): RunningWork;
+/** Replaces one part of the record; the record leaves the state once nothing runs. */
+export declare function writeRunningWork(state: SessionStateMap | undefined, part: Partial<RunningWork>): SessionStateMap | undefined;

package/dist/src/harness/running-work.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";const RUNNING_WORK_STATE_KEY=`eve.work`;function readRunningWork(e){let t=e?.[RUNNING_WORK_STATE_KEY];if(t===void 0)return{calls:[],tasks:[]};if(!isObject(t)||t.version!==1||t.calls!==void 0&&!Array.isArray(t.calls)||t.tasks!==void 0&&!Array.isArray(t.tasks))throw Error(`Corrupt running-work record: invalid version or shape.`);return{calls:Array.isArray(t.calls)?Array.from(t.calls):[],tasks:Array.isArray(t.tasks)?Array.from(t.tasks):[]}}function writeRunningWork(e,t){let n=readRunningWork(e),r=t.calls??n.calls,i=t.tasks??n.tasks;if(r.length===0&&i.length===0){let t={...e};return delete t[RUNNING_WORK_STATE_KEY],Object.keys(t).length===0?void 0:t}let a={version:1};return r.length>0&&(a.calls=r),i.length>0&&(a.tasks=i),{...e,[RUNNING_WORK_STATE_KEY]:a}}export{readRunningWork,writeRunningWork};

package/dist/src/harness/session-machine/cascade.d.ts

@@ -0,0 +1,17 @@
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { SessionView } from "#protocol/session-projection/tables.js";
+import { type Ref } from "#protocol/session-projection/tree.js";
+/**
+ * An owner's end ends everything under it, in the same commit. For each fact that ends an entity
+ * still holding open ones, this closes them first, leaves first, as their families close when
+ * an owner ends; the deliveries a turn consumed settle after it. Writers that already closed
+ * them leave nothing to add.
+ */
+export declare function cascade(view: SessionView, events: readonly SessionEvent[]): SessionEvent[];
+/** The facts that close everything open under `owner`, leaves first, as it its owner cut it. */
+export declare function closeUnder(view: SessionView, owner: Ref, reason: string): SessionEvent[];
+/**
+ * The facts that close the open entities `which` selects, leaves first, as a retry superseded
+ * them. The writer closes what each leaves open under it.
+ */
+export declare function supersede(view: SessionView, which: (ref: Ref) => boolean, reason: string): SessionEvent[];

package/dist/src/harness/session-machine/cascade.js

@@ -0,0 +1 @@
+import{FACT_CATALOG,isFactType,isTerminalType}from"#protocol/session-events/catalog.js";import{copyView,foldReceivedEvent}from"#protocol/session-projection/fold.js";import{isOpen,openUnder,refOf,rowOf,scopeOf}from"#protocol/session-projection/tree.js";const TREE_FAMILY={call:`call`,content:`part`,context:`change`,delivery:`delivery`,interaction:`interaction`,model:`run`,response:`response`,task:`task`,turn:`turn`},ENDS_WITH={call:{cut:`interrupted`,superseded:`abandoned`},change:{cut:`interrupted`,superseded:`interrupted`},delivery:{cut:`handled`,superseded:`handled`},interaction:{cut:`interrupted`,superseded:`abandoned`},response:{cut:`withdrawn`,superseded:`abandoned`},run:{cut:`interrupted`,superseded:`abandoned`},task:{cut:`cancelled`,superseded:`cancelled`},turn:{cut:`cancelled`,superseded:`cancelled`}};function cascade(e,t){if(!t.some(e=>isFactType(e.type)))return[...t];let n=copyView(e),r=[],apply=e=>{foldReceivedEvent(n,{...e,meta:{endOfLine:!1}}),r.push(stamped(n,e))},i=new Set(t.flatMap(t=>{let n=endedBy(e,t,!1);return n===void 0||n===`session`?[]:[`${n.family}:${n.id}`]})),cascaded=e=>e.filter(e=>!i.has(`${e.family}:${e.id}`));for(let e of t){let t=endedBy(n,e);if(t===void 0){apply(e);continue}let{outcome:r,reason:i}=e.data,a={reason:reasonFor(t,r,i),superseded:r===`abandoned`},o=copyView(n);foldReceivedEvent(o,{...e,meta:{endOfLine:!1}});let s=cascaded(openUnder(o,t)),after=e=>e.family===`delivery`&&t!==`session`;for(let e of s.filter(e=>!after(e)))apply(closing(n,e,a,t===`session`));apply(e);for(let e of s.filter(after))apply(closing(n,e,a,!1))}return r}function stamped(e,t){if(!isFactType(t.type))return t;let n=FACT_CATALOG[t.type],r=t.data,i=TREE_FAMILY[n.family],a=r[n.idField],o=i!==void 0&&typeof a==`string`&&rowOf(e,i,a)!==void 0?{family:i,id:a}:refOf(r.owner);if(o===void 0)return t;let s=scopeOf(e,o);return Object.keys(s).length===0?t:{...t,scope:s}}function closeUnder(e,t,n){let r=copyView(e);return openUnder(r,t).map(e=>{let t=closing(r,e,{reason:n,superseded:!1},!1);return foldReceivedEvent(r,{...t,meta:{endOfLine:!1}}),t})}function supersede(e,t,n){let r=copyView(e),i=[];for(let e of openUnder(r,`session`)){if(!isOpen(r,e)||!t(e))continue;let a=closing(r,e,{reason:n,superseded:!0},!1);foldReceivedEvent(r,{...a,meta:{endOfLine:!1}}),i.push(a)}return i}function reasonFor(e,t,n){if(e===`session`)return`session-ended`;switch(e.family){case`turn`:return t===`completed`?`turn-ended`:`turn-${t}`;case`run`:return t===`abandoned`?`model-call-retried`:`steered`;case`task`:return n??`task-ended`;case`interaction`:return n??`interaction-${t??`ended`}`;case`change`:return`context-change-failed`;default:return`${e.family}-${t??`ended`}`}}function endedBy(e,t,n=!0){if(!isFactType(t.type)||!isTerminalType(t.type))return;if(t.type===`session.ended`)return`session`;let r=FACT_CATALOG[t.type],i=TREE_FAMILY[r.family],a=t.data[r.idField];if(i===void 0||typeof a!=`string`)return;let o={family:i,id:a};return!n||isOpen(e,o)?o:void 0}function closing(e,t,n,r){let{reason:i,superseded:a}=n,o=ENDS_WITH[t.family],s=a?o.superseded:o.cut,c=scopeOf(e,t);switch(t.family){case`interaction`:return{data:{interactionId:t.id,outcome:s,reason:i},scope:c,type:`interaction.settled`};case`response`:return{data:{outcome:s,reason:i,responseId:t.id},type:`response.settled`};case`call`:return{data:{callId:t.id,outcome:s,reason:i},scope:c,type:`call.settled`};case`run`:return{data:{outcome:s,runId:t.id},scope:c,type:`model.settled`};case`task`:return{data:{outcome:s,reason:i,taskId:t.id},scope:c,type:`task.ended`};case`change`:return{data:{changeId:t.id,kind:rowOf(e,`change`,t.id).kind,outcome:s},scope:c,type:`context.settled`};case`delivery`:{let n=rowOf(e,`delivery`,t.id)?.turnId;return r||n===void 0?{data:{deliveryId:t.id,outcome:`failed`,reason:i},type:`delivery.settled`}:{data:{deliveryId:t.id,outcome:s,turnId:n},type:`delivery.settled`}}default:{let n=rowOf(e,`turn`,t.id)?.reply;return{data:{outcome:s,...n!==void 0&&n.length>0&&{reply:n},turnId:t.id},scope:c,type:`turn.settled`}}}}export{cascade,closeUnder,supersede};

package/dist/src/harness/session-machine/commit.d.ts

@@ -1,39 +1,39 @@
+import type { SessionEvent } from "#protocol/session-event.js";
 import type { ModelMessage } from "ai";
-import type { AuthorizationChallenge } from "#harness/authorization.js";
 import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { SessionProjection } from "#protocol/session-projection.js";
-import { type RelayChange } from "#harness/hitl/requests.js";
+import { type HitlStateChange } from "#harness/hitl/requests.js";
 import { type TurnState } from "./state.js";
 import type { SessionView } from "./view.js";
 /** What a machine transition returns; approval storage still has direct writers. */
-export interface Transition {
+export interface Transition extends HitlStateChange {
     readonly turn: TurnState;
-    readonly events: readonly UnstampedMessageStreamEvent[];
+    readonly events: readonly SessionEvent[];
     /** Messages the transition commits to the end of history. */
     readonly commit?: readonly ModelMessage[];
     /** The transition empties history, as `clear` does. */
     readonly clearsHistory?: true;
-    /** Every sign-in the session waits on once the transition applies; `[]` withdraws them all. */
-    readonly signIns?: readonly AuthorizationChallenge[];
-    /** Relay routes the transition records or retires. */
-    readonly relays?: RelayChange;
 }
-/** Publishes one event; `messages` is the conversation hooks see with it. */
-export type Publish = (event: UnstampedMessageStreamEvent, messages?: readonly ModelMessage[]) => Promise<void>;
+/**
+ * Publishes one event, or one transition's events as one commit; `messages` is the conversation as
+ * of the commit, for the reactions that read it.
+ */
+export type Publish = (publication: SessionEvent | readonly SessionEvent[], messages?: readonly ModelMessage[]) => Promise<void>;
 export declare function sessionView(projection: SessionProjection, state: SessionStateMap | undefined): SessionView;
 /**
- * Publishes a transition's events, then saves what it changed. A transition that changes history
- * needs a session restored with it.
+ * Publishes a transition's events as one commit, then saves what it changed. A transition that
+ * changes history needs a session restored with it.
  */
 export declare function applyTransition<T extends {
     readonly state?: SessionStateMap;
 }>(session: T, transition: Transition, publish: Publish, messages?: readonly ModelMessage[]): Promise<T>;
-/** Publishes a transition's events, in order. */
-export declare function publishTransition(transition: Transition, publish: Publish, messages?: readonly ModelMessage[]): Promise<void>;
 /** Saves what a transition changes once its events are published. */
 export declare function saveTransition<T extends {
     readonly state?: SessionStateMap;
 }>(session: T, transition: Transition): T;
-/** Drops the private records whose owner the projection shows closed. */
+/**
+ * Drops the private records whose row the projection shows done, the one way they retire: a
+ * relay's route once its asker settles the interaction, and a responder's once their answer
+ * settled. Admitted answers can still be refused while the rest of their batch waits.
+ */
 export declare function dropClosedRecords<T extends HarnessSessionBase>(session: T, projection: SessionProjection): T;

package/dist/src/harness/session-machine/commit.js

@@ -1 +1 @@
-import{readTurnState,writeTurnState}from"./state.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{getSessionUsage}from"#harness/turn-tag-state.js";import{readHitlState,writeHitlState}from"#harness/hitl/requests.js";function sessionView(e,t){let n=readHitlState(t);return{projection:e,relayedRequestIds:new Set(n.relays.keys()),signIns:n.signIns,turn:readTurnState(t),usage:getSessionUsage({state:t})}}const READS_HISTORY=new Set([`turn.started`,`step.started`,`turn.completed`]);async function applyTransition(e,t,n,r){return await publishTransition(t,n,r),saveTransition(e,t)}async function publishTransition(e,t,n){for(let r of e.events)await t(r,READS_HISTORY.has(r.type)?n:void 0)}function saveTransition(e,t){let n=writeTurnState(writeHitlState(e,t),t.turn),r=t.commit??[];if(t.clearsHistory!==!0&&r.length===0)return n;if(!(`history`in e))throw Error(`A transition that changes history needs the session's history.`);let{history:i}=e,a=t.clearsHistory?[]:validateHarnessModelMessages([...i,...r]);return{...n,history:a}}function dropClosedRecords(e,t){let n=[...readHitlState(e.state).relays.keys()].filter(e=>{let n=t.inputs[e];return n===void 0||n.status===`settled`});return writeHitlState(e,{relays:{retire:n}})}export{applyTransition,dropClosedRecords,publishTransition,saveTransition,sessionView};
+import{readTurnState,writeTurnState}from"./state.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{signInInteractionId}from"#harness/interaction-facts.js";import{readHitlState,writeHitlState}from"#harness/hitl/requests.js";function sessionView(e,t){let n=readHitlState(t);return{projection:e,relayedRequestIds:new Set(n.relays.keys()),responders:n.responders,signIns:n.signIns.filter(t=>e.view.interactions[signInInteractionId(t)]?.status!==`settled`),turn:readTurnState(t)}}async function applyTransition(e,t,n,r){return t.events.length>0&&await n(t.events,r),saveTransition(e,t)}function saveTransition(e,t){let n=writeTurnState(writeHitlState(e,t),t.turn),r=t.commit??[];if(t.clearsHistory!==!0&&r.length===0)return n;if(!(`history`in e))throw Error(`A transition that changes history needs the session's history.`);let{history:i}=e,a=t.clearsHistory?[]:validateHarnessModelMessages([...i,...r]);return{...n,history:a}}function dropClosedRecords(e,t){return writeHitlState(e,{},t.view)}export{applyTransition,dropClosedRecords,saveTransition,sessionView};

package/dist/src/harness/session-machine/current.d.ts

@@ -1,8 +1,15 @@
 import type { ContextReader } from "#context/key.js";
-import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
+import type { HarnessSessionBase, SessionPublication, SessionStateMap } from "#harness/types.js";
 import { type SessionProjection } from "#protocol/session-projection.js";
-import type { MessageStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { StoredLine } from "#protocol/session-events/envelope.js";
+import type { SessionView as PublicSessionView } from "#protocol/session-projection/tables.js";
 export declare function enterSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
+/**
+ * Enters a checkpointed projection directly, for a step that publishes without the session's
+ * state, as the session's end does.
+ */
+export declare function enterSessionProjectionAt(ctx: ContextReader, projection: SessionProjection | undefined): void;
 /** Enters the stored projection unless this step already did. */
 export declare function ensureSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
 /**
@@ -14,22 +21,31 @@ export declare function liveProjection(ctx?: ContextReader | undefined): Session
 export declare function currentProjection(ctx?: ContextReader | undefined): SessionProjection;
 /** The step's live projection, or the session's stored one when no step entered it. */
 export declare function projectionFor(ctx: ContextReader, state: SessionStateMap | undefined): SessionProjection;
-export declare function recordPublishedEvent(ctx: ContextReader, event: MessageStreamEvent | UnstampedMessageStreamEvent): void;
+/** The position of the next line the step writes. */
+export declare function nextLinePosition(ctx: ContextReader): number;
+/**
+ * Records that the step wrote one line at `position`: its commit folds into the public view, and
+ * its events into what the view can't hold.
+ */
+export declare function recordPublishedLine(ctx: ContextReader, line: StoredLine, position: number, events: readonly SessionEvent[]): void;
+/** The public view as of the last line the step wrote, if a step entered its projection. */
+export declare function enteredView(ctx: ContextReader): PublicSessionView | undefined;
+/** The projection after one line: its view, then what the view can't hold. */
+export declare function advance(projection: SessionProjection, line: StoredLine, position: number, events: readonly SessionEvent[]): SessionProjection;
+/** The public view as of the last line the step wrote. */
+export declare function currentView(ctx?: ContextReader | undefined): PublicSessionView;
 /** Records the session a transition the step published produced. */
 export declare function recordAppliedSession(ctx: ContextReader, session: HarnessSessionBase): void;
 /** The session the step's last applied transition produced, if it applied any. */
 export declare function appliedSession<T extends HarnessSessionBase>(ctx: ContextReader): T | undefined;
 export declare function saveSessionProjection<T extends HarnessSessionBase>(session: T, ctx: ContextReader): T;
-/**
- * The session saves the lifecycle its steps read. Calls and tasks are for the stream's readers,
- * which fold them from the events, and their outputs can be large, so the checkpoint omits them.
- */
+/** The session saves the coordinates and public view its steps read. */
 export declare function saveProjection<T extends HarnessSessionBase>(session: T, projection: SessionProjection): T;
 /** The projection one step reads and folds what it publishes into. */
 export interface StepProjection {
     read(): SessionProjection;
-    /** Folds an event no publish sink folded: the step runs without one. */
-    record(event: UnstampedMessageStreamEvent): void;
+    /** Folds a publication no sink folded, preserving its commit boundaries. */
+    record(publication: SessionPublication): void;
 }
 /**
  * A step's projection: the context's live one, which the publish sink folds, or, for a step

package/dist/src/harness/session-machine/current.js

@@ -1 +1 @@
-import{SESSION_PROJECTION_STATE_KEY,storedProjection}from"./view.js";import{foldSession,pruneSessionProjection}from"#protocol/session-projection.js";import{contextStorage}from"#context/container.js";const LIVE_PROJECTIONS_GLOBAL_KEY=Symbol.for(`eve.live-session-projections`),liveProjections=globalThis[LIVE_PROJECTIONS_GLOBAL_KEY]??=new WeakMap;function enterSessionProjection(e,t){liveProjections.set(e,{projection:storedProjection(t)})}function ensureSessionProjection(e,t){liveProjections.has(e)||enterSessionProjection(e,t)}function liveProjection(e=contextStorage.getStore()){return e===void 0?void 0:liveProjections.get(e)?.projection}function currentProjection(e=contextStorage.getStore()){let t=e===void 0?void 0:liveProjections.get(e);if(t===void 0)throw Error(`Session lifecycle requires an initialized projection.`);return t.projection}function projectionFor(e,t){return liveProjections.get(e)?.projection??storedProjection(t)}function recordPublishedEvent(e,t){let n=liveProjections.get(e);if(n===void 0)throw Error(`Session publication requires an initialized projection.`);let r=foldSession(n.projection,t);n.projection=t.type===`session.waiting`?pruneSessionProjection(r):r}const appliedSessions=new WeakMap;function recordAppliedSession(e,t){appliedSessions.set(e,t)}function appliedSession(e){return appliedSessions.get(e)}function saveSessionProjection(e,t){return saveProjection(e,currentProjection(t))}function saveProjection(e,t){let n={...t,calls:{},tasks:{}};return{...e,state:{...e.state,[SESSION_PROJECTION_STATE_KEY]:n}}}function stepProjection(e,t){if(e!==void 0)return ensureSessionProjection(e,t),{read:()=>currentProjection(e),record:t=>recordPublishedEvent(e,t)};let n=storedProjection(t);return{read:()=>n,record(e){let t=foldSession(n,e);n=e.type===`session.waiting`?pruneSessionProjection(t):t}}}export{appliedSession,currentProjection,ensureSessionProjection,enterSessionProjection,liveProjection,projectionFor,recordAppliedSession,recordPublishedEvent,saveProjection,saveSessionProjection,stepProjection};
+import{SESSION_PROJECTION_STATE_KEY,storedProjection}from"./view.js";import{copyView,foldLine}from"#protocol/session-projection/fold.js";import{contextStorage}from"#context/container.js";import{linesOf}from"#protocol/session-lines.js";import{foldSession}from"#protocol/session-projection.js";import{cascade}from"#harness/session-machine/cascade.js";import{eventsOf}from"#harness/publication.js";const LIVE_PROJECTIONS_GLOBAL_KEY=Symbol.for(`eve.live-session-projections`),liveProjections=globalThis[LIVE_PROJECTIONS_GLOBAL_KEY]??=new WeakMap;function enterSessionProjection(e,t){liveProjections.set(e,{projection:storedProjection(t)})}function enterSessionProjectionAt(e,t){liveProjections.set(e,{projection:t??storedProjection(void 0)})}function ensureSessionProjection(e,t){liveProjections.has(e)||enterSessionProjection(e,t)}function liveProjection(e=contextStorage.getStore()){return e===void 0?void 0:liveProjections.get(e)?.projection}function currentProjection(e=contextStorage.getStore()){let t=e===void 0?void 0:liveProjections.get(e);if(t===void 0)throw Error(`Session lifecycle requires an initialized projection.`);return t.projection}function projectionFor(e,t){return liveProjections.get(e)?.projection??storedProjection(t)}function nextLinePosition(e){return currentProjection(e).view.position}function recordPublishedLine(e,t,n,r){let i=liveProjections.get(e);if(i===void 0)throw Error(`Session publication requires an initialized projection.`);i.projection=advance(i.projection,t,n,r)}function advanceView(e,t,n){if(!(`facts`in t))return{...e,position:Math.max(e.position,n+1)};let r=copyView(e);return foldLine(r,t,n,{retention:`operational`}),r}function enteredView(e){return liveProjections.get(e)?.projection.view}function advance(e,t,n,r){return n<e.view.position?e:foldSession({...e,view:advanceView(e.view,t,n)},r)}function currentView(e=contextStorage.getStore()){return currentProjection(e).view}const appliedSessions=new WeakMap;function recordAppliedSession(e,t){appliedSessions.set(e,t)}function appliedSession(e){return appliedSessions.get(e)}function saveSessionProjection(e,t){return saveProjection(e,currentProjection(t))}function saveProjection(e,t){return{...e,state:{...e.state,[SESSION_PROJECTION_STATE_KEY]:t}}}function stepProjection(e,t){if(e!==void 0)return ensureSessionProjection(e,t),{read:()=>currentProjection(e),record:t=>{let n=cascade(currentProjection(e).view,eventsOf(t));for(let t of linesOf(n,new Date().toISOString())){let n=`facts`in t?t.facts:[t.progress];recordPublishedLine(e,t,nextLinePosition(e),n)}}};let n=storedProjection(t);return{read:()=>n,record(e){let t=cascade(n.view,eventsOf(e));for(let e of linesOf(t,new Date().toISOString())){let t=`facts`in e?e.facts:[e.progress];n=advance(n,e,n.view.position,t)}}}}export{advance,appliedSession,currentProjection,currentView,ensureSessionProjection,enterSessionProjection,enterSessionProjectionAt,enteredView,liveProjection,nextLinePosition,projectionFor,recordAppliedSession,recordPublishedLine,saveProjection,saveSessionProjection,stepProjection};