eve 0.52.1 → 0.52.3

package/docs/concepts/built-in-tools.md

@@ -7,92 +7,183 @@ eve provides a default tool set for every agent and additional tools you can add
 
 ## Default tools
 
-Default tools require no imports. The exact set depends on the agent and session. `agent` is available only in the root session; `load_skill` and `connection_search` appear only when the agent declares the corresponding resources; `ask_question` requires a session that can request user input; and `web_search` requires a supported model provider. The harness advertises only the tools available to the current session.
+Default tools require no imports. The exact set depends on the agent and session, and the harness advertises only the tools available to the current session.
 
-The default shell and file tools (`bash`, `read_file`, and `write_file`) run in the app and proxy their work into the agent's [sandbox](../sandbox). The table shows where each tool's effect lands.
+### Disable optional default tools
 
-| Tool                | Does                                                                                                                                                                                                                | Where it runs |
-| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
-| `bash`              | Run a shell command.                                                                                                                                                                                                | Sandbox       |
-| `read_file`         | Read a text file with line-numbered output (enables read-before-write).                                                                                                                                             | Sandbox FS    |
-| `write_file`        | Write a complete file; enforces read-before-write and stale-read detection.                                                                                                                                         | Sandbox FS    |
-| `web_fetch`         | Fetch a URL.                                                                                                                                                                                                        | App runtime   |
-| `web_search`        | Search the web (provider-managed; resolved from the model provider).                                                                                                                                                | Provider      |
-| `todo`              | Maintain a durable per-session todo list.                                                                                                                                                                           | App runtime   |
-| `ask_question`      | Ask the user a clarifying question or a choice mid-turn and park until they answer. No `execute`; the model calls it with `{ prompt, options?, allowFreeform? }`. See [Human-in-the-loop](/docs/human-in-the-loop). | App runtime   |
-| `agent`             | From the root session, delegate a subtask to a fresh copy of the root agent.                                                                                                                                        | App runtime   |
-| `load_skill`        | Pull an on-demand [skill](../skills)'s instructions into the current turn. Present only when the agent declares skills.                                                                                             | App runtime   |
-| `connection_search` | Discover tools across declared [connections](../connections); matched tools become directly callable. Present only when the agent declares connections.                                                             | App runtime   |
+Optional default tools are enabled unless you set `defaultTools: false` in `agent/agent.ts`:
 
-The model-facing file tools accept absolute paths and paths beginning with `$HOME/`. eve resolves `$HOME` against the sandbox before invoking non-shell file operations, so packaged skill references such as `$HOME/.agents/skills/<skill>/references/...` work consistently across `read_file`, `write_file`, and the opt-in `glob` and `grep` tools.
+```ts title="agent/agent.ts"
+import { defineAgent } from "eve";
 
-Notes:
+export default defineAgent({
+  defaultTools: false,
+  model: "openai/gpt-5.4",
+});
+```
 
-- **`agent`** is available only in the root session and always runs in the background. Its call returns a task receipt immediately, and task notifications deliver updates or the final result. The child uses the root's instructions, tools, connections, and sandbox, but starts with fresh conversation history and fresh [state](./state). The child receives neither `agent` nor `Workflow`; declared subagents do not receive the built-in `agent` either. See [Subagents](../subagents).
-- **`load_skill`** only pulls instructions into context. It adds no new execution surface, because behavior still comes from the tools the agent already has.
-- **`connection_search`** surfaces a connection's tools by their qualified name (e.g. `linear__list_issues`), which the model can then call directly. The model sees it only when the agent has connections.
-- **`web_search`** has no local executor; the provider runs it. AI Gateway models use Exa by default. To use Parallel instead, export `webSearch({ provider: "parallel" })` from `agent/tools/web_search.ts`. Direct provider models continue to use their native search implementation. To supply your own implementation, override it with `defineTool()`.
-- **`web_fetch`** follows up to ten redirects, rechecking every destination for SSRF safety. Non-success HTTP responses return a plain-text failure result with the response body when available instead of failing the tool call.
+This turns off the optional defaults described below. Add back only the tools the agent needs with the command in each tool's section. Existing files under `agent/tools/` remain available, including same-name replacements such as `agent/tools/bash.ts`.
 
-Review these default tools before production use. Disable, wrap, restrict, or require approval for any tool that can access the filesystem, network, shell, or sensitive data.
+`connection_search` stays available when the agent has connections because it provides access to their tools.
 
-## Add framework-provided tools
+### `bash`
 
