eve 0.59.1 → 0.60.1

package/docs/guides/evaluate.md

@@ -3,28 +3,27 @@ title: Automatic Model Selection
 description: "Choose agent models automatically or evaluate typed questions in your tools and application code."
 ---
 
-Use `autoModel` to choose an agent model from an allowlist before inference begins.
-It uses the [AI SDK evaluation API](https://ai-sdk.dev/docs/ai-sdk-core/evaluation),
+Use `auto` from `eve/models` to choose an agent model from an allowlist before
+inference begins. It uses the [AI SDK evaluation API](https://ai-sdk.dev/docs/ai-sdk-core/evaluation),
 so the evaluator can be a Vercel AI Gateway model ID or an evaluation model from
-an installed provider. Use `evaluate` from the same entrypoint to ask typed
-questions in your own tools or application code.
+an installed provider. Use `evaluate` from `eve/ai` to ask typed questions in
+your own tools or application code.
 
-`eve/experimental/evaluate` is experimental. Its API can change between eve
-releases, and the AI SDK evaluation model specification can change in patch
-releases.
+The AI SDK evaluation model specification is experimental and can change in
+patch releases.
 
 ## Choose from Gateway models
 
-By default, `autoModel` evaluates with `typesafe-ai/jev`. Like other AI SDK
+By default, `auto` evaluates with `typesafe-ai/jev`. Like other AI SDK
 model strings, it uses Vercel AI Gateway unless the application has configured a
 different global default provider.
 
 ```ts title="agent/agent.ts"
 import { defineAgent } from "eve";
-import { autoModel } from "eve/experimental/evaluate";
+import { auto } from "eve/models";
 
 export default defineAgent({
-  model: autoModel({
+  model: auto({
     options: {
       "openai/gpt-5.6-sol": "Difficult reasoning and engineering tasks",
       "openai/gpt-5.6-luna": "Routine tasks where fast completion matters",
@@ -38,7 +37,7 @@ does not add a TypeSafe credential or transport layer. During `eve dev`, a
 Gateway evaluator uses the same connection selected through `/login` as Gateway
 language models. A configured AI SDK default provider still owns string model
 resolution during development. The TUI footer displays `dynamic model` when the
-agent uses `autoModel`, then adds the resolved model for the current turn, such as
+agent uses `auto`, then adds the resolved model for the current turn, such as
 `dynamic model · openai/gpt-5.6-luna`.
 
 ## Use a provider directly
@@ -53,10 +52,10 @@ pnpm add @ai-sdk/typesafe-ai
 ```ts title="agent/agent.ts"
 import { typeSafeAi } from "@ai-sdk/typesafe-ai";
 import { defineAgent } from "eve";
-import { autoModel } from "eve/experimental/evaluate";
+import { auto } from "eve/models";
 
 export default defineAgent({
-  model: autoModel({
+  model: auto({
     model: typeSafeAi.evaluationModel("jev-latest"),
     options: {
       "openai/gpt-5.6-sol": "Difficult reasoning and engineering tasks",
@@ -78,11 +77,11 @@ a provider instance, an alias, or needs a reasoning override.
 ```ts title="agent/agent.ts"
 import { anthropic } from "@ai-sdk/anthropic";
 import { defineAgent } from "eve";
-import { autoModel } from "eve/experimental/evaluate";
+import { auto } from "eve/models";
 
 export default defineAgent({
   reasoning: "medium",
-  model: autoModel({
+  model: auto({
     options: {
       "openai/gpt-5.6-sol": "Hard problems",
       my_secret_model: {
@@ -107,13 +106,13 @@ agent's reasoning setting.
 ## Evaluate inside a tool
 
 Use `evaluate` to ask choice, score, or boolean questions about the state you pass to it.
-It defaults to `typesafe-ai/jev` and uses the same authentication as `autoModel`,
+It defaults to `typesafe-ai/jev` and uses the same authentication as `auto`,
 including the Gateway connection selected through `/login` during `eve dev`.
 Pass `model` to use another evaluation model ID or a provider instance. A configured
 AI SDK default provider takes precedence over the local Gateway connection.
 
 ```ts title="agent/tools/classify-request.ts"
-import { evaluate } from "eve/experimental/evaluate";
+import { evaluate } from "eve/ai";
 import { defineTool } from "eve/tools";
 import { z } from "zod";
 
@@ -142,14 +141,14 @@ export default defineTool({
 
 The choice above is typed as `"billing" | "support"`. Each question appears under
 its authored key in `result.answers`. Results also include token usage, warnings,
-provider metadata, and response metadata.
+provider metadata, and response metadata. To use that choice to delegate while keeping specialist subagents out of the parent model's tools, see [Route to a hidden subagent with JEV](/docs/tools/workflows#route-to-a-hidden-subagent-with-jev).
 
 `evaluate` accepts AI SDK evaluation options, including `maxRetries`, `headers`,
 and `providerOptions`. Pass an `abortSignal` to cancel the request. Input and
 answer validation, retries, and provider errors follow AI SDK semantics.
 
 You can also call `evaluate` outside a tool; it does not require an active eve
-session. Each call performs its own evaluation. `autoModel` uses this function
+session. Each call performs its own evaluation. `auto` uses this function
 and adds the per-turn routing behavior described below.
 
 ## Evaluate tool approvals
@@ -179,7 +178,7 @@ options and data handling.
 
 ## Runtime behavior
 
-`autoModel` evaluates at the first `step.started` event, after the incoming prompt
+`auto` evaluates at the first `step.started` event, after the incoming prompt
 is available and before the selected language model runs. It reuses that choice
 for later tool-loop steps in the same turn. A new turn makes a new choice, and
 child sessions route from their own prompts.

package/docs/guides/frontend/overview.mdx

@@ -98,9 +98,43 @@ export function Chat() {
 }
 ```
 
-Prewarming defaults to `false`: the first send creates the session. Enable it when your
-application's auth, headers, and any chat-record binding are ready at mount. Applications
-that prepare those in the submit handler should keep the default.
+In React, `prewarm` is a live boolean. Use component state to wait until the user starts
+composing a message:
+
+```tsx
+import { useEveAgent } from "eve/react";
+import { useState } from "react";
+
+export function Chat() {
+  const [message, setMessage] = useState("");
+  const agent = useEveAgent({ prewarm: message.length > 0 });
+
+  return (
+    <>
+      <input value={message} onChange={(event) => setMessage(event.currentTarget.value)} />
+      <button
+        onClick={() => {
+          setMessage("");
+          agent.reset();
+        }}
+        type="button"
+      >
+        New chat
+      </button>
+    </>
+  );
+}
+```
+
+An initial `true` value or a later `false` to `true` change prepares the current owned session.
+Changing `prewarm` back to `false` does not abort creation or discard an existing session. If
+a reset and state update happen in the same event, React applies both before deciding whether
+to prepare the next session. Vue and Svelte read `prewarm` when their binding is created; call
+their returned `prewarm()` method for interaction-driven creation.
+
+Prewarming defaults to `false`: the first send creates the session. Set it to `true` only after
+your application's auth, headers, and any chat-record binding are ready. Applications that
+prepare those in the submit handler should keep the default until then.
 
 Prewarming starts the workflow and establishes its inbox, then parks before session hooks,
 dynamic definitions, or sandbox setup run. The first message passes through the channel's
@@ -117,7 +151,9 @@ events are not a prerequisite for sending.
 A failed create sets `error` and calls `onError` when no send is waiting. A waiting send can
 fall back to creating a session with its message. After creation succeeds, initialization
 failures arrive on the stream during the first turn. The configured session timeout starts
-at creation, so an unused prewarmed session can expire before its first message.
+at creation, so an unused prewarmed session can expire before its first message. React does not
+retry a failed prewarm on unrelated renders while the option remains `true`; call `prewarm()`,
+change the option from `false` to `true` again, reset, or send a message to recover.
 
 The hook keeps consuming one session stream across turns and idle periods. Replies,
 authorization updates, and turns started elsewhere all update the same projection. A turn settling
@@ -125,9 +161,9 @@ does not close the connection. The transport reconnects from its cursor after a
 server's renewable 60-second lease; lease renewal does not start a turn or clear UI state.
 Unmounting or resetting closes the local stream without cancelling the old durable session.
 
-`reset()` reuses the hook instance and clears the conversation. With `prewarm: true`, it
-immediately prepares the next owned session; otherwise, the next send creates it. An explicitly supplied
-`session` remains externally owned and is never replaced by prewarming or reset. Use
+`reset()` reuses the hook instance and clears the conversation. When `prewarm` is true after
+the reset, it prepares the next owned session; otherwise, the next send creates it. An explicitly
+supplied `session` remains externally owned and is never replaced by prewarming or reset. Use
 `initialSession` with `resume: true` to restore a saved chat.
 
 `data.messages` are eve-owned `EveMessage[]`. Common text, reasoning, file, and dynamic-tool parts follow the [AI SDK `UIMessage`](https://ai-sdk.dev/docs/reference/ai-sdk-core/ui-message) rendering convention, but the types are not interchangeable. eve also exposes authorization and HITL metadata, and a file part's URL can be absent. Adapt those parts before passing messages to an API typed as `UIMessage[]`.
@@ -351,7 +387,7 @@ then save a final snapshot in `onFinish`.
 
 `initialEvents` must be an ordered prefix of the same session's stream, but its endpoint does not have to line up exactly with where the stream resumes. When the event count matches `initialSession.streamIndex`, catch-up continues from that cursor. A partial or overlapping saved log falls back to index `0`. Every event carries a stable [`meta.id`](/docs/concepts/sessions-runs-and-streaming#the-event-envelope), and the store drops any event whose id it has already applied, so an overlapping replay renders once and `onEvent` only fires for events your UI has not seen.
 
-For multiple chat threads, keep one saved event log and session cursor per thread. `agent`, `host`, `reducer`, `session`, `initialEvents`, `initialSession`, `auth`, `headers`, `optimistic`, `prewarm`, and `resume` are read when the hook creates its store, so remount the chat component when switching threads, for example with `key={chat.id}`.
+For multiple chat threads, keep one saved event log and session cursor per thread. `agent`, `host`, `reducer`, `session`, `initialEvents`, `initialSession`, `auth`, `headers`, `optimistic`, and `resume` are read when the hook creates its store, so remount the chat component when switching threads, for example with `key={chat.id}`. React reads `prewarm` on every render.
 
 Pass `resume: true` with `initialSession` to rebuild the projection from the durable stream after mount. While `status` is `"resuming"`, render hydrated `data` but disable message and HITL submission; do not present cancellation or active-turn progress controls. If catch-up finds an in-flight turn, `status` changes to `"streaming"` before the binding follows it to a boundary. The stream reports its initial durable tail so catch-up can finish without closing the connection or waiting for an idle timeout. A settled tail changes directly to `"ready"`; a newer turn or pending authorization remains `"streaming"`. The connection stays open to receive later events. A terminal session failure changes to `"error"`.
 

package/docs/guides/instrumentation/otel.mdx

@@ -100,52 +100,56 @@ export default disableInstrumentation();
 
 ## Filter a managed destination
 
-`localTraces()` and `agentRuns()` accept an `exportPolicy`. It filters spans
-and attributes before that destination's processors receive them:
+`localTraces()` and `agentRuns()` accept one `exportPolicy` object or an array
+applied in order. Each policy filters spans and attributes before that
+destination's processors receive them:
 
 ```ts title="agent/instrumentation/agent-runs.ts"
 import { agentRuns } from "eve/instrumentation/otel";
 
 export default agentRuns({
   exportPolicy: {
-    span: ({ name }) => name !== "internal.cache.refresh",
-    attribute: ({ key }) => (key === "customer.id" ? { action: "drop" } : { action: "keep" }),
+    span: ({ name }) => ({ emit: name !== "internal.cache.refresh" }),
+    attribute: ({ key }) => (key === "customer.id" ? { emit: false } : { emit: true }),
   },
 });
 ```
 
-Return `false` from `span` to omit that span from this destination. Return
-`{ action: "keep" }`, `{ action: "drop" }`, or
-`{ action: "replace", value }` from `attribute` to retain, remove, or change
+Return `{ emit: true }` from `span` to retain a span unchanged, or
+`{ emit: false }` to omit it from this destination. To retain the span while
+redacting content, return `{ redact: true }` with `inputs: true`,
+`outputs: true`, or both. A redaction decision implies emission and requires
+at least one direction. For example, return
+`{ redact: true, inputs: true, outputs: true }` to redact both directions.
+A throwing `span` callback drops the span from this destination. Return
+`{ emit: true }`, `{ emit: false }`, or
+`{ replace: true, value }` from `attribute` to retain, remove, or change
 one attribute.
 
 ### Further narrow a built-in destination
 
-Use the content redactors to further narrow what a built-in destination
+Return a redaction decision to further narrow what a built-in destination
 receives after the process-wide `otel({ tracePolicy })` has admitted a trace.
 For example, keep the spans in Agent Runs while redacting their inputs and
 outputs unless the session is public:
 
 ```ts title="agent/instrumentation/agent-runs.ts"
-import {
-  agentRuns,
-  composeSpanExportPolicies,
-  redactSpanInputs,
-  redactSpanOutputs,
-} from "eve/instrumentation/otel";
+import { agentRuns } from "eve/instrumentation/otel";
 
 export default agentRuns({
-  exportPolicy: composeSpanExportPolicies(
-    redactSpanInputs(({ audience }) => audience !== "public"),
-    redactSpanOutputs(({ audience }) => audience !== "public"),
-  ),
+  exportPolicy: {
+    span: ({ audience }) =>
+      audience === "public" ? { emit: true } : { redact: true, inputs: true, outputs: true },
+  },
 });
 ```
 
-`redactSpanInputs()` removes eve's known prompt, instruction, document, and
-tool-argument attributes. `redactSpanOutputs()` removes response, reasoning,
-tool-result, exception, and status attributes. They narrow only this
-destination; they do not mutate spans sent to another destination.
+Input redaction removes eve's known prompt, instruction, document, and
+tool-argument attributes. Output redaction removes response, reasoning,
+tool-result, exception, and status attributes. Redaction narrows only this
+destination; it does not mutate spans sent to another destination. Policies run
+in array order, and each policy receives the facade produced by the policies
+before it.
 
 ## What to read next
 

package/docs/reference/typescript-api.md

@@ -56,7 +56,7 @@ export default defineTool({
 | `mockModel`                                           | `eve/evals`                                                             | Deterministic fixture agent models                                                     | [Evals](../evals/overview)                             |
 | `useEveAgent`                                         | `eve/react`, `eve/vue`, `eve/svelte`                                    | frontend                                                                               | [Frontend](../guides/frontend/overview)                |
 
-Tool-wide authoring helpers and types such as `defineTool`, `defineWorkflowTool`, `defineDurableCallback`, `defineDurableSchema`, `defineDynamic`, `disableTool`, and `ToolLabelDefinition` come from `eve/tools`. Capability-specific definitions and helpers use their own subpaths (see [Built-in tools](../concepts/built-in-tools)): reusable definitions such as `bash` and `glob` come from `eve/tools/<name>`, `webSearch` comes from `eve/tools/web_search`, `sleep` comes from `eve/tools/sleep`, and approval policies and types come from `eve/tools/approval`. The route verbs `GET`/`HEAD`/`POST`/`PUT`/`PATCH`/`DELETE`/`OPTIONS`/`WS` plus `disableRoute` come from `eve/channels`, and the channel auth helpers `localDev`/`vercelOidc`/`placeholderAuth` come from `eve/channels/auth`.
+Tool-wide authoring helpers and types such as `defineTool`, `defineWorkflowTool`, `defineDurableCallback`, `defineDurableSchema`, `defineDynamic`, `disableTool`, and `ToolLabelDefinition` come from `eve/tools`. Capability-specific definitions and helpers use their own subpaths (see [Built-in tools](../concepts/built-in-tools)): reusable definitions such as `bash` and `glob` come from `eve/tools/<name>`, `webSearch` comes from `eve/tools/web_search`, `agentRouter` comes from `eve/tools/agent-router`, `sleep` comes from `eve/tools/sleep`, and approval policies and types come from `eve/tools/approval`. The route verbs `GET`/`HEAD`/`POST`/`PUT`/`PATCH`/`DELETE`/`OPTIONS`/`WS` plus `disableRoute` come from `eve/channels`, and the channel auth helpers `localDev`/`vercelOidc`/`placeholderAuth` come from `eve/channels/auth`.
 
 `AgentReasoningDefinition` is exported from `eve` for the top-level `defineAgent({ reasoning })` setting. `AgentLimitsDefinition` is exported for `defineAgent({ limits })`. `AgentWorkflowDefinition`, `AgentWorkflowRetentionDefinition`, and `AgentWorkflowWorldDefinition` are exported from `eve` for the `defineAgent({ experimental: { workflow } })` config shape. `WebSearchToolInput` and `WebSearchProvider` are exported from `eve/tools/web_search`.
 
@@ -108,6 +108,8 @@ import template from "../../prompts/template.txt?raw";
 | `ctx.getToken(provider)`    | Resolve a bearer token for an inline auth provider such as `connect("...")`  |
 | `ctx.requireAuth(provider)` | Evict and re-authorize an inline provider, commonly after a downstream `401` |
 
+Authored workflow tools also receive `ctx.agents`, a replay-stable map of effective declared-subagent descriptions, and `ctx.agent(name, input)` for invocation. See [Workflows as tools](../tools/workflows#delegate-work-ctxagent) for the workflow-only context.
+
 ## Imports at a glance
 
 | Import                                                                      | Holds                                                                                                                          |
@@ -136,9 +138,10 @@ import template from "../../prompts/template.txt?raw";
 | `eve/sandbox`                                                               | `defineSandbox`, backends                                                                                                      |
 | `eve/instrumentation`                                                       | `defineInstrumentation`, `isChannel`                                                                                           |
 | `eve/local-dev`                                                             | `getLocalDevCapability`, `LocalDevCapability`                                                                                  |
+| [`eve/models`](../guides/evaluate)                                          | Automatic model selection with `auto`                                                                                          |
 | `eve/models/openai`                                                         | `openai`, `chatgpt`, deprecated `experimental_chatgpt`                                                                         |
 | `eve/models/anthropic`                                                      | `anthropic`                                                                                                                    |
-| [`eve/experimental/evaluate`](../guides/evaluate)                           | Experimental `autoModel` and standalone `evaluate`                                                                             |
+| [`eve/ai`](../guides/evaluate#evaluate-inside-a-tool)                       | Standalone `evaluate`                                                                                                          |
 | `eve/evals`                                                                 | `defineEval`, `defineEvalConfig`, `mockModel`, eval types                                                                      |
 | `eve/evals/expect`                                                          | `includes`, `equals`, `matches`, `similarity`                                                                                  |
 | `eve/evals/reporters`                                                       | `Braintrust`, `JUnit`, `EvalReporter`                                                                                          |

package/docs/tools/overview.mdx

@@ -32,6 +32,8 @@ A tool definition needs:
 
 When a tool returns structured data, add an optional `outputSchema`. With Zod or Standard Schema it also types the `execute` return.
 
+Compiled tools preserve Zod schema composition, including input and output schemas imported from helper modules. Durable replay metadata stays separate from the original schema, so adding it does not mutate shared schema objects.
+
 ### Label tool activity
 
 Use `label.start(input)` to describe a call in user-facing activity. The callback receives the validated tool input, so it can select the useful fields without exposing the full argument object:

package/docs/tools/workflows.mdx

@@ -15,7 +15,7 @@ suspend in either execution mode; running in the background does not require a s
 
 Workflow tools use the [Workflow SDK](https://workflow-sdk.dev): `"use workflow"`, `"use step"`, `createHook`,
 `createWebhook`, `sleep`, retries, and replay. eve provides `ctx.ask` for questions answered through
-the session's channel and `ctx.agent` for durable subagent delegation. Use `yield` to report
+the session's channel, `ctx.agents` for effective subagent descriptions, and `ctx.agent` for durable subagent delegation. Use `yield` to report
 progress and `await` on a workflow operation to wait durably. Values needed after a durable wait
 stay in local variables in the workflow body.
 
@@ -78,13 +78,13 @@ or days later, the run resumes, deploys, and returns. The model sees one tool re
 - Import `createHook`, `createWebhook`, `sleep`, and `FatalError` from `workflow` in the body.
   `start`, `getRun`, and `resumeHook` from `workflow/api` belong in steps. Your app does not install
   the SDK; for types, new projects list `eve/workflow-modules` in the tsconfig `types`.
-- In the body, `ctx` has `session`, `callId`, `toolName`, `abortSignal`, `agent`, and `ask`.
+- In the body, `ctx` has `session`, `callId`, `toolName`, `abortSignal`, `agent`, `agents`, and `ask`.
   `getToken` and `requireAuth` work inside a `"use step"` helper that receives `ctx` as a direct argument;
   they throw in the workflow body. `getSandbox` and `getSkill` remain unavailable.
 - The tool's input must be a JSON object. Workflow bodies are for static tools under `agent/tools/`,
   not tools returned from `defineDynamic` resolvers.
 
-`ctx.agent` and `ctx.ask` are available only on `WorkflowToolContext`. Ordinary tools, channel
+`ctx.agent`, `ctx.agents`, and `ctx.ask` are available only on `WorkflowToolContext`. Ordinary tools, channel
 handlers, and schedule handlers do not receive these methods. A shared helper may accept
 `WorkflowToolContext` from `eve/tools` and use the context supplied by a workflow tool body.
 
@@ -302,7 +302,7 @@ and can only show the model's input. Both compose: `approval` before the run, `c
 
 ## Delegate work: `ctx.agent`
 
-Workflow tools can call a visible subagent and wait for its result:
+Workflow tools can call a subagent and wait for its result:
 
 ```ts
 const result = await ctx.agent("reviewer", {
@@ -321,6 +321,89 @@ The first argument is the subagent's path-derived name. It can identify a model-
 continue an existing child. An inline `outputSchema` requires structured output and determines the
 return type, so `result` in the example is typed as `{ findings: string[] }`.
 
+### Route to a hidden subagent with JEV
+
+Use an authored workflow tool when the parent model should decide to delegate, but JEV should choose the specialist. Set `tool: false` on each specialist so the parent model sees only the routing tool. The specialists remain available through `ctx.agents` and callable through `ctx.agent()`:
+
+```ts title="agent/subagents/researcher/agent.ts"
+import { defineAgent } from "eve";
+
+export default defineAgent({
+  description: "Investigation, analysis, and explanation",
+  model: "anthropic/claude-opus-4.8",
+  tool: false,
+});
+```
+
+```ts title="agent/subagents/operator/agent.ts"
+import { defineAgent } from "eve";
+
+export default defineAgent({
+  description: "Execution and operational changes",
+  model: "openai/gpt-5.6-sol",
+  tool: false,
+});
+```
+
+Define the model-visible router under `agent/tools/`. Build the JEV criteria from the subagents' effective descriptions, then pass its typed choice directly to `ctx.agent()`:
+
+```ts title="agent/tools/agent-router.ts"
+import { evaluate } from "eve/ai";
+import { defineWorkflowTool, type WorkflowToolContext } from "eve/tools";
+import { z } from "zod";
+
+async function chooseTarget(task: string, ctx: WorkflowToolContext) {
+  "use step";
+
+  const result = await evaluate({
+    abortSignal: ctx.abortSignal,
+    state: { task },
+    questions: {
+      route: {
+        type: "choice",
+        instructions: "Which specialist should handle this task?",
+        criteria: {
+          researcher: ctx.agents.researcher.description,
+          operator: ctx.agents.operator.description,
+        },
+      },
+    },
+  });
+
+  return result.answers.route.choice;
+}
+
+export default defineWorkflowTool({
+  description: "Route a task to the appropriate specialist.",
+  inputSchema: z.object({ task: z.string().min(1).max(8000) }),
+  async execute({ task }, ctx) {
+    "use workflow";
+
+    const target = await chooseTarget(task, ctx);
+
+    return ctx.agent(target, { message: task });
+  },
+});
+```
+
+The evaluation runs in a step so workflow replay records its result instead of making the routing request again. The parent model receives `agent-router`, but not `researcher` or `operator`. JEV returns the typed `"researcher" | "operator"` choice, and the selected subagent's result becomes the `agent-router` tool result.
+
+`ctx.agents` is a replay-stable metadata snapshot taken when the workflow starts. It includes agents hidden from the parent model with `tool: false` or `disableTool()`, but exposes no model definitions, credentials, or callbacks. Invocation still checks the subagent's availability through `ctx.agent()`.
+
+#### Route across every subagent
+
+Use `agentRouter()` when the router should consider every available declared subagent with the default JEV routing instructions:
+
+```ts title="agent/tools/agent-router.ts"
+import { agentRouter } from "eve/tools/agent-router";
+
+export default agentRouter();
+```
+
+Its input is `{ message: string, outputSchema?: object }`. With two or more available subagents, `agentRouter()` sends the message and every effective description to JEV, then invokes the selected path-derived name through `ctx.agent()`. It invokes a sole available subagent without evaluation and forwards an optional `outputSchema`. The built-in root-copy `agent` target is not included.
+
+This pattern controls specialist selection, not whether the parent model delegates at all. Route before the parent model runs if every incoming request must go through JEV.
+
 ## Report progress: `yield`
 
 A workflow body may be an async generator. Ordinary yields report progress in both execution

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.59.1",
+  "version": "0.60.1",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -127,6 +127,11 @@
       "import": "./dist/src/public/memory/file/vercel.js",
       "default": "./dist/src/public/memory/file/vercel.js"
     },
+    "./tools/agent-router": {
+      "types": "./dist/src/public/tools/agent-router.d.ts",
+      "import": "./dist/src/public/tools/agent-router.js",
+      "default": "./dist/src/public/tools/agent-router.js"
+    },
     "./tools/sleep": {
       "types": "./dist/src/public/tools/sleep.d.ts",
       "import": "./dist/src/public/tools/sleep.js",
@@ -211,6 +216,16 @@
       "eve-source": "./dist/src/public/workflow-modules.d.ts",
       "types": "./dist/src/public/workflow-modules.d.ts"
     },
+    "./ai": {
+      "types": "./dist/src/public/ai/index.d.ts",
+      "import": "./dist/src/public/ai/index.js",
+      "default": "./dist/src/public/ai/index.js"
+    },
+    "./models": {
+      "types": "./dist/src/public/models/index.d.ts",
+      "import": "./dist/src/public/models/index.js",
+      "default": "./dist/src/public/models/index.js"
+    },
     "./models/anthropic": {
       "types": "./dist/src/public/models/anthropic/index.d.ts",
       "import": "./dist/src/public/models/anthropic/index.js",
@@ -437,11 +452,6 @@
       "types": "./dist/src/self-modification/config.d.ts",
       "import": "./dist/src/self-modification/config.js",
       "default": "./dist/src/self-modification/config.js"
-    },
-    "./experimental/evaluate": {
-      "types": "./dist/src/public/experimental/evaluate/index.d.ts",
-      "import": "./dist/src/public/experimental/evaluate/index.js",
-      "default": "./dist/src/public/experimental/evaluate/index.js"
     }
   },
   "publishConfig": {