eve 0.58.1 → 0.59.1

package/dist/src/svelte/use-eve-agent.d.ts

@@ -36,6 +36,8 @@ export interface UseEveAgentReturn<TData> {
     readonly events: readonly MessageStreamEvent[];
     /** Replay the attached durable session and follow its in-flight turn, if any. */
     readonly resume: () => Promise<void>;
+    /** Create the session without starting its first turn. */
+    readonly prewarm: () => Promise<void>;
     /** Clear all state and start a new session. */
     readonly reset: () => void;
     /** Send a message with optional turn settings. */
@@ -98,6 +100,8 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      * @default true
      */
     readonly optimistic?: boolean;
+    /** Prewarm an owned session on mount and after reset. @default false */
+    readonly prewarm?: boolean;
     /**
      * Projects stream events into `TData`. Defaults to {@link defaultMessageReducer},
      * which fixes `TData` to {@link EveMessageData}.

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

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

package/dist/src/tools/approval/policies.d.ts

@@ -1,4 +1,22 @@
+import type { Experimental_EvaluationModel as EvaluationModel } from "ai";
 import type { ApprovalPolicy } from "#approval/definition.js";
+export interface AutoApprovalOptions {
+    /** Evaluation model instance or ID. Defaults to TypeSafe Jev. */
+    readonly model?: EvaluationModel;
+    /** Instructions used to classify the exact tool call. */
+    readonly instructions?: string;
+    /** Descriptions of the fixed approval outcomes. */
+    readonly criteria?: {
+        readonly clear?: string;
+        readonly caution?: string;
+    };
+}
+/**
+ * Returns an `approval` callback that asks an AI SDK evaluation model whether
+ * the exact tool call presents concrete security danger. Defaults to TypeSafe Jev.
+ * Unavailable or invalid evaluations require user approval.
+ */
+export declare function auto<TInput = unknown>(options?: AutoApprovalOptions): ApprovalPolicy<TInput>;
 /**
  * Returns an `approval` callback that always requires user approval before
  * the tool executes.

package/dist/src/tools/approval/policies.js

@@ -1 +1 @@
-import{stampDurableDynamicCallback}from"#tools/durable-callbacks.js";function alwaysApproval(e){return`user-approval`}function neverApproval(e){return`not-applicable`}function onceApproval(e,t){return t.approvedTools.has(t.toolName)?`not-applicable`:`user-approval`}function always(){return stampDurableDynamicCallback(()=>`user-approval`,{callback:alwaysApproval,closure:{}})}function never(){return stampDurableDynamicCallback(()=>`not-applicable`,{callback:neverApproval,closure:{}})}function once(){return stampDurableDynamicCallback(({approvedTools:e,toolName:t})=>e.has(t)?`not-applicable`:`user-approval`,{callback:onceApproval,closure:{}})}export{always,never,once};
+import{parseJsonValue}from"#shared/json.js";import{stampDurableDynamicCallback}from"#tools/durable-callbacks.js";import{evaluate}from"#experimental/evaluate/evaluate.js";async function autoApproval(e,t,n){try{let r=parseJsonValue(n.toolInput??null),i=JSON.stringify(r);if(new TextEncoder().encode(i).byteLength>65536)return`user-approval`;let a=AbortSignal.any([n.abortSignal,AbortSignal.timeout(3e4)]);return(await evaluate({model:e,state:{action:{input:r,tool:n.toolName}},questions:{permission:{type:`choice`,instructions:t.instructions??`Review the exact tool action for dangerous effects. Return caution when it could cause meaningful harm, including destructive data loss, credential exposure, financial transactions, deployments or public changes, external communication, privilege or system changes, or concealed execution. Return clear for routine, low-impact actions. Judge the action's actual effects from its name and input. If important effects are unclear, return caution.`,criteria:{clear:t.criteria?.clear??`The action is routine and low impact.`,caution:t.criteria?.caution??`The action is dangerous or its important effects are unclear.`}}},abortSignal:a,maxRetries:0})).answers.permission.choice===`clear`?`approved`:`user-approval`}catch{return n.abortSignal.throwIfAborted(),`user-approval`}}function alwaysApproval(e){return`user-approval`}function neverApproval(e){return`not-applicable`}function onceApproval(e,t){return t.approvedTools.has(t.toolName)?`not-applicable`:`user-approval`}function auto(e={}){let t=e.model??`typesafe-ai/jev`;return stampDurableDynamicCallback(n=>autoApproval(t,e,n),{callback:(n,r)=>autoApproval(t,e,r),closure:{}})}function always(){return stampDurableDynamicCallback(()=>`user-approval`,{callback:alwaysApproval,closure:{}})}function never(){return stampDurableDynamicCallback(()=>`not-applicable`,{callback:neverApproval,closure:{}})}function once(){return stampDurableDynamicCallback(({approvedTools:e,toolName:t})=>e.has(t)?`not-applicable`:`user-approval`,{callback:onceApproval,closure:{}})}export{always,auto,never,once};

package/dist/src/tools/definition.d.ts

@@ -243,6 +243,8 @@ export declare function defineTool<TReturn>(definition: {
 export declare function defineTool<TInput = unknown, TOutput = unknown>(definition: ToolDefinition<TInput, TOutput>): ToolDefinition<TInput, TOutput>;
 export declare function stampToolDefinition<T extends {
     readonly description: string;
+    readonly inputSchema?: unknown;
+    readonly outputSchema?: unknown;
     readonly execute: (...args: never[]) => unknown;
     readonly label?: ToolLabelDefinition;
     readonly approval?: Approval<never>;
@@ -255,14 +257,15 @@ export declare function stampToolDefinition<T extends {
 declare const DISABLED_TOOL_SENTINEL_KIND = "eve:disabled-tool";
 /**
  * Marker value returned from {@link disableTool}. Export this as the default
- * export of a file in `agent/tools/` to remove the framework default whose
- * name matches the file's slug.
+ * export of a file in `agent/tools/` to remove the model tool whose name
+ * matches the file's slug, including framework defaults and derived subagent
+ * tools.
  */
 export interface DisabledToolSentinel {
     readonly kind: typeof DISABLED_TOOL_SENTINEL_KIND;
 }
 /**
- * Returns a sentinel that disables the framework tool whose name matches the
+ * Returns a sentinel that disables the model tool whose name matches the
  * containing file's slug.
  */
 export declare function disableTool(): DisabledToolSentinel;