-Some framework-provided tools stay out of the default set. Add the corresponding file when your agent needs one:
+`bash` runs shell commands in the agent's [sandbox](../sandbox).
 
-| Tool    | Definition to export             | Purpose                                    |
-| ------- | -------------------------------- | ------------------------------------------ |
-| `glob`  | `glob` from `eve/tools/glob`     | Find sandbox files by glob pattern.        |
-| `grep`  | `grep` from `eve/tools/grep`     | Search sandbox file contents by regex.     |
-| `sleep` | `sleep()` from `eve/tools/sleep` | Pause and durably resume the current turn. |
+```sh
+eve add tool/bash
+```
 
-For example, add file discovery and content search with two files:
+```ts title="agent/tools/bash.ts"
+export { default } from "eve/tools/bash";
+```
 
-```ts title="agent/tools/glob.ts"
-export { glob as default } from "eve/tools/glob";
+Override its description, approval policy, or executor by wrapping the exported definition:
+
+```ts title="agent/tools/bash.ts"
+import { defineTool } from "eve/tools";
+import { bash } from "eve/tools/bash";
+
+export default defineTool({
+  ...bash,
+  description: "Run approved project maintenance commands.",
+  async execute(input, ctx) {
+    console.info("Running sandbox command", input.command);
+    return bash.execute(input, ctx);
+  },
+});
 ```
 
-```ts title="agent/tools/grep.ts"
-export { grep as default } from "eve/tools/grep";
+Disable only `bash`:
+
+```ts title="agent/tools/bash.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
 ```
 
-The filename supplies the model-facing tool name. The tools run against the agent's sandbox and use the same schemas, results, and error behavior as eve's framework implementations. Wrap either definition with `defineTool({ ...glob, description: "..." })` or `defineTool({ ...grep, description: "..." })` when you need to change its description or approval policy.
+### `read_file`
+
+`read_file` reads text files from the sandbox with line-numbered output. It accepts absolute paths and paths beginning with `$HOME/`.
 
-The section below covers `sleep` in more detail.
+```sh
+eve add tool/read_file
+```
+
+```ts title="agent/tools/read_file.ts"
+export { default } from "eve/tools/read_file";
+```
 
-## Override a default
+Override it:
 
