eve 0.59.1 → 0.60.0

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";
 
@@ -149,7 +148,7 @@ 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

@@ -136,9 +136,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.59.1",
+  "version": "0.60.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -211,6 +211,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 +447,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": {