eve 0.30.7 → 0.31.0

package/docs/guides/frontend/overview.mdx

@@ -36,7 +36,7 @@ export function Chat() {
         const form = new FormData(event.currentTarget);
         const message = String(form.get("message") ?? "").trim();
         if (message.length > 0) {
-          void agent.send({ message });
+          void agent.send(message);
         }
       }}
     >
@@ -61,16 +61,17 @@ export function Chat() {
 
 `useEveAgent()` returns the current UI state plus commands:
 
-| Field     | What it is                                                                     |
-| --------- | ------------------------------------------------------------------------------ |
-| `data`    | Projected UI state from the reducer. Defaults to `{ messages }`.               |
-| `status`  | `"ready"`, `"submitted"`, `"streaming"`, or `"error"`. Drives the composer.    |
-| `error`   | The last `Error` thrown, if any.                                               |
-| `events`  | Raw eve stream events for this session.                                        |
-| `session` | Serializable session cursor (`sessionId`, `continuationToken`, `streamIndex`). |
-| `send`    | Send text or the full turn payload (multi-part messages, HITL responses).      |
-| `stop`    | Abort the client's in-flight stream. The server-side turn keeps running.       |
-| `reset`   | Clear local events, data, errors, and the local session cursor.                |
+| Field     | What it is                                                                  |
+| --------- | --------------------------------------------------------------------------- |
+| `data`    | Projected UI state from the reducer. Defaults to `{ messages }`.            |
+| `status`  | `"ready"`, `"submitted"`, `"streaming"`, or `"error"`. Drives the composer. |
+| `error`   | The last `Error` thrown, if any.                                            |
+| `events`  | Raw eve stream events for this session.                                     |
+| `session` | Serializable fixed session cursor (`sessionId`, `streamIndex`).             |
+| `send`    | Send text or a multi-part message, with per-turn options.                   |
+| `respond` | Answer pending HITL input requests, with per-turn options.                  |
+| `stop`    | Abort the client's in-flight stream. The server-side turn keeps running.    |
+| `reset`   | Clear local events, data, errors, and the local session cursor.             |
 
 Most chat UIs only need `data.messages` and `status`. Drop down to `events` when you need the authoritative wire events directly, for example to persist an audit log or build a custom projection.
 
@@ -78,29 +79,31 @@ Most chat UIs only need `data.messages` and `status`. Drop down to `events` when
 
 ## Sending and streaming
 
-Pass an object to `send()` for text, multi-part messages, attachments, HITL responses, and per-turn context:
+Pass the message first and optional per-turn settings second. Use `respond()` for HITL answers:
 
 ```tsx
-await agent.send({ message: "Summarize this session." });
-
-await agent.send({
-  message: [
-    { type: "text", text: "What is in this file?" },
-    {
-      type: "file",
-      data: fileDataUrl, // base64 data URL
-      mediaType: "application/pdf",
-      filename: "report.pdf",
-    },
-  ],
-});
+await agent.send("Summarize this session.");
+
+await agent.send([
+  { type: "text", text: "What is in this file?" },
+  {
+    type: "file",
+    data: fileDataUrl, // base64 data URL
+    mediaType: "application/pdf",
+    filename: "report.pdf",
+  },
+]);
 ```
 
 Assistant text, reasoning, tool calls, and tool results stream into `data` as they arrive, and `status` moves from `ready` to `submitted` to `streaming` and back. Call `stop()` to abort the client's in-flight stream, and `reset()` to clear local state so the next send starts a fresh durable session.
 
 `stop()` is local: turns are resumable across disconnects, so detaching the stream never cancels the work — the turn keeps running and billing on the server. To stop the turn itself, POST the session's [cancel route](../../channels/eve#routes); the turn then settles on the stream as `turn.cancelled` followed by `session.waiting`.
 
-A chat UI with a Stop button should own the `ClientSession` passed to `useEveAgent`, create it with `preserveCompletedSessions: true`, and call `session.cancel({ turnId })` after observing that turn's `turn.started` event. The `turnId` guard makes a late click a harmless no-op instead of cancelling a newer turn. Keep the stream open until the cancellation boundary arrives; do not use `stop()` for this interaction.
+A chat UI with a server-side Cancel button can use the `sessionId` exposed by the
+hook, attach a fixed `ClientSession`, and call `session.cancel({ turnId })` after
+observing that turn's `turn.started` event. The `turnId` guard makes a late click
+a harmless no-op instead of cancelling a newer turn. Keep the stream open until
+the cancellation boundary arrives; do not use `stop()` for this interaction.
 
 After eve confirms an attachment turn with `message.received`, the default reducer projects each
 received attachment as a `file` part on the user message. The part includes `mediaType`, optional
@@ -108,7 +111,7 @@ received attachment as a `file` part on the user message. The part includes `med
 
 ## Human-in-the-loop prompts
 
-Tools opt into approval with `approval`, and the model can also ask a question with `ask_question` — see [Human-in-the-loop](/docs/human-in-the-loop) for the server-side model. Either way the stream emits an `input.requested` event, and the pending request rides on a `dynamic-tool` part of the latest message at `part.toolMetadata?.eve?.inputRequest`. Read it, then answer through the same session with `send()`:
+Tools opt into approval with `approval`, and the model can also ask a question with `ask_question` — see [Human-in-the-loop](/docs/human-in-the-loop) for the server-side model. Either way the stream emits an `input.requested` event, and the pending request rides on a `dynamic-tool` part of the latest message at `part.toolMetadata?.eve?.inputRequest`. Read it, then answer through the same session with `respond()`:
 
 ```tsx
 const request = agent.data.messages
@@ -117,9 +120,7 @@ const request = agent.data.messages
   ?.toolMetadata?.eve?.inputRequest;
 
 if (request) {
-  await agent.send({
-    inputResponses: [{ requestId: request.requestId, optionId: "approve" }],
-  });
+  await agent.respond([{ requestId: request.requestId, optionId: "approve" }]);
 }
 ```
 
@@ -159,11 +160,10 @@ For fully custom state machines, `authorization.required` and `authorization.com
 
 ## Attach page context per turn
 
-`clientContext` adds ephemeral context for the next model call only. Strings (or an array of strings) become user-role context messages; an object is JSON-serialized into one. It rides along with a message or HITL response, so it never dispatches a turn on its own and never lands in durable session history. Pass it directly to `send()`:
+`clientContext` adds ephemeral context for the next model call only. Strings (or an array of strings) become user-role context messages; an object is JSON-serialized into one. It rides along with a message or HITL response, so it never dispatches a turn on its own and never lands in durable session history. Pass it in the second argument to `send()` or `respond()`:
 
 ```tsx
-await agent.send({
-  message: "What should I do on this screen?",
+await agent.send("What should I do on this screen?", {
   clientContext: { route: "/billing", plan: "pro", seatsUsed: 4 },
 });
 ```
@@ -226,11 +226,11 @@ const agent = useEveAgent({ reducer: toolCounter });
 The browser conversation lives durably on the server. Persist both the rendered event log and the `session` cursor to pick it back up after a reload:
 
 ```tsx
-import type { SessionState, MessageStreamEvent } from "eve/client";
+import type { ClientSessionState, MessageStreamEvent } from "eve/client";
 
 type SavedEveChat = {
   events?: readonly MessageStreamEvent[];
-  session?: SessionState;
+  session?: ClientSessionState;
 };
 
 const [saved] = useState<SavedEveChat>(() => {
@@ -253,7 +253,11 @@ const agent = useEveAgent({
 });
 ```
 
-Store the full `session` object (`sessionId`, `continuationToken`, `streamIndex`), not a single field. The session cursor lets eve continue the durable conversation; the event log lets your UI render historical messages without replaying the whole stream. A database-backed chat app should usually persist stream events as they arrive with `onEvent` and then save a final snapshot in `onFinish`.
+Store the full `session` object (`sessionId`, `streamIndex`). The session cursor
+lets eve continue the exact durable conversation; the event log lets your UI
+render historical messages without replaying the whole stream. A database-backed
+chat app should usually persist stream events as they arrive with `onEvent` and
+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. 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 a saved log that overlaps the replayed prefix renders once, and `onEvent` only fires for events your UI has not seen.
 

package/docs/guides/frontend/sveltekit.mdx

@@ -56,7 +56,7 @@ With the plugin in `vite.config.ts`, components call [`useEveAgent`](./use-eve-a
     const text = message.trim();
     if (!text || isBusy) return;
     message = "";
-    await agent.send({ message: text });
+    await agent.send(text);
   }
 </script>
 

package/docs/guides/frontend/use-eve-agent-svelte.mdx

@@ -23,16 +23,17 @@ Import from `eve/svelte` and read the reactive getters directly. No `$` prefix:
 
 ## What it returns
 
-| Property  | Type                                        | Description                                                               |
-| --------- | ------------------------------------------- | ------------------------------------------------------------------------- |
-| `data`    | `TData`                                     | Projected state. With the default reducer, `EveMessageData` (`messages`). |
-| `status`  | `UseEveAgentStatus`                         | `"ready"`, `"submitted"`, `"streaming"`, or `"error"`.                    |
-| `error`   | `Error \| undefined`                        | Last transport-level error.                                               |
-| `events`  | `readonly MessageStreamEvent[]`             | Raw server events for this session.                                       |
-| `session` | `SessionState`                              | Snapshot of session state.                                                |
-| `send`    | `(input: SendTurnPayload) => Promise<void>` | Send text or a full turn (multi-part, attachments, HITL responses).       |
-| `stop`    | `() => void`                                | Abort the client's in-flight stream.                                      |
-| `reset`   | `() => void`                                | Clear state and start a new session.                                      |
+| Property  | Type                                          | Description                                                               |
+| --------- | --------------------------------------------- | ------------------------------------------------------------------------- |
+| `data`    | `TData`                                       | Projected state. With the default reducer, `EveMessageData` (`messages`). |
+| `status`  | `UseEveAgentStatus`                           | `"ready"`, `"submitted"`, `"streaming"`, or `"error"`.                    |
+| `error`   | `Error \| undefined`                          | Last transport-level error.                                               |
+| `events`  | `readonly MessageStreamEvent[]`               | Raw server events for this session.                                       |
+| `session` | `ClientSessionState \| undefined`             | Fixed session ID and stream cursor.                                       |
+| `send`    | `(message, options?) => Promise<void>`        | Send text or a multi-part message.                                        |
+| `respond` | `(inputResponses, options?) => Promise<void>` | Answer pending HITL input requests.                                       |
+| `stop`    | `() => void`                                  | Abort the client's in-flight stream.                                      |
+| `reset`   | `() => void`                                  | Clear state and start a new session.                                      |
 
 These state fields are reactive getters, so read them straight from templates, `$derived`, or `$effect`. They are not stores, so don't prefix them with `$`.
 
@@ -49,7 +50,7 @@ These state fields are reactive getters, so read them straight from templates, `
     const text = message.trim();
     if (!text) return;
     message = "";
-    await agent.send({ message: text });
+    await agent.send(text);
   }
 </script>
 
@@ -68,17 +69,15 @@ When a turn is more than plain text, reach for `send()`. Attachments follow the
 const bytes = new Uint8Array(await file.arrayBuffer());
 const base64 = btoa(String.fromCodePoint(...bytes));
 
-await agent.send({
-  message: [
-    { type: "text", text: "Describe this image." },
-    { type: "file", data: `data:${file.type};base64,${base64}`, mediaType: file.type },
-  ],
-});
+await agent.send([
+  { type: "text", text: "Describe this image." },
+  { type: "file", data: `data:${file.type};base64,${base64}`, mediaType: file.type },
+]);
 ```
 
 ## Human-in-the-loop prompts
 
-A tool opts into approval with `approval` ([Tools](../../tools)). When one fires, the pending request rides along on a `dynamic-tool` part of the latest message at `part.toolMetadata?.eve?.inputRequest`. Read it, then answer through the same session with `agent.send({ inputResponses })`:
+A tool opts into approval with `approval` ([Tools](../../tools)). When one fires, the pending request rides along on a `dynamic-tool` part of the latest message at `part.toolMetadata?.eve?.inputRequest`. Read it, then answer through the same session with `agent.respond(inputResponses)`:
 
 ```ts
 import type { EveDynamicToolPart, EveMessagePart } from "eve/svelte";
@@ -93,9 +92,7 @@ const request = agent.data.messages
   .find((value) => value !== undefined);
 
 if (request) {
-  await agent.send({
-    inputResponses: [{ requestId: request.requestId, optionId: "approve" }],
-  });
+  await agent.respond([{ requestId: request.requestId, optionId: "approve" }]);
 }
 ```
 
@@ -133,8 +130,7 @@ const agent = useEveAgent({
 `clientContext` adds ephemeral context for the next model call and nothing more. Strings (or an array of strings) become user-role context messages; an object is JSON-serialized into one. It rides along with a message or HITL response, never dispatches a turn on its own, and never lands in durable session history. Pass it to `send()`:
 
 ```ts
-await agent.send({
-  message: "What should I do on this screen?",
+await agent.send("What should I do on this screen?", {
   clientContext: { route: "/billing", plan: "pro", seatsUsed: 4 },
 });
 ```

package/docs/guides/frontend/use-eve-agent-vue.mdx

@@ -25,16 +25,17 @@ const { data } = useEveAgent();
 
 ## What it returns
 
-| Property  | Type                                         | Description                                                               |
-| --------- | -------------------------------------------- | ------------------------------------------------------------------------- |
-| `data`    | `ComputedRef<TData>`                         | Projected state. With the default reducer, `EveMessageData` (`messages`). |
-| `status`  | `ComputedRef<UseEveAgentStatus>`             | `"ready"`, `"submitted"`, `"streaming"`, or `"error"`.                    |
-| `error`   | `ComputedRef<Error \| undefined>`            | Last transport-level error.                                               |
-| `events`  | `ComputedRef<readonly MessageStreamEvent[]>` | Raw server events for this session.                                       |
-| `session` | `ComputedRef<SessionState>`                  | Snapshot of session state.                                                |
-| `send`    | `(input: SendTurnPayload) => Promise<void>`  | Send text or a full turn (multi-part, attachments, HITL responses).       |
-| `stop`    | `() => void`                                 | Abort the client's in-flight stream.                                      |
-| `reset`   | `() => void`                                 | Clear state and start a new session.                                      |
+| Property  | Type                                           | Description                                                               |
+| --------- | ---------------------------------------------- | ------------------------------------------------------------------------- |
+| `data`    | `ComputedRef<TData>`                           | Projected state. With the default reducer, `EveMessageData` (`messages`). |
+| `status`  | `ComputedRef<UseEveAgentStatus>`               | `"ready"`, `"submitted"`, `"streaming"`, or `"error"`.                    |
+| `error`   | `ComputedRef<Error \| undefined>`              | Last transport-level error.                                               |
+| `events`  | `ComputedRef<readonly MessageStreamEvent[]>`   | Raw server events for this session.                                       |
+| `session` | `ComputedRef<ClientSessionState \| undefined>` | Fixed session ID and stream cursor.                                       |
+| `send`    | `(message, options?) => Promise<void>`         | Send text or a multi-part message.                                        |
+| `respond` | `(inputResponses, options?) => Promise<void>`  | Answer pending HITL input requests.                                       |
+| `stop`    | `() => void`                                   | Abort the client's in-flight stream.                                      |
+| `reset`   | `() => void`                                   | Clear state and start a new session.                                      |
 
 The first five are `ComputedRef`s; the rest are methods. Destructure whatever you need, since refs keep their reactivity through destructuring. Read them with `.value` in `<script>`, and unwrapped in `<template>`.
 
@@ -52,7 +53,7 @@ async function handleSubmit() {
   const text = message.value.trim();
   if (!text) return;
   message.value = "";
-  await send({ message: text });
+  await send(text);
 }
 </script>
 
@@ -77,24 +78,22 @@ async function onFileChange(event: Event) {
   if (!file) return;
   const bytes = new Uint8Array(await file.arrayBuffer());
   const base64 = btoa(String.fromCodePoint(...bytes));
-  await send({
-    message: [
-      { type: "text", text: "Describe this image." },
-      { type: "file", data: `data:${file.type};base64,${base64}`, mediaType: file.type },
-    ],
-  });
+  await send([
+    { type: "text", text: "Describe this image." },
+    { type: "file", data: `data:${file.type};base64,${base64}`, mediaType: file.type },
+  ]);
 }
 </script>
 ```
 
 ## Human-in-the-loop prompts
 
-A tool opts into approval with `approval` ([Tools](../../tools)). When it triggers, the pending request shows up as a `dynamic-tool` part on the latest message at `part.toolMetadata?.eve?.inputRequest`. Read it, then answer through the same session with `send({ inputResponses })`:
+A tool opts into approval with `approval` ([Tools](../../tools)). When it triggers, the pending request shows up as a `dynamic-tool` part on the latest message at `part.toolMetadata?.eve?.inputRequest`. Read it, then answer through the same session with `respond(inputResponses)`:
 
 ```ts
 import type { EveDynamicToolPart, EveMessagePart } from "eve/vue";
 
-const { data, send } = useEveAgent();
+const { data, respond } = useEveAgent();
 
 const isDynamicToolPart = (part: EveMessagePart): part is EveDynamicToolPart =>
   part.type === "dynamic-tool";
@@ -106,9 +105,7 @@ const request = data.value.messages
   .find((value) => value !== undefined);
 
 if (request) {
-  await send({
-    inputResponses: [{ requestId: request.requestId, optionId: "approve" }],
-  });
+  await respond([{ requestId: request.requestId, optionId: "approve" }]);
 }
 ```
 
@@ -143,11 +140,10 @@ const agent = useEveAgent({
 
 ## Attach page context per turn
 
-`clientContext` adds ephemeral context for the next model call and nothing more. Strings (or an array of strings) become user-role context messages; an object is JSON-serialized into one. It rides along with a message or HITL response, never dispatches a turn on its own, and never lands in durable session history. Pass it to `send()`:
+`clientContext` adds ephemeral context for the next model call and nothing more. Strings (or an array of strings) become user-role context messages; an object is JSON-serialized into one. It rides along with a message or HITL response, never dispatches a turn on its own, and never lands in durable session history. Pass it in the second argument to `send()` or `respond()`:
 
 ```ts
-await send({
-  message: "What should I do on this screen?",
+await send("What should I do on this screen?", {
   clientContext: { route: "/billing", plan: "pro", seatsUsed: 4 },
 });
 ```

package/docs/guides/hooks.md

@@ -26,7 +26,7 @@ The slug is the path-relative basename. `agent/hooks/audit.ts` becomes `"audit"`
 
 `defineHook`, `HookDefinition`, and `HookContext` live on `eve/hooks`.
 
-A hook file declares stream-event subscribers under the `events` map, keyed by event type, with `*` matching every event. Subscribe to any event in the runtime stream vocabulary documented in [Sessions, runs and streaming](../concepts/sessions-runs-and-streaming), including the lifecycle events `session.started`, `turn.completed`, `message.completed`, and `action.result`. Handlers are observe-only. They cannot inject model context. To contribute runtime model messages, use `defineDynamic` and `defineInstructions` in `agent/instructions/`.
+A hook file declares stream-event subscribers under the `events` map, keyed by event type, with `*` matching every event. Subscribe to any event in the runtime stream vocabulary documented in [Sessions, runs and streaming](../concepts/sessions-runs-and-streaming), including the lifecycle events `session.started`, `turn.completed`, `message.completed`, `action.partial`, and `action.result`. Handlers are observe-only. They cannot inject model context. To contribute runtime model messages, use `defineDynamic` and `defineInstructions` in `agent/instructions/`.
 
 ## Hook structure and context
 

package/docs/guides/instrumentation.md

@@ -181,7 +181,7 @@ When `eve build` fails on discovery errors, the CLI prints the full diagnostics
 | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Tool not discovered (the model never sees it) | Run `eve info`. Confirm the file is in the right slot (`agent/tools/<name>.ts`) and default-exports `defineTool(...)`, and check `.eve/diagnostics.json` for shape errors. `schedules/` are root-only.                                                                      |
 | Model won't call a tool it should             | Tighten the tool `description` and `inputSchema`; put procedural guidance in a [skill](../skills), not the description. Confirm it's in the active set with `eve info`.                                                                                                     |
-| Stuck on `session.waiting`                    | The turn is parked on an approval, a question, or a connection sign-in. Answer it, or POST a follow-up with the `continuationToken` (a stale token is rejected).                                                                                                            |
+| Stuck on `session.waiting`                    | The turn is parked for input. Answer the pending approval or question, or POST a follow-up to `/eve/v1/session/:sessionId`.                                                                                                                                                 |
 | 401 on production routes                      | Expected: auth fails closed. Replace `placeholderAuth()` with your route policy. Use `vercelOidc()` only for Vercel-issued tokens; otherwise configure `httpBasic()`, JWT/OIDC helpers, or a custom `AuthFn`. See [Auth and route protection](./auth-and-route-protection). |
 | Build fails with discovery errors             | Read the printed diagnostics and `.eve/diagnostics.json`; confirm the root-vs-subagent boundary is valid and secrets come from env vars.                                                                                                                                    |
 

package/docs/install-integrations.mdx

@@ -12,13 +12,15 @@ Run `eve add` from an eve agent project. This installs the integration's depende
 
 ```bash
 eve add extension/agent-browser
-eve add connection/linear
+eve add linear
 eve add instrumentation/braintrust
 ```
 
 Extensions may create a mount under `agent/extensions/`. Connections write their initial definition under `agent/connections/` and install `@vercel/connect` when required. Instrumentation providers write `agent/instrumentation.ts`; because an agent has one instrumentation file, compose multiple exporters there by hand. Configure generated files and required environment variables before running your agent.
 
-When an official item has an interactive setup flow, eve asks whether to run it after installation. Run the printed `eve add <item> --skip-install` command to resume a skipped or cancelled setup later.
+Some integrations package several independently installable components. For example, `eve add linear` lets you choose the Linear Channel, Linear MCP, or both; both are selected by default. The specific `eve add channel/linear-agent` and `eve add connection/linear` commands remain available.
+
+When an official item declares an interactive setup flow or flows, eve asks whether to run them after installation and runs multiple flows in declaration order. Run the printed `eve add <item> --skip-install` command to resume a skipped or cancelled setup later; it reruns the selected components' declared flows from the beginning.
 
 ## Find an integration
 

package/docs/patterns/dynamic-scheduling.md

@@ -35,7 +35,7 @@ import { scheduleStore } from "../lib/schedule-store";
 
 export default defineSchedule({
   cron: "* * * * *",
-  run({ receive, waitUntil }) {
+  run({ to, waitUntil }) {
     waitUntil(
       (async () => {
         const jobs = await scheduleStore.claimDue({
@@ -47,25 +47,26 @@ export default defineSchedule({
         await Promise.all(
           jobs.map(async (job) => {
             try {
-              await receive(slack, {
-                message: [
+              await to(slack, { channelId: job.channelId }).send(
+                [
                   `Run dynamic schedule ${job.id}.`,
                   "Complete this tenant-owned task:",
                   job.prompt,
                 ].join("\n\n"),
-                target: { channelId: job.channelId },
-                auth: {
-                  attributes: {
-                    tenantId: job.tenantId,
-                    role: job.ownerRole,
-                    scheduleId: job.id,
+                {
+                  auth: {
+                    attributes: {
+                      tenantId: job.tenantId,
+                      role: job.ownerRole,
+                      scheduleId: job.id,
+                    },
+                    authenticator: job.authenticator,
+                    ...(job.issuer ? { issuer: job.issuer } : {}),
+                    principalId: job.ownerId,
+                    principalType: "user",
                   },
-                  authenticator: job.authenticator,
-                  ...(job.issuer ? { issuer: job.issuer } : {}),
-                  principalId: job.ownerId,
-                  principalType: "user",
                 },
-              });
+              );
               await scheduleStore.complete(job);
             } catch (error) {
               await scheduleStore.release(job, { error, retryAt: new Date(Date.now() + 300_000) });
@@ -78,7 +79,7 @@ export default defineSchedule({
 });
 ```
 
-`waitUntil` keeps the cron invocation alive until claiming and handoff settle. `receive` starts the same durable runtime used by inbound channel messages.
+`waitUntil` keeps the cron invocation alive until claiming and handoff settle. `to(...).send(...)` starts the same durable runtime used by inbound channel messages.
 
 This example uses Slack because it has a proactive target of `{ channelId }`. Any channel that implements `receive` can replace it.
 

package/docs/reference/cli.md

@@ -87,6 +87,7 @@ Commands for installing and discovering [shadcn registry](https://ui.shadcn.com/
 
 ```bash
 eve add extension/agent-browser
+eve add linear
 eve add channel/slack --skip-install
 eve add https://example.com/r/my-extension.json --overwrite
 eve registry add @acme=https://example.com/r/{name}.json
@@ -97,7 +98,9 @@ eve registry view @acme/my-extension
 eve add @acme/my-extension
 ```
 
-`eve add` asks before running setup declared by an official item and prints the matching `eve add <item> --skip-install` command when setup is skipped or cancelled. `--skip-install` reruns setup without reinstalling the item.
+`eve add` asks before running setup declared by an official item and runs multiple declared flows in declaration order. Product-level packages can offer independently installable components: `eve add linear` lets you select the Linear Channel, Linear MCP, or both, with both selected by default. `--yes` installs a package's default components.
+
+When setup is skipped or cancelled, eve prints the matching `eve add <item> --skip-install` command. `--skip-install` reruns the selected components' declared flows from the beginning without reinstalling them.
 
 `eve registry add` records configured sources in `package.json#registries`. `eve registry list` aggregates the official catalog and all configured sources by default. `eve registry search` also includes [skills.sh](https://skills.sh), available without configuration at `@skills`, and groups results by source with each source's available result count. Search returns up to 10 matches per source by default; pass `--limit <count>` to request between 1 and 100. Either command can browse one supplied URL or namespace. Official and other universal items with explicit file targets do not require shadcn project configuration.
 

package/docs/schedules.mdx

@@ -19,7 +19,7 @@ interface ScheduleDefinition {
 }
 
 interface ScheduleHandlerArgs {
-  receive: CrossChannelReceiveFn; // hand the work off to a channel
+  to: ScheduleToFn; // select a channel target, then send
   waitUntil: (task: Promise<unknown>) => void; // keep the cron task alive past return
   appAuth: SessionAuthContext; // pre-built app principal
 }
@@ -56,7 +56,7 @@ Sweep stale workflow state.
 
 ## Handler form (`run`)
 
-Use a handler when the schedule needs to deliver to a channel, branch on conditions, or compute its arguments at fire time. The handler is in full control. It has no channel of its own, so it passes the work to one with `receive`.
+Use a handler when the schedule needs to deliver to a channel, branch on conditions, or compute its arguments at fire time. The handler is in full control. It has no channel of its own, so it selects a channel target with `to(...)` and sends through the returned handle.
 
 ```ts title="agent/schedules/critical-alerts.ts"
 import { defineSchedule } from "eve/schedules";
@@ -65,13 +65,12 @@ import slack from "../channels/slack";
 
 export default defineSchedule({
   cron: "* * * * *",
-  async run({ receive, waitUntil, appAuth }) {
+  async run({ to, waitUntil, appAuth }) {
     waitUntil(
-      receive(slack, {
-        message: "Check for new critical alerts. Report only when there are any.",
-        target: { channelId: "C0123ABC" },
-        auth: appAuth,
-      }),
+      to(slack, { channelId: "C0123ABC" }).send(
+        "Check for new critical alerts. Report only when there are any.",
+        { auth: appAuth },
+      ),
     );
   },
 });
@@ -79,9 +78,9 @@ export default defineSchedule({
 
 The agent does not have to deliver a message on every run. When a prompt makes delivery conditional, as in the alert check above, eve tells the agent how to finish successfully without sending anything to the channel. Frequent polling schedules do not need a separate filter or delivery setting.
 
-- `receive(channel, { message, target, auth })`: starts a session on another channel. Same contract as a route handler's `args.receive`.
-- `waitUntil(promise)`: extends the cron task's lifetime so the parked session and any in-flight fetches settle before the task ends. Wrap the `receive` call in it.
-- `appAuth`: the app principal (`{ authenticator: "app", principalId: "eve:app", principalType: "runtime" }`). Pass it as `receive(..., { auth: appAuth })` for work the agent does on its own behalf.
+- `to(channel, target).send(message, { auth })`: starts a session on another channel. It has the same contract as a route handler's `ctx.to(...)` handle.
+- `waitUntil(promise)`: extends the cron task's lifetime so the parked session and any in-flight fetches settle before the task ends. Wrap the `send` call in it.
+- `appAuth`: the app principal (`{ authenticator: "app", principalId: "eve:app", principalType: "runtime" }`). Pass it as `to(...).send(..., { auth: appAuth })` for work the agent does on its own behalf.
 
 A handler-form session runs on the same durable runtime engine as any other session, so it can park (durably suspend), for instance when the channel handoff is waiting for a Slack reply. Only markdown task mode is barred from waiting.
 

package/docs/subagents.mdx

@@ -192,7 +192,7 @@ Without the opt-in, delegated children run as one-shot tasks: they answer once a
 
 With it enabled, a child parks after answering instead of terminating, keeping its session and conversation history alive. A failed child turn can also leave the child parked — its latest status shows the error and the parent may message it again. Pass a parked child's `agentId` to the same subagent tool with a new `message` to continue that session. Omitting `agentId` (or passing an empty string or `null`) always starts a new child, and an `agentId` that matches no known agent falls back to starting a new child rather than failing. Passing a known `agentId` through a different subagent tool fails with `AGENT_MISMATCH`, and messaging a child that is still starting or working on its previous request fails with `AGENT_BUSY` — wait for its result before continuing it.
 
-On every model call, eve injects a system message containing an `<agents>` block listing the currently parked (resumable) children — each entry carries the `agentId`, name, and latest status. It is a per-call injection, not part of the conversation history: it always reflects the current state, never accumulates stale copies, and children that are starting or running do not appear until they park again.
+Whenever the set of parked (resumable) children changes, eve appends a framework-injected note to the conversation — labeled `[Agents]` and carrying an `<agents>` block — listing each child's `agentId`, name, and latest status. The static system prompt tells the model the note is injected by eve, not written by the user. The note is appended only when the listing changes (an append-only design that preserves the provider prompt cache), the most recent note is authoritative, and children that are starting or running do not appear until they park again.
 
 The parent holds agent handles only for its session lifetime. When the parent session ends, eve terminates its local children. Remote children are not terminated on parent shutdown — that is a known gap: a parked remote child stays alive on its own deployment until that deployment's own lifecycle ends it. For [remote agents](./guides/remote-agents), both deployments must run the same eve version to use agent messaging.
 

package/docs/tools/human-in-the-loop.md

@@ -58,7 +58,7 @@ Gating a side effect on approval is also how you make non-idempotent work safe a
 
 ### Skipping approval for schedule-dispatched turns
 
-`session.auth.current` identifies the caller of this turn. Markdown schedules use the app principal (`authenticator: "app"`, `principalId: "eve:app"`, `principalType: "runtime"`) automatically. A `run` schedule must pass its `appAuth` to `receive(...)` for the child session to use that principal. Match all three fields to skip approval for automated turns while still prompting when a person calls the same tool:
+`session.auth.current` identifies the caller of this turn. Markdown schedules use the app principal (`authenticator: "app"`, `principalId: "eve:app"`, `principalType: "runtime"`) automatically. A `run` schedule must pass its `appAuth` to `send(...)` for the child session to use that principal. Match all three fields to skip approval for automated turns while still prompting when a person calls the same tool:
 
 ```ts title="agent/tools/refund_charge.ts"
 import { defineTool } from "eve/tools";

package/docs/tools/overview.mdx

@@ -28,10 +28,34 @@ A tool definition needs:
 - a filename slug under `agent/tools/`, the model-facing name.
 - a `description`: what the tool does, written for the model.
 - an `inputSchema`: a Zod schema (or any Standard Schema, or a plain JSON Schema object). Required. For no input, pass `z.object({})`. Zod and Standard Schema infer the `input` type in `execute`. Plain JSON Schema types it as `Record<string, unknown>`.
-- an `execute(input, ctx)`: the implementation. May be sync or async.
+- an `execute(input, ctx)`: the implementation. May be sync, async, or an async generator.
 
 When a tool returns structured data, add an optional `outputSchema`. With Zod or Standard Schema it also types the `execute` return.
 
+### Stream preliminary tool results
+
+An async generator lets a long-running tool stream complete output snapshots
+before it finishes. Each `yield` replaces the previous snapshot; the final
+yield is the normal tool result the model receives:
+
+```ts title="agent/tools/build_report.ts"
+export default defineTool({
+  description: "Build a project report.",
+  inputSchema: z.object({ project: z.string() }),
+  async *execute({ project }) {
+    yield { phase: "collecting", report: null };
+    const report = await buildReport(project);
+    yield { phase: "complete", report };
+  },
+});
+```
+
+eve publishes every earlier yield as an `action.partial` stream event. The
+snapshot is visible to channels, hooks, and clients but never enters model
+history or `toModelOutput`; only the final yield does. Treat snapshots as
+last-write-wins by tool call id, not append-only progress. The durable runtime
+can retry a step and replay overlapping snapshots.
+
 ### The `ctx` parameter
 
 `execute` gets a `ctx` carrying the runtime accessors:
@@ -78,7 +102,7 @@ toModelOutput(output) {
 },
 ```
 
-`toModelOutput` receives the full, typed `execute` return and only affects the model. Channel event handlers and hooks still get the full output on `action.result`, so a channel can render rich platform output (Slack Block Kit, say) the model never sees. Return `{ type: "text", value }` for a summary, or `{ type: "json", value }` for a smaller object.
+`toModelOutput` receives the final, typed `execute` return and only affects the model. Channel event handlers and hooks still get the full output on `action.result`, so a channel can render rich platform output (Slack Block Kit, say) the model never sees. Return `{ type: "text", value }` for a summary, or `{ type: "json", value }` for a smaller object.
 
 Tool outputs must be JSON-serializable. Return plain objects, arrays, strings, numbers, booleans, or `null`; convert values like `Date`, `Map`, `Set`, `NaN`, and cyclic objects before returning them from `execute` or from a `{ type: "json" }` `toModelOutput`.
 

package/docs/tutorial/ship-it.mdx

@@ -43,7 +43,7 @@ export function AgentChat() {
         event.preventDefault();
         const data = new FormData(event.currentTarget);
         const message = String(data.get("q") ?? "").trim();
-        if (message) void agent.send({ message });
+        if (message) void agent.send(message);
       }}
     >
       {agent.data.messages.map((message) => (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.30.7",
+  "version": "0.31.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [

package/dist/src/channel/cancel.d.ts

@@ -1,6 +0,0 @@
-import type { CancelFn } from "#channel/routes.js";
-import type { Runtime } from "#channel/types.js";
-/**
- * Builds the route-handler `cancel` helper for one channel.
- */
-export declare function createCancelFn(runtime: Runtime, channelName: string): CancelFn;

package/dist/src/channel/cancel.js

@@ -1 +0,0 @@
-function createCancelFn(e,t){return async n=>await e.dispatchContinuation({command:{kind:`cancel`,turnId:n.turnId},continuationToken:`${t}:${n.continuationToken}`})}export{createCancelFn};

package/dist/src/channel/clear-session.d.ts

@@ -1,4 +0,0 @@
-import type { ClearFn } from "#channel/routes.js";
-import type { Runtime } from "#channel/types.js";
-/** Builds a channel-scoped context-clear helper. */
-export declare function createClearFn(runtime: Runtime, channelName: string): ClearFn;

package/dist/src/channel/clear-session.js

@@ -1 +0,0 @@
-function createClearFn(e,t){return async n=>await e.dispatchContinuation({command:{kind:`clear`},continuationToken:`${t}:${n.continuationToken}`})}export{createClearFn};