-Author a tool at the same slug and it takes over the built-in of that name. The file `agent/tools/write_file.ts` replaces the built-in `write_file` by existing:
+```ts title="agent/tools/read_file.ts"
+import { defineTool } from "eve/tools";
+import { readFile } from "eve/tools/read_file";
+
+export default defineTool({
+  ...readFile,
+  description: "Read project files from the sandbox.",
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/read_file.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `write_file`
+
+`write_file` writes complete files in the sandbox. It enforces read-before-write and stale-read detection, and accepts absolute paths and paths beginning with `$HOME/`.
+
+```sh
+eve add tool/write_file
+```
+
+```ts title="agent/tools/write_file.ts"
+export { default } from "eve/tools/write_file";
+```
+
+Override it:
 
 ```ts title="agent/tools/write_file.ts"
 import { defineTool } from "eve/tools";
 import { writeFile } from "eve/tools/write_file";
 
 export default defineTool({
-  ...writeFile, // keep the default description, schema, and executor
+  ...writeFile,
+  description: "Write approved project files in the sandbox.",
   async execute(input, ctx) {
-    console.log("[write_file]", input.path);
+    if (!input.filePath.startsWith("/workspace/")) {
+      throw new Error("write_file is limited to /workspace");
+    }
     return writeFile.execute(input, ctx);
   },
 });
 ```
 
-Import each reusable definition from its own subpath:
+Disable it:
+
+```ts title="agent/tools/write_file.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `web_fetch`
+
+`web_fetch` fetches URLs from the app runtime. It follows up to ten redirects and checks every destination for SSRF safety. Non-success responses return plain text with the response body when available.
+
+```sh
+eve add tool/web_fetch
+```
+
+```ts title="agent/tools/web_fetch.ts"
+export { default } from "eve/tools/web_fetch";
+```
+
+Override it:
+
+```ts title="agent/tools/web_fetch.ts"
+import { defineTool } from "eve/tools";
+import { webFetch } from "eve/tools/web_fetch";
+
+export default defineTool({
+  ...webFetch,
+  description: "Fetch approved public documentation URLs.",
+  async execute(input, ctx) {
+    const hostname = new URL(input.url).hostname;
+    if (hostname !== "docs.example.com") {
+      throw new Error("web_fetch is limited to docs.example.com");
+    }
+    return webFetch.execute(input, ctx);
+  },
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/web_fetch.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `web_search`
 
-| Definition  | Import                 | Registered by default |
-| ----------- | ---------------------- | --------------------- |
-| `bash`      | `eve/tools/bash`       | Yes                   |
-| `readFile`  | `eve/tools/read_file`  | Yes                   |
-| `writeFile` | `eve/tools/write_file` | Yes                   |
-| `todo`      | `eve/tools/todo`       | Yes                   |
-| `webFetch`  | `eve/tools/web_fetch`  | Yes                   |
-| `loadSkill` | `eve/tools/load_skill` | Yes                   |
-| `glob`      | `eve/tools/glob`       | No                    |
-| `grep`      | `eve/tools/grep`       | No                    |
+`web_search` uses provider-managed web search and appears only for supported model providers. AI Gateway models use Exa by default; direct provider models use their native search implementation.
 
-Importing a definition does not add it to an agent; export it from the corresponding `agent/tools/*.ts` file. Skip the spread and your replacement owns its own context. A fresh `defineTool` for `todo` does not inherit the default's durable state key.
+```sh
+eve add tool/web_search
+```
 
-Provider-managed web search has a dedicated configuration helper instead of an executable default:
+```ts title="agent/tools/web_search.ts"
+export { default } from "eve/tools/web_search";
+```
+
+Override the provider-managed configuration for AI Gateway:
 
 ```ts title="agent/tools/web_search.ts"
 import { webSearch } from "eve/tools/web_search";
@@ -100,41 +191,279 @@ import { webSearch } from "eve/tools/web_search";
 export default webSearch({ provider: "parallel" });
 ```
 
-Set `provider` to `"exa"` or `"parallel"`. Without this file, AI Gateway models use Exa.
+Replace provider-managed search with an authored implementation:
+
+```ts title="agent/tools/web_search.ts"
+import { defineTool } from "eve/tools";
 
-## Disable a default
+export default defineTool({
+  description: "Search the internal documentation index.",
+  inputSchema: { type: "object" },
+  async execute(input) {
+    return { results: [], query: input };
+  },
+});
+```
 
-Export a `disableTool()` sentinel from a file named after the tool's slug. The filename is what picks the default to remove:
+Disable it:
 
-```ts title="agent/tools/bash.ts"
+```ts title="agent/tools/web_search.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `todo`
+
+`todo` maintains a durable todo list for the session.
+
+```sh
+eve add tool/todo
+```
+
+```ts title="agent/tools/todo.ts"
+export { default } from "eve/tools/todo";
+```
+
+Override it. Spreading the definition preserves its durable state key:
+
+```ts title="agent/tools/todo.ts"
+import { defineTool } from "eve/tools";
+import { todo } from "eve/tools/todo";
+
+export default defineTool({
+  ...todo,
+  description: "Track the current implementation plan.",
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/todo.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `ask_question`
+
+`ask_question` asks the user for clarification or a choice, then parks the turn until they answer. It appears only when the session can request user input. See [Human-in-the-loop](/docs/human-in-the-loop).
+
+```sh
+eve add tool/ask_question
+```
+
+```ts title="agent/tools/ask_question.ts"
+export { default } from "eve/tools/ask_question";
+```
+
+Replace its request-input behavior with an ordinary authored tool:
+
+```ts title="agent/tools/ask_question.ts"
+import { defineTool } from "eve/tools";
+
+export default defineTool({
+  description: "Record a clarification request.",
+  inputSchema: { type: "object" },
+  async execute(input) {
+    return { recorded: input };
+  },
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/ask_question.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `agent`
+
+`agent` delegates a subtask to a fresh copy of the root agent. It is root-only, always runs in the background, and returns a task receipt immediately. The child receives the root's instructions, tools, connections, and sandbox, but starts with fresh conversation history and [state](./state). See [Subagents](../subagents).
+
+```sh
+eve add tool/agent
+```
+
+```ts title="agent/tools/agent.ts"
+export { default } from "eve/tools/agent";
+```
+
+The framework behavior cannot be overridden. Re-export the definition above to restore it, or disable it:
+
+```ts title="agent/tools/agent.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `task_cancel`
+
+`task_cancel` lets the root session cancel background tasks.
+
+```sh
+eve add tool/task_cancel
+```
+
+```ts title="agent/tools/task_cancel.ts"
+export { default } from "eve/tools/task_cancel";
+```
+
+The framework behavior cannot be overridden. Re-export the definition above to restore it, or disable it:
+
+```ts title="agent/tools/task_cancel.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `task_update`
+
+`task_update` lets a background task report progress to its parent. It appears only in delegated task sessions.
+
+```sh
+eve add tool/task_update
+```
+
+```ts title="agent/tools/task_update.ts"
+export { default } from "eve/tools/task_update";
+```
+
+The framework behavior cannot be overridden. Re-export the definition above to restore it, or disable it:
+
+```ts title="agent/tools/task_update.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `load_skill`
+
+`load_skill` pulls an on-demand [skill](../skills)'s instructions into the current turn. It appears only when the agent declares skills and adds no execution surface by itself.
+
+```sh
+eve add tool/load_skill
+```
+
+```ts title="agent/tools/load_skill.ts"
+export { default } from "eve/tools/load_skill";
+```
+
+Override it:
+
+```ts title="agent/tools/load_skill.ts"
+import { defineTool } from "eve/tools";
+import { loadSkill } from "eve/tools/load_skill";
+
+export default defineTool({
+  ...loadSkill,
+  description: "Load instructions for an available skill.",
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/load_skill.ts"
 import { disableTool } from "eve/tools";
 
 export default disableTool();
 ```
 
-Use `agent/tools/agent.ts` to remove the root-only `agent` delegation tool. The root session then receives no tool for delegating to a fresh copy of itself, and the model never sees that tool.
+### `connection_search`
+
+`connection_search` discovers tools across declared [connections](../connections) and makes matches directly callable by qualified name, such as `linear__list_issues`. eve adds it automatically when connections exist, even when `defaultTools` is `false`, so there is no add command.
 
-If the filename matches no known framework tool, resolution fails instead of silently doing nothing, so a typo surfaces at build time rather than removing the wrong tool.
+An authored `agent/tools/connection_search.ts` replaces the framework behavior. Import the framework definition from `eve/tools/connection_search` when you need to reference it directly. Exporting `disableTool()` from this slot is an error because agents with connections require connection discovery.
 
-## When to override, disable, or author a new tool
+Review these tools before production use. Disable, wrap, restrict, or require approval for any tool that can access the filesystem, network, shell, or sensitive data.
 
-Three moves shape the harness. The right one depends on whether the model should keep the built-in capability.
+You can also add the opt-in framework tools described below.
 
-- **Override** when you want the same capability with different behavior. Import its definition from the matching `eve/tools/<name>` subpath and wrap it (logging, an extra guard, or a different backend), and the model still sees a tool by that name. Spreading keeps the default's description, schema, and any framework state, such as the `todo` tool's durable state key. Drop the spread and your replacement owns its own context, losing that wiring.
-- **Disable** when the model should not have the capability at all. A `disableTool()` sentinel removes the built-in, and the model never sees it. Reach for this to lock down `bash` or `web_fetch` in an agent that should not run shell commands or fetch arbitrary URLs.
-- **Author a new tool** when you want a capability the harness does not ship. Give it a fresh slug under `agent/tools/` and it joins the built-ins instead of replacing one. See [Tools](../tools) for the authoring model.
+## Opt-in framework tools
 
-## The opt-in `sleep` tool
+These framework-provided tools are not added by default. Add only the ones the agent needs.
 
-The framework also ships a durable `sleep` tool, but does not add it to agents by default. Enable it with `agent/tools/sleep.ts`:
+### `glob`
+
+`glob` finds sandbox files by glob pattern. Add it:
+
+```sh
+eve add tool/glob
+```
+
+```ts title="agent/tools/glob.ts"
+export { default } from "eve/tools/glob";
+```
+
+Customize it by wrapping the framework definition:
+
+```ts title="agent/tools/glob.ts"
+import { defineTool } from "eve/tools";
+import { glob } from "eve/tools/glob";
+
+export default defineTool({
+  ...glob,
+  description: "Find project files by glob pattern.",
+});
+```
 
-```ts
+Remove the file to remove the tool. `disableTool()` is unnecessary because `glob` is not added by default.
+
+### `grep`
+
+`grep` searches sandbox file contents with a regular expression. Add it:
+
+```sh
+eve add tool/grep
+```
+
+```ts title="agent/tools/grep.ts"
+export { default } from "eve/tools/grep";
+```
+
+Customize it by wrapping the framework definition:
+
+```ts title="agent/tools/grep.ts"
+import { defineTool } from "eve/tools";
+import { grep } from "eve/tools/grep";
+
+export default defineTool({
+  ...grep,
+  description: "Search project files with a regular expression.",
+});
+```
+
+Remove the file to remove the tool. `disableTool()` is unnecessary because `grep` is not added by default.
+
+### `sleep`
+
+`sleep` pauses and durably resumes the current turn. The model calls it with `{ seconds }`; the wait does not hold an application runtime open. Concurrent calls run in parallel, and the turn resumes after the longest wait. Add it:
+
+```sh
+eve add tool/sleep
+```
+
+```ts title="agent/tools/sleep.ts"
 import { sleep } from "eve/tools/sleep";
 
 export default sleep();
 ```
 
-The model calls it with `{ seconds }` when it is useful to wait before checking progress or status again. Each call runs as a durable tool workflow, so it does not hold an application runtime open, and the same turn continues automatically when the duration elapses. Concurrent `sleep` calls run in parallel, so the turn continues after the longest requested duration.
+Customize it by wrapping the framework definition:
+
+```ts title="agent/tools/sleep.ts"
+import { defineWorkflowTool } from "eve/tools";
+import { sleep } from "eve/tools/sleep";
+
+export default defineWorkflowTool({
+  ...sleep(),
+  description: "Pause before checking an external operation again.",
+});
+```
+
+Remove the file to remove the tool. `disableTool()` is unnecessary because `sleep` is not added by default.
 
 ## What to read next
 

package/docs/concepts/default-harness.md

@@ -18,6 +18,12 @@ export default defineAgent({
 });
 ```
 
+Before summarizing, eve tries to shorten oversized tool results in older history.
+It checks whether that reduction is sufficient using the last provider-reported
+input token count plus an estimate of new messages. A smaller character estimate
+alone cannot satisfy compaction triggered by a higher provider count. If trimming
+cannot free enough space, eve summarizes the older history.
+
 Compaction also preserves the framework's own tool state automatically. It resets read-before-write tracking (so a write afterward re-reads the file whose read evidence was summarized away) and re-injects the active todo list, so the model keeps its task list across the summary. There is no per-tool hook to configure.
 
 First-class [memory](../memory) participates in a separate lifecycle. eve asks

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

@@ -119,6 +119,10 @@ Alongside `type` and `data`, every event carries a `meta` envelope:
 
 - **`meta.id`** uniquely identifies the event. It is an `evt_`-prefixed [ULID](https://github.com/ulid/spec): a millisecond timestamp followed by random bits, so ids are broadly time-ordered.
 - **`meta.at`** is the ISO-8601 time the event was emitted.
+- **`meta.deliveryIds`**, when present, identifies the accepted messages that own
+  the turn. `POST /eve/v1/session/:sessionId` returns its `deliveryId`, allowing
+  clients to skip earlier turns when resuming from an old cursor. Coalesced
+  messages share the same turn events.
 
 `meta.id` is stable. eve mints it once, when the event is written to the durable stream, and stores it with the event. Reconnecting from a cursor, rewinding to `startIndex=0`, or replaying a finished session all return the same id for the same event.
 

package/docs/connections/openapi.mdx

@@ -150,6 +150,10 @@ export default defineOpenAPIConnection({
 
 The parameter `name` must exactly match the placeholder inside the path. If the spec omits an `in: "path"` parameter, the generated tool has no input for that segment and eve cannot fill it in from query parameters.
 
+## Schema annotations
+
+eve removes `default` and `example` annotations when their values conflict with the declared schema type. For example, a boolean property with `default: "false"` loses that annotation, while `default: false` is retained. This prevents invalid examples from guiding model input; eve does not coerce annotation values.
+
 ## Approval gates
 
 Generated operations can mutate state like authored tools. Use the shared connection `approval` option for human approval, and combine it with `operations.allow` for the smallest practical surface. See [Per-connection approval](../connections#per-connection-approval) for the helpers and [Human-in-the-loop](../human-in-the-loop#approvals) for policy behavior.

package/docs/connections/overview.mdx

@@ -200,7 +200,7 @@ export default defineMcpClientConnection({
 });
 ```
 
-`"linear/myagent"` is the UID you chose when registering the Connect client. `connect("linear/myagent")` is shorthand for a user-scoped interactive OAuth connection: eve resolves a token for the active user before each tool call, emits `authorization.required` when that user has not authorized yet, and resumes the parked turn after the callback completes.
+Use the connector UID returned by `vercel connect create`; the display name passed to `--name` is not the UID. `connect("linear/myagent")` is shorthand for a user-scoped interactive OAuth connection: eve resolves a token for the active user before each tool call, emits `authorization.required` when that user has not authorized yet, and resumes the parked turn after the callback completes.
 
 When a local subagent needs interactive authorization, eve surfaces the authorization lifecycle on the root session's channel, including through nested subagent chains. The challenge still points to the child session's callback, so completing it resumes the child directly while the parent continues waiting for its result.
 

package/docs/evals/running.mdx

@@ -35,6 +35,8 @@ Tag filters compose: `--tag` keeps evals carrying at least one listed tag, then
 
 An eval that calls `t.skip(reason)` is reported as skipped, does not count as passed or failed, and never changes the exit code.
 
+`eve eval --json` flushes the complete report before exiting, including when stdout is piped to another process or redirected to a file.
+
 ## Artifacts
 
 Each run drops artifacts under `.eve/evals/<timestamp>/`: a run `summary.json`, a `results.jsonl` index, and per-eval assertion results, verdicts, captured event streams, and `t.log` lines under `evals/`. The console output stays tight on purpose; when an eval fails, the artifact has the full story.

package/docs/guides/client/continuations.mdx

@@ -52,6 +52,17 @@ console.log((await response.result()).message);
 `attach()` performs no request. Every later operation targets exactly
 `saved.sessionId`; it never follows or creates a replacement.
 
+`send()` correlates its response with the message accepted by the server. If the
+saved cursor is behind, it skips earlier turns and advances past them before
+collecting the new result, including when another turn is active or queued. You
+do not need to drain the stream before sending. Upgrade the server alongside the
+client: a server that omits the accepted delivery identity causes `send()` to
+throw instead of returning an ambiguous result.
+
+If a configured reconnect limit ends the stream before the accepted turn reaches
+a boundary, collecting its response throws. A partial stream is not a completed
+result.
+
 ## Waiting, completed, and reset sessions
 
 A session that emits `session.waiting` accepts another message through the same

package/docs/guides/client/streaming.mdx

@@ -24,7 +24,7 @@ The cancellation result is discriminated by `status`: only `accepted` includes
 
 Cancellation does not replace stream consumption. Continue reading the response to observe its terminal `turn.cancelled` and `session.waiting` boundary and to advance the client session cursor normally. Use `session.cancel({ turnId })` instead when you have only a fixed session handle and an observed turn ID.
 
-Between turns, `session.compact()` queues context compaction without sending model input. An accepted request reports the session id; consume the durable stream through the following `session.waiting` boundary before sending the next turn. `compaction.completed` confirms that summarization succeeded; without it, eve preserves the previous history. A never-started session returns `no_active_session` as a successful no-op.
+Between turns, `session.compact()` queues context compaction without sending model input. An accepted request reports the session id; consume the durable stream through the following `session.waiting` boundary before sending the next turn. `compaction.completed` confirms that summarization succeeded; without it, eve preserves the previous history, including when the model returns an empty summary. A never-started session returns `no_active_session` as a successful no-op.
 
 ```ts
 const compaction = await session.compact();
@@ -57,6 +57,10 @@ This consumes the stream until the current turn boundary:
 - `session.completed`
 - `session.failed`
 
+`result()` closes that HTTP stream, including when fetch instrumentation clones
+the response for tracing. The durable session remains available for follow-up
+turns after `session.waiting`.
+
 ## Stream events live
 
 Use `for await...of` when you want to render progress:
@@ -149,6 +153,8 @@ The stream can emit an interim `session.waiting` while the authorization callbac
 
 HTTP connections can end before a run does. The client reconnects from the number of events already consumed, so long turns continue without replaying events. By default, a turn response keeps reconnecting until it reaches a turn boundary or is aborted, including while the turn is paused for authorization. A manually opened `session.stream()` eventually stops after repeated empty streams when it can no longer make progress.
 
+Browser failures while reading a response body, including `TypeError: Load failed` and `TypeError: network error`, use the same reconnect policy. Invalid stream events still fail the read.
+
 If your consumer persists events, key on `event.meta.id`. It is stable across reconnects and rewinds, so an overlapping replay is safe to ingest twice. See [the event envelope](../../concepts/sessions-runs-and-streaming#the-event-envelope).
 
 Set `streamReconnectPolicy: { reconnect: false }` when a relay or proxy owns the cursor and reconnection policy. This makes a single stream GET attempt and returns when that connection ends; it does not stop the server-side turn: