eve 0.71.3 → 0.72.1

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

@@ -0,0 +1,48 @@
+import type { ToolSet } from "ai";
+import type { HarnessToolDefinition } from "#harness/execute-tool.js";
+import type { GenerationSteering } from "#harness/generation-steering.js";
+import { type AnthropicCacheMarker } from "#harness/prompt-cache.js";
+import type { Step } from "#harness/step/context.js";
+import { type HarnessToolMap } from "#harness/types.js";
+/** The tools one model call offers, and the views of them the step reads afterwards. */
+export interface ModelTools {
+    /** What the AI SDK receives. */
+    readonly effectiveTools: ToolSet;
+    readonly modelTools: ToolSet;
+    /** Every tool the model can call, by name, for presenting its calls. */
+    readonly presentationTools: HarnessToolMap;
+    /** The advertised harness tools; they decide which calls defer to the runtime. */
+    readonly coordinationTools: HarnessToolMap;
+    /** Tools that can end the turn, with their `endsTurn` option. */
+    readonly endsTurnTools: EndsTurnTools;
+}
+/**
+ * Assembles the tools one model call offers: authored and dynamic subagent tools, task tools,
+ * provider tools, dynamic tools (which override a same-named authored tool), and `final_output`
+ * when the turn asks for a structured result.
+ */
+export declare function prepareModelTools(step: Step, input: {
+    readonly approvedTools: ReadonlySet<string>;
+    readonly model: import("ai").LanguageModel;
+    readonly disabledProviderTools?: ReadonlySet<string>;
+    readonly generation: GenerationSteering;
+    readonly marker: AnthropicCacheMarker | undefined;
+}): Promise<ModelTools>;
+/**
+ * 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 toolName: string;
+        readonly toolCallId: string;
+    };
+    readonly toolOutput: {
+        readonly type: string;
+        readonly error?: unknown;
+    };
+}): void;
+/** Appended to the model-facing description of every tool with `endsTurn: true`. */
+export declare const ENDS_TURN_TOOL_NOTE = "Calling this tool ends your turn once it succeeds: do not write a reply or call other tools in the same step. If it fails, you will see the error and can continue.";
+export type EndsTurnTools = ReadonlyMap<string, NonNullable<HarnessToolDefinition["endsTurn"]>>;

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

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{toModelSchema}from"#tools/schema.js";import{resolveModelProvider}from"#internal/gateway.js";import{buildDynamicSubagentTools}from"#context/dynamic-subagent-lifecycle.js";import{isTurnCancellation}from"#harness/turn-cancellation.js";import{requireSessionModelReference}from"#harness/types.js";import{withTaskTools}from"#execution/tasks/model-step.js";import{buildToolSetFromDefinitions,buildToolSetWithProviderTools}from"#harness/tools.js";import{buildDynamicTools}from"#context/build-dynamic-tools.js";import{FINAL_OUTPUT_TOOL_NAME,buildFinalOutputTool}from"#harness/final-output.js";import{applyLastToolCacheBreakpoint}from"#harness/prompt-cache.js";import{getAdvertisedTools}from"#harness/advertised-tools.js";const log=createLogger(`harness.tool-loop`);async function prepareModelTools(e,t){let{ctx:n}=e,{approvedTools:r,disabledProviderTools:i,marker:a}=t,o=withTaskTools(getAdvertisedTools({session:e.session,tools:buildHarnessToolsWithDynamicSubagents(e.config.tools,n)})),s=await buildToolSetWithProviderTools({approvedTools:r,disabledProviderTools:i,modelProvider:resolveModelProvider(t.model),modelReference:requireSessionModelReference(e.session),tools:o}),c=new Map(o);if(n!==void 0){let t=getAdvertisedTools({session:e.session,tools:buildDynamicTools(n)}),a=buildToolSetFromDefinitions({approvedTools:r,disabledProviderTools:i,tools:t});for(let[e,t]of Object.entries(a)){if(o.get(e)?.workflowId!==void 0)throw Error(`Dynamic tool "${e}" collides with a coordination-visible deferred tool.`);s[e]=t}let l=new Set;for(let e of t)l.has(e.name)||(l.add(e.name),c.set(e.name,e))}e.session.outputSchema!==void 0&&(s[FINAL_OUTPUT_TOOL_NAME]=buildFinalOutputTool(e.session.outputSchema));let l=await getAdvertisedTools({modelTools:s,session:e.session,tools:o});e.session=l.session;let{modelTools:u}=l,d=new Map;if(!e.hasDelegatedCaller&&e.session.outputSchema===void 0)for(let[e,t]of Object.entries(u)){let n=c.get(e)?.endsTurn;t.type!==`provider`&&n!==void 0&&n!==!1&&(d.set(e,n),n===!0&&(t.description=`${t.description??``}\n\n${ENDS_TURN_TOOL_NOTE}`.trimStart()))}let f=a?applyLastToolCacheBreakpoint(u,a):u;for(let e of Object.values(f)){e.inputSchema=toModelSchema(e.inputSchema,`input`),e.outputSchema!==void 0&&(e.outputSchema=toModelSchema(e.outputSchema,`output`));let n=e.execute;n!==void 0&&(e.execute=(...e)=>(t.generation.protectToolExecution(),n(...e)))}return e.frameworkToolNames=new Set([...c].filter(([,e])=>e.frameworkTool===!0).map(([e])=>e)),{coordinationTools:o,effectiveTools:f,endsTurnTools:d,modelTools:u,presentationTools:c}}function logToolExecutionError(e){e.toolOutput.type!==`tool-error`||isTurnCancellation(e.toolOutput.error)||logError(log,`tool execution failed`,e.toolOutput.error,{toolName:e.toolCall.toolName,toolCallId:e.toolCall.toolCallId})}function buildHarnessToolsWithDynamicSubagents(e,t){let n=new Map(e);if(t===void 0)return n;for(let e of buildDynamicSubagentTools(t)){if(n.has(e.name))throw Error(`Dynamic subagent "${e.name}" collides with another runtime-visible tool name.`);n.set(e.name,e)}return n}const ENDS_TURN_TOOL_NOTE=`Calling this tool ends your turn once it succeeds: do not write a reply or call other tools in the same step. If it fails, you will see the error and can continue.`;export{ENDS_TURN_TOOL_NOTE,logToolExecutionError,prepareModelTools};

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

@@ -0,0 +1,23 @@
+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";
+/**
+ * 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.
+ */
+export declare function gatewayModelId(model: LanguageModel): string | undefined;
+export declare function extractTokenUsageDelta(input: {
+    readonly costUsd: number | undefined;
+    readonly usage: HarnessStepResult["usage"] | undefined;
+}): 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.
+ */
+export declare function recordModelUsage(step: Step, input: {
+    readonly model: LanguageModel;
+    readonly result: HarnessStepResult;
+}): Promise<void>;

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

