eve 0.62.0 → 0.64.0

package/docs/schedules.mdx

@@ -44,7 +44,7 @@ export default defineSchedule({
 });
 ```
 
-You can write the same thing as a plain `.md` file: its frontmatter takes `cron` and nothing else, and the body is the prompt.
+You can write the same thing as a plain `.md` file: its frontmatter takes `cron`, and the body is the prompt.
 
 `agent/schedules/cleanup.md`:
 
@@ -88,6 +88,40 @@ The `auth` option controls which principal the session runs as. A handler may in
 
 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.
 
+## Background task results
+
+New sessions started by schedules default to `"cohort"`: background
+outcomes wait for overlapping tasks to settle before waking the parent. To report
+independently useful results as they arrive, pass `taskDeliveryPolicy: "auto"` to
+`send(...)` inside a schedule handler:
+
+```ts title="agent/schedules/digest.ts"
+import { defineSchedule } from "eve/schedules";
+import slack from "../channels/slack";
+
+export default defineSchedule({
+  cron: "0 9 * * *",
+  run({ to, waitUntil, appAuth }) {
+    waitUntil(
+      to(slack, { channelId: "C0123ABC" }).send("Prepare the daily reports.", {
+        auth: appAuth,
+        taskDeliveryPolicy: "auto",
+      }),
+    );
+  },
+});
+```
+
+The option belongs to `send(...)`. Markdown schedules use the `"cohort"` default;
+use a handler when you need to override it. Sending to an existing session preserves
+its policy unless the send supplies an explicit value.
+
+Under `"auto"`, a model call may finish silently while related work is pending.
+Available results remain in the next reporting context so the parent can combine
+previously withheld outputs later. A scheduled task-mode session stays alive while
+it owns pending background tasks. See
+[Background task results](./channels/overview#background-task-results).
+
 ## Session continuity
 
 Markdown schedules start a new session on every fire. Handler schedules do too, unless they send to an existing conversation, such as a Slack thread. Store data that must survive across fires outside session state.

package/docs/subagents/index.mdx

@@ -3,17 +3,36 @@ title: "Subagents"
 description: "Delegate work to root-agent copies or declared specialists with their own tools and sandbox."
 ---
 
-eve supports two ways to delegate work: the root-only built-in `agent` tool, which starts or continues a copy of the root agent, and declared subagents, which are specialists with their own directories. Use a subagent to run independent work in parallel, narrow the available tools, or give a task to a specialist.
+Use a subagent to run independent work in parallel, narrow the available tools, or give a task to a specialist.
+
+- Use the root-only [built-in `agent` tool](#the-built-in-agent-tool) to start or continue a copy of the root agent that shares its sandbox.
+- Use a [declared local subagent](#declared-subagents) for a specialist with its own directory and authored capabilities, rather than inheriting the root's.
+- Use a [remote agent](./guides/remote-agents) to delegate to a separately deployed eve agent, with its own configuration and authentication.
 
 ## Completion batching
 
 Overlapping background work owned by a session forms a cohort. Tasks launched in
 later user turns join the open cohort while earlier work is still pending or its
-successful results await delivery. eve holds successful completion notifications
+terminal results await delivery. With `taskDeliveryPolicy: "cohort"`, eve holds
+completion, failure, and cancellation notifications
 until every task in that cohort has completed, failed, or been cancelled, then
-delivers the successful results together in one parent turn. Partial completions
+delivers all outcomes together in one parent turn. Partial settlements
 do not invoke the parent model. Work started after the cohort settles forms a new
-cohort. No configuration or debounce timer is required.
+cohort.
+
+New channel sessions default to `"auto"`; schedules default to `"cohort"`.
+Pass `taskDeliveryPolicy` to `send(...)` to select or update the session policy. See
+[Background task results](/docs/channels/overview#background-task-results).
+
+With `"auto"`, a terminal outcome can start a parent turn while other tasks are
+still running. The parent reports independently useful results and stays silent
+when a useful answer depends on unfinished tasks. Ready results may share a turn.
+The reporting context includes the whole cohort and every available output,
+including previously withheld results, for a later combined report.
+
+The setting applies to background tools and built-in, declared, and remote
+subagents owned by the session. Internal subagent sessions use `"cohort"` for
+background work they start.
 
 User messages, input requests, authorization events, failures, and cancellation
 are handled without waiting for the cohort. Child lifecycle events are processed
@@ -197,7 +216,7 @@ A declared subagent inherits nothing from the root's authored slots. Discovery t
 | Tools        | Inherited except root-only    | Own `tools/`                           |
 | Connections  | Inherited                     | Own `connections/`                     |
 | Skills       | Inherited                     | Own `skills/`                          |
-| Sandbox      | Shared with parent            | Own `sandbox/`, else framework default |
+| Sandbox      | Reuses the parent sandbox     | Own `sandbox/`, else framework default |
 | Hooks        | Inherited                     | Own `hooks/`                           |
 | Extensions   | Inherited contributions       | Own `extensions/`                      |
 | State        | Fresh                         | Fresh                                  |
@@ -206,7 +225,7 @@ A declared subagent inherits nothing from the root's authored slots. Discovery t
 
 For a declared subagent this means authoring or mounting anything the child needs. When two subagents need the same procedure, package the skill in a [workspace extension](./extensions#use-an-extension-in-a-workspace) and mount that extension in each subagent. Share typed helpers through `lib/`. The sandbox does not inherit from the parent; eve selects the default sandbox source unless the subagent authors `subagents/<id>/sandbox.ts` or seeds files via `subagents/<id>/sandbox/workspace/`.
 
-The root built-in `agent` tool is the exception. Its children share the root's sandbox and tools because they are copies of the same agent working on the same files.
+The root built-in `agent` tool is the exception. Its children reuse the root's sandbox and tools because they are copies of the same agent working on the same files.
 
 `defineState` is never shared, for either kind. Each child starts with fresh durable state.
 
@@ -234,6 +253,8 @@ Do not rely on subagent delegation by itself as an approval boundary. Put sensit
 
 Each delegated subagent spins up its own child session and stream. The parent stream carries the control-plane events `subagent.called` and `subagent.completed`, plus interactive `input.requested`, `authorization.required`, and `authorization.completed` events proxied from descendants so the root channel can prompt the user. To follow the child's other progress, read `subagent.called.data.childSessionId` and subscribe at `GET /eve/v1/session/:childSessionId/stream`.
 
+Both blocking and background invocations emit `subagent.called` after dispatch and `subagent.completed` after the parent records successful completion. Completion carries the actual output and identifies the same invocation by `callId`; the child session can remain available for reuse. A background working receipt is returned as an `action.result` tool output and does not emit completion. Background completion events do not wait for the cohort report. Failure and cancellation are not successful completion; task notifications retain those outcomes.
+
 Channels with activity reporting attribute the backing agent's tool activity to its background task. Local and remote subagents share the task's progress item rather than adding a separate agent item. Continuing or steering a child with `agentId` attaches its new activity to the new task; the previous task keeps its completed or cancelled status. This applies to the built-in `agent` and declared subagent tools, not to child invocations inside custom workflow tools. Activity reporting is best-effort and does not change task execution or result delivery.
 
 A background task that was already admitted survives cancellation of the turn that started it; background work that has not yet been admitted is rejected with the cancelled step. Use `task_cancel` to stop an admitted task. Cancellation delivers the task's final notification to an active parent even if the task must be stopped forcibly. Parent-session finalization cancels remaining live tasks.

package/docs/subagents/meta.json

@@ -1,5 +1,5 @@
 {
   "title": "Subagents",
   "defaultOpen": false,
-  "pages": ["index"]
+  "pages": ["index", "../guides/remote-agents"]
 }

package/docs/tools/overview.mdx

@@ -121,33 +121,25 @@ receive only the projected text.
 
 ### Background execution
 
-Background execution controls how a tool delivers its result to the parent agent. Durable
-suspension controls whether the executor can pause at a workflow wait and release compute.
-These are independent choices: `execution: "background"` selects the task lifecycle;
-`defineWorkflowTool` with a leading `"use workflow"` directive enables durable suspension.
-
-| Definition                                       | Durable waits inside `execute`                                  | Result delivered to the model                                          |
-| ------------------------------------------------ | --------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `defineTool`                                     | No; the executor runs inside the initiating step.               | Executor output after it finishes.                                     |
-| `defineTool` + `execution: "background"`         | No; the initiating step still waits for the executor to finish. | Task receipt, followed by task notifications.                          |
-| `defineWorkflowTool`                             | Yes; the tool call waits while the workflow can suspend.        | Workflow output after it finishes.                                     |
-| `defineWorkflowTool` + `execution: "background"` | Yes; the workflow body can outlive the initiating step.         | Task receipt before the body finishes, followed by task notifications. |
-
-A background tool receives a third `task` argument. Its tool result is the receipt
-`{ status: "working", taskId }`; its eventual output belongs to the task. Use a background
-workflow tool when the conversation should continue while the body waits for a person,
-webhook, or timer. Setting `execution: "background"` on an ordinary tool does not move its
-executor into a separate workflow or make an ordinary Promise a durable wait.
+Background execution controls how a workflow tool delivers its result to the parent agent.
+Set `execution: "background"` on `defineWorkflowTool`; ordinary `defineTool` calls always finish
+inside the initiating step.
+
+| Definition                                       | Durable waits inside `execute`                           | Result delivered to the model                                                                          |
+| ------------------------------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `defineTool`                                     | No; the executor runs inside the initiating step.        | Executor output after it finishes.                                                                     |
+| `defineWorkflowTool`                             | Yes; the tool call waits while the workflow can suspend. | Workflow output after it finishes.                                                                     |
+| `defineWorkflowTool` + `execution: "background"` | Yes; the workflow body can outlive the initiating step.  | Task receipt before the body finishes; one combined report after all tasks in its cohort are terminal. |
+
+A background workflow tool's result is the receipt `{ status: "working", taskId }`; its eventual
+output belongs to the task. Use this mode when the conversation should continue while the body
+waits for a person, webhook, or timer.
 
 For background tools, `outputSchema` and `toModelOutput` describe the fixed receipt. The body's
 return value is available through the completed task's output.
 
-`task.delegated()` has been removed. Move external work into a `defineWorkflowTool` executor and
-return its result when it finishes. Rebuild extensions using the removed API after migrating.
-
-`yield task.postMessage(message)` is the only yield that requests a parent-agent turn. Calling
-`task.postMessage` only constructs the message descriptor; you must yield it to send it.
-In a workflow body, keep values needed after a wait in local variables; workflow replay
+The `TaskExec` argument and `task.postMessage` have been removed. Return the terminal result;
+background yields are consumed without publishing progress or retaining a task-progress stream. In a workflow body, keep values needed after a wait in local variables; workflow replay
 reconstructs them across durable waits.
 Use [`ctx.ask`](/docs/tools/workflows#ask-a-human-ctxask) when the body needs an answer from the human.
 Background tools are a normal execution mode and need no root-agent flag. Built-in, declared local,
@@ -157,11 +149,20 @@ After the initiating turn accepts background tasks, eve supplies runtime-authore
 cohort and instructs the model to acknowledge that the work started without waiting for results.
 [Schedule](/docs/schedules)-initiated turns are the exception: no user prompted them, so their
 launches keep conditional delivery and send no acknowledgement.
-Later task-triggered parent turns receive fresh state for the same cohort. Once every related
-task is terminal, the state includes their outputs so the model can combine the useful results.
-eve does not instruct the model to stay silent while sibling tasks are pending; a new user
-question can receive an answer while background work continues. [Completion batching](/docs/subagents#completion-batching)
-combines successful results already queued for the parent.
+Channel sessions default to `taskDeliveryPolicy: "auto"`: ready results can invoke
+the parent while other tasks continue. The parent reports independently useful
+results and can stay silent until related work settles. Each reporting context
+includes the whole cohort and available outputs, including previously withheld
+results. Ready results may share a turn.
+Schedules default to `"cohort"`: terminal outcomes wait for overlapping tasks
+to settle, then arrive together. Pass `taskDeliveryPolicy` to `send(...)` to select
+or update the session policy. See
+[Background task results](/docs/channels/overview#background-task-results) and
+[Schedules](/docs/schedules#background-task-results).
+User questions, input requests, and explicit task messages do not wait for the
+cohort under either policy. Failure and cancellation update lifecycle state
+immediately; their automatic reports follow the selected policy.
+See [Completion batching](/docs/subagents#completion-batching).
 
 ### Yield and return
 
@@ -169,19 +170,18 @@ combines successful results already queued for the parent.
 It does not by itself create a durable wait for a person, timer, or external event. The value's
 meaning depends on the tool's execution mode:
 
-| Executor                                         | Ordinary `yield value`                                                                  | Final output                                                                                                      |
-| ------------------------------------------------ | --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
-| `defineTool`, default execution                  | Earlier values are `action.partial` snapshots; the final yield becomes the tool result. | Last yielded value; a generator `return` value is ignored.                                                        |
-| `defineWorkflowTool`, default execution          | Every yield is an `action.partial` snapshot.                                            | Explicit return value; falls back to the last yield if the return is `null` or `undefined`, then to `null`.       |
-| Either definition with `execution: "background"` | Stream-only task progress; does not request a parent-agent turn.                        | Explicit return value becomes the task output; no return completes with `null`. The last yield is not a fallback. |
+| Executor                                            | Ordinary `yield value`                                                                  | Final output                                                                                                      |
+| --------------------------------------------------- | --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `defineTool`, default execution                     | Earlier values are `action.partial` snapshots; the final yield becomes the tool result. | Last yielded value; a generator `return` value is ignored.                                                        |
+| `defineWorkflowTool`, default execution             | Every yield is an `action.partial` snapshot.                                            | Explicit return value; falls back to the last yield if the return is `null` or `undefined`, then to `null`.       |
+| `defineWorkflowTool` with `execution: "background"` | Consumed without publishing progress or requesting a parent-agent turn.                 | Explicit return value becomes the task output; no return completes with `null`. The last yield is not a fallback. |
 
-For either kind of background tool, `yield task.postMessage(message)` sends a message to the
-parent agent while the task remains open. Return completes the task; throw fails it. These
-notifications are separate from the original tool call's receipt.
+For a background workflow tool, return completes the task and throw fails it. The automatic
+cohort report is separate from the original tool call's receipt.
 
 Progress snapshots do not enter model history as intermediate tool results. For a default
 executor, the final output selected by the rules above becomes the tool result. For a background
-executor, task messages and completion notifications provide input to later parent-agent turns.
+executor, the terminal cohort report provides input to a later parent-agent turn.
 
 ### Workflows as tools
 

package/docs/tools/workflows.mdx

@@ -178,8 +178,7 @@ agent should receive a tool result:
 
 Use default execution when the model needs the answer to continue. Use background execution when
 the conversation should continue while the task is pending. Background tools need no root-agent
-flag. Ordinary `defineTool` also accepts `execution: "background"`, but its executor still runs
-inside the initiating step and cannot suspend at workflow waits. See the
+flag. `defineTool` does not accept background execution. See the
 [tool execution comparison](/docs/tools#background-execution).
 
 ### How suspension works
@@ -429,23 +428,23 @@ This pattern controls specialist selection, not whether the parent model delegat
 
 ## Report progress: `yield`
 
-A workflow body may be an async generator. Ordinary yields report progress in both execution
-modes. After processing a yield, eve advances the generator; use an awaited workflow operation
+A workflow body may be an async generator. In default execution, yields report progress.
+Background execution consumes yielded values without publishing them or retaining a task-progress
+stream. After processing a yield, eve advances the generator; use an awaited workflow operation
 when the body needs to suspend.
 
-| Operation                         | Default execution                                                 | `execution: "background"`                                              |
-| --------------------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `yield value`                     | Emits an `action.partial` snapshot for the pending tool call.     | Emits stream-only task progress; does not request a parent-agent turn. |
-| `yield task.postMessage(message)` | Unavailable; there is no `task` argument.                         | Sends a message requesting a parent-agent turn; the task stays open.   |
-| `return value`                    | Settles the tool call with its output.                            | Completes the task and delivers its output in a later notification.    |
-| No return value                   | Uses the last yield as output, or `null` if there were no yields. | Completes with `null`; yielded progress is not the task output.        |
+| Operation       | Default execution                                                 | `execution: "background"`                                                         |
+| --------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| `yield value`   | Emits an `action.partial` snapshot for the pending tool call.     | Consumes the value without publishing progress or requesting a parent-agent turn. |
+| `return value`  | Settles the tool call with its output.                            | Completes the task and contributes to its cohort's terminal report.               |
+| No return value | Uses the last yield as output, or `null` if there were no yields. | Completes with `null`; yielded progress is not the task output.                   |
 
 For default execution, an explicit `return null` also falls back to the last yield. Prefer an
 explicit object return when progress snapshots and the final result have different shapes.
 Progress snapshots are last-write-wins by tool call id and do not enter model history as
 intermediate tool results. A snapshot used as the final output does enter history as the tool result.
 
-This background workflow reports progress, sends the parent one message, and then suspends:
+This background workflow consumes an intermediate yield, then suspends until its timer expires:
 
 ```ts title="agent/tools/remind_with_progress.ts"
 import { defineWorkflowTool } from "eve/tools";
