eve 0.74.0 → 0.75.1

package/dist/src/setup/scaffold/index.js

@@ -1 +1 @@
-import{WriteFileExistsError}from"./files.js";import{CURRENT_DIRECTORY_PROJECT_NAME,byokProviderEnvVar,isEveProject,scaffoldBaseProject}from"./create/project.js";import{scaffoldExtensionProject}from"./create/extension.js";import{DEFAULT_SLACK_CONNECTOR_SLUG,SLACK_CHANNEL_DEFAULT_ROUTE,deriveSlackConnectorSlug,ensureChannel,hasVercelHostFramework,isNextJsProject,listAuthoredChannels,normalizeSlackConnectorSlug,resolveVercelHostFrameworkPreset}from"./update/channels.js";import{SCAFFOLDABLE_CHANNELS}from"./channels-catalog.js";import{CONNECTION_CATALOG,CUSTOM_CONNECTION_SLUG,SUPPORTED_PROTOCOLS,catalogSlugs,effectiveProtocols,endpointForProtocol,getCatalogEntry,isValidConnectionSlug}from"./connections/catalog.js";import{ensureConnection,ensureConnectionDependencies,listAuthoredConnections}from"./update/connections.js";import{ensurePackageDependencies}from"./update/dependencies.js";import{HumanActionRequiredError}from"../human-action.js";export{CONNECTION_CATALOG,CURRENT_DIRECTORY_PROJECT_NAME,CUSTOM_CONNECTION_SLUG,DEFAULT_SLACK_CONNECTOR_SLUG,HumanActionRequiredError,SCAFFOLDABLE_CHANNELS,SLACK_CHANNEL_DEFAULT_ROUTE,SUPPORTED_PROTOCOLS,WriteFileExistsError,byokProviderEnvVar,catalogSlugs,deriveSlackConnectorSlug,effectiveProtocols,endpointForProtocol,ensureChannel,ensureConnection,ensureConnectionDependencies,ensurePackageDependencies,getCatalogEntry,hasVercelHostFramework,isEveProject,isNextJsProject,isValidConnectionSlug,listAuthoredChannels,listAuthoredConnections,normalizeSlackConnectorSlug,resolveVercelHostFrameworkPreset,scaffoldBaseProject,scaffoldExtensionProject};
+import{HumanActionRequiredError}from"../human-action.js";import{WriteFileExistsError}from"./files.js";import{CURRENT_DIRECTORY_PROJECT_NAME,byokProviderEnvVar,isEveProject,scaffoldBaseProject}from"./create/project.js";import{scaffoldExtensionProject}from"./create/extension.js";import{DEFAULT_SLACK_CONNECTOR_SLUG,SLACK_CHANNEL_DEFAULT_ROUTE,deriveSlackConnectorSlug,ensureChannel,hasVercelHostFramework,isNextJsProject,listAuthoredChannels,normalizeSlackConnectorSlug,resolveVercelHostFrameworkPreset}from"./update/channels.js";import{SCAFFOLDABLE_CHANNELS}from"./channels-catalog.js";import{CONNECTION_CATALOG,CUSTOM_CONNECTION_SLUG,SUPPORTED_PROTOCOLS,catalogSlugs,effectiveProtocols,endpointForProtocol,getCatalogEntry,isValidConnectionSlug}from"./connections/catalog.js";import{ensureConnection,ensureConnectionDependencies,listAuthoredConnections}from"./update/connections.js";import{ensurePackageDependencies}from"./update/dependencies.js";export{CONNECTION_CATALOG,CURRENT_DIRECTORY_PROJECT_NAME,CUSTOM_CONNECTION_SLUG,DEFAULT_SLACK_CONNECTOR_SLUG,HumanActionRequiredError,SCAFFOLDABLE_CHANNELS,SLACK_CHANNEL_DEFAULT_ROUTE,SUPPORTED_PROTOCOLS,WriteFileExistsError,byokProviderEnvVar,catalogSlugs,deriveSlackConnectorSlug,effectiveProtocols,endpointForProtocol,ensureChannel,ensureConnection,ensureConnectionDependencies,ensurePackageDependencies,getCatalogEntry,hasVercelHostFramework,isEveProject,isNextJsProject,isValidConnectionSlug,listAuthoredChannels,listAuthoredConnections,normalizeSlackConnectorSlug,resolveVercelHostFrameworkPreset,scaffoldBaseProject,scaffoldExtensionProject};

package/dist/src/setup/vercel-project.d.ts

@@ -20,7 +20,7 @@ interface PickTeamOptions extends VercelProjectOperationOptions {
     selectMessage?: (currentTeam: string) => string;
 }
 export interface LinkProjectOperationOptions extends CreatedProjectFrameworkOptions {
-    /** Configure 100% trace sampling when creating a Vercel project. */
+    /** Configure 100% trace sampling when creating a Vercel project. Defaults to true. */
     traceSampling?: boolean;
 }
 export declare function unresolvedProject(): ProjectResolution;