@@ -0,0 +1 @@
+import{formatLanguageModelGatewayId}from"#internal/runtime-model.js";import{accumulateTurnUsage,getTurnUsageState,setTurnUsageState}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){let n=accumulateTurnUsage({previous:getTurnUsageState(e.session.state),turnId:e.position().turnId,usage:extractTokenUsageDelta({costUsd:extractGatewayCostUsd(t.result.providerMetadata),usage:t.result.usage})});e.session=setTurnUsageState(e.session,n),await setEveAttributes({"$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})}export{extractGatewayCostUsd,extractTokenUsageDelta,gatewayModelId,recordModelUsage};

package/dist/src/harness/nested-actions.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessEmissionState } from "#harness/emission-state.js";
+import type { TurnPosition } from "#harness/session-machine/view.js";
 import type { HarnessEmitFn } from "#harness/types.js";
 import type { JsonObject } from "#shared/json.js";
 /**
@@ -20,4 +20,4 @@ export declare function reportNestedToolAction(parentCallId: string, action: Nes
  * `actions.requested` and `action.result` pair. Call ids derive from the
  * parent's, so a re-run step reports the same ids.
  */
-export declare function emitNestedToolActions(emitFn: HarnessEmitFn, state: Pick<HarnessEmissionState, "sequence" | "stepIndex" | "turnId">, parentCallId: string): Promise<void>;
+export declare function emitNestedToolActions(emitFn: HarnessEmitFn, state: Pick<TurnPosition, "sequence" | "stepIndex" | "turnId">, parentCallId: string): Promise<void>;

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

@@ -5,7 +5,7 @@ import type { WebSearchProvider } from "#shared/web-search.js";
 /**
  * The provider backend resolved for one web search tool invocation.
  */
-type WebSearchBackend = "anthropic" | "exa" | "google" | "openai" | "parallel";
+type WebSearchBackend = "anthropic" | "exa" | "google" | "openai" | "parallel" | "browserbase";
 /**
  * Returns the framework tool name that produced an upstream provider tool
  * `type`, or `null` when the type is not one we know how to remove.
@@ -19,7 +19,7 @@ export declare function resolveFrameworkToolFromUpstreamType(type: string): stri
  * Returns the output schema for the provider-managed web search tool that
  * will be injected for `backend`.
  */
-export declare function resolveWebSearchOutputSchema(backend: WebSearchBackend): JsonObject;
+export declare function resolveWebSearchOutputSchema(backend: Exclude<WebSearchBackend, "browserbase">): JsonObject;
 /**
  * Determines the web search backend for a model reference.
  *

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

@@ -1 +1 @@
-import{jsonSchema}from"ai";import{WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA,WEB_SEARCH_EXA_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_NAME}from"#harness/provider-tool-schemas.js";const UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME={web_search_20250305:WEB_SEARCH_TOOL_NAME};function resolveFrameworkToolFromUpstreamType(e){return UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME[e]??null}function resolveWebSearchOutputSchema(e){switch(e){case`anthropic`:return WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA;case`exa`:return WEB_SEARCH_EXA_OUTPUT_SCHEMA;case`google`:return WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA;case`openai`:return WEB_SEARCH_OPENAI_OUTPUT_SCHEMA;case`parallel`:return WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA}}function resolveWebSearchBackend(e,t=`exa`,n){let r=n?.split(`.`)[0]??(e.source===void 0?`gateway`:e.id.split(`/`)[0]??``);return r===`gateway`?t:r===`openai`||r.startsWith(`openai.`)?`openai`:r===`anthropic`||r.startsWith(`anthropic.`)?`anthropic`:r===`google`||r.startsWith(`google.`)?`google`:null}async function resolveWebSearchProviderTool(e){switch(e){case`openai`:{let{openai:t}=await import(`#compiled/@ai-sdk/openai/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch({}),e)}case`anthropic`:{let{anthropic:t}=await import(`#compiled/@ai-sdk/anthropic/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch_20250305(),e)}case`google`:{let{google:t}=await import(`#compiled/@ai-sdk/google/index.js`);return attachWebSearchOutputSchema(t.tools.googleSearch({}),e)}case`exa`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.exaSearch({contents:{highlights:{maxCharacters:1e3}},numResults:10}),e)}case`parallel`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.parallelSearch(),e)}}}function attachWebSearchOutputSchema(e,t){return{...e,outputSchema:jsonSchema(resolveWebSearchOutputSchema(t))}}export{resolveFrameworkToolFromUpstreamType,resolveWebSearchBackend,resolveWebSearchOutputSchema,resolveWebSearchProviderTool};
+import{jsonSchema}from"ai";import{WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA,WEB_SEARCH_EXA_OUTPUT_SCHEMA,WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA,WEB_SEARCH_OPENAI_OUTPUT_SCHEMA,WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA,WEB_SEARCH_TOOL_NAME}from"#harness/provider-tool-schemas.js";const UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME={web_search_20250305:WEB_SEARCH_TOOL_NAME};function resolveFrameworkToolFromUpstreamType(e){return UPSTREAM_TOOL_TYPE_TO_FRAMEWORK_NAME[e]??null}function resolveWebSearchOutputSchema(e){switch(e){case`anthropic`:return WEB_SEARCH_ANTHROPIC_OUTPUT_SCHEMA;case`exa`:return WEB_SEARCH_EXA_OUTPUT_SCHEMA;case`google`:return WEB_SEARCH_GOOGLE_OUTPUT_SCHEMA;case`openai`:return WEB_SEARCH_OPENAI_OUTPUT_SCHEMA;case`parallel`:return WEB_SEARCH_PARALLEL_OUTPUT_SCHEMA}}function resolveWebSearchBackend(e,t=`exa`,n){let r=n?.split(`.`)[0]??(e.source===void 0?`gateway`:e.id.split(`/`)[0]??``);return r===`gateway`?t:r===`openai`||r.startsWith(`openai.`)?`openai`:r===`anthropic`||r.startsWith(`anthropic.`)?`anthropic`:r===`google`||r.startsWith(`google.`)?`google`:null}async function resolveWebSearchProviderTool(e){switch(e){case`browserbase`:{let{gateway:e}=await import(`ai`);return e.tools.browserbaseSearch()}case`openai`:{let{openai:t}=await import(`#compiled/@ai-sdk/openai/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch({}),e)}case`anthropic`:{let{anthropic:t}=await import(`#compiled/@ai-sdk/anthropic/index.js`);return attachWebSearchOutputSchema(t.tools.webSearch_20250305(),e)}case`google`:{let{google:t}=await import(`#compiled/@ai-sdk/google/index.js`);return attachWebSearchOutputSchema(t.tools.googleSearch({}),e)}case`exa`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.exaSearch({contents:{highlights:{maxCharacters:1e3}},numResults:10}),e)}case`parallel`:{let{gateway:t}=await import(`ai`);return attachWebSearchOutputSchema(t.tools.parallelSearch(),e)}}}function attachWebSearchOutputSchema(e,t){return{...e,outputSchema:jsonSchema(resolveWebSearchOutputSchema(t))}}export{resolveFrameworkToolFromUpstreamType,resolveWebSearchBackend,resolveWebSearchOutputSchema,resolveWebSearchProviderTool};

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

@@ -1,10 +1,9 @@
 import type { SubagentInputRequestHookPayload } from "#channel/types.js";
-import type { PendingInputBatchEvent } from "#harness/pending-input-batches.js";
+import type { StepCoordinates as PendingInputBatchEvent } from "#harness/session-machine/view.js";
 import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
 import { type InputOption, type InputRequestKind } from "#shared/input.js";
 import { type SessionInboxAddress } from "#execution/session-inbox/address.js";
 import type { RemoteAgentBinding } from "#eve-channel/support.js";
-import { type InputResolvedStreamEvent } from "#protocol/message.js";
 /**
  * Marks a request as a workflow tool run's `ctx.ask()` question, rather than a
  * child session's. Its answer goes to the run's control hook, which carries
@@ -79,17 +78,10 @@ export declare function upsertProxyInputRequestState(input: {
     readonly forChildContinuationToken: string;
     readonly state: SessionStateMap | undefined;
 }): SessionStateMap | undefined;
-/**
- * Retires the requests `select` picks, which nobody can answer anymore, and
- * returns the `input.resolved` events that report them `cancelled` so
- * channels stop offering them. Publish the events as relayed.
- */
-export declare function withdrawProxyInputRequests<T extends {
+/** Removes every proxy route the predicate selects. */
+export declare function clearProxyInputRequestsWhere<T extends {
     readonly state?: SessionStateMap;
-}>(session: T, select: (requestId: string, route: ProxyInputRequest) => boolean): {
-    readonly events: readonly InputResolvedStreamEvent[];
-    readonly session: T;
-};
+}>(session: T, select: (route: ProxyInputRequest, requestId: string) => boolean): T;
 /** Removes only the request IDs whose responses were successfully forwarded. */
 export declare function retireProxyInputRequests<T extends {
     readonly state?: SessionStateMap;

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

@@ -1 +1 @@
-import{isSessionInboxAddress}from"#execution/session-inbox/address.js";import{inputOptionSchema}from"#shared/input.js";import{createInputResolvedEvent}from"#protocol/message.js";const PROXY_INPUT_REQUESTS_KEY=`eve.runtime.proxyInputRequests`,PROXY_INPUT_REQUEST_KINDS={question:!0,"session-limit":!0,"tool-approval":!0};function getProxyInputRequests(e){return new Map(Object.entries(readMap(e)))}function hasProxyInputRequests(e){for(let t of Object.keys(readMap(e)))return!0;return!1}function upsertProxyInputRequests(e){return{...e.session,state:upsertProxyInputRequestState({entries:e.entries,forChildContinuationToken:e.forChildContinuationToken,inputSource:e.inputSource,state:e.session.state})}}function upsertProxyInputRequestState(e){let t={};for(let[n,r]of Object.entries(readMap(e.state)))(r.childContinuationToken!==e.forChildContinuationToken||r.inputSource!==e.inputSource)&&(t[n]=r);for(let[n,r]of e.entries)t[n]=r;let n={...e.state};return Object.keys(t).length===0?delete n[PROXY_INPUT_REQUESTS_KEY]:n[PROXY_INPUT_REQUESTS_KEY]=t,Object.keys(n).length>0?n:void 0}function withdrawProxyInputRequests(e,t){let n=[],r=[];for(let[i,a]of Object.entries(readMap(e.state)))t(i,a)&&(n.push(i),r.push(createInputResolvedEvent({resolutions:[{kind:a.kind,outcome:`cancelled`,requestId:i}],...a.event})));return{events:r,session:retireProxyInputRequests(e,n)}}function retireProxyInputRequests(e,t){let n={...readMap(e.state)},r=!1;for(let e of t)Object.hasOwn(n,e)&&(delete n[e],r=!0);return r?writeMap(e,n):e}function toProxyInputRequestEntries(e){let t={approvalRequestIds:e.event.requests.flatMap(e=>e.kind===`tool-approval`?[e.requestId]:[]),requestIds:e.event.requests.map(e=>e.requestId)},n={sequence:e.event.sequence,stepIndex:e.event.stepIndex,turnId:e.event.turnId};return e.event.requests.map(r=>{let i={batch:t,childContinuationToken:e.childContinuationToken,...e.inputSource!==void 0&&{inputSource:e.inputSource},...e.remote!==void 0&&{remote:e.remote},event:n,kind:r.kind};return r.kind===`question`&&(i.question={...r.allowFreeform!==void 0&&{allowFreeform:r.allowFreeform},...r.options!==void 0&&{options:[...r.options]}}),e.childSessionInbox?.sessionId===e.childSessionId&&(i.childSessionInbox=e.childSessionInbox),[r.requestId,i]})}function readMap(e){let t=e?.[PROXY_INPUT_REQUESTS_KEY];if(typeof t!=`object`||!t||Array.isArray(t))return{};let n={};for(let[e,r]of Object.entries(t)){let t=parseProxyInputRequest(r,e);t!==void 0&&(n[e]=t)}return n}function writeMap(e,t){let n={...e.state};return Object.keys(t).length===0?(delete n[PROXY_INPUT_REQUESTS_KEY],{...e,state:Object.keys(n).length>0?n:void 0}):(n[PROXY_INPUT_REQUESTS_KEY]=t,{...e,state:n})}function parseProxyInputRequest(e,t){if(typeof e!=`object`||!e||Array.isArray(e)||!(`childContinuationToken`in e)||!(`kind`in e)||typeof e.childContinuationToken!=`string`||!isInputRequestKind(e.kind))return;let n=`remote`in e?parseRemoteAgentBinding(e.remote):void 0;if(`remote`in e&&n===void 0)return;let r=`inputSource`in e?e.inputSource:void 0;if(r!==void 0&&(typeof r!=`string`||r.length===0))return;let i=`event`in e?parseInputRequestEvent(e.event):void 0;if(i===void 0)return;let a=`batch`in e?parseProxyInputRequestBatch(e.batch):void 0,o=`workflowAsk`in e?parseWorkflowAskRoute(e.workflowAsk):void 0;if(`workflowAsk`in e&&o===void 0)return;let s=`runId`in e?e.runId:void 0;if(s!==void 0&&(typeof s!=`string`||s.length===0))return;let c=`question`in e?parseProxyInputQuestion(e.question):void 0;if(`question`in e&&c===void 0)return;let l=`childSessionInbox`in e?e.childSessionInbox:void 0;if(l!==void 0&&!isSessionInboxAddress(l))return;let u={childContinuationToken:e.childContinuationToken,event:i,kind:e.kind};return typeof r==`string`&&(u.inputSource=r),n!==void 0&&(u.remote=n),o!==void 0&&(u.workflowAsk=o),typeof s==`string`&&(u.runId=s),l!==void 0&&(u.childSessionInbox=l),a!==void 0&&a.requestIds.includes(t)&&(u.batch=a),c!==void 0&&(u.question=c),u}function parseInputRequestEvent(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`sequence`),n=Reflect.get(e,`stepIndex`),r=Reflect.get(e,`turnId`);if(typeof t==`number`&&typeof n==`number`&&typeof r==`string`)return{sequence:t,stepIndex:n,turnId:r}}function parseWorkflowAskRoute(e){if(typeof e!=`object`||!e)return;let t=Reflect.get(e,`control`);if(typeof t!=`string`||t.length===0)return;let n=parseProxyInputQuestion(Reflect.get(e,`question`));if(n!==void 0)return{control:t,question:n}}function parseRemoteAgentBinding(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`name`),n=Reflect.get(e,`url`),r=Reflect.get(e,`resolverId`),i=Reflect.get(e,`forwardPrincipal`),a=Reflect.get(e,`sessionId`);if(typeof t==`string`&&t&&typeof n==`string`&&n&&typeof a==`string`&&a&&(r===void 0||typeof r==`string`&&r)&&(i===void 0||typeof i==`boolean`))return{name:t,url:n,sessionId:a,...r!==void 0&&{resolverId:r},...i!==void 0&&{forwardPrincipal:i}}}function parseProxyInputQuestion(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t={},n=Reflect.get(e,`allowFreeform`);if(n!==void 0){if(typeof n!=`boolean`)return;t.allowFreeform=n}let r=Reflect.get(e,`options`);if(r!==void 0){let e=inputOptionSchema.array().safeParse(r);if(!e.success)return;t.options=e.data}return t}function parseProxyInputRequestBatch(e){if(typeof e!=`object`||!e||Array.isArray(e)||!(`approvalRequestIds`in e)||!(`requestIds`in e)||!isStringArray(e.approvalRequestIds)||!isStringArray(e.requestIds))return;let t=new Set(e.requestIds);if(!(t.size!==e.requestIds.length||e.approvalRequestIds.some(e=>!t.has(e))))return{approvalRequestIds:e.approvalRequestIds,requestIds:e.requestIds}}function isStringArray(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function isInputRequestKind(e){return typeof e==`string`&&Object.hasOwn(PROXY_INPUT_REQUEST_KINDS,e)}export{getProxyInputRequests,hasProxyInputRequests,retireProxyInputRequests,toProxyInputRequestEntries,upsertProxyInputRequestState,upsertProxyInputRequests,withdrawProxyInputRequests};
+import{isSessionInboxAddress}from"#execution/session-inbox/address.js";import{inputOptionSchema}from"#shared/input.js";const PROXY_INPUT_REQUESTS_KEY=`eve.runtime.proxyInputRequests`,PROXY_INPUT_REQUEST_KINDS={question:!0,"session-limit":!0,"tool-approval":!0};function getProxyInputRequests(e){return new Map(Object.entries(readMap(e)))}function hasProxyInputRequests(e){for(let t of Object.keys(readMap(e)))return!0;return!1}function upsertProxyInputRequests(e){return{...e.session,state:upsertProxyInputRequestState({entries:e.entries,forChildContinuationToken:e.forChildContinuationToken,inputSource:e.inputSource,state:e.session.state})}}function upsertProxyInputRequestState(e){let t={};for(let[n,r]of Object.entries(readMap(e.state)))(r.childContinuationToken!==e.forChildContinuationToken||r.inputSource!==e.inputSource)&&(t[n]=r);for(let[n,r]of e.entries)t[n]=r;let n={...e.state};return Object.keys(t).length===0?delete n[PROXY_INPUT_REQUESTS_KEY]:n[PROXY_INPUT_REQUESTS_KEY]=t,Object.keys(n).length>0?n:void 0}function clearProxyInputRequestsWhere(e,t){return retireProxyInputRequests(e,Object.entries(readMap(e.state)).filter(([e,n])=>t(n,e)).map(([e])=>e))}function retireProxyInputRequests(e,t){let n={...readMap(e.state)},r=!1;for(let e of t)Object.hasOwn(n,e)&&(delete n[e],r=!0);return r?writeMap(e,n):e}function toProxyInputRequestEntries(e){let t={approvalRequestIds:e.event.requests.flatMap(e=>e.kind===`tool-approval`?[e.requestId]:[]),requestIds:e.event.requests.map(e=>e.requestId)},n={sequence:e.event.sequence,stepIndex:e.event.stepIndex,turnId:e.event.turnId};return e.event.requests.map(r=>{let i={batch:t,childContinuationToken:e.childContinuationToken,...e.inputSource!==void 0&&{inputSource:e.inputSource},...e.remote!==void 0&&{remote:e.remote},event:n,kind:r.kind};return r.kind===`question`&&(i.question={...r.allowFreeform!==void 0&&{allowFreeform:r.allowFreeform},...r.options!==void 0&&{options:[...r.options]}}),e.childSessionInbox?.sessionId===e.childSessionId&&(i.childSessionInbox=e.childSessionInbox),[r.requestId,i]})}function readMap(e){let t=e?.[PROXY_INPUT_REQUESTS_KEY];if(typeof t!=`object`||!t||Array.isArray(t))return{};let n={};for(let[e,r]of Object.entries(t)){let t=parseProxyInputRequest(r,e);t!==void 0&&(n[e]=t)}return n}function writeMap(e,t){let n={...e.state};return Object.keys(t).length===0?(delete n[PROXY_INPUT_REQUESTS_KEY],{...e,state:Object.keys(n).length>0?n:void 0}):(n[PROXY_INPUT_REQUESTS_KEY]=t,{...e,state:n})}function parseProxyInputRequest(e,t){if(typeof e!=`object`||!e||Array.isArray(e)||!(`childContinuationToken`in e)||!(`kind`in e)||typeof e.childContinuationToken!=`string`||!isInputRequestKind(e.kind))return;let n=`remote`in e?parseRemoteAgentBinding(e.remote):void 0;if(`remote`in e&&n===void 0)return;let r=`inputSource`in e?e.inputSource:void 0;if(r!==void 0&&(typeof r!=`string`||r.length===0))return;let i=`event`in e?parseInputRequestEvent(e.event):void 0;if(i===void 0)return;let a=`batch`in e?parseProxyInputRequestBatch(e.batch):void 0,o=`workflowAsk`in e?parseWorkflowAskRoute(e.workflowAsk):void 0;if(`workflowAsk`in e&&o===void 0)return;let s=`runId`in e?e.runId:void 0;if(s!==void 0&&(typeof s!=`string`||s.length===0))return;let c=`question`in e?parseProxyInputQuestion(e.question):void 0;if(`question`in e&&c===void 0)return;let l=`childSessionInbox`in e?e.childSessionInbox:void 0;if(l!==void 0&&!isSessionInboxAddress(l))return;let u={childContinuationToken:e.childContinuationToken,event:i,kind:e.kind};return typeof r==`string`&&(u.inputSource=r),n!==void 0&&(u.remote=n),o!==void 0&&(u.workflowAsk=o),typeof s==`string`&&(u.runId=s),l!==void 0&&(u.childSessionInbox=l),a!==void 0&&a.requestIds.includes(t)&&(u.batch=a),c!==void 0&&(u.question=c),u}function parseInputRequestEvent(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`sequence`),n=Reflect.get(e,`stepIndex`),r=Reflect.get(e,`turnId`);if(typeof t==`number`&&typeof n==`number`&&typeof r==`string`)return{sequence:t,stepIndex:n,turnId:r}}function parseWorkflowAskRoute(e){if(typeof e!=`object`||!e)return;let t=Reflect.get(e,`control`);if(typeof t!=`string`||t.length===0)return;let n=parseProxyInputQuestion(Reflect.get(e,`question`));if(n!==void 0)return{control:t,question:n}}function parseRemoteAgentBinding(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`name`),n=Reflect.get(e,`url`),r=Reflect.get(e,`resolverId`),i=Reflect.get(e,`forwardPrincipal`),a=Reflect.get(e,`sessionId`);if(typeof t==`string`&&t&&typeof n==`string`&&n&&typeof a==`string`&&a&&(r===void 0||typeof r==`string`&&r)&&(i===void 0||typeof i==`boolean`))return{name:t,url:n,sessionId:a,...r!==void 0&&{resolverId:r},...i!==void 0&&{forwardPrincipal:i}}}function parseProxyInputQuestion(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t={},n=Reflect.get(e,`allowFreeform`);if(n!==void 0){if(typeof n!=`boolean`)return;t.allowFreeform=n}let r=Reflect.get(e,`options`);if(r!==void 0){let e=inputOptionSchema.array().safeParse(r);if(!e.success)return;t.options=e.data}return t}function parseProxyInputRequestBatch(e){if(typeof e!=`object`||!e||Array.isArray(e)||!(`approvalRequestIds`in e)||!(`requestIds`in e)||!isStringArray(e.approvalRequestIds)||!isStringArray(e.requestIds))return;let t=new Set(e.requestIds);if(!(t.size!==e.requestIds.length||e.approvalRequestIds.some(e=>!t.has(e))))return{approvalRequestIds:e.approvalRequestIds,requestIds:e.requestIds}}function isStringArray(e){return Array.isArray(e)&&e.every(e=>typeof e==`string`)}function isInputRequestKind(e){return typeof e==`string`&&Object.hasOwn(PROXY_INPUT_REQUEST_KINDS,e)}export{clearProxyInputRequestsWhere,getProxyInputRequests,hasProxyInputRequests,retireProxyInputRequests,toProxyInputRequestEntries,upsertProxyInputRequestState,upsertProxyInputRequests};

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