@@ -453,25 +452,22 @@ import { sleep } from "workflow";
 import { z } from "zod";
 
 export default defineWorkflowTool({
-  description: "Schedule a reminder and report progress before waiting.",
+  description: "Schedule a reminder.",
   inputSchema: z.object({ note: z.string(), delay: z.string() }),
   execution: "background",
-  async *execute({ note, delay }, ctx, task) {
+  async *execute({ note, delay }) {
     "use workflow";
-    yield { status: "preparing reminder" }; // Stream-only progress.
-    yield task.postMessage(`Reminder scheduled for ${delay}.`); // Parent-agent message.
+    yield { status: "preparing reminder" }; // Consumed without publishing progress in background mode.
     await sleep(delay); // Durable suspension while the timer is pending.
     return { reminder: note }; // Task completion notification.
   },
 });
 ```
 
-Calling `task.postMessage` constructs a descriptor; yielding it sends the message. It does not
-wait for a reply. Use [`ctx.ask`](#ask-a-human-ctxask) when the workflow needs a human answer.
-Removing `execution: "background"` requires removing the `task` argument and message yield; the
-ordinary progress yield and `await sleep(delay)` still work, but the model waits for the final
-reminder as the tool result. See [yield and return](/docs/tools#yield-and-return) for the different
-final-output rules of ordinary `defineTool` generators.
+Use [`ctx.ask`](#ask-a-human-ctxask) when the workflow needs a human answer. Removing
+`execution: "background"` makes the yield visible as progress and keeps the durable sleep; the model
+waits for the final reminder as the tool result. See [yield and return](/docs/tools#yield-and-return) for the
+final-output rules.
 
 ## Cancel and clean up: `ctx.abortSignal`
 
@@ -497,6 +493,11 @@ as cancelled whether or not it did. A body parked on a hook or a `sleep` does no
 it is abandoned when the grace period ends. Steps that received the signal are how you clean up
 first.
 
+The caller waits up to 35 seconds for a cooperatively cancelled run to settle before forcing it
+to stop. This includes time for the run to publish its outcome after body cleanup. A background
+task records its cancelled status before cleanup finishes, so that status alone does not mean
+its work has stopped.
+
 ## Workflow tool examples
 
 ### Approve with a deadline and an escalation
@@ -607,8 +608,10 @@ it.
 ## Semantics
 
 One call, one result. A waiting tool's call resolves once, with the return value, the error, or a
-cancellation. A background tool's call resolves once, with the receipt; everything after arrives as
-separate session input.
+cancellation. A background tool's call resolves once, with the receipt. Its terminal outcome arrives
+in one automatic report after every task in its cohort is terminal. A cohort includes overlapping
+background work in the same session, including tasks launched in later user turns while earlier
+work remains open.
 
 While a waiting tool runs, the turn is parked. A `queue` message waits for it. A `steer` message
 cancels the turn, which cancels the run, which withdraws its requests. Input responses never steer.
@@ -616,8 +619,12 @@ cancels the turn, which cancels the run, which withdraws its requests. Input res
 Background runs belong to the session. They survive turn completion and cancellation, appear in the
 session's task index, can be cancelled with `task_cancel`, and are cancelled when the session ends.
 
+The parent session records each background task's outcome when it processes the child's notification.
+The first terminal outcome it records is final: a late child result cannot replace a recorded
+cancellation. Task completion does not require the wrapper workflow to have exited.
+
 Errors follow the SDK. A thrown error in a step retries per the step's policy; `FatalError` does
-not. An error that escapes the body fails the run.
+not. An error that escapes the body fails the tool invocation.
 
 Starting a waiting workflow tool can also be retried. If dispatch is interrupted after starting a
 run, its retry starts another run, and both may execute. The parent tracks the run returned by the

package/docs/tutorial/run-analysis.mdx

@@ -34,11 +34,10 @@ Python needs a sandbox that runs real binaries. For local development, start a D
 The default eve images for Docker, microsandbox, and Vercel Sandbox include Python, but not matplotlib. Add this definition alongside `workspace/` to install matplotlib in a virtual environment. It uses the same environment for installation and chart execution, without changing the system Python:
 
 ```ts title="agent/sandbox/sandbox.ts"
-import { defineSandbox } from "eve/sandbox";
+import { DefaultSandbox, defineSandbox } from "eve/sandbox";
 
-export default defineSandbox({
-  async bootstrap({ use }) {
-    const sandbox = await use();
+export const environment = DefaultSandbox.environment({
+  prepare: async (sandbox) => {
     const commands = [
       "sudo apt-get update && sudo apt-get install -y python3 python3-venv",
       "python3 -m venv /workspace/.venv",
@@ -55,9 +54,11 @@ export default defineSandbox({
     }
   },
 });
+
+export default defineSandbox(() => environment.open());
 ```
 
-Bootstrap runs when eve builds the sandbox template, and sessions inherit the installed environment. The first build needs network access to Ubuntu package repositories and PyPI. Keep the default network policy while following this example; a custom `deny-all` or allow-list policy must permit these downloads during bootstrap. The same definition uses Vercel Sandbox after deployment to Vercel.
+Preparation runs when eve builds the sandbox template, and sessions inherit the installed environment. The first build needs network access to Ubuntu package repositories and PyPI. Keep the default network policy while following this example; a custom `deny-all` or allow-list policy must permit these downloads during preparation. The same definition uses Vercel Sandbox after deployment to Vercel.
 
 Restart `npm run dev` after adding the definition. Before asking for a chart, send this message in the TUI:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -256,6 +256,11 @@
       "import": "./dist/src/public/sandbox/index.js",
       "default": "./dist/src/public/sandbox/index.js"
     },
+    "./sandbox/provider": {
+      "types": "./dist/src/public/sandbox/provider.d.ts",
+      "import": "./dist/src/public/sandbox/provider.js",
+      "default": "./dist/src/public/sandbox/provider.js"
+    },
     "./sandbox/docker": {
       "types": "./dist/src/public/sandbox/docker.d.ts",
       "import": "./dist/src/public/sandbox/docker.js",
@@ -471,9 +476,9 @@
     "@ai-sdk/otel": "^1.0.93",
     "@ai-sdk/provider": "^4.0.10",
     "@ai-sdk/provider-utils": "^5.0.36",
-    "@chat-adapter/slack": "4.34.0",
-    "@chat-adapter/state-memory": "4.34.0",
-    "@chat-adapter/twilio": "4.34.0",
+    "@chat-adapter/slack": "4.41.0",
+    "@chat-adapter/state-memory": "4.41.0",
+    "@chat-adapter/twilio": "4.41.0",
     "@clack/core": "1.3.1",
     "@eve/catalog": "0.0.1",
     "@linqapp/chat-sdk-adapter": "^0.5.1",
@@ -496,16 +501,16 @@
     "@vercel/otel": "2.1.3",
     "@vercel/sandbox": "3.3.0",
     "@vercel/sdk": "1.28.8",
-    "@workflow/builders": "5.0.0-beta.53",
-    "@workflow/core": "5.0.0-beta.53",
-    "@workflow/errors": "5.0.0-beta.21",
+    "@workflow/builders": "5.0.0-beta.55",
+    "@workflow/core": "5.0.0-beta.55",
+    "@workflow/errors": "5.0.0-beta.22",
     "@workflow/serde": "5.0.0-beta.2",
     "@workflow/utils": "5.0.0-beta.10",
-    "@workflow/world": "5.0.0-beta.36",
-    "@workflow/world-local": "5.0.0-beta.45",
-    "@workflow/world-vercel": "5.0.0-beta.48",
+    "@workflow/world": "5.0.0-beta.37",
+    "@workflow/world-local": "5.0.0-beta.46",
+    "@workflow/world-vercel": "5.0.0-beta.50",
     "ai": "^7.0.105",
-    "chat": "4.34.0",
+    "chat": "4.41.0",
     "chokidar": "5.0.0",
     "commander": "14.0.3",
     "dd-trace": "6.13.0",
@@ -539,6 +544,7 @@
     "@opentelemetry/api": "^1.0.0",
     "ai": "^7.0.105",
     "braintrust": "^3.0.0",
+    "chat": "^4.41.0",
     "dd-trace": "^6.13.0",
     "just-bash": "^3.1.0",
     "microsandbox": "^0.5.0"
@@ -550,6 +556,9 @@
     "braintrust": {
       "optional": true
     },
+    "chat": {
+      "optional": true
+    },
     "dd-trace": {
       "optional": true
     },

package/dist/src/cli/dev/tui/model-editor.d.ts

@@ -1,103 +0,0 @@
-import { type ReasoningLevel } from "#setup/boxes/model-capabilities.js";
-import type { GatewayModelCapabilities } from "#setup/boxes/model-capabilities.js";
-import { type SelectState } from "#setup/cli/select-state.js";
-import type { ModelSettingsRequest, ModelSettingsResult } from "#setup/flows/model.js";
-import type { SelectOption } from "#setup/prompter.js";
-/** The Change-model menu's rows, in visual order. */
-export type ModelEditorRowId = "model" | "reasoning" | "tier" | "done";
-/**
- * The screen stack, depth two: the value menu, or the model list it opens.
- * Reasoning and tier adjust inline on their menu rows — only the catalog pick
- * warrants its own screen. The list carries scratch select state seeded when
- * opened; Esc drops it, so "returns unchanged" is structural.
- */
-export type ModelEditorScreen = {
-    kind: "menu";
-    cursor: ModelEditorRowId;
-} | {
-    kind: "model";
-    select: SelectState;
-};
-/** The in-progress values; a completed selection is applied immediately. */
-export interface ModelEditorDraft {
-    modelId: string | null;
-    reasoning: "default" | ReasoningLevel;
-    tier: "standard" | "priority";
-}
-/** One Change-model interaction, advanced by {@link transitionModelEditor}. */
-export interface ModelEditorState {
-    screen: ModelEditorScreen;
-    draft: ModelEditorDraft;
-    /** Catalog capabilities for `draft.modelId`; recomputed on every pick. */
-    capabilities: GatewayModelCapabilities | undefined;
-}
-/** Semantic input after terminal-key decoding. */
-export type ModelEditorEvent = {
-    type: "move";
-    direction: "up" | "down";
-} | {
-    type: "adjust";
-    direction: "left" | "right";
-} | {
-    type: "char";
-    char: string;
-} | {
-    type: "backspace";
-} | {
-    type: "cancel";
-} | {
-    type: "submit";
-};
-export type ModelEditorTransition = {
-    kind: "ignore";
-    state: ModelEditorState;
-} | {
-    kind: "render";
-    state: ModelEditorState;
-} | {
-    kind: "cancel";
-} | {
-    kind: "settle";
-    result: ModelSettingsResult;
-};
-/**
- * How a value row presents: an adjustable control, a dim explanatory line the
- * cursor skips, or nothing at all — a control that cannot apply to the
- * drafted model (no priority tier) is noise, while an authored-but-unowned
- * state (custom tier, external provider) still explains itself.
- */
-export type ModelEditorSectionView = {
-    kind: "interactive";
-} | {
-    kind: "static";
-    text: string;
-} | {
-    kind: "hidden";
-};
-/**
- * The reasoning row stays interactive while a level is drafted even when the
- * catalog disowns reasoning, so the authored value at least stays visible.
- */
-export declare function reasoningSectionView(request: ModelSettingsRequest, draft: ModelEditorDraft, capabilities: GatewayModelCapabilities | undefined): ModelEditorSectionView;
-/** The tier row's presentation; static or hidden for every state it cannot own. */
-export declare function tierSectionView(request: ModelSettingsRequest, capabilities: GatewayModelCapabilities | undefined): ModelEditorSectionView;
-/**
- * The track's notch positions: the levels the catalog supports (every level
- * when capabilities are unknown). The provider default is not a notch — an
- * unset draft renders an empty track and the first right-adjust enters the
- * scale at the lowest level. A drafted level the catalog does not list is
- * inserted in canonical level order, so the track never hides the value it
- * is about to replace.
- */
-export declare function reasoningPositions(capabilities: GatewayModelCapabilities | undefined, drafted: "default" | ReasoningLevel): readonly ReasoningLevel[];
-/**
- * The value menu's rows, derived fresh from the draft on every transition and
- * paint: interactive sections are pickable rows, static sections are disabled
- * rows carrying their explanation, and a hidden tier is omitted entirely.
- * Value hints are the painter's job — it styles them with theme glyphs.
- */
-export declare function modelEditorMenuRows(request: ModelSettingsRequest, draft: ModelEditorDraft, capabilities: GatewayModelCapabilities | undefined): SelectOption<ModelEditorRowId>[];
-/** Creates the screen's state; the cursor opens on the first pickable row. */
-export declare function initialModelEditorState(request: ModelSettingsRequest): ModelEditorState;
-/** Applies one keypress worth of semantics; terminal resources stay in the renderer. */
-export declare function transitionModelEditor(state: ModelEditorState, event: ModelEditorEvent, request: ModelSettingsRequest): ModelEditorTransition;

package/dist/src/cli/dev/tui/model-editor.js

@@ -1 +0,0 @@
-import{ALL_REASONING_LEVELS}from"#setup/boxes/model-capabilities.js";import{filterOptions,initialSelectState,reduceSelect,selectValueAtCursor}from"#setup/cli/select-state.js";const NOT_EDITABLE_TEXT=`No editable agent.ts config object is available`;function reasoningSectionView(e,t,n){return e.settingsEditable?n?.reasoning===!1&&t.reasoning==="default"?{kind:`static`,text:`Not supported by the selected model`}:{kind:`interactive`}:{kind:`static`,text:NOT_EDITABLE_TEXT}}function tierSectionView(e,t){return e.settingsEditable?e.externalRouting?{kind:`static`,text:`Disabled for a direct external provider`}:e.serviceTier.kind===`custom`?{kind:`static`,text:`Custom (${e.serviceTier.value}) — authored in agent.ts`}:t!==void 0&&!t.fastMode?{kind:`hidden`}:{kind:`interactive`}:{kind:`static`,text:NOT_EDITABLE_TEXT}}function reasoningPositions(e,t){let n=[...e===void 0?ALL_REASONING_LEVELS:e.reasoningLevels];if(t!=="default"&&!n.includes(t)){let e=ALL_REASONING_LEVELS.indexOf(t),r=n.findIndex(t=>ALL_REASONING_LEVELS.indexOf(t)>e);r===-1?n.push(t):n.splice(r,0,t)}return n}function snapReasoningToCapabilities(e,t){if(e==="default"||t===void 0)return e;let n=t.reasoningLevels;if(!t.reasoning||n.length===0)return`default`;if(n.includes(e))return e;let r=ALL_REASONING_LEVELS.indexOf(e),i=n[0];for(let e of n)Math.abs(ALL_REASONING_LEVELS.indexOf(e)-r)<Math.abs(ALL_REASONING_LEVELS.indexOf(i)-r)&&(i=e);return i}function modelEditorMenuRows(e,t,n){let r=[];e.model.kind===`pick`?r.push({value:`model`,label:`Model`}):r.push({value:`model`,label:`Model`,disabled:!0,description:e.model.reason});let i=reasoningSectionView(e,t,n);i.kind===`static`?r.push({value:`reasoning`,label:`Reasoning effort`,disabled:!0,description:i.text}):r.push({value:`reasoning`,label:`Reasoning effort`});let a=tierSectionView(e,n);return a.kind===`interactive`?r.push({value:`tier`,label:`Service tier`}):a.kind===`static`&&r.push({value:`tier`,label:`Service tier`,disabled:!0,description:a.text}),r}function initialModelEditorState(e){let t={modelId:e.model.current,reasoning:e.reasoning??`default`,tier:e.serviceTier.kind===`priority`?`priority`:`standard`},n=e.capabilitiesFor(t.modelId);return{screen:{kind:`menu`,cursor:modelEditorMenuRows(e,t,n).find(e=>e.disabled!==!0)?.value??`done`},draft:t,capabilities:n}}function expandedModelSelect(e,t){let n={options:e.model.kind===`pick`?e.model.options:[]};return t!==null&&(n.defaultValue=t),initialSelectState(n)}function ignore(e){return{kind:`ignore`,state:e}}function toMenu(e,t){return{kind:`render`,state:{...e,screen:{kind:`menu`,cursor:t}}}}function settleResult(e,t){let n={};if(e.model.kind===`pick`&&t.modelId!==null&&t.modelId!==e.model.current&&(n.model=t.modelId),!e.settingsEditable)return n;t.reasoning!==(e.reasoning??`default`)&&(n.reasoning=t.reasoning);let r=!e.externalRouting&&e.serviceTier.kind!==`custom`,i=e.serviceTier.kind===`priority`?`priority`:`standard`;return r&&t.tier!==i&&(n.serviceTier=t.tier),n}function adjustMenuValue(e,t,n,r){let i=r===`left`?-1:1;if(n===`reasoning`){if(reasoningSectionView(t,e.draft,e.capabilities).kind!==`interactive`)return ignore(e);let n=reasoningPositions(e.capabilities,e.draft.reasoning);if(n.length===0)return ignore(e);let r=e.draft.reasoning==="default"?-1:n.indexOf(e.draft.reasoning),a=r===-1?n[i===1?0:n.length-1]:n[(r+i+n.length)%n.length];return a===e.draft.reasoning?ignore(e):{kind:`render`,state:{...e,draft:{...e.draft,reasoning:a}}}}if(n===`tier`){if(tierSectionView(t,e.capabilities).kind!==`interactive`)return ignore(e);let n=e.draft.tier===`priority`?`standard`:`priority`;return{kind:`render`,state:{...e,draft:{...e.draft,tier:n}}}}return ignore(e)}function transitionMenu(e,t,n,r){let i=modelEditorMenuRows(n,e.draft,e.capabilities);switch(t.type){case`cancel`:return{kind:`cancel`};case`move`:{let n=Math.max(0,i.findIndex(e=>e.value===r)),a=i[reduceSelect({filter:``,cursor:n,selected:new Set},{type:t.direction},{options:i}).cursor]?.value;return a===void 0||a===r?ignore(e):toMenu(e,a)}case`adjust`:return adjustMenuValue(e,n,r,t.direction);case`submit`:{let t=i.find(e=>e.value===r);return t===void 0||t.disabled===!0?ignore(e):r===`model`?{kind:`render`,state:{...e,screen:{kind:`model`,select:expandedModelSelect(n,e.draft.modelId)}}}:{kind:`settle`,result:settleResult(n,e.draft)}}case`char`:case`backspace`:return ignore(e)}}function transitionModelScreen(e,t,n,r){let i=n.model.kind===`pick`?n.model.options:[],renderSelect=t=>t===r?ignore(e):{kind:`render`,state:{...e,screen:{kind:`model`,select:t}}};switch(t.type){case`cancel`:return r.filter.length>0?renderSelect(reduceSelect(r,{type:`clear`},{options:i})):toMenu(e,`model`);case`move`:return renderSelect(reduceSelect(r,{type:t.direction},{options:i}));case`char`:return renderSelect(reduceSelect(r,{type:`char`,char:t.char},{options:i}));case`backspace`:return renderSelect(reduceSelect(r,{type:`backspace`},{options:i}));case`submit`:{let t=filterOptions(i,r.filter),a=selectValueAtCursor(t,r.cursor);if(a===void 0)return ignore(e);let o=n.capabilitiesFor(a);return{kind:`settle`,result:settleResult(n,{...e.draft,modelId:a,reasoning:snapReasoningToCapabilities(e.draft.reasoning,o),tier:o!==void 0&&!o.fastMode?`standard`:e.draft.tier})}}case`adjust`:return ignore(e)}}function transitionModelEditor(e,t,n){switch(e.screen.kind){case`menu`:return transitionMenu(e,t,n,e.screen.cursor);case`model`:return transitionModelScreen(e,t,n,e.screen.select)}}export{initialModelEditorState,modelEditorMenuRows,reasoningPositions,reasoningSectionView,tierSectionView,transitionModelEditor};

package/dist/src/compiled/_chunks/node/chunk-5OX2R7AJ-CxVV-owP.js

@@ -1 +0,0 @@
-var e=class extends Error{body;status;constructor(e,t){super(e),this.name=`TwilioApiError`,this.body=t.body,this.status=t.status}},t=`https://api.twilio.com`;async function n(t,n){let r=t??process.env[n];if(!r)throw new e(`${n} is required`,{body:null,status:0});return typeof r==`function`?await r():r}async function r(r,i={}){let a=typeof r==`string`?{...i,path:r}:r,o=await n(a.credentials?.accountSid,`TWILIO_ACCOUNT_SID`),s=await n(a.credentials?.authToken,`TWILIO_AUTH_TOKEN`),c=new URL(a.path,a.apiUrl??a.apiBaseUrl??t);for(let[e,t]of d(a.search)??[])c.searchParams.append(e,t);let l=d(a.body),u=await(a.fetch??fetch)(c,{body:l,headers:{authorization:f(o,s),...l?{"content-type":`application/x-www-form-urlencoded;charset=UTF-8`}:{}},method:a.method??`POST`}),p=await m(u);if(!u.ok)throw new e(`Twilio API returned HTTP ${u.status}`,{body:p,status:u.status});return{body:p,ok:u.ok,status:u.status}}async function i(e){let t=await n(e.credentials?.accountSid,`TWILIO_ACCOUNT_SID`),i=p(e.mediaUrl);if(!e.body&&i.length===0)throw TypeError(`body or mediaUrl is required`);if(!(e.from||e.messagingServiceSid))throw TypeError(`from or messagingServiceSid is required`);let a=u({Body:e.body,From:e.from,MediaUrl:i,MessagingServiceSid:e.messagingServiceSid,StatusCallback:e.statusCallbackUrl,To:e.to});return(await r(`/2010-04-01/Accounts/${encodeURIComponent(t)}/Messages.json`,{...e,body:a})).body}async function a(e){let t=await n(e.credentials?.accountSid,`TWILIO_ACCOUNT_SID`);return(await r(`/2010-04-01/Accounts/${encodeURIComponent(t)}/Messages/${encodeURIComponent(e.messageSid)}.json`,{...e,method:`GET`})).body}async function o(e){let t=await n(e.credentials?.accountSid,`TWILIO_ACCOUNT_SID`);await r(`/2010-04-01/Accounts/${encodeURIComponent(t)}/Messages/${encodeURIComponent(e.messageSid)}.json`,{...e,method:`DELETE`})}async function s(e){let t=await n(e.credentials?.accountSid,`TWILIO_ACCOUNT_SID`);if(!(e.twiml||e.url||e.status))throw TypeError(`twiml, url, or status is required`);if(e.twiml&&e.url)throw TypeError(`twiml and url are mutually exclusive`);let i=u({Method:e.method,Status:e.status,Twiml:e.twiml,Url:e.url});return(await r(`/2010-04-01/Accounts/${encodeURIComponent(t)}/Calls/${encodeURIComponent(e.callSid)}.json`,{...e,body:i})).body}async function c(t){let r=await n(t.credentials?.accountSid,`TWILIO_ACCOUNT_SID`),i=await n(t.credentials?.authToken,`TWILIO_AUTH_TOKEN`),a=await(t.fetch??fetch)(t.url,{headers:{authorization:f(r,i)},method:`GET`});if(!a.ok)throw new e(`Twilio API returned HTTP ${a.status}`,{body:await m(a),status:a.status});return a.arrayBuffer()}async function l(e={}){let t=await n(e.credentials?.accountSid,`TWILIO_ACCOUNT_SID`),i=u({From:e.from,PageSize:e.pageSize,To:e.to});return((await r(`/2010-04-01/Accounts/${encodeURIComponent(t)}/Messages.json`,{...e,method:`GET`,search:i})).body.messages??[]).slice(0,e.limit)}function u(e){let t=new URLSearchParams;for(let[n,r]of Object.entries(e))if(r!=null){if(Array.isArray(r)){for(let e of r)t.append(n,e);continue}t.set(n,String(r))}return t}function d(e){if(e!==void 0)return e instanceof URLSearchParams?e:u(e)}function f(e,t){return`Basic ${btoa(`${e}:${t}`)}`}function p(e){return e===void 0?[]:typeof e==`string`?[e]:[...e]}async function m(e){let t=await e.text();if(!t)return null;try{return JSON.parse(t)}catch{return t}}export{c as a,n as c,u as i,i as l,r as n,a as o,o as r,l as s,e as t,s as u};

package/dist/src/compiled/_chunks/node/chunk-AYN7QRWH-B__hKQV7.js

@@ -1 +0,0 @@
-var e=/[<>|]/,t=/[\^|>]/,n=/^[A-Z0-9_]+$/,r=/(?<![<\w])@([A-Z][A-Z0-9_]+)/g,i=3e3;function a(e){return e.replace(/&/g,`&amp;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function o(e){return e.replace(/&lt;/g,`<`).replace(/&gt;/g,`>`).replace(/&amp;/g,`&`)}function s(e,t={}){return v(e),{...t.emoji===void 0?{}:{emoji:t.emoji},text:e,type:`plain_text`}}function c(e,t={}){return v(e),{text:e,type:`mrkdwn`,...t.verbatim===void 0?{}:{verbatim:t.verbatim}}}function l(e){return y(e,`userId`),`<@${e}>`}function u(e){return y(e,`channelId`),`<#${e}>`}function d(e){return y(e,`userGroupId`),`<!subteam^${e}>`}function f(e){return`<!${e}>`}function p(e,t){return b(e,`url`),t?`<${e}|${a(t)}>`:`<${e}>`}function m(e,t,n,r={}){x(t,`token`);let i=e instanceof Date?Math.floor(e.getTime()/1e3):e;if(!Number.isInteger(i))throw TypeError(`timestamp must be an integer unix timestamp or Date`);return`<!date^${i}^${t}${r.link?`^${S(r.link)}`:``}|${a(n)}>`}function h(e){let t=e;return t=t.replace(/<@([A-Z0-9_]+)\|([^<>]+)>/g,`@$2`),t=t.replace(/<@([A-Z0-9_]+)>/g,`@$1`),t=t.replace(/<#[A-Z0-9_]+\|([^<>]+)>/g,`#$1`),t=t.replace(/<#([A-Z0-9_]+)>/g,`#$1`),t=t.replace(/<(https?:\/\/[^|<>]+)\|([^<>]+)>/g,`[$2]($1)`),t=t.replace(/<(https?:\/\/[^<>]+)>/g,`$1`),t=t.replace(/(?<![_*\\])\*([^*\n]+)\*(?![_*])/g,`**$1**`),t=t.replace(/(?<!~)~([^~\n]+)~(?!~)/g,`~~$1~~`),o(t)}function g(e){return e.replace(/\*\*(.+?)\*\*/g,`*$1*`)}function _(e){return e.replace(r,`<@$1>`)}function v(e){if(e.length<1||e.length>i)throw TypeError(`text must be between 1 and ${i} characters`)}function y(e,t){if(!n.test(e))throw TypeError(`${t} must be a Slack ID`)}function b(t,n){if(e.test(t))throw TypeError(`${n} cannot contain Slack control characters`)}function x(e,n){if(t.test(e))throw TypeError(`${n} cannot contain Slack date control characters`)}function S(e){return x(e,`link`),e}export{m as a,l as c,g as d,h as f,u as i,d as l,s as n,p as o,o as p,a as r,f as s,c as t,_ as u};

package/dist/src/compiled/_chunks/node/chunk-QZV7YRVM-Dzw4WEBv.js

@@ -1 +0,0 @@
-import{c as e}from"./chunk-5OX2R7AJ-CxVV-owP.js";function t(e){let t=r(e,`MessageStatus`)??r(e,`SmsStatus`),i=r(e,`Body`),a=r(e,`From`),o=r(e,`To`),s=r(e,`MessageSid`)??r(e,`SmsMessageSid`);return t&&!i?{accountSid:r(e,`AccountSid`),from:a,kind:`status`,messageSid:s,messageStatus:t,raw:e,to:o}:a&&o&&(i!==void 0||Number(r(e,`NumMedia`)??0)>0)?{accountSid:r(e,`AccountSid`),body:i??``,from:a,kind:`text`,media:n(e),messageSid:s,raw:e,to:o}:{kind:`unsupported`,raw:e}}function n(e){let t=Number(r(e,`NumMedia`)??0),n=[];for(let i=0;i<t;i++){let t=r(e,`MediaUrl${i}`);t&&n.push({contentType:r(e,`MediaContentType${i}`),url:t})}return n}function r(e,t){let n=e.get(t);return n===null||n.length===0?void 0:n}var i=class extends Error{constructor(e){super(e),this.name=`TwilioWebhookError`}},a=class extends i{constructor(e){super(e),this.name=`TwilioWebhookParseError`}},o=class extends i{constructor(e){super(e),this.name=`TwilioWebhookVerificationError`}};async function s(t,n={}){let r=await t.text();if(n.webhookVerifier){let e=await n.webhookVerifier(t,r);if(!e)throw new o(`Twilio webhook verifier rejected the request`);return{body:typeof e==`string`?e:r,params:d(t,typeof e==`string`?e:r)}}let i=t.headers.get(`x-twilio-signature`);if(!i)throw new o(`Twilio signature header is required`);let a=await e(n.authToken,`TWILIO_AUTH_TOKEN`),s=await u(t,n.webhookUrl),l=d(t,r);if(!p(await c({authToken:a,params:t.method.toUpperCase()===`GET`?null:l,url:s}),i))throw new o(`Twilio signature is invalid`);return{body:r,params:l}}async function c(e){let t=await crypto.subtle.importKey(`raw`,new TextEncoder().encode(e.authToken),{hash:`SHA-1`,name:`HMAC`},!1,[`sign`]);return f(await crypto.subtle.sign(`HMAC`,t,new TextEncoder().encode(l(e.url,e.params))))}function l(e,t){if(!t)return e;let n=e,r=new Map;for(let[e,n]of t){let t=r.get(e)??new Set;t.add(n),r.set(e,t)}for(let e of[...r.keys()].sort())for(let t of[...r.get(e)??[]].sort())n+=`${e}${t}`;return n}async function u(e,t){return typeof t==`function`?t(e):t??e.url}function d(e,t){return e.method.toUpperCase()===`GET`?new URL(e.url).searchParams:new URLSearchParams(t)}function f(e){let t=``,n=new Uint8Array(e);for(let e of n)t+=String.fromCharCode(e);return btoa(t)}function p(e,t){let n=Math.abs(e.length-t.length),r=Math.max(e.length,t.length);for(let i=0;i<r;i++){let r=e.charCodeAt(i)||0,a=t.charCodeAt(i)||0;n+=Number(r!==a)}return n===0}async function m(e,n={}){return t((await s(e,n)).params)}export{m as a,l as c,t as i,s as l,a as n,u as o,o as r,c as s,i as t};