package/dist/src/tools/definition.js

@@ -1 +1 @@
-import{collectDurableDynamicToolCallbacks,stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{TOOL_BRAND}from"#tools/dynamic.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineTool(e){return stampToolDefinition(e,`defineTool`)}function stampToolDefinition(e,t){if(e.auth!==void 0)throw Error(`${t}: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(e,collectDurableDynamicToolCallbacks({label:e.label,approval:e.approval,approvalKey:e.approvalKey,execute:e.execute,toModelOutput:e.toModelOutput})),stampDefinitionKey(e,`tool:${e.description}`),e}const DISABLED_TOOL_SENTINEL_KIND=`eve:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}export{defineTool,disableTool,isDisabledToolSentinel,stampToolDefinition};
+import{collectDurableDynamicToolCallbacks,stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{TOOL_BRAND}from"#tools/dynamic.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineTool(e){return stampToolDefinition(e,`defineTool`)}function stampToolDefinition(e,t){if(e.auth!==void 0)throw Error(`${t}: The "auth" field is no longer supported. Pass auth providers inline to ctx.getToken(provider) or ctx.requireAuth(provider).`);return Object.assign(e,{[TOOL_BRAND]:!0}),stampDurableDynamicToolCallbacks(e,collectDurableDynamicToolCallbacks({inputSchema:e.inputSchema,outputSchema:e.outputSchema,label:e.label,approval:e.approval,approvalKey:e.approvalKey,execute:e.execute,toModelOutput:e.toModelOutput})),stampDefinitionKey(e,`tool:${e.description}`),e}const DISABLED_TOOL_SENTINEL_KIND=`eve:disabled-tool`;function disableTool(){return{kind:DISABLED_TOOL_SENTINEL_KIND}}function isDisabledToolSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_TOOL_SENTINEL_KIND}export{defineTool,disableTool,isDisabledToolSentinel,stampToolDefinition};

package/dist/src/tools/durable-callbacks.d.ts

@@ -1,6 +1,6 @@
 import type { Approval } from "#approval/definition.js";
 import type { JsonObject, JsonPrimitive } from "#shared/json.js";
-export type DurableDynamicCallbackPhase = "labelComplete" | "labelDelta" | "labelStart" | "approvalKey" | "approvalRequest" | "approvalResponse" | "execute" | "toModelOutput";
+export type DurableDynamicCallbackPhase = "labelComplete" | "labelDelta" | "labelStart" | "approvalKey" | "approvalRequest" | "approvalResponse" | "execute" | "toModelOutput" | "inputSchema" | "outputSchema";
 export type DurableDynamicCallbackFn = (closure: JsonObject, ...args: never[]) => unknown;
 /**
  * Persisted binding for one callback phase. Identity is
@@ -14,6 +14,8 @@ export interface DurableDynamicCallbackReference {
 }
 export interface DurableDynamicToolCallbacks {
     readonly execute: DurableDynamicCallbackReference;
+    readonly inputSchema?: DurableDynamicCallbackReference;
+    readonly outputSchema?: DurableDynamicCallbackReference;
     readonly label?: {
         readonly complete?: DurableDynamicCallbackReference;
         readonly delta?: DurableDynamicCallbackReference;
@@ -31,6 +33,8 @@ export interface StampedDurableDynamicCallback {
 }
 export type LiveDurableDynamicToolCallbacks = Partial<{
     execute: StampedDurableDynamicCallback;
+    inputSchema: StampedDurableDynamicCallback;
+    outputSchema: StampedDurableDynamicCallback;
     label: {
         readonly complete?: StampedDurableDynamicCallback;
         readonly delta?: StampedDurableDynamicCallback;
@@ -72,7 +76,7 @@ export declare function hasUnregisteredDurableDynamicCallbacks(metadata: readonl
     entryKey: string;
 }[], scope: Pick<DynamicToolCallbackOwner, "sessionId" | "scope">): boolean;
 type DurableCallbackJsonValue<T> = T extends (...args: never[]) => unknown ? never : T extends JsonPrimitive ? T : T extends readonly (infer TItem)[] ? readonly DurableCallbackJsonValue<TItem>[] : T extends object ? DurableCallbackJsonObject<T> : never;
-type DurableCallbackJsonObject<T extends object> = Extract<keyof T, symbol> extends never ? {
+export type DurableCallbackJsonObject<T extends object> = Extract<keyof T, symbol> extends never ? {
     readonly [TKey in keyof T]: DurableCallbackJsonValue<Exclude<T[TKey], undefined>> | Extract<T[TKey], undefined>;
 } : never;
 /**
@@ -93,6 +97,8 @@ export declare function readDurableDynamicCallback(callback: unknown): StampedDu
 /** Copies phase-specific callback descriptors onto a branded tool definition. */
 export declare function stampDurableDynamicToolCallbacks(definition: object, callbacks: LiveDurableDynamicToolCallbacks): void;
 export declare function collectDurableDynamicToolCallbacks(input: {
+    readonly inputSchema?: unknown;
+    readonly outputSchema?: unknown;
     readonly label?: {
         readonly complete?: (...args: never[]) => unknown;
         readonly delta?: (...args: never[]) => unknown;

package/dist/src/tools/durable-callbacks.js

@@ -1 +1 @@
-import{resolveApprovalPolicy}from"#approval/definition.js";const STAMPED_CALLBACK=Symbol.for(`eve:durable-dynamic-callback`),DURABLE_DYNAMIC_TOOL_CALLBACKS=Symbol.for(`eve:durable-dynamic-tool-callbacks`),REGISTRY=Symbol.for(`eve:scoped-dynamic-tool-callbacks`);function getRegistry(){let e=globalThis;return e[REGISTRY]??=new Map}function getSessionBindings(e){let t=getRegistry(),n=t.get(e);return n!==void 0&&(t.delete(e),t.set(e,n)),n}function callbackKey(e,t){return JSON.stringify([e.scope,e.resolverSlug,e.entryKey,e.name,t])}function registerDurableDynamicCallback(e){let t=getRegistry(),n=getSessionBindings(e.owner.sessionId);n===void 0&&(n=new Map,t.set(e.owner.sessionId,n),t.size>1024&&t.delete(t.keys().next().value)),n.set(callbackKey(e.owner,e.phase),e.callback)}function lookupDurableDynamicCallback(e,t){return getSessionBindings(e.sessionId)?.get(callbackKey(e,t))}function clearDurableDynamicCallbacks(e,t){if(t===void 0){getRegistry().delete(e);return}let n=getSessionBindings(e);if(n===void 0)return;let r=JSON.stringify([t.scope,t.resolverSlug]).slice(0,-1)+`,`;for(let e of n.keys())e.startsWith(r)&&n.delete(e)}function callDurableDynamicCallback(e,t,...n){return e(t,...n)}function hasUnregisteredDurableDynamicCallbacks(e,t){return e.some(e=>durableCallbackPhases(e.callbacks).some(n=>lookupDurableDynamicCallback({...e,...t},n)===void 0))}function durableCallbackPhases(e){return[[`execute`,e.execute],[`labelComplete`,e.label?.complete],[`labelDelta`,e.label?.delta],[`labelStart`,e.label?.start],[`approvalKey`,e.approvalKey],[`approvalRequest`,e.approvalRequest],[`approvalResponse`,e.approvalResponse],[`toModelOutput`,e.toModelOutput]].flatMap(([e,t])=>t===void 0?[]:[e])}function defineDurableCallback(e){return stampDurableDynamicCallback((...t)=>e.callback(e.closure,...t),{callback:(t,...n)=>Reflect.apply(e.callback,void 0,[t,...n]),closure:e.closure})}function stampDurableDynamicCallback(e,t){return Object.defineProperty(e,STAMPED_CALLBACK,{configurable:!0,value:t}),e}function readDurableDynamicCallback(e){if(typeof e==`function`)return Reflect.get(e,STAMPED_CALLBACK)}function stampDurableDynamicToolCallbacks(e,t){Object.defineProperty(e,DURABLE_DYNAMIC_TOOL_CALLBACKS,{configurable:!0,value:t})}function collectDurableDynamicToolCallbacks(e){let t=readDurableDynamicCallback(e.label?.complete),n=readDurableDynamicCallback(e.label?.delta),r=readDurableDynamicCallback(e.label?.start),i=e.approval===void 0?void 0:readDurableDynamicCallback(resolveApprovalPolicy(e.approval)),a=e.approval===void 0||typeof e.approval==`function`?void 0:readDurableDynamicCallback(e.approval.response),o=readDurableDynamicCallback(e.approvalKey),s=readDurableDynamicCallback(e.execute),c=readDurableDynamicCallback(e.toModelOutput),l={};return s!==void 0&&(l.execute=s),(t!==void 0||n!==void 0||r!==void 0)&&(l.label={complete:t,delta:n,start:r}),o!==void 0&&(l.approvalKey=o),i!==void 0&&(l.approvalRequest=i),a!==void 0&&(l.approvalResponse=a),c!==void 0&&(l.toModelOutput=c),l}function readDurableDynamicToolCallbacks(e){return e[DURABLE_DYNAMIC_TOOL_CALLBACKS]}export{DURABLE_DYNAMIC_TOOL_CALLBACKS,callDurableDynamicCallback,clearDurableDynamicCallbacks,collectDurableDynamicToolCallbacks,defineDurableCallback,hasUnregisteredDurableDynamicCallbacks,lookupDurableDynamicCallback,readDurableDynamicCallback,readDurableDynamicToolCallbacks,registerDurableDynamicCallback,stampDurableDynamicCallback,stampDurableDynamicToolCallbacks};
+import{readDurableSchema}from"#tools/durable-schema.js";import{resolveApprovalPolicy}from"#approval/definition.js";const STAMPED_CALLBACK=Symbol.for(`eve:durable-dynamic-callback`),DURABLE_DYNAMIC_TOOL_CALLBACKS=Symbol.for(`eve:durable-dynamic-tool-callbacks`),REGISTRY=Symbol.for(`eve:scoped-dynamic-tool-callbacks`);function getRegistry(){let e=globalThis;return e[REGISTRY]??=new Map}function getSessionBindings(e){let t=getRegistry(),n=t.get(e);return n!==void 0&&(t.delete(e),t.set(e,n)),n}function callbackKey(e,t){return JSON.stringify([e.scope,e.resolverSlug,e.entryKey,e.name,t])}function registerDurableDynamicCallback(e){let t=getRegistry(),n=getSessionBindings(e.owner.sessionId);n===void 0&&(n=new Map,t.set(e.owner.sessionId,n),t.size>1024&&t.delete(t.keys().next().value)),n.set(callbackKey(e.owner,e.phase),e.callback)}function lookupDurableDynamicCallback(e,t){return getSessionBindings(e.sessionId)?.get(callbackKey(e,t))}function clearDurableDynamicCallbacks(e,t){if(t===void 0){getRegistry().delete(e);return}let n=getSessionBindings(e);if(n===void 0)return;let r=JSON.stringify([t.scope,t.resolverSlug]).slice(0,-1)+`,`;for(let e of n.keys())e.startsWith(r)&&n.delete(e)}function callDurableDynamicCallback(e,t,...n){return e(t,...n)}function hasUnregisteredDurableDynamicCallbacks(e,t){return e.some(e=>durableCallbackPhases(e.callbacks).some(n=>lookupDurableDynamicCallback({...e,...t},n)===void 0))}function durableCallbackPhases(e){return[[`execute`,e.execute],[`inputSchema`,e.inputSchema],[`outputSchema`,e.outputSchema],[`labelComplete`,e.label?.complete],[`labelDelta`,e.label?.delta],[`labelStart`,e.label?.start],[`approvalKey`,e.approvalKey],[`approvalRequest`,e.approvalRequest],[`approvalResponse`,e.approvalResponse],[`toModelOutput`,e.toModelOutput]].flatMap(([e,t])=>t===void 0?[]:[e])}function defineDurableCallback(e){return stampDurableDynamicCallback((...t)=>e.callback(e.closure,...t),{callback:(t,...n)=>Reflect.apply(e.callback,void 0,[t,...n]),closure:e.closure})}function stampDurableDynamicCallback(e,t){return Object.defineProperty(e,STAMPED_CALLBACK,{configurable:!0,value:t}),e}function readDurableDynamicCallback(e){if(typeof e==`function`)return Reflect.get(e,STAMPED_CALLBACK)}function stampDurableDynamicToolCallbacks(e,t){Object.defineProperty(e,DURABLE_DYNAMIC_TOOL_CALLBACKS,{configurable:!0,value:t})}function collectDurableDynamicToolCallbacks(e){let t=readDurableDynamicCallback(e.label?.complete),n=readDurableDynamicCallback(e.label?.delta),r=readDurableDynamicCallback(e.label?.start),i=e.approval===void 0?void 0:readDurableDynamicCallback(resolveApprovalPolicy(e.approval)),a=e.approval===void 0||typeof e.approval==`function`?void 0:readDurableDynamicCallback(e.approval.response),o=readDurableDynamicCallback(e.approvalKey),s=readDurableDynamicCallback(e.execute),c=readDurableDynamicCallback(e.toModelOutput),l={},u=readDurableSchema(e.inputSchema),d=readDurableSchema(e.outputSchema);return u!==void 0&&(l.inputSchema=u),d!==void 0&&(l.outputSchema=d),s!==void 0&&(l.execute=s),(t!==void 0||n!==void 0||r!==void 0)&&(l.label={complete:t,delta:n,start:r}),o!==void 0&&(l.approvalKey=o),i!==void 0&&(l.approvalRequest=i),a!==void 0&&(l.approvalResponse=a),c!==void 0&&(l.toModelOutput=c),l}function readDurableDynamicToolCallbacks(e){return e[DURABLE_DYNAMIC_TOOL_CALLBACKS]}export{DURABLE_DYNAMIC_TOOL_CALLBACKS,callDurableDynamicCallback,clearDurableDynamicCallbacks,collectDurableDynamicToolCallbacks,defineDurableCallback,hasUnregisteredDurableDynamicCallbacks,lookupDurableDynamicCallback,readDurableDynamicCallback,readDurableDynamicToolCallbacks,registerDurableDynamicCallback,stampDurableDynamicCallback,stampDurableDynamicToolCallbacks};

package/dist/src/tools/durable-schema.d.ts

@@ -0,0 +1,16 @@
+import type { StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import type { DurableCallbackJsonObject, StampedDurableDynamicCallback } from "#tools/durable-callbacks.js";
+import { type ToolSchema, type ToolSchemaSource } from "#tools/schema.js";
+export declare function hasSchemaValidator(source: unknown): source is StandardSchemaV1;
+type DurableSchema<TSchema> = TSchema extends StandardSchemaV1 ? ToolSchema<StandardSchemaV1.InferInput<TSchema>, StandardSchemaV1.InferOutput<TSchema>> : TSchema;
+/**
+ * Defines a replayable schema for dynamic tools returned by provider packages.
+ * Put per-tool values in `closure`; `schema` rebuilds the validator from that
+ * JSON snapshot. Authored inline schema expressions are transformed automatically.
+ */
+export declare function defineDurableSchema<TClosure extends object, TSchema extends ToolSchemaSource | undefined>(input: {
+    readonly closure: TClosure & DurableCallbackJsonObject<TClosure>;
+    readonly schema: (closure: TClosure) => TSchema;
+}): DurableSchema<TSchema>;
+export declare function readDurableSchema(source: unknown): StampedDurableDynamicCallback | undefined;
+export {};

package/dist/src/tools/durable-schema.js

@@ -0,0 +1 @@
+import{serializeInputSchema,serializeOutputSchema}from"#tools/schema.js";const DURABLE_SCHEMA=Symbol.for(`eve:durable-dynamic-schema`);function hasSchemaValidator(e){if(typeof e!=`object`||!e||!(`~standard`in e))return!1;let t=e[`~standard`];return typeof t==`object`&&!!t&&`validate`in t&&typeof t.validate==`function`}function defineDurableSchema(e){let t=e.schema(e.closure);if(!hasSchemaValidator(t))return t;let n={"~standard":{version:1,vendor:`eve`,validate:e=>t[`~standard`].validate(e),jsonSchema:{input:()=>serializeInputSchema(t),output:()=>serializeOutputSchema(t)}}};return Object.defineProperty(n,DURABLE_SCHEMA,{value:{callback:t=>e.schema(t),closure:e.closure}}),n}function readDurableSchema(e){if(typeof e==`object`&&e)return Reflect.get(e,DURABLE_SCHEMA)}export{defineDurableSchema,hasSchemaValidator,readDurableSchema};

package/dist/src/vue/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-X0asmJg-.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-Dmc6sX4d.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/vue/use-eve-agent.d.ts

@@ -35,6 +35,8 @@ export interface UseEveAgentReturn<TData> {
     readonly events: ComputedRef<readonly MessageStreamEvent[]>;
     /** Replay the attached durable session and follow its in-flight turn, if any. */
     readonly resume: () => Promise<void>;
+    /** Create the session without starting its first turn. */
+    readonly prewarm: () => Promise<void>;
     /** Clear all state and start a new session. */
     readonly reset: () => void;
     /** Send a message with optional turn settings. */
@@ -98,6 +100,8 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      * @default true
      */
     readonly optimistic?: boolean;
+    /** Prewarm an owned session on mount and after reset. @default false */
+    readonly prewarm?: boolean;
     /**
      * Projects stream events into `TData`.
      *

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

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

package/docs/agent-config.md

@@ -336,6 +336,7 @@ it falls back to the World's default retention period.
 | `experimental` | `AgentExperimentalDefinition`           | unset            | Unstable opt-ins. `workflow.world` selects the Workflow world package on the root agent; `workflow.modelCallsPerStep` batches sequential model calls into a wider replay unit; `workflow.retention` controls how long the durable runtime keeps run data. |
 | `outputSchema` | Standard Schema or a JSON Schema object | none             | Structured return type for function-like invocations such as a subagent turn, schedule, or remote job. Ordinary interactive turns ignore it unless the client supplies a per-message schema.                                                              |
 | `build`        | `{ externalDependencies?: string[] }`   | none             | Hosted-build packaging controls. `externalDependencies` keeps listed packages external while eve compiles authored modules such as tools and channels, and traces those packages into the hosted output.                                                  |
+| `tool`         | `boolean`                               | `true`           | Exposes this agent to its parent model as a tool. On the root agent, controls the built-in `agent` tool. A subagent with `tool: false` remains callable from authored workflow tools through `ctx.agent()`.                                               |
 
 `externalDependencies` is a packaging control only. It keeps selected packages as runtime dependencies in the hosted output; it does not authorize, configure, or review any third-party service those packages may call.
 

package/docs/channels/eve.mdx

@@ -24,7 +24,7 @@ The default eve channel inspects the agent, creates sessions, accepts callbacks
 
 - `GET /eve/v1/health` (check whether the application is reachable)
 - `GET /eve/v1/info` (inspect the agent)
-- `POST /eve/v1/session` (start a session and send its first message)
+- `POST /eve/v1/session` (create a session, optionally sending its first message)
 - `POST /eve/v1/session/:sessionId` (send a follow-up)
 - `POST /eve/v1/session/:sessionId/cancel` (cancel the in-flight turn)
 - `POST /eve/v1/session/:sessionId/clear` (clear the session's model history)
@@ -38,7 +38,21 @@ The session routes use only durable session IDs. Create a session explicitly, th
 
 ### Start and continue a session
 
-Start a session with an initial message, then use the returned `sessionId` for every follow-up and control operation:
+Create a conversation session before its first message with a bodyless request:
+
+```bash
+curl -X POST https://<deployment>/eve/v1/session
+# {"ok":true,"sessionId":"wrun_A","status":"accepted"}
+```
+
+See [Start a session](../concepts/sessions-runs-and-streaming#start-a-session) for the
+initialization boundary, first-turn identity, readiness response, and retry behavior.
+
+The create request still requires route auth. Session audience and the timeout are selected
+at creation; they do not change when the first message arrives. Task mode and turn-scoped
+fields such as `clientContext` and `outputSchema` require a message on the create request.
+
+Include an initial message to create the session and start its first turn in one request:
 
 ```bash
 curl -X POST https://<deployment>/eve/v1/session \
@@ -47,11 +61,6 @@ curl -X POST https://<deployment>/eve/v1/session \
 # {"ok":true,"sessionId":"wrun_A","status":"accepted"}
 ```
 
-The `202` response means Workflow accepted the durable run. The route does not wait for command
-inbox or continuation-token ownership. The inbox may still be starting, so an immediate follow-up
-or control request can report that the session is not active. The event-stream client retries the
-brief window before the new run becomes readable.
-
 Authenticated callers that may retry a create request can pass their own `operationId` for
 create-once semantics. Once the operation owner is active, the same operation under the same
 authenticated principal returns that session instead of dispatching the input again. The create
@@ -69,7 +78,7 @@ curl -X POST https://<deployment>/eve/v1/session \
 # {"ok":true,"sessionId":"wrun_A","status":"accepted"}
 ```
 
-The first request requires `message`. A follow-up request accepts exactly one of
+When the create request includes a message, a follow-up request accepts exactly one of
 `message` or `inputResponses`; use the latter to answer a pending HITL request:
 
 ```bash
@@ -82,8 +91,9 @@ Follow-up messages use `turnPolicy: "steer"` by default. Before assistant answer
 
 Set `turnPolicy: "queue"` on `eveChannel(...)` when follow-ups should wait for active turns to finish. `inputResponses` answer their addressed requests.
 
-Sending a message to an unknown, terminal, or not-yet-active session ID returns `409` with
+Sending a message to an unknown or terminal session ID returns `409` with
 `{"code":"session_not_active","error":"The session is no longer active.","ok":false}`.
+An existing workflow whose inbox is not yet available returns `409 session_not_ready` instead.
 TypeScript clients expose the stable code as `ClientError.code`. The route never
 creates or follows a replacement session.
 
@@ -225,7 +235,7 @@ export default eveChannel({
 });
 ```
 
-`onMessage` must return an auth result. Return `title` alongside `auth` to set the title when the dispatch starts a run. A successful canonical eve HTTP message always dispatches and therefore always produces or continues a session.
+`onMessage` must return an auth result. Return `title` alongside `auth` to set the title when the dispatch creates a session or sends the first message to a prewarmed session. A successful canonical eve HTTP message always dispatches and therefore always produces or continues a session.
 
 ## Clients
 

package/docs/concepts/context-control.md

@@ -58,6 +58,10 @@ See [Dynamic capabilities](../guides/dynamic-capabilities) for the resolver API,
 
 ## Compaction and clear
 
+Before a model call, eve checks the projected history together with the effective system instructions and advertised tool schemas. The check runs after `step.started` resolves dynamic capabilities. When the provider reports input usage, eve adds estimates for new messages and growth in the instructions and tool catalog to that count; unchanged schemas are not counted again.
+
+Compaction reserves space for those instructions and tools while reducing conversation history. It cannot shrink the instructions or tool catalog themselves, so keep them within the selected model's context window.
+
 User-role instructions follow the normal history lifecycle. Compaction can summarize them, and clear removes them without rerunning their static definitions or dynamic resolvers. System-role instructions remain outside history and continue to apply after either operation.
 
 Recalled memory also uses user-role messages, but eve keeps their attribution

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

@@ -33,16 +33,31 @@ React, Vue, and Svelte apps reach for [`useEveAgent()`](../guides/frontend/overv
 
 ## Start a session
 
+Create and park a conversation session before its first turn by omitting `message`:
+
+```bash
+curl -X POST http://127.0.0.1:2000/eve/v1/session
+```
+
+eve starts the durable workflow, establishes its inbox, and waits for the first message before
+running session-scoped initialization or emitting `session.started`. The first message sent to the returned
+`sessionId` remains `turn_0`. Message-free creation supports conversation mode only and does not
+accept turn-scoped `clientContext`, `outputSchema`, callbacks, or activity observers.
+
+To create the session and start its first turn in one request, include the message:
+
 ```bash
 curl -X POST http://127.0.0.1:2000/eve/v1/session \
   -H 'content-type: application/json' \
   -d '{"message":"Summarize the latest forecast."}'
 ```
 
-eve responds with `202` and the durable `sessionId` in the JSON body and
+In both forms, eve responds with `202` and the durable `sessionId` in the JSON body and
 `x-eve-session-id` header as soon as Workflow accepts the run. The command inbox can still be
-starting at that point. An immediate follow-up can return `409 session_not_active`; wait for
-`session.waiting` before sending the next message.
+starting at that point. An immediate follow-up can return `409 session_not_ready`; retry that
+code with bounded backoff. The TypeScript client retries sends for up to 20 seconds and respects
+the caller's abort signal. Do not wait
+for `session.waiting` on a prewarmed session: initialization and its first events require a message.
 
 ## Stream a session
 

package/docs/connections/mcp.mdx

@@ -100,11 +100,11 @@ Prefer `allow` for the smallest safe surface, especially when the server exposes
 
 ## Approval gates
 
-Use the shared `approval` option to gate every tool served by an MCP connection. The [connections overview](../connections#per-connection-approval) defines the `never()`, `once()`, and `always()` helpers; [Human-in-the-loop](../human-in-the-loop#approvals) defines the pause-and-resume contract.
+Use the shared `approval` option to gate every tool served by an MCP connection. The [connections overview](../connections#per-connection-approval) defines the `never()`, `once()`, `always()`, and `auto()` helpers; [Human-in-the-loop](../human-in-the-loop#approvals) defines the pause-and-resume contract.
 
 ### Gate specific tools by name or input
 
-A remote MCP server usually mixes read tools with destructive or publishing ones, so a blanket `always()` would prompt on every harmless call. Pass a custom policy instead — the same [`Approval`](/docs/human-in-the-loop#approvals) shape authored tools use — to gate only the calls that matter. The policy receives `{ session, toolName, toolInput, approvedTools }` and returns an approval status, synchronously or as a promise.
+A remote MCP server usually mixes read tools with destructive or publishing ones, so a blanket `always()` would prompt on every harmless call. Pass a custom policy instead — the same [`Approval`](/docs/human-in-the-loop#approvals) shape authored tools use — to gate only the calls that matter. The policy receives `{ session, toolName, toolInput, approvedTools, callId, abortSignal }` and returns an approval status, synchronously or as a promise.
 
 This connection always gates deletes, gates a publish only when the call actually schedules a post, and lets everything else through:
 

package/docs/connections/overview.mdx

@@ -172,7 +172,7 @@ export default defineMcpClientConnection({
 });
 ```
 
-`never()` lets every call through, `once()` asks for approval the first time in a session, and `always()` asks every time. The pause and resume is the same human-in-the-loop flow covered in [Tools](/docs/tools).
+`never()` lets every call through, `once()` asks for approval the first time in a session, `always()` asks every time, and `auto()` uses an evaluation model to allow routine calls and ask about dangerous or unclear effects. The pause and resume is the same human-in-the-loop flow covered in [Tools](/docs/tools).
 
 For connection tools that can create, modify, delete, transmit, purchase, message, or access sensitive data, use approval, allow-lists, or other safeguards appropriate to the action.
 

package/docs/evals/assertions.mdx

@@ -50,15 +50,15 @@ attached.messageIncludes("Sunny");
 
 ## Value assertions with `t.check`
 
-`t.check(value, assertion)` grades an explicit value against a builder from `eve/evals/expect`. The value can be `t.reply`, a turn's `.message`, parsed JSON, or any local you computed:
+`t.check(value, assertion)` grades an explicit value against a builder from `eve/evals/expect`. The value can be a turn’s `.message`, parsed JSON, or any local you computed:
 
 ```ts
 import { includes, equals, matches, satisfies, similarity } from "eve/evals/expect";
 
-t.check(t.reply, includes(/sunny/i)); // substring or RegExp (gate)
+t.check(turn.message, includes(/sunny/i)); // substring or RegExp (gate)
 t.check(parsed, equals({ city: "Brooklyn" })); // deep structural equality (gate)
 t.check(parsed, matches(WeatherSchema)); // Standard Schema, e.g. Zod (gate)
-t.check(t.reply, similarity("Sunny, 72F")); // fuzzy 0–1 Levenshtein (soft)
+t.check(turn.message, similarity("Sunny, 72F")); // fuzzy 0–1 Levenshtein (soft)
 t.check(
   latencyMs,
   satisfies((value) => value < 1_000, "latency under one second"),
@@ -114,7 +114,7 @@ const request = session.requireInputRequest({
 
 ## Run state and derived facts
 
-Beyond the raw `t.events` stream, the runner derives typed facts the assertions read: tool calls (name, input, output, lifecycle status), subagent calls, and HITL input requests. A turn that leaves the session open for a next message is the normal end state of a successful turn; parking on unanswered HITL input is tracked separately.
+Beyond the raw `session.events` stream, the runner derives typed facts the assertions read: tool calls (name, input, output, lifecycle status), subagent calls, and HITL input requests. A turn that leaves the session open for a next message is the normal end state of a successful turn; parking on unanswered HITL input is tracked separately.
 
 Typed event matching covers presence, absence, numeric or predicate counts, partial event data, and ordering:
 
@@ -166,8 +166,8 @@ The defaults are chosen so you rarely set severity. Run-level methods and `inclu
 
 ```ts
 t.calledTool("get_weather").soft(); // record the tool call as a metric, don't gate
-t.check(t.reply, similarity("Sunny")).label("forecast wording").atLeast(0.8);
-t.check(t.reply, includes("error")).soft(); // track without failing the build
+t.check(turn.message, similarity("Sunny")).label("forecast wording").atLeast(0.8);
+t.check(turn.message, includes("error")).soft(); // track without failing the build
 ```
 
 ## What to read next

package/docs/evals/cases.mdx

@@ -15,7 +15,7 @@ export default defineEvalConfig({});
 
 ## Single-turn evals
 
-The common case sends one turn and asserts on the reply. `t.send(input)` resolves once the turn settles, and `t.reply` is the last assistant message:
+The common case sends one turn and asserts on the reply. `t.send(input)` resolves once the turn settles, and the returned turn’s `.message` is the assistant reply:
 
 ```ts title="evals/weather/brooklyn-forecast.eval.ts"
 import { defineEval } from "eve/evals";
@@ -23,9 +23,9 @@ import { includes } from "eve/evals/expect";
 
 export default defineEval({
   async test(t) {
-    await t.send("What is the weather in Brooklyn?");
+    const turn = await t.send("What is the weather in Brooklyn?");
     t.succeeded();
-    t.check(t.reply, includes("Sunny"));
+    t.check(turn.message, includes("Sunny"));
   },
 });
 ```
@@ -60,7 +60,7 @@ evals/
 
 ## Multi-turn evals
 
-Drive several turns in sequence for branching, HITL approvals, structured output, attachments, or multiple sessions. Because assertions live in the function, an intermediate value is a local variable. Judge a draft before the next turn overwrites it, then keep going.
+Drive several turns in sequence for branching, HITL approvals, structured output, attachments, or multiple sessions. Because assertions live in the function, an intermediate value is a local variable. Keep each turn in a local variable and continue through its `.session`.
 
 ```ts title="evals/draft-then-send.eval.ts"
 import { defineEval } from "eve/evals";
@@ -72,7 +72,7 @@ export default defineEval({
     t.check(draft.message, includes("Best regards"));
     t.judge.autoevals.closedQA("professional tone", { on: draft.message }).atLeast(0.6);
 
-    await t.send("Now send it.");
+    await draft.session.send("Now send it.");
     t.calledTool("send_email");
   },
 });
@@ -88,7 +88,7 @@ export default defineEval({
   async test(t) {
     const first = await t.send("My favorite word is marigold.");
 
-    const second = await t.send("What is my favorite word?");
+    const second = await first.session.send("What is my favorite word?");
     await t.require(second.sessionId, equals(first.sessionId));
 
     t.succeeded();
@@ -96,7 +96,7 @@ export default defineEval({
 
     t.judge.autoevals
       .closedQA("The assistant remembers the user's favorite word across turns", {
-        on: t.transcript,
+        on: first.session.transcript,
       })
       .atLeast(0.8);
   },
@@ -105,21 +105,56 @@ export default defineEval({
 
 ## The drive API
 
-`t` drives the primary session; `t.newSession()` returns an independent `EveEvalSession` against the same target, whose events feed the same run-level assertions.
+Every `t.session()` or `t.send()` creates a new independent conversation. Continue an existing conversation through its session handle. Events from all sessions feed the same run-level assertions.
 
-- `t.send(message, options?)` sends a turn and waits for it to settle. It matches `ClientSession.send()` and resolves to a turn carrying `.message` and `.expectOk()`.
-- `t.start(message)` starts a text turn but returns as soon as the server accepts it. The returned live turn exposes `.sessionId`, `.waitForEvent(...)`, `.cancel()`, and `.result()` for coordinating with work that is still running.
-- `t.cancel()` requests cooperative cancellation of the primary session's active turn. Both `accepted` and `no_active_turn` are successful outcomes.
-- `t.sendFile(text, path, mediaType?)` attaches a local file as a data URL.
-- `t.requireInputRequest(filter?)` records a gate, requires exactly one pending request, and returns it. Filters match tool name, action input, prompt, display, and option ids.
-- `t.respond(responses, options?)` answers specific pending input requests and sends them as the next turn.
-- `t.respondAll(optionId)` answers every pending input request with the same option and sends the responses as the next turn.
-- `t.reply` is the last assistant message (or `null`); `t.sessionId` is the current session id; `t.events` is the full typed event stream captured so far.
-- `t.transcript` formats the primary session's observed user and assistant messages in turn order. Pass it as a judge's `on` value to grade the complete conversation. An independent session returned by `t.newSession()` exposes its own `session.transcript`.
+- `t.session(options?)` creates a session without starting a turn or consuming its stream. It resolves on `202 Accepted` with an `EveEvalSession` whose `.sessionId` and `.state` are available. Options accept per-request `headers` and `signal`; creation uses the eval timeout signal by default.
+- `t.send(message, options?)` creates a new session with its first message in one request and waits for the turn to settle. The returned turn carries `.session`, `.message`, and `.expectOk()`.
+- `session.send(message, options?)` sends a follow-up on that session and waits for it to settle.
+- `session.start(message, options?)` starts a text turn and returns as soon as the server accepts it. The live turn exposes `.session`, `.sessionId`, `.waitForEvent(...)`, `.cancel()`, and `.result()`.
+- `session.cancel()` requests cooperative cancellation of that session's active turn. Both `accepted` and `no_active_turn` are successful outcomes.
+- `session.sendFile(text, path, mediaType?)` attaches a local file as a data URL.
+- `session.requireInputRequest(filter?)` records a gate, requires exactly one pending request, and returns it. Filters match tool name, action input, prompt, display, and option ids.
+- `session.respond(responses, options?)` answers specific pending input requests and sends them as the next turn. `session.startRespond(...)` returns a live turn for the same operation.
+- `session.respondAll(optionId)` answers every pending input request with the same option and sends the responses as the next turn.
+- `session.events` contains the events captured for that session. `session.transcript` formats its observed user and assistant messages in turn order.
 
-The transcript uses `User:` and `Assistant:` labels separated by blank lines. It excludes reasoning, tool calls, tool results, and messages from other sessions. It updates after each turn settles, so read it after `await t.send(...)`, `await t.respond(...)`, or `await live.result()`.
+The transcript uses `User:` and `Assistant:` labels separated by blank lines. It excludes reasoning, tool calls, tool results, and messages from other sessions. It updates after each turn settles, so read it after `await session.send(...)`, `await session.respond(...)`, or `await live.result()`.
 
-Each `send` (and `respond`/`respondAll`) resolves to an immutable turn with `.message`, `.data`, `.events`, `.inputRequests`, `.toolCalls`, `.sessionId`, `.status`, and `.expectOk()`. Use `.sessionId` to relate turns or attach follow-up work to the session that produced a specific turn. `expectOk()` throws only when the turn ended failed; a session left open for a next message is the normal end state of a successful turn.
+Each `send` (and `respond`/`respondAll`) resolves to a turn with `.message`, `.data`, `.events`, `.inputRequests`, `.toolCalls`, `.session`, `.sessionId`, `.status`, and `.expectOk()`. Turn results retain their captured output and events; `.session` references the live conversation handle. `expectOk()` throws only when the turn ended failed; a session left open for a next message is the normal end state of a successful turn.
+
+## Prewarming a session
+
+Use `t.session()` to create a session before its first message:
+
+```ts title="evals/prewarm.eval.ts"
+import { defineEval } from "eve/evals";
+import { equals } from "eve/evals/expect";
+
+export default defineEval({
+  async test(t) {
+    const session = await t.session();
+    const turn = await session.send("Greet Alice briefly.");
+    await t.require(turn.sessionId, equals(session.sessionId));
+    turn.event("session.started", { count: 1 });
+    turn.event("turn.started", { count: 1, data: { turnId: "turn_0" } });
+    t.succeeded();
+  },
+});
+```
+
+Acceptance is not an initialization barrier. The first message runs session initialization;
+the TypeScript client handles bounded retries if the workflow inbox is still starting.
+Creation failures reject `t.session()` without returning a handle. Each call creates an
+independent session, including concurrent calls. Accepted sessions appear in eval results
+and participate in timeout cleanup even when no message was sent.
+
+## Migrating existing evals
+
+Replace `t.newSession()` and `t.prewarm()` with `const session = await t.session()`.
+Replace consecutive `t.send()` calls with `session.send()` calls, or continue the first
+returned turn through `turn.session.send()`. Read identity, cursor, events, and transcript
+from `session`; read replies from `turn.message`. Session operations such as `respond()`,
+`requireInputRequest()`, and `cancel()` also move from `t` to `session`.
 
 ## In-flight turns
 
@@ -130,7 +165,8 @@ import { defineEval } from "eve/evals";
 
 export default defineEval({
   async test(t) {
-    const live = await t.start("Run the long operation.");
+    const session = await t.session();
+    const live = await session.start("Run the long operation.");
 
     await live.waitForEvent("actions.requested", {
       data: {
@@ -152,7 +188,7 @@ export default defineEval({
 
 Use `expectOk()` only when the next operation depends on that intermediate turn succeeding. A final `t.succeeded()` already records a complete-run gate.
 
-To intentionally omit an eval for the current target, call `t.skip(reason)` before sending messages or recording assertions. Skipped evals are reported separately and do not affect the exit code.
+To intentionally omit an eval for the current target, call `t.skip(reason)` before creating sessions, sending messages, or recording assertions. Skipped evals are reported separately and do not affect the exit code.
 
 Events from every session are captured in the result and artifacts. `t.log(message)` records debug lines into the eval artifact; `--verbose` also streams them to stdout as evals run. `t.signal` is an `AbortSignal` that fires on timeout.
 
@@ -174,9 +210,9 @@ export default rows.map((row) =>
   defineEval({
     description: row.task,
     async test(t) {
-      await t.send(row.prompt);
+      const turn = await t.send(row.prompt);
       t.succeeded();
-      t.check(t.reply, equals(row.sql));
+      t.check(turn.message, equals(row.sql));
     },
   }),
 );