@@ -31,8 +31,7 @@ export declare function assertNewProjectNameAvailable(projectRoot: string, team:
  * The Vercel auth state, read-only. `cli-missing` (ENOENT) and `unavailable` (a
  * transient network/API fault) are each kept distinct from `logged-out` so a
  * caller never tells the user to log in when the real cause is a missing CLI or
- * an unreachable network. `logged-out` is claimed only from the explicit
- * not-authenticated diagnostic.
+ * an unreachable network.
  */
 export type VercelAuthStatus = "authenticated" | "logged-out" | "cli-missing" | "unavailable";
 export declare function getVercelAuthStatus(projectRoot: string, options?: VercelProjectOperationOptions): Promise<VercelAuthStatus>;

package/dist/src/shared/sandbox-provider.d.ts

@@ -73,10 +73,17 @@ export interface SandboxProviderSessionContext {
 export interface SandboxProviderHandle<Session extends SandboxSession = SandboxSession> {
     readonly sandbox: Session;
     onRuntimeShutdown(): Promise<void>;
-    onSessionDelete(options?: SandboxDeleteOptions): Promise<void>;
-    onSessionStop(): Promise<void>;
+    onSandboxDelete(options?: SandboxDeleteOptions): Promise<void>;
+    onSandboxStop(): Promise<void>;
 }
 export interface SandboxProviderImplementation<OpenOptions extends object | undefined, PreparedArtifact extends SandboxPreparedArtifact, SessionState, Session extends SandboxSession = SandboxSession> {
+    /**
+     * Permanently releases resources owned by a durable session after its terminal outcome.
+     * Implementations must be idempotent because the cleanup step may retry.
+     */
+    onSessionEnd?(context: SandboxProviderSessionContext, artifact: Readonly<PreparedArtifact>, state: Readonly<SessionState>, options: {
+        readonly reason: "completed" | "expired" | "failed";
+    }): Promise<void>;
     prepare(context: SandboxProviderPrepareContext): Promise<PreparedArtifact>;
     resume(context: SandboxProviderSessionContext, artifact: Readonly<PreparedArtifact>, state: Readonly<SessionState>): Promise<SandboxProviderHandle<Session>>;
     start(context: SandboxProviderSessionContext, options: Readonly<OpenOptions> | undefined, artifact: Readonly<PreparedArtifact>): Promise<{

package/dist/src/subagents/adapter.d.ts

@@ -3,7 +3,8 @@ import type { ChannelAdapter } from "#channel/adapter.js";
  * Framework adapter that bridges a child subagent session to its
  * parent.
  *
- * It proxies child `input.requested` events upward so the parent channel
- * can render HITL prompts and route responses back down to the child.
+ * It proxies child `input.requested` events upward so the parent channel can
+ * render HITL prompts and route responses back down to the child, and the
+ * `input.resolved` of requests only the child can close.
  */
 export declare const SUBAGENT_ADAPTER: ChannelAdapter;

package/dist/src/subagents/adapter.js

@@ -1 +1 @@
-import{createErrorId,createLogger}from"#internal/logging.js";import{ContinuationTokenKey,SessionIdKey,SessionInboxKey}from"#context/keys.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#subagents/adapter-state.js";const log=createLogger(`execution.subagent-adapter`),SUBAGENT_ADAPTER={kind:SUBAGENT_ADAPTER_KIND,async"approval.candidate"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`approval.candidate`},t)},async"approval.settled"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`approval.settled`},t)},async"authorization.required"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`authorization.required`},t)},async"authorization.completed"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`authorization.completed`},t)},async"input.requested"(e,t){let n=t.state;isSubagentAdapterState(n)&&await forwardSubagentInputRequestStep({hookPayload:{callId:n.callId,childContinuationToken:t.ctx.require(ContinuationTokenKey),childSessionId:t.ctx.require(SessionIdKey),childSessionInbox:t.ctx.get(SessionInboxKey),inputSource:t.inputSource,event:{requests:e.requests,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId},kind:`subagent-input-request`,subagentName:n.subagentName},parentContinuationToken:n.parentContinuationToken})}};async function forwardSubagentAuthorizationEvent(e,t){let n=t.state;isSubagentAdapterState(n)&&await forwardSubagentAuthorizationEventStep({hookPayload:{callId:n.callId,childSessionId:t.ctx.require(SessionIdKey),event:e,kind:`subagent-authorization-event`,subagentName:n.subagentName},parentContinuationToken:n.parentContinuationToken})}async function forwardSubagentAuthorizationEventStep(e){"use step";try{await resumeParentHook(e.parentContinuationToken,e.hookPayload)}catch(t){let n=createErrorId();throw log.warn(`failed to forward subagent authorization event to parent`,{callId:e.hookPayload.callId,childSessionId:e.hookPayload.childSessionId,errorId:n,eventType:e.hookPayload.event.type,parentContinuationToken:e.parentContinuationToken,subagentName:e.hookPayload.subagentName,error:t}),t}}async function forwardSubagentInputRequestStep(e){"use step";try{await resumeParentHook(e.parentContinuationToken,e.hookPayload)}catch(t){let n=createErrorId();throw log.warn(`failed to forward proxied HITL batch to parent`,{callId:e.hookPayload.callId,childContinuationToken:e.hookPayload.childContinuationToken,childSessionId:e.hookPayload.childSessionId,errorId:n,parentContinuationToken:e.parentContinuationToken,subagentName:e.hookPayload.subagentName,error:t}),t}}async function resumeParentHook(e,t){let{resumeHook:n}=await import(`#internal/workflow/runtime.js`);await n(e,t)}export{SUBAGENT_ADAPTER};
+import{createErrorId,createLogger}from"#internal/logging.js";import{ContinuationTokenKey,SessionIdKey,SessionInboxKey}from"#context/keys.js";import{resolvedForParent}from"#harness/proxy-input-requests.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#subagents/adapter-state.js";const log=createLogger(`execution.subagent-adapter`),SUBAGENT_ADAPTER={kind:SUBAGENT_ADAPTER_KIND,async"approval.candidate"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`approval.candidate`},t)},async"approval.settled"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`approval.settled`},t)},async"authorization.required"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`authorization.required`},t)},async"authorization.completed"(e,t){await forwardSubagentAuthorizationEvent({data:e,type:`authorization.completed`},t)},async"input.resolved"(e,t){let n=resolvedForParent(e);n!==void 0&&await forwardSubagentAuthorizationEvent({data:n,type:`input.resolved`},t)},async"input.requested"(e,t){let n=t.state;isSubagentAdapterState(n)&&await forwardSubagentInputRequestStep({hookPayload:{callId:n.callId,childContinuationToken:t.ctx.require(ContinuationTokenKey),childSessionId:t.ctx.require(SessionIdKey),childSessionInbox:t.ctx.get(SessionInboxKey),inputSource:t.inputSource,event:{requests:e.requests,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId},kind:`subagent-input-request`,subagentName:n.subagentName},parentContinuationToken:n.parentContinuationToken})}};async function forwardSubagentAuthorizationEvent(e,t){let n=t.state;isSubagentAdapterState(n)&&await forwardSubagentAuthorizationEventStep({hookPayload:{callId:n.callId,childSessionId:t.ctx.require(SessionIdKey),event:e,kind:`subagent-authorization-event`,subagentName:n.subagentName},parentContinuationToken:n.parentContinuationToken})}async function forwardSubagentAuthorizationEventStep(e){"use step";try{await resumeParentHook(e.parentContinuationToken,e.hookPayload)}catch(t){let n=createErrorId();throw log.warn(`failed to forward subagent authorization event to parent`,{callId:e.hookPayload.callId,childSessionId:e.hookPayload.childSessionId,errorId:n,eventType:e.hookPayload.event.type,parentContinuationToken:e.parentContinuationToken,subagentName:e.hookPayload.subagentName,error:t}),t}}async function forwardSubagentInputRequestStep(e){"use step";try{await resumeParentHook(e.parentContinuationToken,e.hookPayload)}catch(t){let n=createErrorId();throw log.warn(`failed to forward proxied HITL batch to parent`,{callId:e.hookPayload.callId,childContinuationToken:e.hookPayload.childContinuationToken,childSessionId:e.hookPayload.childSessionId,errorId:n,parentContinuationToken:e.parentContinuationToken,subagentName:e.hookPayload.subagentName,error:t}),t}}async function resumeParentHook(e,t){let{resumeHook:n}=await import(`#internal/workflow/runtime.js`);await n(e,t)}export{SUBAGENT_ADAPTER};