@@ -0,0 +1,28 @@
+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 TurnState } from "./state.js";
+import type { SessionView } from "./view.js";
+/** What a transition returns. Nothing else changes session state. */
+export interface Transition {
+    readonly turn: TurnState;
+    readonly events: readonly UnstampedMessageStreamEvent[];
+    /** 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[];
+}
+/** Publishes one event; `messages` is the conversation hooks see with it. */
+export type Publish = (event: UnstampedMessageStreamEvent, 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.
+ */
+export declare function applyTransition<T extends HarnessSessionBase>(session: T, transition: Transition, publish: Publish, messages?: readonly ModelMessage[]): Promise<T>;
+/** Drops the private records whose owner the projection shows closed. */
+export declare function dropClosedRecords<T extends HarnessSessionBase>(session: T, projection: SessionProjection): T;

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

@@ -0,0 +1 @@
+import{readTurnState,writeTurnState}from"./state.js";import{validateHarnessModelMessages}from"#harness/messages.js";import{getSessionUsage}from"#harness/turn-tag-state.js";import{clearProxyInputRequestsWhere,getProxyInputRequests}from"#harness/proxy-input-requests.js";import{clearPendingAuthorization,getPendingAuthorization,setPendingAuthorization}from"#harness/authorization.js";function sessionView(e,t){return{projection:e,relayedRequestIds:new Set(getProxyInputRequests(t).keys()),signIns:getPendingAuthorization(t)?.challenges??[],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){for(let e of t.events)await n(e,READS_HISTORY.has(e.type)?r:void 0);let i=t.signIns===void 0?e.state:t.signIns.length===0?clearPendingAuthorization(e.state):setPendingAuthorization(clearPendingAuthorization(e.state),{challenges:t.signIns}),a=writeTurnState({...e,state:i},t.turn),o=t.commit??[];if(t.clearsHistory!==!0&&o.length===0)return a;if(!(`history`in e))throw Error(`A transition that changes history needs the session's history.`);let{history:s}=e,c=t.clearsHistory?[]:validateHarnessModelMessages([...s,...o]);return{...a,history:c}}function dropClosedRecords(e,t){return clearProxyInputRequestsWhere(e,(e,n)=>{let r=t.inputs[n];return r===void 0||r.status===`settled`})}export{applyTransition,dropClosedRecords,sessionView};

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

@@ -0,0 +1,29 @@
+import type { ContextReader } from "#context/key.js";
+import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
+import { type SessionProjection } from "#protocol/session-projection.js";
+import type { MessageStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
+export declare function enterSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
+/** Enters the stored projection unless this step already did. */
+export declare function ensureSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
+/** The projection as of the last event the current step published. */
+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;
+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.
+ */
+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;
+}
+/**
+ * A step's projection: the context's live one, which the publish sink folds, or, for a step
+ * that runs without a context, a detached one the step folds itself.
+ */
+export declare function stepProjection(ctx: ContextReader | undefined, state: SessionStateMap | undefined): StepProjection;

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

@@ -0,0 +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 liveProjections=new WeakMap;function enterSessionProjection(e,t){liveProjections.set(e,{projection:storedProjection(t)})}function ensureSessionProjection(e,t){liveProjections.has(e)||enterSessionProjection(e,t)}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}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{currentProjection,ensureSessionProjection,enterSessionProjection,projectionFor,recordPublishedEvent,saveProjection,saveSessionProjection,stepProjection};

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

@@ -0,0 +1,6 @@
+import { type AuthorizationCompletedStreamEvent, type InputResolvedStreamEvent } from "#protocol/message.js";
+import type { SessionAuthorization, SessionInput } from "#protocol/session-projection.js";
+/** Reports an open request withdrawn: nobody may answer it anymore. */
+export declare function inputWithdrawn(input: SessionInput): InputResolvedStreamEvent;
+/** Reports an open sign-in withdrawn, as declined: its callback no longer resumes anything. */
+export declare function signInWithdrawn(attempt: SessionAuthorization, reason: string): AuthorizationCompletedStreamEvent;

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

@@ -0,0 +1 @@
+import{createAuthorizationCompletedEvent,createInputResolvedEvent}from"#protocol/message.js";function inputWithdrawn(e){return createInputResolvedEvent({resolutions:[{kind:e.request.kind,outcome:`cancelled`,requestId:e.request.requestId}],sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId})}function signInWithdrawn(e,t){return createAuthorizationCompletedEvent({attemptId:e.attemptId,candidateId:e.candidateId,name:e.name,outcome:`declined`,principalId:e.principalId,reason:t,sequence:e.sequence,stepIndex:e.stepIndex,taskId:e.taskId,turnId:e.turnId})}export{inputWithdrawn,signInWithdrawn};

package/dist/src/harness/session-machine/resolver-events.d.ts

@@ -0,0 +1,12 @@
+import { type RuntimeIdentity } from "#protocol/message.js";
+export declare function sessionStartedForResolvers(runtime?: RuntimeIdentity): import("#protocol/message.js").SessionStartedStreamEvent;
+export declare function turnStartedForResolvers(turn: {
+    readonly sequence: number;
+    readonly turnId: string;
+}): import("#protocol/message.js").TurnStartedStreamEvent;
+export declare function stepStartedForResolvers(step: {
+    readonly modelId: string;
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}): import("#protocol/message.js").StepStartedStreamEvent;

package/dist/src/harness/session-machine/resolver-events.js

@@ -0,0 +1 @@
+import{createSessionStartedEvent,createStepStartedEvent,createTurnStartedEvent}from"#protocol/message.js";function sessionStartedForResolvers(e){return createSessionStartedEvent({runtime:e})}function turnStartedForResolvers(e){return createTurnStartedEvent(e)}function stepStartedForResolvers(e){return createStepStartedEvent(e)}export{sessionStartedForResolvers,stepStartedForResolvers,turnStartedForResolvers};

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

@@ -0,0 +1,47 @@
+import type { ModelMessage } from "ai";
+import type { SessionAuthContext } from "#channel/types.js";
+import type { SessionStateMap, StepInput } from "#harness/types.js";
+import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import type { InputRequest } from "#shared/input.js";
+/** The coordinates of the model step a suspended step parked from. */
+export interface StepCoordinates {
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}
+/**
+ * A model step whose calls can't all settle yet: some await an approval, others the runtime.
+ * Its response stays out of history until every call it made has a result there, so a call
+ * never reaches the model without its result.
+ */
+export interface SuspendedStep {
+    readonly event: StepCoordinates;
+    /** The withheld response. Results join it as they arrive. */
+    readonly messages: readonly ModelMessage[];
+    /** Approvals the step still waits on. */
+    readonly requests: readonly InputRequest[];
+    /**
+     * Calls a person approved that haven't run. They run when the turn next calls the model, after
+     * its step starts and its budget allows it, as calls the model makes do.
+     */
+    readonly approved?: readonly InputRequest[];
+    /** Workflow and agent calls the runtime runs for the step. */
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    /** Who approved each task an approval started, by call id: the task runs as them. */
+    readonly approvers?: Readonly<Record<string, SessionAuthContext>>;
+    readonly responseAuthRequiredRequestIds?: readonly string[];
+    /** The caller whose turn parked the step; `null` when unauthenticated. */
+    readonly requester?: SessionAuthContext | null;
+}
+export interface TurnState {
+    /** Input that arrived before it could run: a partial answer, or input behind a policy pass. */
+    readonly queued?: StepInput;
+    readonly suspended: readonly SuspendedStep[];
+    /** Approval keys a `once()` approval granted for the rest of the session. */
+    readonly grants: readonly string[];
+}
+export declare const EMPTY_TURN_STATE: TurnState;
+export declare function readTurnState(state: SessionStateMap | undefined): TurnState;
+export declare function writeTurnState<T extends {
+    readonly state?: SessionStateMap;
+}>(session: T, turn: TurnState): T;

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

@@ -0,0 +1 @@
+const TURN_STATE_KEY=`eve.harness.turnState`,EMPTY_TURN_STATE={grants:[],suspended:[]};function readTurnState(e){return e?.[TURN_STATE_KEY]??EMPTY_TURN_STATE}function writeTurnState(e,t){let n={...e.state};return t.suspended.length===0&&t.queued===void 0&&t.grants.length===0?delete n[TURN_STATE_KEY]:n[TURN_STATE_KEY]=t,{...e,state:Object.keys(n).length===0?void 0:n}}export{EMPTY_TURN_STATE,readTurnState,writeTurnState};

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

@@ -0,0 +1,188 @@
+import type { ModelMessage, UserContent } from "ai";
+import type { SubagentAuthorizationEventHookPayload, SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { AuthorizationChallenge } from "#harness/authorization.js";
+import { type TurnWaitingOn, createSessionCompletedEvent, createSessionFailedEvent, type InputResolution, type RuntimeIdentity, type RuntimeTraceContext, type TaskCancelReason, type TaskStartedStreamEvent, type UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { RuntimeActionResult } from "#shared/action-types.js";
+import type { InputRequest } from "#shared/input.js";
+import type { JsonObject, JsonValue } from "#shared/json.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { Transition } from "./commit.js";
+import type { StepCoordinates, SuspendedStep, TurnState } from "./state.js";
+import { type SessionView } from "./view.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+export type ToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
+/**
+ * Input arrives: the session starts once, a turn opens unless one is open (steering joins it),
+ * and a message is received.
+ */
+export declare function receive(view: SessionView, input: {
+    readonly message?: string | UserContent;
+    readonly runtime?: RuntimeIdentity;
+    readonly trace?: RuntimeTraceContext;
+}): Transition;
+/** The open turn calls the model. */
+export declare function startStep(view: SessionView, input: {
+    readonly modelId: string;
+}): Transition;
+/**
+ * The open turn parks: on `"tasks"` while work it started runs, on `"input"` while a person must
+ * act on a sign-in, approval, or question. It resumes in the same turn.
+ */
+export declare function hold(view: SessionView, input: {
+    readonly on: TurnWaitingOn;
+}): Transition;
+/** Nothing is left to run: the turn completes, with its structured result when it has one. */
+export declare function finishTurn(view: SessionView, input?: {
+    readonly result?: JsonValue;
+}): Transition;
+/**
+ * The step failed. A recoverable failure parks the session for the user to retry; a terminal
+ * one ends it.
+ */
+export declare function fail(view: SessionView, failure: {
+    readonly code: string;
+    readonly details?: JsonObject;
+    readonly message: string;
+    readonly terminal?: {
+        readonly sessionId: string;
+    };
+}): Transition;
+/** The session waits for its next delivery. */
+export declare function idle(view: SessionView): Transition;
+export declare function sessionCompleted(usage: TokenUsage | undefined): ReturnType<typeof createSessionCompletedEvent>;
+export declare function sessionFailed(input: {
+    readonly code: string;
+    readonly details?: JsonObject;
+    readonly message: string;
+    readonly sessionId: string;
+    readonly usage: TokenUsage | undefined;
+}): ReturnType<typeof createSessionFailedEvent>;
+/** One call's result, ready for its step's transcript. */
+export interface SettledCall {
+    readonly part: ToolResultPart;
+    /** A runtime result, reported at the coordinates of the step that made the call. */
+    readonly result?: RuntimeActionResult;
+}
+/**
+ * Results reach the steps that made their calls. A step whose every call now has a result
+ * commits to history, where the model reads it.
+ */
+export declare function settle(view: SessionView, input: {
+    readonly results: readonly SettledCall[];
+}): {
+    commit: ModelMessage[];
+    events: UnstampedMessageStreamEvent[];
+    turn: {
+        queued?: import("../types.ts").StepInput;
+        grants: readonly string[];
+        suspended: SuspendedStep[];
+    };
+};
+/**
+ * A model response made calls the runtime runs. The response waits in a suspended step until
+ * every call it made has a result, so a call never reaches the model without its result.
+ */
+export declare function suspendStep(view: SessionView, step: Pick<SuspendedStep, "event" | "messages" | "tasks">): Transition;
+/** The step without the approved calls in `callIds`, which have run or joined the runtime. */
+export declare function withoutApproved(step: SuspendedStep, callIds: ReadonlySet<string>): SuspendedStep;
+/** Approved calls of suspended steps that haven't run. */
+export declare function approvedCalls(turn: TurnState): readonly InputRequest[];
+export declare function suspend(turn: TurnState, step: SuspendedStep): TurnState;
+/** The ids of the calls a step's response made, except provider-executed ones. */
+export declare function stepCallIds(step: Pick<SuspendedStep, "messages">): ReadonlySet<string>;
+/** Places a result right after the message that made its call. */
+export declare function withResult(messages: readonly ModelMessage[], part: ToolResultPart): ModelMessage[];
+/** A call started or reached a task. */
+export declare function startTask(view: SessionView, task: TaskStartedStreamEvent["data"]): Transition;
+export type TaskCallOutcome = {
+    readonly status: "completed";
+    readonly output?: JsonValue;
+} | {
+    readonly status: "failed";
+    readonly error: string;
+} | {
+    readonly status: "cancelled";
+    readonly reason?: TaskCancelReason;
+};
+/** A task's run settled calls: each reports its outcome, naming the task as it started. */
+export declare function settleTask(view: SessionView, input: {
+    readonly task: {
+        readonly id: string;
+        readonly kind?: TaskStartedStreamEvent["data"]["kind"];
+        readonly name?: string;
+    };
+    readonly calls: readonly {
+        readonly callId: string;
+        readonly turnId: string;
+    }[];
+    readonly outcome: TaskCallOutcome;
+}): Transition;
+/**
+ * A task or workflow run ended, on its own or cancelled: nobody can answer what it relayed, so
+ * each request still open is withdrawn.
+ */
+export declare function finishRun(view: SessionView, run: {
+    readonly taskId?: string;
+    readonly requestIds?: Iterable<string>;
+}): Transition;
+/**
+ * A child session or workflow run asks a question or for a sign-in. The session passes it up
+ * with its original coordinates, and the open turn waits on the call it serves.
+ * A child's fresh batch replaces its earlier one, whose open requests are withdrawn.
+ */
+export declare function relay(view: SessionView, input: {
+    readonly payload: SubagentInputRequestHookPayload | SubagentAuthorizationEventHookPayload;
+    readonly replacedRequestIds?: Iterable<string>;
+}): Transition;
+/**
+ * Answers to relayed requests are on their way to the asker: each request resolves here.
+ */
+export declare function receiveRelayedAnswer(input: {
+    readonly message: string | UserContent;
+    readonly sequence: number;
+    readonly turnId: string;
+}): import("#protocol/message.js").MessageReceivedStreamEvent;
+export declare function routeAnswer(view: SessionView, input: {
+    readonly children: readonly {
+        readonly event: StepCoordinates;
+        readonly resolutions: readonly InputResolution[];
+    }[];
+}): Transition;
+/**
+ * A workflow run's sign-in, reported to the session that owns the run, which relays it. Built
+ * where the run asks, at the coordinates of the call it serves.
+ */
+export declare function runSignIn(from: {
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly taskId?: string;
+    readonly turnId: string;
+}, challenge: AuthorizationChallenge, outcome?: "authorized" | "failed"): import("#protocol/message.js").AuthorizationCompletedStreamEvent | import("#protocol/message.js").AuthorizationRequiredStreamEvent;
+/** Sign-in callbacks arrived: each completion is reported at the coordinates of the turn that asked. */
+export declare function completeSignIn(view: SessionView, input: {
+    readonly completions: readonly AuthorizationChallenge[];
+}): Transition;
+/** Requests this session asked itself and still awaits; relayed requests answer elsewhere. */
+export declare function ownOpenRequestIds(view: Omit<SessionView, "turn">): ReadonlySet<string>;
+/** What the model reads for a call its turn's cancellation stopped before the call settled. */
+export declare const CANCELLED_CALL_RESULT = "The turn was cancelled before this call finished.";
+/**
+ * `session.cancel()`: the open turn ends cancelled. Its requests, its sign-ins, and every
+ * relayed request are withdrawn, since the cancel stops the work that asked them; its unsettled
+ * calls are stopped. The steps it ran commit to history, each unfinished call answered as
+ * cancelled, so the model sees that the work started and stopped.
+ */
+export declare function cancel(view: SessionView): Transition;
+/**
+ * `session.clear()`: everything the cleared history asked for is withdrawn, its approvals and
+ * the session-limit prompt and every sign-in, and the calls awaiting them stop. Requests relayed
+ * from live tasks stay: clearing doesn't stop the work that asked them.
+ */
+export declare function clear(view: SessionView, input: {
+    readonly sessionId: string;
+}): Transition;
+export {};

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

@@ -0,0 +1 @@
+import{activeTurnId,answeredCallIds,nextStepIndex,turnPosition}from"./view.js";import{inputWithdrawn,signInWithdrawn}from"./events.js";import{openInputs,openSignIns,turnCoordinates}from"#protocol/session-projection.js";import{createActionResultEvent,createAuthorizationCompletedEvent,createAuthorizationRequiredEvent,createContextClearedEvent,createInputRequestedEvent,createInputResolvedEvent,createMessageReceivedEvent,createResultCompletedEvent,createSessionCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTaskSettledEvent,createTaskStartedEvent,createTurnCancelledEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent,createTurnWaitingEvent}from"#protocol/message.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";const unchanged=(e,t)=>({events:t,turn:e.turn});function at(e){let t=turnPosition(e);return{sequence:t.sequence,stepIndex:t.stepIndex,turnId:activeTurnId(t)}}function receive(e,t){let n=turnPosition(e.projection),r=activeTurnId(n),i=[];return n.sessionStarted||i.push(createSessionStartedEvent({runtime:t.runtime,trace:t.trace})),n.turnId===``&&i.push(createTurnStartedEvent({sequence:n.sequence,trace:t.trace,turnId:r})),t.message!==void 0&&i.push(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:r})),unchanged(e,i)}function startStep(e,t){let{sequence:n,turnId:r}=at(e.projection);return unchanged(e,[createStepStartedEvent({modelId:t.modelId,sequence:n,stepIndex:nextStepIndex(e.projection),turnId:r})])}function hold(e,t){let{sequence:n,turnId:r}=turnPosition(e.projection);return r===``?unchanged(e,[]):unchanged(e,[createTurnWaitingEvent({on:t.on,sequence:n,turnId:r,usage:e.usage})])}function finishTurn(e,t={}){let{sequence:n,stepIndex:r,turnId:i}=at(e.projection),a=[];return t.result!==void 0&&a.push(createResultCompletedEvent({result:t.result,sequence:n,stepIndex:r,turnId:i})),e.projection.activeTurnId!==void 0&&a.push(createTurnCompletedEvent({sequence:n,turnId:i})),a.push(createSessionWaitingEvent(e.usage)),unchanged(e,a)}function fail(e,t){let{sequence:n,stepIndex:r,turnId:i}=at(e.projection),a=e.turn.suspended.filter(e=>(e.approved?.length??0)>0);return{commit:a.flatMap(cancelledTranscript),events:failedEvents(e,t,{sequence:n,stepIndex:r,turnId:i}),turn:{...e.turn,suspended:e.turn.suspended.filter(e=>!a.includes(e))}}}function failedEvents(e,t,n){let{sequence:r,stepIndex:i,turnId:a}=n,{code:o,details:s,message:c}=t;return[createStepFailedEvent({code:o,details:s,message:c,sequence:r,stepIndex:i,turnId:a}),createTurnFailedEvent({code:o,details:s,message:c,sequence:r,turnId:a}),t.terminal===void 0?createSessionWaitingEvent(e.usage):createSessionFailedEvent({code:o,details:s,message:c,sessionId:t.terminal.sessionId,usage:e.usage})]}function idle(e){return unchanged(e,[createSessionWaitingEvent(e.usage)])}function sessionCompleted(e){return createSessionCompletedEvent(e)}function sessionFailed(e){return createSessionFailedEvent(e)}function settle(e,t){let n=[],r=[...e.turn.suspended];for(let{part:e,result:i}of t.results){let t=r.findIndex(t=>stepCallIds(t).has(e.toolCallId)),a=r[t];a!==void 0&&(r[t]=withoutApproved({...a,messages:withResult(a.messages,e)},new Set([e.toolCallId])),i!==void 0&&n.push(createActionResultEvent({result:i,...a.event})))}let i=r.filter(isComplete);return{commit:i.flatMap(e=>e.messages),events:n,turn:{...e.turn,suspended:r.filter(e=>!i.includes(e))}}}function suspendStep(e,t){return{events:[],turn:suspend(e.turn,{...t,requests:[]})}}function withoutApproved(e,t){if(e.approved===void 0)return e;let n=e.approved.filter(e=>!t.has(e.action.callId));if(n.length===e.approved.length)return e;let{approved:r,...i}=e;return n.length===0?i:{...i,approved:n}}function approvedCalls(e){return e.suspended.flatMap(e=>e.approved??[])}function suspend(e,t){return{...e,suspended:[...e.suspended,t]}}function stepCallIds(e){let t=new Set;for(let n of e.messages)if(n.role===`assistant`&&typeof n.content!=`string`)for(let e of n.content)e.type===`tool-call`&&e.providerExecuted!==!0&&t.add(e.toolCallId);return t}function isComplete(e){if(e.requests.length>0)return!1;let t=answeredCallIds(e.messages);return[...stepCallIds(e)].every(e=>t.has(e))}function withResult(e,t){let n=[...e],r=n.findIndex(e=>e.role===`assistant`&&Array.isArray(e.content)&&e.content.some(e=>e.type===`tool-call`&&e.toolCallId===t.toolCallId)),i=n[r+1];return r>=0&&i?.role===`tool`?n[r+1]={...i,content:[...i.content,t]}:n.splice(r>=0?r+1:n.length,0,{content:[t],role:`tool`}),n}function startTask(e,t){return unchanged(e,[createTaskStartedEvent(t)])}function settleTask(e,t){let{outcome:n,task:r}=t;return unchanged(e,t.calls.map(e=>{let t={callId:e.callId,kind:r.kind,name:r.name,taskId:r.id,turnId:e.turnId};switch(n.status){case`completed`:return createTaskSettledEvent({...t,output:n.output,status:`completed`});case`failed`:return createTaskSettledEvent({...t,error:{message:n.error},status:`failed`});case`cancelled`:return createTaskSettledEvent(n.reason===void 0?{...t,status:`cancelled`}:{...t,cancel:{reason:n.reason},status:`cancelled`})}}))}function finishRun(e,t){let n=new Set(t.requestIds);return unchanged(e,openInputs(e.projection).filter(e=>n.has(e.request.requestId)||t.taskId!==void 0&&e.taskId===t.taskId).map(inputWithdrawn))}function relay(e,t){let{payload:n}=t,r=[...finishRun(e,{requestIds:t.replacedRequestIds}).events];if(n.kind===`subagent-input-request`){let{event:e}=n;r.push(createInputRequestedEvent({callId:n.callId,requests:e.requests,sequence:e.sequence,stepIndex:e.stepIndex,taskId:e.taskId,turnId:e.turnId}))}else{let{event:t}=n;if(r.push(t),t.type!==`authorization.required`)return unchanged(e,r)}return r.push(...hold(e,{on:`input`}).events),unchanged(e,r)}function receiveRelayedAnswer(e){return createMessageReceivedEvent(e)}function routeAnswer(e,t){let n=t.children.filter(e=>e.resolutions.length>0).map(e=>createInputResolvedEvent({resolutions:e.resolutions,...e.event}));return unchanged(e,n)}function runSignIn(e,t,n){let r={...authorizationEventFields(t),sequence:e.sequence,stepIndex:e.stepIndex,taskId:e.taskId,turnId:e.turnId};return n===void 0?createAuthorizationRequiredEvent({...r,description:`Sign in to ${t.name} to continue.`,webhookUrl:t.hookUrl}):createAuthorizationCompletedEvent({...r,outcome:n})}function completeSignIn(e,t){let n=at(e.projection);return unchanged(e,t.completions.map(t=>{let r=t.attemptId===void 0?void 0:e.projection.authorizations[t.attemptId];return createAuthorizationCompletedEvent({...authorizationEventFields(t),outcome:`authorized`,sequence:r?.sequence??n.sequence,stepIndex:r?.stepIndex??n.stepIndex,turnId:r?.turnId??n.turnId})}))}function ownOpenRequestIds(e){return new Set(openInputs(e.projection).filter(t=>t.callId===void 0&&t.taskId===void 0&&!e.relayedRequestIds.has(t.request.requestId)).map(e=>e.request.requestId))}const CANCELLED_CALL_RESULT=`The turn was cancelled before this call finished.`;function cancel(e){let{projection:t}=e,n=t.activeTurnId,r=e.turn.suspended.filter(e=>n!==void 0&&e.event.turnId===n||e.tasks.some(t=>!answeredCallIds(e.messages).has(t.callId))||(e.approved?.length??0)>0),i=new Set(r.flatMap(e=>e.requests.map(e=>e.requestId))),a=[...openInputs(t).filter(t=>t.turnId===n||i.has(t.request.requestId)||e.relayedRequestIds.has(t.request.requestId)||t.request.kind===`session-limit`).map(inputWithdrawn),...openSignIns(t).filter(e=>e.turnId===n).map(e=>signInWithdrawn(e,`Cancelled.`))];if(n!==void 0){let{sequence:e}=turnCoordinates(t);a.push(createTurnCancelledEvent({sequence:e,turnId:n}))}return a.push(createSessionWaitingEvent(e.usage)),{commit:r.flatMap(cancelledTranscript),events:a,signIns:[],turn:{...e.turn,suspended:e.turn.suspended.filter(e=>!r.includes(e))}}}function cancelledTranscript(e){let t=answeredCallIds(e.messages),n=[...e.messages];for(let r of e.messages)if(r.role===`assistant`&&typeof r.content!=`string`)for(let e of r.content)e.type===`tool-call`&&e.providerExecuted!==!0&&(t.has(e.toolCallId)||(n=withResult(n,{output:{type:`text`,value:CANCELLED_CALL_RESULT},toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-result`})));return n}function clear(e,t){let{projection:n}=e,{sequence:r,turnId:i}=turnCoordinates(n);return{clearsHistory:!0,events:[...openInputs(n).filter(t=>!e.relayedRequestIds.has(t.request.requestId)).map(inputWithdrawn),...openSignIns(n).map(e=>signInWithdrawn(e,`The context was cleared.`)),createContextClearedEvent({sequence:r,sessionId:t.sessionId,turnId:i}),createSessionWaitingEvent(e.usage)],turn:{grants:e.turn.grants,suspended:[]}}}export{CANCELLED_CALL_RESULT,approvedCalls,cancel,clear,completeSignIn,fail,finishRun,finishTurn,hold,idle,ownOpenRequestIds,receive,receiveRelayedAnswer,relay,routeAnswer,runSignIn,sessionCompleted,sessionFailed,settle,settleTask,startStep,startTask,stepCallIds,suspend,suspendStep,withResult,withoutApproved};

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

@@ -0,0 +1,58 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { ModelMessage } from "ai";
+import type { AuthorizationChallenge } from "#harness/authorization.js";
+import { type TaskToolCall } from "#execution/tasks/calls.js";
+import type { SessionStateMap, StepInput } from "#harness/types.js";
+import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
+import { type SessionProjection } from "#protocol/session-projection.js";
+import { type StepCoordinates, type SuspendedStep, type TurnState } from "./state.js";
+export type { StepCoordinates, SuspendedStep, TurnState } from "./state.js";
+export declare const SESSION_PROJECTION_STATE_KEY = "eve.harness.sessionProjection";
+/** What a transition sees. */
+export interface SessionView {
+    readonly turn: TurnState;
+    readonly projection: SessionProjection;
+    /** Requests this session relays for a child session or a workflow run, by `requestId`. */
+    readonly relayedRequestIds: ReadonlySet<string>;
+    /** The sign-in attempts the session waits on, with what completing them needs. */
+    readonly signIns: readonly AuthorizationChallenge[];
+    /** The session's token usage so far, which its waiting and terminal events report. */
+    readonly usage: TokenUsage;
+}
+/** Reads the authoritative lifecycle facts saved alongside execution state. */
+export declare function storedProjection(state: SessionStateMap | undefined): SessionProjection;
+/** Coordinates the next lifecycle event carries, and whether a turn is open. */
+export interface TurnPosition {
+    readonly sessionStarted: boolean;
+    readonly sequence: number;
+    readonly stepIndex: number;
+    /** The open turn's id, or `""` between turns. */
+    readonly turnId: string;
+    /** The open turn streamed assistant output, so steering can no longer restart it. */
+    readonly assistantOutputStarted?: boolean;
+}
+export declare function turnPosition(projection: SessionProjection): TurnPosition;
+/** The open turn's id, or the id the next turn takes. */
+export declare function activeTurnId(position: Pick<TurnPosition, "sequence" | "turnId">): string;
+export declare function isBetweenTurns(projection: SessionProjection): boolean;
+/** The index the open turn's next `step.started` takes. */
+export declare function nextStepIndex(projection: SessionProjection): number;
+/** Input the session holds until it can run. */
+export declare function queuedInput(state: SessionStateMap | undefined): StepInput | undefined;
+export declare function suspendedSteps(state: SessionStateMap | undefined): readonly SuspendedStep[];
+/** The ids of calls that already have a result in `messages`. */
+export declare function answeredCallIds(messages: readonly ModelMessage[]): ReadonlySet<string>;
+/** Workflow and agent calls of `step` the runtime still runs. */
+export declare function runningTasks(step: SuspendedStep): readonly RuntimeWorkflowTaskRequest[];
+/** What the turn waits on the runtime for: dispatched runs and the task tool calls. */
+export interface RuntimeWait {
+    readonly event: StepCoordinates;
+    readonly callIds: readonly string[];
+    readonly tasks: readonly RuntimeWorkflowTaskRequest[];
+    readonly taskToolCalls: readonly TaskToolCall[];
+    /** Who approved each task an approval started, by call id. */
+    readonly approvers: Readonly<Record<string, SessionAuthContext>>;
+}
+/** The calls suspended steps wait on the runtime for, or `undefined` when none do. */
+export declare function runtimeWait(state: SessionStateMap | undefined): RuntimeWait | undefined;