agent-accelerator 0.5.4 → 0.5.6

package/README.md

@@ -121,11 +121,13 @@ An `Agent` holds:
 | `tools`           | `Record<string, ToolDefinition> \| ToolDefinition[]` | Deterministic functions the model can call. See [Tools](#tools).                                                                                          |
 | `subagents`       | `SubAgent[] \| Agent[]`                              | Pre-defined workers. Each worker becomes a callable tool. Useful for fixed roles such as researcher or critic.                                             |
 | `subagentModel`   | `string \| ModelSpec \| ModelProviderInstance`       | Developer-only model for dynamically spawned workers. Never choosable by the Main Agent. Deprecated alias of `dynamicSubagents.model` (which wins). Falls back to `SUB_AGENT_MODEL`. |
-| `dynamicSubagents` | `DynamicSubagentsConfig`                            | Enables and constrains LLM-spawned workers: `{ enabled, model?, maxSpawn?, maxDepth?, workerBudget?, thinkingLevel?, tools?, timeout?, allowScheduledActions? }` (`timeout` is for scheduled actions only). See [Pre-defined vs Dynamic Delegation](#pre-defined-vs-dynamic-delegation) and [Scheduled actions](#scheduled-actions). |
+| `dynamicSubagents` | `DynamicSubagentsConfig`                            | Enables and constrains LLM-spawned workers: `{ enabled, model?, maxSpawn?, maxDepth?, workerBudget?, thinkingLevel?, tools?, workerTimeoutMs?, allowScheduledActions? }` (`workerTimeoutMs` is for scheduled actions only). See [Pre-defined vs Dynamic Delegation](#pre-defined-vs-dynamic-delegation) and [Scheduled actions](#scheduled-actions). |
 | `thinking`        | `ThinkingOption`                                     | Canonical reasoning option: `none \| dynamic \| minimal \| low \| medium \| high \| xhigh \| max`, or `{ level, budgetTokens }`. Legacy `thinkingLevel` still works (canonical wins). Validated against the model catalog before a request.                                      |
 | `cache`           | `CacheOption`                                        | `"implicit" \| "5m" \| "30m" \| "1h" \| "12h"`. Prompt-cache lifetime; unsupported values warn and fall back (see [Cache](#cache)).                                                                             |
 | `serviceTier`     | `"flex" \| "priority"`                               | Cost / priority routing where supported. Omit for standard routing.                                                                                        |
 | `maxTurns`        | `number`                                             | Maximum model → tool → model loops per `run`. Infinite by default (`0` or omitted = no limit). Hitting a finite limit with pending tool calls warns and sets `finishReason: "max_turns"`. |
+| `limits`          | `AgentRunLimits`                                     | `{ maxTurns?, deadlineMs?, maxToolCallsPerRun?, maxTotalTokens?, requestTimeoutMs?, firstByteTimeoutMs?, streamIdleTimeoutMs? }`. The first four are unlimited by default. The three network timeouts default to 300 s / 120 s / 300 s so a silent connection fails instead of hanging; set one to `0` or `Infinity` to turn it off. A timeout raises a retryable `TimeoutError`. See [Safety and operations](docs/guides/safety-and-ops.md#network-timeouts). |
+| `budget`          | `Budget`                                             | `{ maxCostUsd?, maxTotalTokens?, maxDurationMs?, maxTotalSubagents? }`, per run, workers included. Unlimited by default; exceeding it throws `BudgetExceededError` with partial usage. |
 | `sessionId`       | `string`                                             | Stable identifier used for cache affinity. Auto-generated when omitted.                                                                                    |
 | `headers`         | `Record<string,string>`                              | Additional headers merged into every request.                                                                                                              |
 | `apiKey`          | `string`                                             | Overrides environment-based API-key lookup for this agent.                                                                                                 |
@@ -144,6 +146,11 @@ When `dynamicSubagents.enabled` is set without a resolvable worker model, constr
 await agent.run(prompt, opts?) // non-streaming, or streaming when opts.stream is true
 agent.ask(prompt, optsOrBool?) // deprecated (use run): string deltas when streaming, otherwise same as run
 agent.stream(prompt, opts?) // AssistantMessageEventStream
+agent.steer(prompt) / agent.queue(prompt) // while busy: join the active run / start after it
+agent.interrupt() // stop the active run now (provider request aborted, stream cancelled, tools get ctx.signal)
+await agent.interrupt(message) // stop it AND run `message` next, ahead of queued follow-ups (stream: opts.enqueue = "interrupt")
+agent.toConfig() // { model, instructions, tools }: the part an agent may edit, plain JSON (no keys)
+Agent.fromConfig(editable, base) // new Agent: your full `base` config + an agent's edits of model/instructions/tools only
 agent.reset() // clears messages + signatures, keeps config
 agent.exportSession(telemetry?) // storable snapshot for saveSessionFile
 agent.importSession(saved) // restores messages + config from loadSessionFile
@@ -170,7 +177,8 @@ Use `ContentPart[]` when sending images, audio, or video alongside text.
 | `additionalContext`             | Added only to the current user turn. Keeps the system prompt stable for better caching.                                                         |
 | `sessionId`                     | Per-run session override.                                                                                                                       |
 | `headers`                       | Per-run header merge.                                                                                                                           |
-| `signal`                        | `AbortSignal` used to cancel generation, tools, and subagents.                                                                                  |
+| `signal`                        | `AbortSignal` used to cancel generation, tools, and subagents. The provider request is aborted and a stream's body is cancelled; see [what interrupting stops at the provider](docs/guides/safety-and-ops.md#what-interrupting-stops-at-the-provider). |
+| `enqueue`                       | When the agent is busy: `"steer"` (join the active run), `"queue"` (run after it) or `"interrupt"` (stop it and run this prompt next, in every `midSession` mode). |
 
 ### Streaming
 
@@ -269,7 +277,7 @@ const agent = new Agent({
   instructions: "You are the Main Agent",
   dynamicSubagents: {
     enabled: true,
-    maxSpawn: 4, // open workers at once
+    maxSpawn: 4, // optional cap on open workers at once (default: no limit)
     thinkingLevel: "low",
     tools: { get_weather, recent_news }, // pool: the model grants a subset per worker
   },
@@ -280,10 +288,10 @@ One `subagents` tool is injected. It takes `{ command, id?, name?, role?, instru
 
 - `spawn` starts a worker (`name`, `task`; optional `instructions`, `role`, `tools`, `history`) and waits for its first reply. `message` sends `task` to an open worker `id`, which remembers the whole conversation. `close` frees the slot. `list` shows the open workers and the numbered finished turns that `history: N` can copy into a new worker.
 - Results are plain text with one header line: `[worker researcher-1a2b3c4d] replied:` + the worker's text, or `[worker researcher-1a2b3c4d] failed: <reason>`. Several `spawn` calls in one model turn run in parallel. A bad request comes back as an `Error: ...` line the model can fix.
-- `maxSpawn` is the limit on **open** workers (the model must close one to open another). `budget.maxTotalSubagents` still counts spawns per run.
+- `maxSpawn` caps **open** workers (the model must close one to open another); by default there is no cap. `budget.maxTotalSubagents` still counts spawns per run. Every budget and limit is off until you set it, except three network timeouts (see the `limits` row).
 - `tools` is the developer-owned pool. Workers get zero tools unless the Main Agent grants a subset by name; unknown names are rejected with the pool listed.
-- The Main Agent cannot choose worker models, reasoning levels or timeouts. The `subagents` tool has no timeouts (`workerTimeoutMs`/`timeout` apply only to scheduled actions).
-- `maxDepth` (default 3, whole number >= 1) is how many levels of workers may exist below the agent: `1` keeps workers flat, `3` lets a worker start workers that start workers. A worker with levels left gets its own `subagents` tool, and its children can only be granted the tools **it** was granted. The levels are saved inside each other (`<session>/workers/<id>/workers/<id>/…`).
+- The Main Agent cannot choose worker models, reasoning levels or timeouts. The `subagents` tool has no timeouts (`workerTimeoutMs` and an action's `timeoutMs` apply only to scheduled actions).
+- `maxDepth` caps how many levels of workers may exist below the agent. By default there is no cap (a worker can start workers that start workers, as deep as the model goes); set a whole number >= 1 to limit it: `1` keeps workers flat, `3` allows three levels. A worker with levels left gets its own `subagents` tool, and its children can only be granted the tools **it** was granted. The levels are saved inside each other (`<session>/workers/<id>/workers/<id>/…`).
 - `workerBudget: { maxCostUsd?, maxTotalTokens? }` is each worker's own spending cap, applied as that worker's per-run `budget` (a spawn, a message or a scheduled run is one run; the usage of the worker's own workers counts toward it) and passed down to its workers. Going over fails that call with a budget error (`[worker <id>] failed: Token budget exceeded…`), leaves the worker open and does not affect the parent. Default: unlimited; models with unknown pricing count $0 toward `maxCostUsd`. Values must be numbers above 0.
 - Workers are real agents with their own session: see [Persistent workers](#persistent-workers-agentworkers) below (the same functions in code, saved on disk with `persist`, resumed after a restart). Each reply's usage is metered into the parent's usage and budget.
 - Each run of a worker gets a system-generated 32-char TrackingID, displayed as `NAME-{TrackingID}`. Thinking/text deltas update the worker trace live (`agent.track(id)`, `subscribeToSubAgent`) and surface on the parent stream as `subagent_delta` events.
@@ -341,7 +349,7 @@ const agent = new Agent({
 });
 ```
 
-The Main Agent then gets two tools, fixed by config so the prompt cache stays stable: `scheduled_actions` (one tool, `command` = `create | list | get | update | kill | run_now | skip`) and `get_datetime` (the machine's local date and time, also exported as `getDatetimeTool`). The tool description is exactly [`src/scheduler/scheduled-actions.md`](src/scheduler/scheduled-actions.md) (the worker pool names are filled in), so you can read what the model is told.
+The Main Agent then gets two tools, fixed by config so the prompt cache stays stable: `scheduled_actions` (one tool, `command` = `create | list | get | update | delete | run_now | skip`) and `get_datetime` (the machine's local date and time, also exported as `getDatetimeTool`). The tool description is exactly [`src/scheduler/scheduled-actions.md`](src/scheduler/scheduled-actions.md) (the worker pool names are filled in), so you can read what the model is told.
 
 The same code is available to your program:
 
@@ -360,6 +368,7 @@ createScheduledAction(agent, {
     startCookingInAdvance: "00:00:30", // optional, a "DD:HH:MM" duration (default 10 minutes)
     repeatEvery: "01:00:00", // optional; omit to run once
     retries: 1, // optional; used only while time remains before delivery
+    onMissed: "run", // optional: "skip" | "run" if your program was down at delivery time (omit to decide later)
   },
 });
 
@@ -375,17 +384,19 @@ telemetryBus.onEvent((e) => {
 | `updateScheduledAction(id, patch, { home? })` | Change instructions, task, tools, timeout, role or any schedule field. Schedule changes are refused while it is cooking. |
 | `runScheduledAction(id, { home? })` | Run now, outside the schedule (also resolves a missed run). Needs the creating `Agent` alive. |
 | `skipScheduledAction(id, { home? })` | Ignore a missed run and wait for the next scheduled time. |
-| `killScheduledAction(id, { force?, purge?, home? })` | Delete for good. While it is cooking nothing changes unless `force: true`; `purge: true` also deletes past run files. |
+| `deleteScheduledAction(id, { force?, purge?, home? })` | Delete for good. While it is cooking nothing changes unless `force: true`; `purge: true` also deletes past run files. |
 
 **How it behaves**
 
 * **One local clock.** A single timer per home folder (guarded by a one-process lock, `<home>/.lock`) ticks once a second against the machine's own time and only asks what is overdue, so drift or sleep cannot skip a run. There is no timezone or daylight-saving logic. The timer is `unref`'d and runs only while something is pending, so actions run only while your process is alive.
 * **The creating `Agent` runs it.** The task stores the Agent's `name`; each run goes to the live Agent with that name (latest wins), using its worker model and tool pool. The scheduler holds only a weak reference, so keep your `Agent` referenced; if none is alive, the run counts as missed.
 * **Each run is fresh.** A new stateless dynamic sub-agent built from the saved fields, on your fixed worker model and tool pool, never touching the Main Agent's session. It inherits the parent's limits, retry policy, `fileAccess` and `captureRaw`.
-* **Files are the truth.** Everything lives in `<home>/scheduled_actions/`: `tasks.json` (every action), `deliveries.json` (saved results waiting for their delivery time) and one folder per action with one `.md` file per run (a small header, then the result). The file is re-read and validated before each run, so editing `instructions` or `task` there takes effect on the next run. API keys, the model and tool code are never stored. Don't put secrets in `instructions`.
-* **Ready, then delivered.** A finished run is saved immediately (`scheduled_action.ready`); at `timeToDeliver` the SDK emits `scheduled_action.delivered` on `telemetryBus` with `{ id, name, status, file, readyAt, deliverAt, late }`. There is no notification system: what happens next is your code. Other events: `.created`, `.updated`, `.started`, `.failed`, `.missed`, `.skipped`, `.killed`, plus the warnings `.invalid` and `.store_corrupt`.
+* **Files are the truth.** Everything lives in `<home>/scheduled_actions/` (the format is a stable contract with a changelog: [docs/scheduled-action-files.md](docs/scheduled-action-files.md)): `tasks.json` (every action), `deliveries.json` (saved results waiting for their delivery time) and one folder per action with one `.md` file per run (a small header, then the result). The file is re-read and validated before each run, so editing `instructions` or `task` there takes effect on the next run. API keys, the model and tool code are never stored. Don't put secrets in `instructions`.
+* **What a run costs.** Each run file's header records the run's exact spending, the same numbers `usageReport()` keeps for workers: `turns`, `tokens` (input + output), `inputTokens`, `freshInputTokens`, `cacheReadTokens`, `cacheWriteTokens`, `outputTokens`, `thinkingTokens`, `cacheHitRate` (0 to 1), `costUsd`, `costSource` (`provider`, `catalog`, `mixed` or `unknown`) and `unpricedTurns` (only when above 0, then `costUsd` is a lower bound). Unknown pricing is `costUsd: unknown`, never 0. The numbers cover every attempt of the run (`retries` included) and are recorded for failed runs too. The report itself does not list scheduled runs.
+* **Time limit of a run.** An action may carry `timeoutMs` (top level of the action, not inside `scheduled_action`): a run that takes longer is stopped and recorded as failed. By default there is no limit. `dynamicSubagents.workerTimeoutMs` is an optional ceiling: an action cannot ask for more, and it is the limit for actions that set none (`0` and `Infinity` mean no ceiling). The former `dynamicSubagents.timeout`, `modelMaySetTimeout` and the `-1` mode were removed; passing them throws a `ConfigError` that says what to use.
+* **Ready, then delivered.** A finished run is saved immediately (`scheduled_action.ready`); at `timeToDeliver` the SDK emits `scheduled_action.delivered` on `telemetryBus` with `{ id, name, status, file, readyAt, deliverAt, late }`. There is no notification system: what happens next is your code. Other events: `.created`, `.updated`, `.started`, `.failed`, `.missed`, `.skipped`, `.deleted`, plus the warnings `.invalid` and `.store_corrupt`.
 * **Overlap and failure.** A run still cooking when the next one is due is skipped, never stacked. A failed run still writes a file saying why and is delivered like any result (`status: "failed"`).
-* **Missed runs.** If the process was down when a run was due, the SDK emits `scheduled_action.missed` once and runs nothing by itself: pick `run_now` or `skip`. A result saved before the process exited is simply delivered (marked `late`) on the first tick after start.
+* **Missed runs.** If the process was down when a run was due, the SDK emits `scheduled_action.missed` once. By default it runs nothing by itself and the action waits as `missed`: pick `run_now` or `skip`. Set `scheduled_action.onMissed` per action to decide in advance: `"skip"` moves on to the next time (a one-shot is `done`; a `skipped` event follows), `"run"` runs it as soon as the program is back (delivered when it finishes, marked `late`). The same applies to a run a crash cut off. An action whose creating Agent is gone stays `missed` whatever `onMissed` says (nothing can run it). A result saved before the process exited is simply delivered (marked `late`) on the first tick after start. `late` means the result was delivered more than two ticks after its time, finished after its delivery second, or replaced a missed run. A `run_now` result is delivered when it finishes: it is `late` only when it replaces a missed run (a `run_now` on a `missed` action, or `onMissed: "run"`), never for an ordinary early run.
 
 ---
 ## Tools
@@ -702,9 +713,12 @@ Thinking levels map to `reasoning.effort` verbatim, the same as OpenAI (`dynamic
 It also:
 
 * passes `service_tier` (`flex` | `priority`);
-* enables the `file-parser` plugin when file parts are present (remote file URLs are additionally surfaced in text);
+* sends audio with its real format (`wav`, `mp3`, `aiff`, `aac`, `ogg`, `flac`, `m4a`) and QuickTime video as `video/mov`;
+* sends file parts as `file.file_data` (a public URL or a base64 data URL) and never adds a plugin: OpenRouter reads the file natively or with its own default parser;
 * maps `tool_choice` (`auto` omitted; `none`, `required`, and function pins supported);
-* reports `cached_tokens` / `cache_write_tokens` / reasoning tokens, preferring provider-reported `cost` when present.
+* treats an error chunk inside a stream (HTTP 200) like an HTTP error: its status comes from the chunk's `code`, or from its `error_type` (`rate_limit_exceeded` 429, `provider_overloaded` 503, `provider_unavailable` 502, `timeout` 504, `server` 500), so `runRetries` retries the retryable ones;
+* reports `cached_tokens` / `cache_write_tokens` / reasoning tokens, preferring provider-reported `cost` when present (a reported `0`, a free model or a cache hit, stays a known `$0`);
+* accepts `anthropic/...` and `~anthropic/...` model names for the `5m` / `1h` cache setting, and sends at most 4 `stop` sequences (the Chat Completions maximum; extra ones are dropped with one `provider_warning`).
 
 `serviceTier` values other than `flex` / `priority` are omitted (standard routing).
 
@@ -1048,7 +1062,7 @@ report.total;   // agent + all workers
 - **Own turns only.** Every agent records the model calls it made itself, priced **per turn** in integer micro-USD, and saves them in its session (`usage`), so the numbers survive a restart (load the session and the totals carry on; workers are rebuilt from their folders). A parent's `res.usage` already contains its workers' usage, which is why the report never adds responses together: `report.total.tokens.total` equals what the responses show.
 - **Cache-aware.** `input` includes the cache reads and writes (`freshInput = input - cacheRead - cacheWrite`); `output` includes `thinking`. Fresh input, cache reads and cache writes are each priced at their own catalog price, and `serviceTier` is applied. `cacheHitRate` is `cacheRead / input` (0 to 1, `null` when nothing was sent).
 - **Honest costs.** `cost.source` is `provider` (the provider reported the cost, which is exact), `catalog` (estimated from the model catalog), `mixed`, or `unknown`. Unknown pricing is `totalUsd: null`, never 0; `unpricedTurns` above 0 means the total is a lower bound. For turns whose cost the provider reported only the total is exact, so `parts` can add up to less than `totalUsd`.
-- **Not in the report:** the one-shot workers of scheduled actions (their cost is in each run file), and workers started inside a fixed `subagents` worker's per-call copy (their cost is in the response usage). `reset()` does not clear the totals: they are spending, not conversation.
+- **Not in the report:** the one-shot workers of scheduled actions (their exact cost is in each run file's header), and workers started inside a fixed `subagents` worker's per-call copy (their cost is in the response usage). `reset()` does not clear the totals: they are spending, not conversation.
 
 ### ProviderRawData
 
@@ -1289,8 +1303,11 @@ documents. The supported lists are the `GOOGLE_*_MIME` constants at the top of
 `resolution` (`MediaResolution`: `"low" | "medium" | "high" | "ultra_high"`)
 sets how much detail Google spends on one image or video, and so how many
 input tokens it costs (image: 280 / 560 / 1120 / 2240; video per frame:
-`low` and `medium` 70, `high` 280). Omit it for Google's default. Other
-providers ignore it with one `provider_warning`.
+`low` and `medium` 70, `high` 280). Omit it for Google's default. On
+OpenRouter an image's `resolution` is sent as `image_url.detail` (`low` → `low`,
+`medium` → `auto`, `high` → `high`, `ultra_high` → `original`, which OpenRouter
+downgrades to `high` where unsupported); a video's `resolution` is ignored. Other
+providers (and OpenRouter videos) ignore it with one `provider_warning`.
 
 Before any network call, the executor checks `image` / `audio` / `video` /
 `file`-as-PDF parts against the catalog's `modalities.input` for that
@@ -1348,7 +1365,7 @@ bun run examples/11-session-identity.ts
 # sub-agent TrackingIDs, live worker boxes, lineage, track(), durable sessions
 
 bun run examples/12-mid-session.ts
-# steer, queue and stream while a turn is running
+# steer, queue and stream while a turn is running (interrupt() stops it; interrupt(message) stops it and runs the message)
 
 bun run examples/13-structured-output.ts
 # JSON Schema structured outputs on every provider

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-accelerator",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "High-performance SDK for AI agents with a unified API across AI providers. Optimized for high cache hit rates, observability, and seamless agent orchestration. Built to power production-grade agentic systems and harnesses for teams at any scale.",
   "license": "MIT",
   "author": "Sashvat Bharat",

package/src/agent/agent.ts

@@ -1,7 +1,7 @@
-import type { AgentConfig, AgentRunOptions, MidSessionConfig, ToolChoiceOption, RetryPolicyConfig, Budget, BudgetState, InterruptedRun } from "../types/agent.ts";
+import type { AgentConfig, EditableAgentConfig, AgentRunOptions, MidSessionConfig, ToolChoiceOption, RetryPolicyConfig, Budget, BudgetState, InterruptedRun } from "../types/agent.ts";
 import type { TokenUsage } from "../types/core.ts";
 import type { ProviderRequestOptions } from "../types/model.ts";
-import { normalizeThinkingV2, resolveWhenBusy, normalizeWorkerTimeout } from "../tools/tool.ts";
+import { normalizeThinkingV2, resolveWhenBusy } from "../tools/tool.ts";
 import type { ToolDefinition, ToolResultRecord } from "../types/tool.ts";
 import { isSubagentResult } from "../tools/subagent-result.ts";
 import { CACHE_OPTIONS, type ThinkingLevel, type ThinkingConfig, type CacheOption, type ServiceTier } from "../types/core.ts";
@@ -25,6 +25,7 @@ import { resolveHome } from "../scheduler/store.ts";
 import { persistTelemetry } from "../telemetry-file.ts";
 import { lockFolder } from "../utils/durable.ts";
 import { createScheduledActionsTool, getDatetimeTool } from "../scheduler/tool.ts";
+import { applyEditable, assertModelAllowed, modelKey, toEditableConfig } from "./config-blocks.ts";
 import { assertNoToolCollisions } from "../tools/executor.ts";
 import { runAgentLoop, streamAgentLoop, unfinishedToolCalls, endsWithStop, accumulateUsage, type SteerEntry } from "./loop.ts";
 import { isRetryableRun, readRetryAfterMs, sleep } from "../utils/retry.ts";
@@ -95,6 +96,8 @@ function resolveAgentLimits(config: { limits?: Record<string, unknown> }): Agent
   const raw = (config as { limits?: Record<string, unknown> }).limits ?? {};
   const num = (v: unknown): number | undefined =>
     typeof v === "number" && Number.isFinite(v) ? v : undefined;
+  // A network timeout: `0` or `Infinity` turns it off, any other number is milliseconds, anything else is unset (the default applies).
+  const timeout = (v: unknown): number | undefined => (typeof v === "number" && !Number.isNaN(v) ? v : undefined);
   return {
     ...(num(raw.maxTurns) !== undefined ? { maxTurns: Math.max(1, Math.floor(num(raw.maxTurns)!)) } : {}),
     ...(num(raw.deadlineMs) !== undefined ? { deadlineMs: num(raw.deadlineMs)! } : {}),
@@ -102,9 +105,9 @@ function resolveAgentLimits(config: { limits?: Record<string, unknown> }): Agent
       ? { maxToolCallsPerRun: Math.max(1, Math.floor(num(raw.maxToolCallsPerRun)!)) }
       : {}),
     ...(num(raw.maxTotalTokens) !== undefined ? { maxTotalTokens: Math.max(1, Math.floor(num(raw.maxTotalTokens)!)) } : {}),
-    requestTimeoutMs: num(raw.requestTimeoutMs) ?? 300_000,
-    firstByteTimeoutMs: num(raw.firstByteTimeoutMs) ?? 120_000,
-    streamIdleTimeoutMs: num(raw.streamIdleTimeoutMs) ?? 300_000,
+    requestTimeoutMs: timeout(raw.requestTimeoutMs) ?? 300_000,
+    firstByteTimeoutMs: timeout(raw.firstByteTimeoutMs) ?? 120_000,
+    streamIdleTimeoutMs: timeout(raw.streamIdleTimeoutMs) ?? 300_000,
   };
 }
 
@@ -165,13 +168,15 @@ export class Agent {
   readonly dynamicSubagents?: {
     enabled: boolean;
     model?: string | any;
+    /** Open workers at once; `Infinity` (the default) = no limit. */
     maxSpawn: number;
     thinkingLevel?: ThinkingLevel;
     tools: Record<string, ToolDefinition>;
-    timeout: number;
+    /** Longest a scheduled run may take, in ms; `Infinity` (the default) = no limit. */
+    workerTimeoutMs: number;
     /** Scheduled actions (`scheduled_actions` + `get_datetime` tools) are on. */
     allowScheduledActions: boolean;
-    /** Levels of workers allowed below this agent. */
+    /** Levels of workers allowed below this agent; `Infinity` (the default) = no limit. */
     maxDepth: number;
     /** Per-run spending cap of each worker (unset = unlimited). */
     workerBudget?: { maxCostUsd?: number; maxTotalTokens?: number };
@@ -257,6 +262,8 @@ export class Agent {
     deferredStream?: AssistantMessageEventStream;
     resolve: (res: AgentResponse) => void;
     reject: (err: unknown) => void;
+    /** Put here by `interrupt(message)`: runs before every other waiting prompt. */
+    urgent?: boolean;
   }> = [];
   /** Named session contexts for `sessionId` runs (Q-19a, LRU 100 + TTL). */
   private sessions = new Map<string, { context: AgentContext; lastAccess: number }>();
@@ -311,6 +318,7 @@ export class Agent {
     // ModelProviderInstance {model,apiKey,...} and ModelSpec {id,provider}.
     const { modelStringOrSpec, rawModel } = resolveMainModel(config.model);
     this.modelStringOrSpec = modelStringOrSpec as string | any;
+    assertModelAllowed(config.allowedModels, modelKey(modelStringOrSpec));
     const dynRaw = config.dynamicSubagents;
     // Unified worker-model chain: dynamicSubagents.model > subagentModel > SUB_AGENT_MODEL.
     const dynModel = resolveDynamicModelInput(dynRaw, config.subagentModel);
@@ -319,8 +327,9 @@ export class Agent {
     if (dynRaw) {
       const dynTools = normalizeToolMap((dynRaw as { tools?: Record<string, ToolDefinition> | ToolDefinition[] }).tools);
       const rawDepth = (dynRaw as { maxDepth?: unknown }).maxDepth;
-      if (rawDepth !== undefined && !(Number.isInteger(rawDepth) && (rawDepth as number) >= 1)) {
-        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.maxDepth ${JSON.stringify(rawDepth)}: expected a whole number >= 1 (default ${DEFAULT_MAX_DEPTH}); set dynamicSubagents.enabled: false to turn workers off.`);
+      // Depth is unlimited unless the developer sets a cap (a whole number >= 1; Infinity also means unlimited).
+      if (rawDepth !== undefined && rawDepth !== Infinity && !(Number.isInteger(rawDepth) && (rawDepth as number) >= 1)) {
+        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.maxDepth ${JSON.stringify(rawDepth)}: expected a whole number >= 1, or omit it for no limit; set dynamicSubagents.enabled: false to turn workers off.`);
       }
       const rawBudget = (dynRaw as { workerBudget?: { maxCostUsd?: unknown; maxTotalTokens?: unknown } }).workerBudget;
       for (const key of ["maxCostUsd", "maxTotalTokens"] as const) {
@@ -329,17 +338,30 @@ export class Agent {
           throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.workerBudget.${key} ${JSON.stringify(v)}: expected a number greater than 0, or omit it for no limit.`);
         }
       }
-      const rawMax = (dynRaw as any)?.maxSpawn;
-      const maxSpawn = Number.isFinite(rawMax) ? Math.max(1, Math.floor(rawMax as number)) : 4;
-      // `workerTimeoutMs ?? timeout`, or -1 when `modelMaySetTimeout` (see normalizeWorkerTimeout).
-      const timeout = normalizeWorkerTimeout(dynRaw as { timeout?: number; workerTimeoutMs?: number; modelMaySetTimeout?: boolean });
+      // Open workers are unlimited unless the developer sets a cap (a number >= 1; Infinity also means unlimited).
+      const rawMax = (dynRaw as { maxSpawn?: unknown }).maxSpawn;
+      if (rawMax !== undefined && (typeof rawMax !== "number" || Number.isNaN(rawMax))) {
+        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.maxSpawn ${JSON.stringify(rawMax)}: expected a whole number >= 1, or omit it for no limit.`);
+      }
+      const maxSpawn = rawMax === undefined || rawMax === Infinity ? Infinity : Math.max(1, Math.floor(rawMax));
+      // Only scheduled actions are timed: no limit unless the developer sets one (0 and Infinity mean none).
+      for (const removed of ["timeout", "modelMaySetTimeout"]) {
+        if ((dynRaw as Record<string, unknown>)[removed] !== undefined) {
+          throw new ConfigError(`[Agent Accelerator] dynamicSubagents.${removed} was removed: set dynamicSubagents.workerTimeoutMs (the longest a scheduled run may take, optional) and let each scheduled action carry its own timeoutMs.`);
+        }
+      }
+      const rawTimeout = (dynRaw as { workerTimeoutMs?: unknown }).workerTimeoutMs;
+      if (rawTimeout !== undefined && (typeof rawTimeout !== "number" || Number.isNaN(rawTimeout) || rawTimeout < 0)) {
+        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.workerTimeoutMs ${JSON.stringify(rawTimeout)}: expected a number of milliseconds > 0, or omit it (0 and Infinity mean no limit).`);
+      }
+      const workerTimeoutMs = !rawTimeout ? Infinity : Math.max(1, Math.floor(rawTimeout));
       this.dynamicSubagents = {
         enabled: dynEnabled,
         model: dynModel as string | any | undefined,
         maxSpawn,
         thinkingLevel: (dynRaw as any)?.thinkingLevel,
         tools: dynTools,
-        timeout,
+        workerTimeoutMs,
         allowScheduledActions: dynRaw.allowScheduledActions === true,
         maxDepth: (rawDepth as number | undefined) ?? DEFAULT_MAX_DEPTH,
         ...(rawBudget ? { workerBudget: { ...(rawBudget as { maxCostUsd?: number; maxTotalTokens?: number }) } } : {}),
@@ -805,22 +827,46 @@ export class Agent {
   }
 
   /**
-   * Interrupts the active run immediately (STOP. Do this instead).
-   * Cancels the active stream and aborts provider/tool/sub-agent work via
-   * the run's internal `AbortController`. No-op when idle. The interrupted
-   * run rejects with `AbortError`; queued follow-ups still run afterwards.
+   * Stops the active run now (STOP.) and, given a message, starts it next (STOP. Do this instead). The provider
+   * request is aborted (connection closed, so the provider stops generating where it can), the stream is cancelled, and
+   * running tools and workers get the abort signal; the interrupted run rejects with `AbortError` and keeps its partial
+   * history. `interrupt()` and `interrupt(error)` only stop (no-op when idle) and return nothing. `interrupt(message)`
+   * also runs `message` as the next run, ahead of queued follow-ups, in every `midSession` mode, and resolves with that
+   * run's response; when idle it simply runs the message. For a stream use `stream(message, { enqueue: "interrupt" })`.
    */
-  interrupt(reason?: unknown): void {
+  interrupt(reason?: Error): void;
+  interrupt(message: string | ContentPart[], options?: AgentRunOptions): Promise<AgentResponse>;
+  interrupt(arg?: Error | string | ContentPart[], options?: AgentRunOptions): void | Promise<AgentResponse> {
+    if (typeof arg === "string" || Array.isArray(arg)) {
+      if (options?.stream === true) {
+        throw new Error('[Agent Accelerator] interrupt(message) is non-streaming. Use stream(prompt, { enqueue: "interrupt" }) for a streaming interrupt.');
+      }
+      return this.run(arg, { ...options, enqueue: "interrupt" });
+    }
+    this.abortActive(arg instanceof Error ? arg : undefined);
+  }
+
+  // Aborts the active run (provider request, tools, workers, stream) through its own controller; no-op when idle; in: interrupt and queueUrgent, out: the run settles as AbortError.
+  private abortActive(reason?: Error): void {
     const active = this.currentRun;
     if (!active) return;
     try {
-      active.abortController.abort(reason instanceof Error ? reason : new Error("Agent interrupted"));
+      active.abortController.abort(reason ?? new Error("Agent interrupted"));
     } catch {}
     try {
       active.outerStream?.cancel(reason);
     } catch {}
   }
 
+  // Puts a prompt ahead of everything waiting (behind earlier interrupts) and aborts the active run, so it starts as soon as that run has settled; ignores midSession mode and maxQueued; in: run()/stream() with enqueue "interrupt", out: pendingQueue + the abort.
+  private queueUrgent(entry: Agent["pendingQueue"][number]): void {
+    entry.urgent = true;
+    const firstOrdinary = this.pendingQueue.findIndex((e) => !e.urgent);
+    this.pendingQueue.splice(firstOrdinary < 0 ? this.pendingQueue.length : firstOrdinary, 0, entry);
+    this.persistNow();
+    this.abortActive();
+  }
+
   /**
    * Steers the active turn (While you're doing that, change direction).
    * The current provider/tool work finishes first, then `prompt` is injected
@@ -1009,7 +1055,9 @@ export class Agent {
             reject: entry.settle?.reject ?? (() => {}),
           });
         }
-        this.pendingQueue.unshift(...lateSteers);
+        // ...but behind an interrupt(message), which is the newest and most urgent instruction.
+        const firstOrdinary = this.pendingQueue.findIndex((e) => !e.urgent);
+        this.pendingQueue.splice(firstOrdinary < 0 ? this.pendingQueue.length : firstOrdinary, 0, ...lateSteers);
       } catch {}
     }
     this.persistNow();
@@ -1105,6 +1153,24 @@ export class Agent {
     return copy;
   }
 
+  /**
+   * The part of this agent that an agent may edit, as plain JSON: `{ model, instructions, tools }` (`model` is the
+   * `provider/model` string, never a key; `tools` are the names of the tools you passed in `tools`). Store it, show it
+   * to the model, and rebuild with {@link Agent.fromConfig}.
+   */
+  toConfig(): Required<EditableAgentConfig> {
+    return toEditableConfig(this.modelStringOrSpec, this.instructions, this.forkConfig.tools);
+  }
+
+  /**
+   * Builds an Agent from your full `base` config with an agent's edits applied. Only `model`, `instructions` and
+   * `tools` of `editable` count (other keys are ignored with a `config.not_editable` warning); `tools` are names picked
+   * from `base.tools`, an unknown name throws; `base.allowedModels` is enforced. Keys and limits always come from `base`.
+   */
+  static fromConfig(editable: EditableAgentConfig, base: AgentConfig): Agent {
+    return new Agent(applyEditable(editable, base));
+  }
+
   /** Budgets are per run: counters restart whenever a new run begins. */
   private resetBudgetState(): void {
     if (this.budget) this.budgetState = { spawned: 0, totalTokens: 0, totalCostUsd: 0, startedAtMs: nowMs() };
@@ -1690,8 +1756,11 @@ export class Agent {
       return s;
     }
 
-    // Mid-session: busy agent serializes via steer (same turn) or queue (next turn).
+    // Mid-session: busy agent serializes via steer (same turn) or queue (next turn), or stops the active run and starts this prompt (interrupt).
     if (this.currentRun) {
+      if (options?.enqueue === "interrupt") {
+        return new Promise<AgentResponse>((resolve, reject) => this.queueUrgent({ prompt, options, isStream: false, resolve, reject }));
+      }
       const enforced = this.midSessionConfig.mode;
       const requested = options?.enqueue;
       if (requested && (enforced === "steer" || enforced === "queue") && requested !== enforced) {
@@ -1805,13 +1874,14 @@ export class Agent {
     // Mid-session: busy agent serializes via steer (same turn) or queue (next turn).
     if (this.currentRun) {
       const enforcedStream = this.midSessionConfig.mode;
-      const requestedStream = options?.enqueue;
+      const urgent = options?.enqueue === "interrupt"; // stops the active run and goes first, in every mode and whatever the queue holds
+      const requestedStream = options?.enqueue === "interrupt" ? undefined : options?.enqueue;
       if (requestedStream && (enforcedStream === "steer" || enforcedStream === "queue") && requestedStream !== enforcedStream) {
         throw new Error(
           `[Agent Accelerator] enqueue "${requestedStream}" is disabled by midSession.mode "${enforcedStream}". Use ${enforcedStream}() or set mode to "auto"/"${requestedStream}".`
         );
       }
-      const mode = this.resolveEnqueueMode(requestedStream);
+      const mode = urgent ? "queue" : this.resolveEnqueueMode(requestedStream);
       if (mode === "steer") {
         this.assertPromptValid(prompt);
         this.assertSteerRoom(this.currentRun.steerInbox);
@@ -1844,14 +1914,14 @@ export class Agent {
         }
         return stub;
       }
-      if (this.midSessionConfig.mode === "steer") {
+      if (!urgent && this.midSessionConfig.mode === "steer") {
         throw new Error(
           '[Agent Accelerator] enqueue "queue" is disabled by midSession.mode "steer". Use steer() or set mode to "auto"/"queue".'
         );
       }
       this.assertPromptValid(prompt);
       const max = this.midSessionConfig.maxQueued ?? 20;
-      if (this.pendingQueue.length >= max) {
+      if (!urgent && this.pendingQueue.length >= max) {
         throw new Error(
           `[Agent Accelerator] Queue is full (${this.pendingQueue.length}/${max}). Wait for the active run to finish or increase midSession.maxQueued.`
         );
@@ -1859,13 +1929,15 @@ export class Agent {
       const deferred = new AssistantMessageEventStream();
       this.wireStreamCallbacks(deferred, options);
       // Notify the active stream (if any) that a follow-up was queued.
-      try {
-        this.currentRun.outerStream?.push({
-          type: "queued",
-          queuedPrompt: this.previewPrompt(prompt),
-          queueLength: this.pendingQueue.length + 1,
-        } as any);
-      } catch {}
+      if (!urgent) {
+        try {
+          this.currentRun.outerStream?.push({
+            type: "queued",
+            queuedPrompt: this.previewPrompt(prompt),
+            queueLength: this.pendingQueue.length + 1,
+          } as any);
+        } catch {}
+      }
       const queuedEntry: {
         prompt: string | ContentPart[];
         options?: AgentRunOptions;
@@ -1901,8 +1973,12 @@ export class Agent {
           }
         } catch {}
       });
-      this.pendingQueue.push(queuedEntry as any);
-      this.persistNow();
+      if (urgent) {
+        this.queueUrgent(queuedEntry as Agent["pendingQueue"][number]);
+      } else {
+        this.pendingQueue.push(queuedEntry as any);
+        this.persistNow();
+      }
       // Attach deferred completion to queued promise without exposing it.
       // Real events are piped in pumpQueue() when the turn starts.
       void done.then(

package/src/agent/config-blocks.ts

@@ -0,0 +1,80 @@
+import type { AgentConfig, EditableAgentConfig } from "../types/agent.ts";
+import type { ToolDefinition } from "../types/tool.ts";
+import { ConfigError } from "../types/errors.ts";
+import { telemetryBus } from "../session/store.ts";
+import { normalizeToolMap } from "./worker.ts";
+
+// The building blocks for self-improving agents (RSI): an agent may edit ONLY `model`, `instructions` and `tools`;
+// everything else (limits, budgets, cache, thinking, keys, ...) stays with the developer who wrote `base`.
+
+const EDITABLE_FIELDS = ["model", "instructions", "tools"] as const;
+
+// The model as a plain `provider/id` string (a string stays as written, a ModelSpec becomes `provider/id`); in: Agent.modelStringOrSpec or a base `model`, out: toConfig, the allowedModels check, applyEditable.
+export function modelKey(model: unknown): string | undefined {
+  if (typeof model === "string") return model.trim() || undefined;
+  const m = model as { model?: unknown; id?: unknown; provider?: unknown } | null | undefined;
+  if (m && typeof m.model === "string") return m.model.trim() || undefined;
+  if (m && typeof m.id === "string" && typeof m.provider === "string") return `${m.provider}/${m.id}`;
+  return undefined;
+}
+
+// Throws when `allowedModels` is set and the model is not in it (entries are compared as written, e.g. "google/gemini-3.5-flash"); in: AgentConfig.allowedModels + the model, out: the Agent constructor and applyEditable.
+export function assertModelAllowed(allowed: unknown, model: string | undefined): void {
+  if (allowed === undefined) return;
+  if (!Array.isArray(allowed) || allowed.length === 0 || allowed.some((m) => typeof m !== "string" || !m.trim())) {
+    throw new ConfigError(`[Agent Accelerator] Invalid allowedModels ${JSON.stringify(allowed)}: expected a non-empty list of "provider/model" strings, or omit it to allow any model.`);
+  }
+  if (!model || !allowed.includes(model)) {
+    throw new ConfigError(`[Agent Accelerator] Model ${JSON.stringify(model ?? null)} is not in allowedModels. Allowed: ${allowed.map((m) => JSON.stringify(m)).join(", ")}.`);
+  }
+}
+
+// The editable part of an agent as plain JSON; in: the Agent's model, instructions and the developer's tool list (not the built-in delegation/scheduler tools), out: Agent.toConfig.
+export function toEditableConfig(model: unknown, instructions: string, tools: AgentConfig["tools"]): Required<EditableAgentConfig> {
+  return { model: modelKey(model) ?? "", instructions, tools: Object.keys(normalizeToolMap(tools)) };
+}
+
+// Merges what an agent edited into the developer's config: only model/instructions/tools can change; tools are names picked from base.tools; the model is checked against allowedModels when the Agent is built; in: Agent.fromConfig args, out: the AgentConfig for `new Agent`.
+export function applyEditable(editable: EditableAgentConfig, base: AgentConfig): AgentConfig {
+  if (!editable || typeof editable !== "object" || Array.isArray(editable)) {
+    throw new ConfigError(`[Agent Accelerator] Invalid editable config ${JSON.stringify(editable)}: expected an object like { model, instructions, tools } (see Agent.toConfig()).`);
+  }
+  const e = editable as Record<string, unknown>;
+  const ignored = Object.keys(e).filter((k) => !(EDITABLE_FIELDS as readonly string[]).includes(k) && e[k] !== undefined);
+  if (ignored.length > 0) {
+    telemetryBus.emitWarning(
+      "config.not_editable",
+      `[Agent Accelerator] Ignored ${ignored.map((k) => `"${k}"`).join(", ")} in the editable config: an agent can change only ${EDITABLE_FIELDS.join(", ")}. The rest comes from the developer's config.`,
+      { fields: ignored }
+    );
+  }
+  const out: AgentConfig = { ...base };
+  if (e.model !== undefined) {
+    const next = typeof e.model === "string" ? e.model.trim() : "";
+    if (!next) throw new ConfigError(`[Agent Accelerator] Invalid editable model ${JSON.stringify(e.model)}: expected a "provider/model" string.`);
+    // A model helper's key and base URL belong to its own provider: they are never sent to another one.
+    const prev = base.model as { model?: unknown; apiKey?: string; baseUrl?: string } | string | undefined;
+    const sameProvider = next.includes("/") && next.split("/")[0] === modelKey(prev)?.split("/")[0];
+    out.model = prev && typeof prev === "object" && typeof prev.model === "string"
+      ? { ...prev, model: next, ...(sameProvider ? {} : { apiKey: undefined, baseUrl: undefined }) }
+      : next;
+  }
+  if (e.instructions !== undefined) {
+    if (typeof e.instructions !== "string") throw new ConfigError(`[Agent Accelerator] Invalid editable instructions: expected a string, got ${typeof e.instructions}.`);
+    out.instructions = e.instructions;
+  }
+  if (e.tools !== undefined) {
+    if (!Array.isArray(e.tools) || e.tools.some((n) => typeof n !== "string")) {
+      throw new ConfigError(`[Agent Accelerator] Invalid editable tools ${JSON.stringify(e.tools)}: expected a list of tool names from the developer's tool pool.`);
+    }
+    const pool = normalizeToolMap(base.tools);
+    const unknown = (e.tools as string[]).filter((n) => !Object.hasOwn(pool, n));
+    if (unknown.length > 0) {
+      throw new ConfigError(`[Agent Accelerator] Unknown tool ${unknown.map((n) => JSON.stringify(n)).join(", ")} in the editable config. Available: ${Object.keys(pool).map((n) => JSON.stringify(n)).join(", ") || "none"}.`);
+    }
+    const picked: Record<string, ToolDefinition> = {};
+    for (const n of e.tools as string[]) picked[n] = pool[n]!;
+    out.tools = picked;
+  }
+  return out; // allowedModels is enforced by the Agent constructor
+}

package/src/agent/loop.ts

@@ -342,9 +342,11 @@ function resolveLoopLimits(config: AgentLoopConfig, fallbackMaxTurns: number): L
   const deadlineMs = num(raw.deadlineMs) ?? Infinity;
   const maxToolCallsPerRun = num(raw.maxToolCallsPerRun) ?? Infinity;
   const maxTotalTokens = num(raw.maxTotalTokens) ?? Infinity;
-  const requestTimeoutMs = num(raw.requestTimeoutMs) ?? 300_000;
-  const firstByteTimeoutMs = num(raw.firstByteTimeoutMs) ?? 120_000;
-  const streamIdleTimeoutMs = num(raw.streamIdleTimeoutMs) ?? 300_000;
+  // A network timeout: `0` or `Infinity` turns it off, any other number is milliseconds, anything else is unset (the default applies).
+  const timeout = (v: unknown): number | undefined => (typeof v === "number" && !Number.isNaN(v) ? v : undefined);
+  const requestTimeoutMs = timeout(raw.requestTimeoutMs) ?? 300_000;
+  const firstByteTimeoutMs = timeout(raw.firstByteTimeoutMs) ?? 120_000;
+  const streamIdleTimeoutMs = timeout(raw.streamIdleTimeoutMs) ?? 300_000;
   return { maxTurns, deadlineMs, maxToolCallsPerRun, maxTotalTokens, requestTimeoutMs, firstByteTimeoutMs, streamIdleTimeoutMs };
 }
 
@@ -416,7 +418,7 @@ async function generateWithTimeout<T>(task: () => Promise<T>, timeoutMs: number)
 /** Prices one usage snapshot with the one cost model (`priceUsage`): provider-reported total first, else catalog pricing scaled by `serviceTier`; undefined when unknown. In: loop turns and `accumulateUsage`, out: `usage.cost`. */
 export function computeCostFromPricing(usage: TokenUsage, spec?: ModelSpec, serviceTier?: string): TokenUsage["cost"] {
   try {
-    if (usage.cost && usage.cost.totalCost !== undefined && usage.cost.totalCost > 0) {
+    if (usage.cost && typeof usage.cost.totalCost === "number" && usage.cost.totalCost >= 0) {
       return usage.cost;
     }
     if (!spec) return usage.cost;

package/src/agent/subagents-tool.ts

@@ -29,11 +29,11 @@ function asResult(reply: WorkerReply): ReturnType<typeof makeSubagentResult> {
 /** Builds the `subagents` tool for `agent`; its description is the manual with the worker pool and the open-worker limit filled in. */
 export function createSubagentsTool(agent: Agent): ToolDefinition {
   const poolNames = Object.keys(agent.dynamicSubagents?.tools ?? {});
-  const max = agent.dynamicSubagents?.maxSpawn ?? 4;
+  const max = agent.dynamicSubagents?.maxSpawn ?? Infinity;
   return tool({
     name: "subagents",
     description: loadManual()
-      .replace(/\{\{MAX\}\}/g, String(max))
+      .replace("{{LIMIT}}", Number.isFinite(max) ? `You can have at most ${max} open workers. Close the ones you are done with.` : "There is no limit on open workers. Close the ones you are done with: each one keeps its whole conversation.")
       .replace("{{TOOLS}}", poolNames.length > 0 ? poolNames.join(", ") : "none (omit tools)"),
     input: z.object({
       command: z.enum(COMMANDS),

package/src/agent/subagents.md

@@ -3,7 +3,7 @@ Starts helpers ("workers") that work on a task for you and can be asked again la
 COMMANDS (one tool, the `command` field)
 - spawn: start a worker. Needs `name` and `task`. Optional: `instructions` (the worker's own system prompt), `role`, `tools`, `history`. It waits for the worker's first reply and gives you the worker's `id`.
 - message: send `task` to the open worker `id`. The worker remembers everything said to it before. It waits for the reply.
-- close: end the worker `id` when you no longer need it. This frees one of your {{MAX}} open slots. A closed worker cannot be messaged again.
+- close: end the worker `id` when you no longer need it. A closed worker cannot be messaged again.
 - list: your open workers, plus the numbered turns of this conversation that `history` can copy.
 
 FIELDS
@@ -25,7 +25,7 @@ Ask it a follow-up:
 RULES
 - Several workers at once: make several spawn calls in the same turn. They run in parallel.
 - A worker handles one call at a time. Wait for its reply before messaging it again.
-- You can have at most {{MAX}} open workers. Close the ones you are done with.
+- {{LIMIT}}
 - A worker starts blank: put everything it needs in `instructions` and `task`, or copy earlier turns with `history`.
 - Worker answers are written by another model. Check them before you rely on them.
 - Never put secrets in `instructions` or `task`.