package/dist/src/subagents/callback-route.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{inputRequestSchema}from"#shared/input.js";import{jsonValueSchema}from"#shared/json-schemas.js";import{renameLegacyTaskCallback}from"#execution/legacy-remote-agent/protocol.js";import{resumeHook}from"#internal/workflow/runtime.js";import{agentTurnOutcomeWithCostSchema}from"#shared/agent-turn-outcome.js";const sessionInputCallbackSchema=z.object({callId:z.string().min(1),childContinuationToken:z.string().min(1),childSessionId:z.string().min(1),childSessionInbox:z.object({sessionId:z.string().min(1)}).strict().optional(),inputSource:z.string().min(1).optional(),remote:z.object({name:z.string().min(1),url:z.string().url(),forwardPrincipal:z.boolean().optional(),sessionId:z.string().min(1),resolverId:z.string().min(1).optional()}).strict().optional(),kind:z.literal(`subagent-input-request`),subagentName:z.string().min(1),event:z.object({requests:z.array(inputRequestSchema).min(1),sequence:z.number(),stepIndex:z.number(),taskId:z.string().optional(),turnId:z.string()})}),sessionAuthorizationCallbackSchema=z.object({callId:z.string().min(1),childSessionId:z.string().min(1),kind:z.literal(`subagent-authorization-event`),subagentName:z.string().min(1),event:z.discriminatedUnion(`type`,[z.object({type:z.literal(`approval.candidate`),data:z.object({candidateId:z.string(),outcome:z.enum([`pending`,`rejected`,`failed`,`timed-out`,`stale`]),requestId:z.string(),responderPrincipalId:z.string(),reason:z.string().optional(),sequence:z.number(),stepIndex:z.number(),turnId:z.string()}).passthrough()}),z.object({type:z.literal(`approval.settled`),data:z.object({outcome:z.enum([`approved`,`cancelled`]),requestId:z.string(),responderPrincipalId:z.string(),sequence:z.number(),stepIndex:z.number(),turnId:z.string()}).passthrough()}),z.object({type:z.literal(`authorization.required`),data:z.object({description:z.string(),name:z.string(),sequence:z.number(),stepIndex:z.number(),turnId:z.string(),webhookUrl:z.string().optional(),attemptId:z.string().optional(),taskId:z.string().optional(),principalId:z.string().optional()}).passthrough()}),z.object({type:z.literal(`authorization.completed`),data:z.object({name:z.string(),outcome:z.enum([`authorized`,`declined`,`failed`,`timed-out`]),sequence:z.number(),stepIndex:z.number(),turnId:z.string(),attemptId:z.string().optional(),taskId:z.string().optional(),principalId:z.string().optional()}).passthrough()})])}),sessionResultCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string().min(1),kind:z.literal(`turn.completed`),outcome:agentTurnOutcomeWithCostSchema,output:jsonValueSchema.optional(),subagentName:z.string().min(1)}),z.object({callId:z.string().min(1),error:jsonValueSchema,kind:z.literal(`turn.failed`),outcome:agentTurnOutcomeWithCostSchema,subagentName:z.string().min(1)})]);async function handleSessionCallbackRequest(e,t){let n=t.params.token;if(typeof n!=`string`||n.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let r;try{r=renameLegacyTaskCallback(await e.json())}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let i=callbackKind(r),a=i===`subagent-input-request`?sessionInputCallbackSchema.safeParse(r):i===`subagent-authorization-event`?sessionAuthorizationCallbackSchema.safeParse(r):void 0;if(a!==void 0&&!a.success)return Response.json({error:`Invalid session input callback.`,ok:!1},{status:400});let o=a===void 0?projectSessionCallbackResult(r):void 0;if(o instanceof Response)return o;try{await resumeHook(n,a?.success?a.data:{kind:`runtime-action-result`,results:[o]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function callbackKind(e){if(typeof e==`object`&&e)return Reflect.get(e,`kind`)}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=callbackKind(e);if(t!==`turn.completed`&&t!==`turn.failed`)return Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400});let n=sessionResultCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid session result callback.`,ok:!1},{status:400});let r=n.data;return r.kind===`turn.completed`?{callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.output??``,subagentName:r.subagentName,usage:r.outcome.usageDelta}:{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.error,subagentName:r.subagentName}}export{handleSessionCallbackRequest};
+import{z}from"#compiled/zod/index.js";import{inputRequestSchema,inputResponseSchema}from"#shared/input.js";import{jsonValueSchema}from"#shared/json-schemas.js";import{resumeHook}from"#internal/workflow/runtime.js";import{renameLegacyTaskCallback}from"#execution/legacy-remote-agent/protocol.js";import{agentTurnOutcomeWithCostSchema}from"#shared/agent-turn-outcome.js";const sessionInputCallbackSchema=z.object({callId:z.string().min(1),childContinuationToken:z.string().min(1),childSessionId:z.string().min(1),childSessionInbox:z.object({sessionId:z.string().min(1)}).strict().optional(),inputSource:z.string().min(1).optional(),remote:z.object({name:z.string().min(1),url:z.string().url(),forwardPrincipal:z.boolean().optional(),sessionId:z.string().min(1),resolverId:z.string().min(1).optional()}).strict().optional(),kind:z.literal(`subagent-input-request`),subagentName:z.string().min(1),event:z.object({requests:z.array(inputRequestSchema).min(1),sequence:z.number(),stepIndex:z.number(),taskId:z.string().optional(),turnId:z.string()})}),sessionAuthorizationCallbackSchema=z.object({callId:z.string().min(1),childSessionId:z.string().min(1),kind:z.literal(`subagent-authorization-event`),subagentName:z.string().min(1),event:z.discriminatedUnion(`type`,[z.object({type:z.literal(`approval.candidate`),data:z.object({candidateId:z.string(),outcome:z.enum([`pending`,`rejected`,`failed`,`timed-out`,`stale`]),requestId:z.string(),responderPrincipalId:z.string(),reason:z.string().optional(),sequence:z.number(),stepIndex:z.number(),turnId:z.string()}).passthrough()}),z.object({type:z.literal(`approval.settled`),data:z.object({outcome:z.enum([`approved`,`cancelled`]),requestId:z.string(),responderPrincipalId:z.string(),sequence:z.number(),stepIndex:z.number(),turnId:z.string()}).passthrough()}),z.object({type:z.literal(`input.resolved`),data:z.object({resolutions:z.array(z.object({kind:z.enum([`question`,`session-limit`,`tool-approval`]),outcome:z.enum([`answered`,`approved`,`cancelled`,`denied`,`ignored`,`invalid`]),requestId:z.string(),response:inputResponseSchema.optional()}).passthrough()),sequence:z.number(),stepIndex:z.number(),turnId:z.string()}).passthrough()}),z.object({type:z.literal(`authorization.required`),data:z.object({description:z.string(),name:z.string(),sequence:z.number(),stepIndex:z.number(),turnId:z.string(),webhookUrl:z.string().optional(),attemptId:z.string().optional(),taskId:z.string().optional(),principalId:z.string().optional()}).passthrough()}),z.object({type:z.literal(`authorization.completed`),data:z.object({name:z.string(),outcome:z.enum([`authorized`,`declined`,`failed`,`timed-out`]),sequence:z.number(),stepIndex:z.number(),turnId:z.string(),attemptId:z.string().optional(),taskId:z.string().optional(),principalId:z.string().optional()}).passthrough()})])}),sessionResultCallbackSchema=z.discriminatedUnion(`kind`,[z.object({callId:z.string().min(1),kind:z.literal(`turn.completed`),outcome:agentTurnOutcomeWithCostSchema,output:jsonValueSchema.optional(),subagentName:z.string().min(1)}),z.object({callId:z.string().min(1),error:jsonValueSchema,kind:z.literal(`turn.failed`),outcome:agentTurnOutcomeWithCostSchema,subagentName:z.string().min(1)})]);async function handleSessionCallbackRequest(e,t){let n=t.params.token;if(typeof n!=`string`||n.length===0)return Response.json({error:`Missing callback token.`,ok:!1},{status:400});let r;try{r=renameLegacyTaskCallback(await e.json())}catch{return Response.json({error:`Invalid JSON body.`,ok:!1},{status:400})}let i=callbackKind(r),a=i===`subagent-input-request`?sessionInputCallbackSchema.safeParse(r):i===`subagent-authorization-event`?sessionAuthorizationCallbackSchema.safeParse(r):void 0;if(a!==void 0&&!a.success)return Response.json({error:`Invalid session input callback.`,ok:!1},{status:400});let o=a===void 0?projectSessionCallbackResult(r):void 0;if(o instanceof Response)return o;try{await resumeHook(n,a?.success?a.data:{kind:`runtime-action-result`,results:[o]})}catch{return Response.json({error:`Session callback not pending.`,ok:!1},{status:404})}return Response.json({ok:!0},{status:202})}function callbackKind(e){if(typeof e==`object`&&e)return Reflect.get(e,`kind`)}function projectSessionCallbackResult(e){if(typeof e!=`object`||!e)return Response.json({error:`Expected a JSON object.`,ok:!1},{status:400});let t=callbackKind(e);if(t!==`turn.completed`&&t!==`turn.failed`)return Response.json({error:`Unsupported callback kind.`,ok:!1},{status:400});let n=sessionResultCallbackSchema.safeParse(e);if(!n.success)return Response.json({error:`Invalid session result callback.`,ok:!1},{status:400});let r=n.data;return r.kind===`turn.completed`?{callId:r.callId,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.output??``,subagentName:r.subagentName,usage:r.outcome.usageDelta}:{callId:r.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:r.outcome,output:r.error,subagentName:r.subagentName}}export{handleSessionCallbackRequest};

package/dist/src/subagents/hitl-proxy.d.ts

@@ -45,9 +45,10 @@ export interface RoutedDeliverPayload {
 /**
  * Splits a deliver payload into parent-local and proxied-child buckets.
  *
- * With `resolveMessage`, a plain-text message is also resolved against pending
- * `ctx.ask()` questions: when exactly one question is pending, a matching option or
- * permitted free text answers it and consumes the message along with its
+ * With `resolveMessage`, a plain-text message is also resolved against the
+ * first open request when a child asked it, whether a `ctx.ask()` question, a
+ * tool approval, or a session-limit prompt: a matching option or permitted free
+ * text answers that one request, and the message is consumed along with its
  * `context`. Otherwise the message stays with the parent.
  */
 export declare function routeDeliverPayload(input: {

package/dist/src/subagents/hitl-proxy.js

@@ -1 +1 @@
-import{inputTextKey,readAnswerText}from"#internal/input-text.js";import{firstOpenInput}from"#harness/open-input-request.js";import{resolveTextToResponse}from"#channel/resolve-text.js";import{storedProjection}from"#harness/session-machine/view.js";import{getProxyInputRequests}from"#harness/proxy-input-requests.js";import{resolveInputOutcome}from"#harness/input-request-resolution.js";import{SESSION_LIMIT_STOP_OPTION_ID}from"#harness/hitl/budget-request.js";const CONSUMED_MESSAGE_KEYS=new Set([`context`,`message`,inputTextKey]);function routeDeliverPayload(e){let t=getProxyInputRequests(e.state),routable=(t,n)=>n!==void 0&&e.allowRoute?.(t,n)!==!1,n=resolveMessageAgainstQuestions({enabled:e.resolveMessage===!0,entries:t,payload:e.payload,routable,state:e.state}),[r]=n.responses,i=[...e.payload.inputResponses??[],...n.responses],a=new Map,o=[],s,bucketFor=e=>{let t=JSON.stringify([e.childContinuationToken,e.childSessionInbox?.sessionId??``,e.remote?.sessionId??``,e.event.sequence,e.event.stepIndex,e.event.turnId,e.inputSource??null]),n=a.get(t);if(n!==void 0)return n;let r={childContinuationToken:e.childContinuationToken,remote:e.remote,event:e.event,parentRequestIds:[],responses:[],routes:[],...e.childSessionInbox!==void 0&&{childSessionInbox:e.childSessionInbox},...e.workflowAsk!==void 0&&{workflowAsk:e.workflowAsk}};return a.set(t,r),r},c=new Set;for(let e of i){let n=t.get(e.requestId);if(n===void 0||!routable(e.requestId,n)){o.push(e);continue}if(c.has(e.requestId))continue;c.add(e.requestId),n.kind===`session-limit`&&e.optionId===SESSION_LIMIT_STOP_OPTION_ID&&(s={kind:`cancel-turn`});let r=bucketFor(n);r.parentRequestIds.push(e.requestId),r.responses.push(e),r.routes.push(n)}let l=[...a.values()].map(({workflowAsk:n,remote:i,childContinuationToken:a,childSessionInbox:o,event:s,parentRequestIds:c,responses:l,routes:u})=>{let d=new Set(c),f=new Set(d);for(let e of u)if(e.batch!==void 0&&batchResolves({batch:e.batch,childContinuationToken:a,entries:t,responseIds:d}))for(let t of e.batch.requestIds)f.add(t);return{childContinuationToken:a,payload:{inputResponses:l},resolved:{event:s,resolutions:resolveRetiredRequests({entries:t,responses:l,retireRequestIds:f})},...o!==void 0&&{childSessionInbox:o},...r!==void 0&&l.includes(r)&&{message:e.payload.message},...n!==void 0&&{workflowAsk:n},...i!==void 0&&{remote:i},...u[0]?.inputSource!==void 0&&{inputSource:u[0].inputSource}}}),u={};for(let[t,r]of Object.entries(e.payload))t!==`inputResponses`&&r!==void 0&&(n.consumed&&CONSUMED_MESSAGE_KEYS.has(t)||(u[t]=r));return o.length>0&&(u.inputResponses=o),{forChildren:l,forSelf:Object.keys(u).length>0?u:void 0,parentAction:s}}function resolveRetiredRequests(e){let t=new Map(e.responses.map(e=>[e.requestId,e])),n=[];for(let r of e.retireRequestIds){let i=e.entries.get(r);i!==void 0&&n.push(toInputResolution(r,i,t.get(r)))}return n}function toInputResolution(e,t,n){let r=resolveInputOutcome(t.kind,n),i={kind:t.kind,outcome:r,requestId:e};return n===void 0?i:{...i,response:n}}function resolveMessageAgainstQuestions(e){let t={consumed:!1,responses:[]};if(!e.enabled||(e.payload.inputResponses?.length??0)>0)return t;let n=readAnswerText(e.payload);if(n===void 0)return t;let answered=t=>{let n=e.entries.get(t);return n!==void 0&&!e.routable(t,n)},r=firstOpenInput(storedProjection(e.state),answered)?.request.requestId??[...e.entries.keys()].find(e=>!answered(e)),i=r===void 0?void 0:e.entries.get(r);if(r===void 0||i?.kind!==`question`)return t;let a=i.workflowAsk?.question??i.question,o=a===void 0?void 0:resolveTextToResponse(n,{requestId:r,...a});return o===void 0?t:{consumed:!0,responses:[o]}}function batchResolves(e){return e.batch.approvalRequestIds.length===0||e.batch.approvalRequestIds.every(t=>{let n=e.entries.get(t);return n===void 0||!sameBatch(n,e)||e.responseIds.has(t)})}function sameBatch(e,t){return e.childContinuationToken===t.childContinuationToken&&e.batch?.requestIds.length===t.batch.requestIds.length&&e.batch.requestIds.every((e,n)=>e===t.batch.requestIds[n])}export{routeDeliverPayload};
+import{inputTextKey,readAnswerText}from"#internal/input-text.js";import{firstOpenInput}from"#harness/open-input-request.js";import{resolveTextToResponse}from"#channel/resolve-text.js";import{storedProjection}from"#harness/session-machine/view.js";import{getProxyInputRequests,resolvedByChild}from"#harness/proxy-input-requests.js";import{resolveInputOutcome}from"#harness/input-request-resolution.js";import{SESSION_LIMIT_STOP_OPTION_ID}from"#harness/hitl/budget-request.js";const CONSUMED_MESSAGE_KEYS=new Set([`context`,`message`,inputTextKey]);function routeDeliverPayload(e){let t=getProxyInputRequests(e.state),routable=(t,n)=>n!==void 0&&e.allowRoute?.(t,n)!==!1,n=resolveMessageAgainstFirstRequest({enabled:e.resolveMessage===!0,entries:t,payload:e.payload,routable,state:e.state}),[r]=n.responses,i=[...e.payload.inputResponses??[],...n.responses],a=new Map,o=[],s,bucketFor=e=>{let t=JSON.stringify([e.childContinuationToken,e.childSessionInbox?.sessionId??``,e.remote?.sessionId??``,e.event.sequence,e.event.stepIndex,e.event.turnId,e.inputSource??null]),n=a.get(t);if(n!==void 0)return n;let r={childContinuationToken:e.childContinuationToken,remote:e.remote,event:e.event,parentRequestIds:[],responses:[],routes:[],...e.childSessionInbox!==void 0&&{childSessionInbox:e.childSessionInbox},...e.workflowAsk!==void 0&&{workflowAsk:e.workflowAsk}};return a.set(t,r),r},c=new Set;for(let e of i){let n=t.get(e.requestId);if(n===void 0||!routable(e.requestId,n)){o.push(e);continue}if(c.has(e.requestId))continue;c.add(e.requestId),n.kind===`session-limit`&&e.optionId===SESSION_LIMIT_STOP_OPTION_ID&&(s={kind:`cancel-turn`});let r=bucketFor(n);r.parentRequestIds.push(e.requestId),r.responses.push(e),r.routes.push(n)}let l=[...a.values()].map(({workflowAsk:n,remote:i,childContinuationToken:a,childSessionInbox:o,event:s,parentRequestIds:c,responses:l,routes:u})=>{let d=new Set(c),decided=e=>{let n=t.get(e)?.kind;return n===void 0||!resolvedByChild(n)},f=new Set([...d].filter(decided));for(let e of u)if(e.batch!==void 0&&batchResolves({batch:e.batch,childContinuationToken:a,entries:t,responseIds:d}))for(let t of e.batch.requestIds)decided(t)&&f.add(t);return{childContinuationToken:a,payload:{inputResponses:l},resolved:{event:s,resolutions:resolveRetiredRequests({entries:t,responses:l,retireRequestIds:f})},...o!==void 0&&{childSessionInbox:o},...r!==void 0&&l.includes(r)&&{message:e.payload.message},...n!==void 0&&{workflowAsk:n},...i!==void 0&&{remote:i},...u[0]?.inputSource!==void 0&&{inputSource:u[0].inputSource}}}),u={};for(let[t,r]of Object.entries(e.payload))t!==`inputResponses`&&r!==void 0&&(n.consumed&&CONSUMED_MESSAGE_KEYS.has(t)||(u[t]=r));return o.length>0&&(u.inputResponses=o),{forChildren:l,forSelf:Object.keys(u).length>0?u:void 0,parentAction:s}}function resolveRetiredRequests(e){let t=new Map(e.responses.map(e=>[e.requestId,e])),n=[];for(let r of e.retireRequestIds){let i=e.entries.get(r);i!==void 0&&n.push(toInputResolution(r,i,t.get(r)))}return n}function toInputResolution(e,t,n){let r=resolveInputOutcome(t.kind,n),i={kind:t.kind,outcome:r,requestId:e};return n===void 0?i:{...i,response:n}}function resolveMessageAgainstFirstRequest(e){let t={consumed:!1,responses:[]};if(!e.enabled||(e.payload.inputResponses?.length??0)>0)return t;let n=readAnswerText(e.payload);if(n===void 0)return t;let answered=t=>{let n=e.entries.get(t);return n!==void 0&&!e.routable(t,n)},r=firstOpenInput(storedProjection(e.state),answered)?.request.requestId??[...e.entries.keys()].find(e=>!answered(e)),i=r===void 0?void 0:e.entries.get(r)?.reply;if(r===void 0||i===void 0)return t;let a=resolveTextToResponse(n,{requestId:r,...i});return a===void 0?t:{consumed:!0,responses:[a]}}function batchResolves(e){return e.batch.approvalRequestIds.length===0||e.batch.approvalRequestIds.every(t=>{let n=e.entries.get(t);return n===void 0||!sameBatch(n,e)||e.responseIds.has(t)})}function sameBatch(e,t){return e.childContinuationToken===t.childContinuationToken&&e.batch?.requestIds.length===t.batch.requestIds.length&&e.batch.requestIds.every((e,n)=>e===t.batch.requestIds[n])}export{routeDeliverPayload};

package/dist/src/subagents/parent-notification.js

@@ -1 +1 @@
-import{createLogger}from"#internal/logging.js";import{SessionCallbackKey}from"#context/keys.js";import{toErrorMessage}from"#shared/errors.js";import{parseJsonValue}from"#shared/json.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{parseSessionCallback}from"#channel/session-callback.js";import{deserializeContext}from"#context/serialize.js";import{postSessionCallbackRequest}from"#execution/session-callback-request.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{resumeHook}from"#internal/workflow/runtime.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#subagents/adapter-state.js";const log=createLogger(`execution.delegated-parent-notification`),SUBAGENT_EXECUTION_FAILED=`SUBAGENT_EXECUTION_FAILED`,ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0};async function notifyTurnCallerStep(e){"use step";if(e.caller===void 0)return;let t=createSettledTurnResult({caller:e.caller,lifecycle:e.lifecycle,sessionId:e.sessionId,settled:e.settled});if(e.caller.replyTo.kind===`callback`){await postSettledTurnCallback({result:t,sessionId:e.sessionId,url:e.caller.replyTo.url});return}await resumeSettledTurnHook(e.caller.replyTo.token,t)}async function notifyCancelledTaskCallerStep(e){"use step";let t=e.usage??ZERO_TOKEN_USAGE,n={code:SUBAGENT_EXECUTION_FAILED,message:`The agent invocation was cancelled.`},r={callId:e.caller.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:`parked`,result:{kind:`cancelled`},usageDelta:t},output:n,subagentName:e.caller.subagentName},i=e.usage===void 0?r:{...r,usage:e.usage};if(e.caller.replyTo.kind===`callback`){await postSettledTurnCallback({result:i,sessionId:e.sessionId,url:e.caller.replyTo.url});return}await resumeSettledTurnHook(e.caller.replyTo.token,i)}function createSettledTurnResult(e){let t=e.settled.usage??ZERO_TOKEN_USAGE;if(e.settled.isError===!0){let n={code:SUBAGENT_EXECUTION_FAILED,message:toErrorMessage(e.settled.output)};return{callId:e.caller.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:e.lifecycle,result:{error:n,kind:`failed`},usageDelta:t},output:n,subagentName:e.caller.subagentName}}let n=parseJsonValue(e.settled.output),r={callId:e.caller.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:e.lifecycle,result:{kind:`succeeded`,output:n},usageDelta:t},output:n,subagentName:e.caller.subagentName};return e.settled.usage===void 0?r:{...r,usage:e.settled.usage}}async function resolveInitialTurnCallerStep(e){"use step";let t=e.serializedContext[SessionCallbackKey.name];if(t!==void 0){let e=parseSessionCallback(t);if(!e.ok)throw Error(`Serialized session callback is invalid.`,{cause:e.cause});return{callId:e.callback.callId,replyTo:{kind:`callback`,token:e.callback.token,url:e.callback.url},subagentName:e.callback.subagentName}}let n=(await deserializeContext(e.serializedContext)).get(ChannelKey);if(n?.kind===SUBAGENT_ADAPTER_KIND&&isSubagentAdapterState(n.state))return{callId:n.state.callId,replyTo:{kind:`hook`,token:n.state.parentContinuationToken},subagentName:n.state.subagentName}}function bindTurnCallerContext(e,t){if(e===void 0)return t;if(e.replyTo.kind===`callback`){let n={callId:e.callId,subagentName:e.subagentName,token:e.replyTo.token,url:e.replyTo.url};return{...t,[SessionCallbackKey.name]:n}}let n=t[ChannelKey.name];if(typeof n!=`object`||!n||Reflect.get(n,`kind`)!==SUBAGENT_ADAPTER_KIND||!isSubagentAdapterState(Reflect.get(n,`state`)))throw Error(`Delegated local turn is missing its subagent adapter binding.`);let r={...Reflect.get(n,`state`),callId:e.callId,parentContinuationToken:e.replyTo.token,subagentName:e.subagentName};return{...t,[ChannelKey.name]:{...n,state:r}}}async function postSettledTurnCallback(e){let{sessionId:t}=e;if(e.result.isError===!0){await postCallbackPayload({payload:{callId:e.result.callId,error:e.result.output,kind:`turn.failed`,outcome:e.result.outcome,sessionId:t,subagentName:e.result.subagentName},url:e.url});return}await postCallbackPayload({payload:{callId:e.result.callId,kind:`turn.completed`,outcome:e.result.outcome,output:e.result.output,sessionId:t,subagentName:e.result.subagentName},url:e.url})}async function postCallbackPayload(e){let t=await postSessionCallbackRequest({body:e.payload,url:e.url});if(!t.ok)throw Error(`Turn callback failed with HTTP ${t.status}.`)}async function resumeSettledTurnHook(e,t){try{await resumeHook(e,{kind:`runtime-action-result`,results:[t]})}catch(n){if(!HookNotFoundError.is(n))throw n;log.warn(`turn caller hook no longer exists`,{callId:t.callId,callerToken:e})}}export{bindTurnCallerContext,notifyCancelledTaskCallerStep,notifyTurnCallerStep,resolveInitialTurnCallerStep};
+import{createLogger}from"#internal/logging.js";import{SessionCallbackKey}from"#context/keys.js";import{toErrorMessage}from"#shared/errors.js";import{parseJsonValue}from"#shared/json.js";import{ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{resumeHook}from"#internal/workflow/runtime.js";import{parseSessionCallback}from"#channel/session-callback.js";import{deserializeContext}from"#context/serialize.js";import{postSessionCallbackRequest}from"#execution/session-callback-request.js";import{HookNotFoundError}from"#compiled/@workflow/errors/index.js";import{SUBAGENT_ADAPTER_KIND,isSubagentAdapterState}from"#subagents/adapter-state.js";const log=createLogger(`execution.delegated-parent-notification`),SUBAGENT_EXECUTION_FAILED=`SUBAGENT_EXECUTION_FAILED`,ZERO_TOKEN_USAGE={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0};async function notifyTurnCallerStep(e){"use step";if(e.caller===void 0)return;let t=createSettledTurnResult({caller:e.caller,lifecycle:e.lifecycle,sessionId:e.sessionId,settled:e.settled});if(e.caller.replyTo.kind===`callback`){await postSettledTurnCallback({result:t,sessionId:e.sessionId,url:e.caller.replyTo.url});return}await resumeSettledTurnHook(e.caller.replyTo.token,t)}async function notifyCancelledTaskCallerStep(e){"use step";let t=e.usage??ZERO_TOKEN_USAGE,n={code:SUBAGENT_EXECUTION_FAILED,message:`The agent invocation was cancelled.`},r={callId:e.caller.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:`parked`,result:{kind:`cancelled`},usageDelta:t},output:n,subagentName:e.caller.subagentName},i=e.usage===void 0?r:{...r,usage:e.usage};if(e.caller.replyTo.kind===`callback`){await postSettledTurnCallback({result:i,sessionId:e.sessionId,url:e.caller.replyTo.url});return}await resumeSettledTurnHook(e.caller.replyTo.token,i)}function createSettledTurnResult(e){let t=e.settled.usage??ZERO_TOKEN_USAGE;if(e.settled.isError===!0){let n={code:SUBAGENT_EXECUTION_FAILED,message:toErrorMessage(e.settled.output)};return{callId:e.caller.callId,isError:!0,kind:`subagent-result`,origin:`child`,outcome:{kind:e.lifecycle,result:{error:n,kind:`failed`},usageDelta:t},output:n,subagentName:e.caller.subagentName}}let n=parseJsonValue(e.settled.output),r={callId:e.caller.callId,kind:`subagent-result`,origin:`child`,outcome:{kind:e.lifecycle,result:{kind:`succeeded`,output:n},usageDelta:t},output:n,subagentName:e.caller.subagentName};return e.settled.usage===void 0?r:{...r,usage:e.settled.usage}}async function resolveInitialTurnCallerStep(e){"use step";let t=e.serializedContext[SessionCallbackKey.name];if(t!==void 0){let e=parseSessionCallback(t);if(!e.ok)throw Error(`Serialized session callback is invalid.`,{cause:e.cause});return{callId:e.callback.callId,replyTo:{kind:`callback`,token:e.callback.token,url:e.callback.url},subagentName:e.callback.subagentName}}let n=(await deserializeContext(e.serializedContext)).get(ChannelKey);if(n?.kind===SUBAGENT_ADAPTER_KIND&&isSubagentAdapterState(n.state))return{callId:n.state.callId,replyTo:{kind:`hook`,token:n.state.parentContinuationToken},subagentName:n.state.subagentName}}function bindTurnCallerContext(e,t){if(e===void 0)return t;if(e.replyTo.kind===`callback`){let n={callId:e.callId,subagentName:e.subagentName,token:e.replyTo.token,url:e.replyTo.url};return{...t,[SessionCallbackKey.name]:n}}let n=t[ChannelKey.name];if(typeof n!=`object`||!n||Reflect.get(n,`kind`)!==SUBAGENT_ADAPTER_KIND||!isSubagentAdapterState(Reflect.get(n,`state`)))throw Error(`Delegated local turn is missing its subagent adapter binding.`);let r={...Reflect.get(n,`state`),callId:e.callId,parentContinuationToken:e.replyTo.token,subagentName:e.subagentName};return{...t,[ChannelKey.name]:{...n,state:r}}}async function postSettledTurnCallback(e){let{sessionId:t}=e;if(e.result.isError===!0){await postCallbackPayload({payload:{callId:e.result.callId,error:e.result.output,kind:`turn.failed`,outcome:e.result.outcome,sessionId:t,subagentName:e.result.subagentName},url:e.url});return}await postCallbackPayload({payload:{callId:e.result.callId,kind:`turn.completed`,outcome:e.result.outcome,output:e.result.output,sessionId:t,subagentName:e.result.subagentName},url:e.url})}async function postCallbackPayload(e){let t=await postSessionCallbackRequest({body:e.payload,url:e.url});if(!t.ok)throw Error(`Turn callback failed with HTTP ${t.status}.`)}async function resumeSettledTurnHook(e,t){try{await resumeHook(e,{kind:`runtime-action-result`,results:[t]})}catch(n){if(!HookNotFoundError.is(n))throw n;log.warn(`turn caller hook no longer exists`,{callId:t.callId,callerToken:e})}}export{bindTurnCallerContext,notifyCancelledTaskCallerStep,notifyTurnCallerStep,resolveInitialTurnCallerStep};

package/dist/src/svelte/index.js

@@ -1,4 +1,4 @@
-import { a as conversationProjection, i as openConversationInputs, n as conversationReducer, o as callStatus, r as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-mP0M7SrL.js";
+import { a as conversationProjection, i as openConversationInputs, n as conversationReducer, o as callStatus, r as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-B2Kne9z6.js";
 
 //#region src/client/tool-call-state.ts
 function toolCallState(conversation, callId, options = {}) {

package/dist/src/svelte/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-mP0M7SrL.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-B2Kne9z6.js";
 
 export { useEveAgent };

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

@@ -0,0 +1,13 @@
+import type { StubResult } from "#tool-stubs/types.js";
+import type { ToolExecuteOptions } from "#tools/definition.js";
+/** Tool inputs and approvals have already been checked before a stub can replace execution. */
+export declare function executeWithToolStub(tool: string, input: unknown, options: ToolExecuteOptions, execute: () => unknown): unknown;
+/** The connection wrapper checks operation inputs and approvals before requesting a stub. */
+export declare function connectionToolStub(tool: string, input: unknown, callId: string): Promise<StubResult>;
+/** Record errors converting stub responses so eval verification can detect them. */
+export declare function recordToolStubFailure(tool: string, callId: string | undefined, turnId?: string): Promise<void>;
+/** Record stub failures even when the caller recovers with fallback output. */
+export declare function observeToolOutput<T>(tool: string, calls: readonly {
+    readonly callId: string;
+    readonly turnId?: string;
+}[], project: () => T | Promise<T>, recover?: (error: unknown) => T): Promise<T>;

package/dist/src/tool-stubs/execute.js

@@ -0,0 +1 @@
+import{contextStorage}from"#context/container.js";import{SessionKey,ToolStubsKey}from"#context/keys.js";import{ToolStubPlaybackKey}from"#context/providers/tool-stubs-key.js";import{findStubTarget,stubCallId}from"#tool-stubs/target.js";import{isAsyncIterable}from"#shared/async-iterable.js";import{toolStubOutput}from"#tool-stubs/output.js";function executeWithToolStub(e,t,n,r){let i=contextStubCall(e,t,n.toolCallId);return i===void 0?r():executeStubbedTool(i.playback,i.call,n,r)}async function*executeStubbedTool(e,t,n,r){n.abortSignal?.throwIfAborted();let i=await e.call(t);if(i.kind===`error`)throw Error(i.error);if(i.kind===`stub`){yield toolStubOutput(i.outcome);return}let a=await r();isAsyncIterable(a)?yield*a:yield a}async function connectionToolStub(e,t,n){let r=contextStubCall(e,t,n);return r===void 0?{kind:`real`}:await r.playback.call(r.call)}function contextStubCall(e,t,n){let r=contextStorage.getStore();if(r===void 0)return;let i=findStubTarget(r.get(ToolStubsKey),e);if(i===void 0)return;let a=r.require(SessionKey);return{playback:r.require(ToolStubPlaybackKey),call:{tool:i.tool,input:t,callId:stubCallId(a.sessionId,a.turn.id,n)}}}async function recordToolStubFailure(e,t,n){let r=contextStorage.getStore(),i=r?.get(ToolStubsKey);if(i===void 0||t===void 0||e!==`connection_execute`&&findStubTarget(i,e)===void 0)return;let a=r.require(SessionKey);await r.require(ToolStubPlaybackKey).fail(stubCallId(a.sessionId,n??a.turn.id,t),`Stubbed tool "${e}" failed during output processing.`)}async function observeToolOutput(e,t,n,r){try{return await n()}catch(n){try{for(let n of t)await recordToolStubFailure(e,n.callId,n.turnId)}catch(e){throw AggregateError([n,e],`Tool output processing and failure reporting failed.`,{cause:n})}if(r!==void 0)return r(n);throw n}}export{connectionToolStub,executeWithToolStub,observeToolOutput,recordToolStubFailure};

package/dist/src/tool-stubs/output.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from "#shared/json.js";
+import type { ToolStubOutcome } from "#tool-stubs/types.js";
+/** Throws at the tool boundary, after the outcome has been recorded for replay. */
+export declare function toolStubOutput(outcome: ToolStubOutcome): JsonValue;

package/dist/src/tool-stubs/output.js

@@ -0,0 +1 @@
+function toolStubOutput(e){if(e.throw!==void 0){let t=Error(e.throw.message);throw t.name=e.throw.name??`Error`,t}return e.response}export{toolStubOutput};

package/dist/src/tool-stubs/playback.d.ts

@@ -0,0 +1,15 @@
+import type { StubCall, StubResult, ToolStub } from "#tool-stubs/types.js";
+/**
+ * Selects stub outcomes and advances their sequences.
+ * The surrounding workflow orders calls and restores progress on replay.
+ */
+export declare class StubPlayback {
+    private readonly rules;
+    private readonly results;
+    private readonly positions;
+    constructor(rules: readonly ToolStub[]);
+    get matchedRuleCount(): number;
+    call(call: StubCall): StubResult;
+    private record;
+    fail(callId: string, error: string): StubResult;
+}

package/dist/src/tool-stubs/playback.js

@@ -0,0 +1 @@
+import{isObject}from"#shared/guards.js";import{createStubValidator}from"#tool-stubs/schema.js";var StubPlayback=class{rules;results=new Map;positions=new Map;constructor(e){this.rules=e.map(e=>({...e,constraints:Object.entries(e.match??{}).map(([t,n])=>{try{return{property:t,validator:createStubValidator(n)}}catch(n){throw Error(`Could not create validator for matcher "${t}" in tool stub "${e.id}".`,{cause:n})}})}))}get matchedRuleCount(){return this.positions.size}call(e){let t=this.results.get(e.callId);if(t!==void 0)return t;if(this.results.size>=1e4)return{kind:`error`,error:`Tool stub session exceeded 10,000 calls. Start a new eval session.`};let n=this.rules.filter(t=>t.tool===e.tool);if(e.persistent&&n.some(e=>e.constraints.length>0))return this.record(e,{kind:`error`,error:`Persistent tool "${e.tool}" requires an unconditional stub.`});let r=n.find(t=>t.constraints.every(({property:t,validator:n})=>isObject(e.input)&&Object.hasOwn(e.input,t)&&n.validate(e.input[t]).valid));if(r===void 0)return this.record(e,{kind:`real`});let i=r.outcomes??[r.outcome],a=Math.min(this.positions.get(r.id)??0,i.length-1);return this.positions.set(r.id,a+1),this.record(e,{kind:`stub`,ruleId:r.id,position:a,outcome:i[a]})}record(e,t){return this.results.set(e.callId,t),t}fail(e,t){return this.results.get(e)?.kind===`stub`?{kind:`error`,error:t}:{kind:`real`}}};export{StubPlayback};

package/dist/src/tool-stubs/rules.d.ts

@@ -0,0 +1,3 @@
+import type { ToolStub } from "#tool-stubs/types.js";
+/** Validates stubs before creating the session. */
+export declare function parseToolStubs(value: unknown): readonly ToolStub[];

package/dist/src/tool-stubs/rules.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{parseJsonValue}from"#shared/json.js";import{createStubValidator,validateStubConstraint}from"#tool-stubs/schema.js";const ruleSchema=z.strictObject({id:z.string().min(1),tool:z.string().min(1),match:z.record(z.string(),z.union([z.boolean(),z.record(z.string(),z.json())])).optional()}),outcomeSchema=z.union([z.strictObject({response:z.json()}),z.strictObject({throw:z.strictObject({message:z.string(),name:z.string().min(1).optional()})})]),toolStubsSchema=z.array(z.union([ruleSchema.extend({outcome:outcomeSchema}),ruleSchema.extend({outcomes:z.tuple([outcomeSchema]).rest(outcomeSchema)})])).max(100);function parseToolStubs(e){boundStubConfiguration(e);let t=toolStubsSchema.parse(parseJsonValue(e)),n=new Set;for(let e of t){if(n.has(e.id))throw Error(`Duplicate tool stub id "${e.id}".`);if(n.add(e.id),[`connection_execute`,`connection_search`].includes(e.tool.split(`/`).at(-1)))throw Error(`Cannot stub connection_execute or connection_search. Stub a specific connection operation, such as linear__list_issues.`);for(let[t,n]of Object.entries(e.match??{})){validateStubConstraint(n,e.id,t);try{createStubValidator(n)}catch(n){throw Error(`Could not create matcher "${t}" in tool stub "${e.id}".`,{cause:n})}}}return t}function boundStubConfiguration(e){let t=[{value:e,depth:0}],n=0,r=0;for(;t.length>0;){let e=t.pop();if(++n>2e4||e.depth>32)throw Error(`Tool stubs exceed the size or nesting limit.`);if(typeof e.value==`string`&&(r+=e.value.length),e.value!==null&&typeof e.value==`object`)for(let[n,i]of Object.entries(e.value)){if(n===`__proto__`)throw Error(`Tool stubs cannot contain prototype keys.`);r+=n.length,t.push({value:i,depth:e.depth+1})}if(r>1e6)throw Error(`Tool stubs exceed the size or nesting limit.`)}}export{parseToolStubs};

package/dist/src/tool-stubs/schema.d.ts

@@ -0,0 +1,4 @@
+import { Validator } from "#compiled/@cfworker/json-schema/index.js";
+import type { JsonObject } from "#shared/json.js";
+export declare function validateStubConstraint(value: unknown, ruleId: string, property: string): void;
+export declare function createStubValidator(value: JsonObject | boolean): Validator;

package/dist/src/tool-stubs/schema.js

@@ -0,0 +1 @@
+import{Validator}from"#compiled/@cfworker/json-schema/index.js";const schema={$ref:`#`},schemaList={type:`array`,minItems:1,items:schema},propertyName={type:`string`,not:{enum:Object.getOwnPropertyNames(Object.prototype)}},schemaMap={type:`object`,propertyNames:propertyName,additionalProperties:schema},strings={type:`array`,uniqueItems:!0,items:propertyName},nonnegativeInteger={type:`integer`,minimum:0},jsonType={enum:[`array`,`boolean`,`integer`,`null`,`number`,`object`,`string`]},constraintSchema=new Validator({anyOf:[{type:`boolean`},{type:`object`,additionalProperties:!1,properties:{type:{anyOf:[jsonType,{type:`array`,minItems:1,uniqueItems:!0,items:jsonType}]},const:{type:[`string`,`number`,`boolean`,`null`]},enum:{type:`array`,minItems:1,uniqueItems:!0,items:{type:[`string`,`number`,`boolean`,`null`]}},title:{type:`string`},description:{type:`string`},default:!0,minimum:{type:`number`},maximum:{type:`number`},exclusiveMinimum:{type:`number`},exclusiveMaximum:{type:`number`},minLength:nonnegativeInteger,maxLength:nonnegativeInteger,pattern:{type:`string`,format:`regex`},minItems:nonnegativeInteger,maxItems:nonnegativeInteger,items:schema,prefixItems:schemaList,contains:schema,minProperties:nonnegativeInteger,maxProperties:nonnegativeInteger,properties:schemaMap,propertyNames:schema,required:strings,additionalProperties:schema,allOf:schemaList,anyOf:schemaList,oneOf:schemaList,not:schema,if:schema,then:schema,else:schema}}]},`2020-12`);function validateStubConstraint(e,t,n){let r=constraintSchema.validate(e);if(!r.valid){let e=r.errors.at(-1),i=e.keyword===`false`?`Unsupported JSON Schema keyword.`:e.error;throw Error(`Invalid matcher "${n}" in tool stub "${t}" at ${e.instanceLocation}: ${i}`)}}function createStubValidator(e){return new Validator(structuredClone(e),`2020-12`)}export{createStubValidator,validateStubConstraint};

package/dist/src/tool-stubs/target.d.ts

@@ -0,0 +1,8 @@
+import type { StubScope } from "#tool-stubs/types.js";
+/** Qualify names for stub matching without changing the names sent to the model. */
+export declare function stubToolPath(scope: StubScope | undefined, tool: string): string;
+export declare function findStubTarget(scope: StubScope | undefined, tool: string): {
+    scope: StubScope;
+    tool: string;
+} | undefined;
+export declare function stubCallId(sessionId: string, turnId: string, callId: string): string;

package/dist/src/tool-stubs/target.js

@@ -0,0 +1 @@
+function stubToolPath(e,t){return e?.agentPath===void 0?t:`${e.agentPath}/${t}`}function findStubTarget(e,t){if(e!==void 0)return t=stubToolPath(e,t),e.rules.some(e=>e.tool===t)?{scope:e,tool:t}:void 0}function stubCallId(e,t,n){return`${e}:${t}:${n}`}export{findStubTarget,stubCallId,stubToolPath};

package/dist/src/tool-stubs/types.d.ts

@@ -0,0 +1,56 @@
+import type { JsonObject, JsonValue } from "#shared/json.js";
+/** Return JSON or immediately throw an error for a matching tool call. */
+export type ToolStubOutcome = {
+    readonly response: JsonValue;
+    readonly throw?: never;
+} | {
+    readonly response?: never;
+    readonly throw: {
+        readonly message: string;
+        /** Defaults to Error. Sets the name, not a custom JavaScript class. */
+        readonly name?: string;
+    };
+};
+/** Stub outcomes selected by tool name and input fields. */
+export type ToolStub = {
+    readonly id: string;
+    /** Use list_tasks for a root tool or researcher/list_tasks for a local subagent's tool. */
+    readonly tool: string;
+    /** Each named input property must exist and satisfy its JSON Schema. */
+    readonly match?: Readonly<Record<string, JsonObject | boolean>>;
+} & ({
+    readonly outcome: ToolStubOutcome;
+    readonly outcomes?: never;
+} | {
+    readonly outcome?: never;
+    readonly outcomes: readonly [ToolStubOutcome, ...ToolStubOutcome[]];
+});
+export interface StubCall {
+    /** Combines the session, turn, and tool call IDs. */
+    readonly callId: string;
+    readonly tool: string;
+    readonly input: unknown;
+    readonly persistent?: boolean;
+}
+export type StubResult = {
+    readonly kind: "real";
+} | {
+    readonly kind: "error";
+    readonly error: string;
+} | {
+    readonly kind: "stub";
+    readonly ruleId: string;
+    readonly position: number;
+    readonly outcome: ToolStubOutcome;
+};
+/** Rules and workflow routing set by the server after it authorizes tool stubs. */
+export interface StubScope {
+    readonly token: string;
+    readonly rules: readonly ToolStub[];
+    readonly rootSessionId?: string;
+    readonly agentPath?: string;
+}
+export declare const STUB_CONTEXT_KEY = "eve.toolStubs";
+export declare const STUB_MATCHES_NAMESPACE = "eve.tool-stubs.matches";
+export declare const STUB_FAILURE_NAMESPACE = "eve.tool-stubs.failure";
+export declare const stubResponseNamespace: (callId: string) => string;

package/dist/src/tool-stubs/types.js

@@ -0,0 +1 @@
+const STUB_CONTEXT_KEY=`eve.toolStubs`,STUB_MATCHES_NAMESPACE=`eve.tool-stubs.matches`,STUB_FAILURE_NAMESPACE=`eve.tool-stubs.failure`,stubResponseNamespace=e=>`eve.tool-stubs.${e}`;export{STUB_CONTEXT_KEY,STUB_FAILURE_NAMESPACE,STUB_MATCHES_NAMESPACE,stubResponseNamespace};

package/dist/src/tool-stubs/validate-targets.d.ts

@@ -0,0 +1,6 @@
+import type { ResolvedAgentGraphBundle } from "#runtime/graph.js";
+import type { ToolStub } from "#tool-stubs/types.js";
+export declare class InvalidToolStubTargetError extends Error {
+}
+/** Check compiled tools without running dynamic resolvers or contacting connections. */
+export declare function validateToolStubTargets(rules: readonly ToolStub[], graph: ResolvedAgentGraphBundle): void;

package/dist/src/tool-stubs/validate-targets.js

@@ -0,0 +1 @@
+var InvalidToolStubTargetError=class extends Error{};function validateToolStubTargets(e,t){for(let n of e)if(!hasToolPath(t,n.tool.split(`/`)))throw new InvalidToolStubTargetError(`Tool stub "${n.id}" names an unknown or unsupported tool path "${n.tool}".`)}function hasToolPath(e,t){if(t.some(e=>e.length===0))return!1;let n=e.root;for(let[r,i]of t.entries()){let a=n.turnAgent.tools.find(e=>e.name===i);if(r===t.length-1)return a===void 0?n.agent.dynamicToolResolvers.some(e=>e.slug!==`connection_tools`&&(e.extensionNamespace===void 0||i.startsWith(`${e.extensionNamespace}__`)))||n.subagentRegistry.dynamicResolvers.some(e=>e.name===i)||i.includes(`__`)&&((n.agent.dynamicConnectionResolvers?.length??0)>0||n.agent.connections.some(e=>i.startsWith(`${e.connectionName}__`))):a.behavior?.handling?.kind!==`provider-tool`;if(a===void 0)return n.subagentRegistry.dynamicResolvers.some(e=>e.name===i);let o=a.behavior?.handling;if(o?.kind!==`dispatch`||o.target.kind!==`subagent-call`&&o.target.kind!==`self-agent-call`)return!1;n=e.nodesByNodeId.get(o.target.nodeId)}return!1}export{InvalidToolStubTargetError,validateToolStubTargets};

package/dist/src/tools/provided/ask-question-workflow.js

@@ -1 +1 @@
-async function executeAskQuestionTool(e,t){"use workflow";return toAskQuestionOutput(await t.ask(toAskQuestionRequest(e)))}function toAskQuestionRequest(e){let t=e.options?.map(e=>({description:e.description,id:e.label,label:e.label}));return{allowFreeform:!0,display:t===void 0?`text`:`select`,prompt:e.question,...t!==void 0&&{options:t}}}function toAskQuestionOutput(e){switch(e.status){case`answered`:return{answer:e.optionId??e.text??``,status:`answered`};case`cancelled`:return{interrupted:!0};case`unavailable`:return{status:`unavailable`}}}executeAskQuestionTool.workflowId=`workflow//eve@0.74.0//executeAskQuestionTool`;export{executeAskQuestionTool,toAskQuestionOutput,toAskQuestionRequest};
+async function executeAskQuestionTool(e,t){"use workflow";return toAskQuestionOutput(await t.ask(toAskQuestionRequest(e)))}function toAskQuestionRequest(e){let t=e.options?.map(e=>({description:e.description,id:e.label,label:e.label}));return{allowFreeform:!0,display:t===void 0?`text`:`select`,prompt:e.question,...t!==void 0&&{options:t}}}function toAskQuestionOutput(e){switch(e.status){case`answered`:return{answer:e.optionId??e.text??``,status:`answered`};case`cancelled`:return{interrupted:!0};case`unavailable`:return{status:`unavailable`}}}executeAskQuestionTool.workflowId=`workflow//eve@0.75.1//executeAskQuestionTool`;export{executeAskQuestionTool,toAskQuestionOutput,toAskQuestionRequest};

package/dist/src/tools/provided/sleep-workflow.js

@@ -1 +1 @@
-import{sleep}from"#compiled/@workflow/core/index.js";async function executeSleepTool(e,t){"use workflow";let n=new Promise(e=>t.abortSignal.addEventListener(`abort`,()=>e(`interrupted`),{once:!0})),r=sleep(Math.ceil(e.seconds*1e3)).then(()=>`elapsed`);return await Promise.race([r,n])===`elapsed`?{waitedSeconds:e.seconds}:{interrupted:!0}}executeSleepTool.workflowId=`workflow//eve@0.74.0//executeSleepTool`;export{executeSleepTool};
+import{sleep}from"#compiled/@workflow/core/index.js";async function executeSleepTool(e,t){"use workflow";let n=new Promise(e=>t.abortSignal.addEventListener(`abort`,()=>e(`interrupted`),{once:!0})),r=sleep(Math.ceil(e.seconds*1e3)).then(()=>`elapsed`);return await Promise.race([r,n])===`elapsed`?{waitedSeconds:e.seconds}:{interrupted:!0}}executeSleepTool.workflowId=`workflow//eve@0.75.1//executeSleepTool`;export{executeSleepTool};

package/dist/src/vue/index.js

@@ -1,4 +1,4 @@
-import { a as conversationProjection, i as openConversationInputs, n as conversationReducer, o as callStatus, r as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-DOOXadF0.js";
+import { a as conversationProjection, i as openConversationInputs, n as conversationReducer, o as callStatus, r as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-DK_T88EP.js";
 
 //#region src/client/tool-call-state.ts
 function toolCallState(conversation, callId, options = {}) {

package/dist/src/vue/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-DOOXadF0.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-DK_T88EP.js";
 
 export { useEveAgent };

package/docs/concepts/sessions-runs-and-streaming.md

@@ -123,7 +123,7 @@ Note: consider the privacy, confidentiality, and user-experience implications fo
 
 A delegated subagent publishes progress on its own child-session stream. When a subagent tool call or a workflow tool's `ctx.agent` opens a session, the parent emits `agent.started` with the call's `callId` and `turnId`, its `taskId` when the call runs as a task, the child's `sessionId`, and a `streamPath` that a client follows with `session.agent(started).stream()`. A subagent tool call is a [task](#task-events) whose `task.started` has `kind: "agent"`: its `task.started` and `task.settled` carry the call, and `task.settled.data.output` is the child's reply. A call that fails before the child session opens has no `agent.started`. A settled call does not end the child session; later calls with the same `taskId` reach it.
 
-A question or sign-in from inside a running call does not end the turn. This covers a workflow tool's `ctx.ask()`, including the built-in `ask_question` tool, and a delegated subagent's question or sign-in. The stream emits `input.requested` or `authorization.required`, then `turn.waiting` with `on: "input"` and the open turn's `turnId`. After the answer or sign-in, the turn resumes with the next `step.started` for the same `turnId`, and only `turn.completed`, `turn.failed`, or `turn.cancelled` ends it. When you answer a question that belongs to a workflow tool or a subagent, the session you answer on emits `input.resolved` for it as it routes the answer down. While other relayed questions are still pending, it then emits `turn.waiting` with `on: "input"` again. If the workflow tool run that relayed a question or approval ends before anyone answers, that session emits `input.resolved` with `outcome: "cancelled"` for it. This covers the run's own `ctx.ask()` questions and requests from sessions it opened with `ctx.agent`. A cancelled turn does the same for every question or approval the session relays. A sign-in or tool approval the turn raises itself holds it the same way, also with `on: "input"`. A message from the same person steers the turn and cancels the request: a sign-in reports `authorization.completed` with `outcome: "declined"`, and an approval reports `input.resolved` with `outcome: "ignored"`. Messages from other people wait until the turn ends. Cancelling the turn ends both: a held sign-in reports `authorization.completed` with `outcome: "declined"`, and a held approval reports `input.resolved` with `outcome: "cancelled"`.
+A question or sign-in from inside a running call does not end the turn. This covers a workflow tool's `ctx.ask()`, including the built-in `ask_question` tool, and a delegated subagent's question or sign-in. The stream emits `input.requested` or `authorization.required`, then `turn.waiting` with `on: "input"` and the open turn's `turnId`. After the answer or sign-in, the turn resumes with the next `step.started` for the same `turnId`, and only `turn.completed`, `turn.failed`, or `turn.cancelled` ends it. When you answer a question that belongs to a workflow tool or a subagent, the session you answer on emits `input.resolved` for it as it routes the answer down. A subagent's tool approval instead stays open until the subagent resolves it, and the session relays that subagent's `input.resolved`. While other relayed questions are still pending, it then emits `turn.waiting` with `on: "input"` again. If the workflow tool run that relayed a question or approval ends before anyone answers, that session emits `input.resolved` with `outcome: "cancelled"` for it. This covers the run's own `ctx.ask()` questions and requests from sessions it opened with `ctx.agent`. A cancelled turn does the same for every question or approval the session relays. A sign-in or tool approval the turn raises itself holds it the same way, also with `on: "input"`. A message from the same person steers the turn and cancels the request: a sign-in reports `authorization.completed` with `outcome: "declined"`, and an approval reports `input.resolved` with `outcome: "ignored"`. Messages from other people wait until the turn ends. Cancelling the turn ends both: a held sign-in reports `authorization.completed` with `outcome: "declined"`, and a held approval reports `input.resolved` with `outcome: "cancelled"`.
 
 ### Task events
 
@@ -219,7 +219,7 @@ Message sends default to `"steer"`. Before assistant output begins, eve interrup
 
 If the session is waiting on a human-in-the-loop approval, respond with the channel’s Approve or Cancel controls. Text that doesn't match an option doesn't approve the call. From the person the turn serves, it steers the turn and cancels the approval, even when sent with `turnPolicy: "queue"`, since the turn can't end until that person acts; from anyone else, it waits until the turn ends. If they had already approved some calls in the batch, those calls still run. Cancelling the turn withdraws the approval, and a later answer to it approves nothing.
 
-A pending `ctx.ask()` question from a tool, such as `ask_question`, can be answered with plain text. When it is the only pending question, a message that matches an option answers it, and so does any message when the question allows free text. The stream records that message as `message.received`, carrying its delivery id, just before the `input.resolved` it produces. Otherwise eve does not guess which question the text addresses: the message follows the normal `turnPolicy`. A steering message withdraws the questions of the `execute` workflow tool calls the turn waits on, which resolve as `cancelled`; a task's questions stay open. Questions from subagents always need a structured response. Use structured responses to target requests unambiguously.
+A pending prompt, whether a `ctx.ask()` question from a tool such as `ask_question`, a tool approval, or a session-limit prompt, can be answered with plain text, including prompts proxied from a subagent. A message answers the first open prompt, as described in [Several requests at once](/docs/human-in-the-loop#several-requests-at-once): a reply that matches one of its options, such as `approve` or `continue`, answers it as if the sender had pressed that option, and so does any message when the prompt allows free text. Send one message per prompt to answer several. The stream records a message that answers a question as `message.received`, carrying its delivery id, just before the `input.resolved` it produces. A message that doesn't answer the first open prompt follows the normal `turnPolicy`. A steering message withdraws the questions of the `execute` workflow tool calls the turn waits on, which resolve as `cancelled`; a task's questions stay open. Use structured responses to target requests unambiguously.
 
 A structured response matches any currently pending request by ID, not only the newest batch. It becomes stale only after that request was answered, cleared, or cancelled. eve delivers a stale response to the model as a new user message, and the model decides whether the old selection still matters. A stale approval never authorizes the earlier tool call; the model must request the action and approval again if they are still needed.
 

package/docs/evals/meta.json

@@ -1,5 +1,14 @@
 {
   "title": "Evals",
   "defaultOpen": false,
-  "pages": ["overview", "cases", "assertions", "judge", "targets", "reporters", "running"]
+  "pages": [
+    "overview",
+    "cases",
+    "assertions",
+    "tool-stubs",
+    "judge",
+    "targets",
+    "reporters",
+    "running"
+  ]
 }

package/docs/evals/overview.mdx

@@ -7,6 +7,8 @@ An eval is a scored check that runs your agent against real sessions and grades
 
 Evals exercise the same HTTP surface your users hit. The runner boots (or targets) a real agent server, drives sessions through the [TypeScript client](../guides/client/overview) protocol, and grades what comes back, so a passing eval means the agent booted, accepted a request, and produced the result you asserted.
 
+Define [tool stubs](./tool-stubs) in your eval to control tool results, then assert on the agent's tool calls and responses.
+
 ## `defineEval`
 
 eve discovers evals under the app-root `evals/` directory, in `.eval.ts` files. Each file is one eval by default. A file can also default-export an array to fan out over a dataset (see [Cases](./cases)). The file path is the eval's identity, so you don't author an `id` or `name`. Directories group related evals (`evals/weather/brooklyn-forecast.eval.ts` becomes id `weather/brooklyn-forecast`).