agents 0.21.0 → 0.22.0

package/docs/mcp-client.md

@@ -13,6 +13,61 @@ The MCP client capability lets your agent:
 
 > **Note:** This page covers connecting to MCP servers as a client. To create your own MCP server, see [Creating MCP Servers](./mcp-servers.md).
 
+## Compose the MCP client with a Durable Object
+
+`MCPClientManager` is a lifecycle capability. A class can extend the platform
+`DurableObject` directly and install the manager without extending `Agent`:
+
+```typescript
+import { DurableObject } from "cloudflare:workers";
+import { Lifecycle } from "agents/lifecycle";
+import { MCPClientManager } from "agents/mcp/client";
+
+export class MyObject extends DurableObject<Env> {
+  readonly mcp = new MCPClientManager("my-object", "1.0.0");
+
+  readonly lifecycle = Lifecycle.install(this).use(this.mcp);
+
+  onRequest() {
+    return Response.json({ tools: this.mcp.listTools() });
+  }
+}
+```
+
+The lifecycle calls the manager automatically:
+
+- `onStart()` initializes its schema and restores persisted connections before
+  the host handles work.
+- `onRequest()` intercepts registered OAuth callback URLs before the host's
+  request handler.
+
+Do not call these hooks manually. For a native Durable Object RPC method,
+which bypasses `fetch`, call `await this.lifecycle.start()` before using the
+manager. Explicit cleanup remains available through `mcp.dispose()`; Durable
+Objects do not provide an eviction callback.
+
+The manager does not require a particular OAuth callback route. Pass the exact
+callback URL to `registerServer()` and route that request to the same named
+Durable Object. The manager persists the URL and only intercepts a callback
+whose origin and pathname match it.
+
+An HTTP-only manager does not need `env`. Pass the Durable Object environment
+when the catalog can contain RPC servers so persisted binding names can be
+resolved after a wake:
+
+```ts
+readonly mcp = new MCPClientManager("my-object", "1.0.0", {
+  env: this.env
+});
+```
+
+If an RPC row exists without `env`, startup logs a warning identifying the
+server and does not recreate that connection.
+
+`Agent` installs this same capability object directly. Existing `this.mcp`,
+`addMcpServer()`, `removeMcpServer()`, and `getMcpServers()` APIs remain
+available.
+
 ## Quick Start
 
 Install the exact MCP client peer used by this Agents release:

package/docs/observability.md

@@ -158,17 +158,17 @@ These events are emitted by `AIChatAgent` from `@cloudflare/ai-chat`. They track
 
 ### Chat recovery events
 
-| Type                      | Payload                                                                  | When                                                                                                                                                                                                                                                                                                                                      |
-| ------------------------- | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `chat:request:failed`     | `{ requestId?, stage, messagesPersisted?, error }`                       | A Think chat request fails while parsing, persisting, running, or streaming                                                                                                                                                                                                                                                               |
-| `chat:recovery:detected`  | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | An interrupted chat fiber is first observed                                                                                                                                                                                                                                                                                               |
-| `chat:recovery:attempt`   | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | The framework begins a recovery attempt                                                                                                                                                                                                                                                                                                   |
-| `chat:recovery:scheduled` | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | A retry or continuation callback is scheduled                                                                                                                                                                                                                                                                                             |
-| `chat:recovery:completed` | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | Recovery completed successfully                                                                                                                                                                                                                                                                                                           |
-| `chat:recovery:skipped`   | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind, reason? }` | Recovery was skipped because the conversation changed or was no longer recoverable                                                                                                                                                                                                                                                        |
-| `chat:recovery:failed`    | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind, reason? }` | Recovery ran but failed                                                                                                                                                                                                                                                                                                                   |
-| `chat:recovery:exhausted` | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind, reason }`  | Recovery exceeded its configured attempt budget                                                                                                                                                                                                                                                                                           |
-| `chat:stream:stalled`     | `{ requestId, timeoutMs }`                                               | The inactivity watchdog fired — no stream chunk arrived within `chatStreamStallTimeoutMs`. With `chatRecovery` on (the default) the turn then routes into bounded recovery (look for `chat:recovery:*`); with recovery off it terminalizes. See [Think configuration](https://github.com/cloudflare/agents/blob/main/docs/think/index.md) |
+| Type                      | Payload                                                                  | When                                                                                                                                                                                                                                                             |
+| ------------------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `chat:request:failed`     | `{ requestId?, stage, messagesPersisted?, error }`                       | A Think chat request fails while parsing, persisting, running, or streaming                                                                                                                                                                                      |
+| `chat:recovery:detected`  | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | An interrupted chat fiber is first observed                                                                                                                                                                                                                      |
+| `chat:recovery:attempt`   | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | The framework begins a recovery attempt                                                                                                                                                                                                                          |
+| `chat:recovery:scheduled` | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | A retry or continuation callback is scheduled                                                                                                                                                                                                                    |
+| `chat:recovery:completed` | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind }`          | Recovery completed successfully                                                                                                                                                                                                                                  |
+| `chat:recovery:skipped`   | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind, reason? }` | Recovery was skipped because the conversation changed or was no longer recoverable                                                                                                                                                                               |
+| `chat:recovery:failed`    | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind, reason? }` | Recovery ran but failed                                                                                                                                                                                                                                          |
+| `chat:recovery:exhausted` | `{ incidentId, requestId, attempt, maxAttempts, recoveryKind, reason }`  | Recovery exceeded its configured attempt budget                                                                                                                                                                                                                  |
+| `chat:stream:stalled`     | `{ requestId, timeoutMs }`                                               | The inactivity watchdog fired — no stream chunk arrived within `chatStreamStallTimeoutMs`. The turn then routes into bounded recovery; look for `chat:recovery:*`. See [Think configuration](https://github.com/cloudflare/agents/blob/main/docs/think/index.md) |
 
 `recoveryKind` is `"retry"` when recovery replays an unanswered user turn and `"continue"` when it continues a partial assistant turn.
 

package/docs/resumable-streaming.md

@@ -2,7 +2,7 @@
 
 The `AIChatAgent` class provides **automatic resumable streaming** out of the box. When a client disconnects and reconnects during an active stream, the response automatically resumes from where it left off.
 
-This is client reconnect recovery, not Durable Object eviction recovery. If the Worker process or Durable Object is evicted while the model call is in flight, enable `chatRecovery` so the turn runs inside a recoverable fiber. `Think` enables `chatRecovery` by default; plain `AIChatAgent` subclasses opt in with `override chatRecovery = true`.
+This is client reconnect recovery, not Durable Object eviction recovery. Durable Object eviction recovery is also always enabled for `AIChatAgent` and `Think`: every turn runs inside a recoverable fiber. Use `chatRecovery` only to tune its budgets and terminal behavior.
 
 ## How It Works
 

package/docs/scheduling.md

@@ -15,6 +15,91 @@ The scheduling system supports four modes:
 
 Under the hood, scheduling uses [Durable Object alarms](https://developers.cloudflare.com/durable-objects/api/alarms/) to wake the agent at the right time. Tasks are stored in a SQLite table and executed in order.
 
+## Scheduler Lifecycle primitive
+
+> **Experimental.** The `Scheduler` primitive and the `agents/lifecycle`
+> surface it builds on may change between releases. Agent's established
+> scheduling methods (`this.schedule()` and friends) are stable.
+
+`Scheduler` is a reusable Lifecycle capability. A plain Lifecycle Object can
+install it without extending `Agent`:
+
+```typescript
+import { DurableObject } from "cloudflare:workers";
+import { Lifecycle } from "agents/lifecycle";
+import { Scheduler, type Schedule } from "agents/schedules";
+
+export class ReminderObject extends DurableObject<Env> {
+  readonly scheduler = new Scheduler({
+    callbacks: {
+      sendReminder: (
+        payload: { message: string },
+        schedule: Schedule<{ message: string }>
+      ) => {
+        console.log(schedule.id, payload.message);
+      }
+    }
+  });
+
+  readonly lifecycle = Lifecycle.install(this).use(this.scheduler);
+
+  async createReminder(message: string): Promise<string> {
+    const schedule = await this.scheduler.set(300, "sendReminder", {
+      message
+    });
+    return schedule.id;
+  }
+}
+```
+
+Lifecycle owns the physical Durable Object alarm. Scheduler contributes its
+earliest pending task or hung-interval recheck. Lifecycle selects the earliest
+contribution from Scheduler, other capabilities, and the host, then rearms after
+every alarm phase. A future Fiber or MCP capability can contribute its own wake
+time without storing work in Scheduler or depending on it.
+
+Scheduler's primary API is small: callbacks are registered by name in the
+constructor, `set()` and `every()` create schedules typed against that
+registration, and `get()`, `list()`, and `cancel()` manage them. All of these
+are asynchronous and work inside routed sub-agents.
+
+Scheduler Lifecycle hooks run without ambient host context. Registered
+callbacks are user code, so they run inside the host invocation context with
+the Lifecycle Object available through `getCurrentAgent()`.
+
+## Using Scheduler through Agent
+
+Every `Agent` constructs and installs the same primitive at `this.scheduler`.
+Existing Agent applications continue to use the established methods:
+
+- `this.schedule()` and `this.scheduleEvery()` create schedules.
+- `this.getScheduleById()` and `this.listSchedules()` read schedules.
+- `this.cancelSchedule()` removes a schedule.
+
+These methods delegate to `this.scheduler`; no setup or migration is required.
+Agent registers no callbacks map — a composition-root resolver keeps
+`this.schedule(60, "methodName")` dispatching to Agent methods. Agent passes
+only policy options (retry defaults, hung-interval timeout, error routing) and
+adapts Lifecycle's event sink, facet transport, and host invocation boundary
+at its composition root — there is no Agent-specific Scheduler adapter. Scheduler contributes its next wake time to the same Lifecycle alarm
+selection as Agent keep-alive, fibers, sub-agent work, and deferred
+destruction.
+
+Import `Scheduler` and runtime schedule types from the dependency-light entry
+point:
+
+```typescript
+import {
+  Scheduler,
+  type Schedule,
+  type ScheduleCriteria
+} from "agents/schedules";
+```
+
+Natural-language parsing helpers use Zod and live under
+`agents/schedules/parser`. The previous `agents/schedule` path remains as a
+deprecated compatibility alias.
+
 ## Quick Start
 
 ```typescript
@@ -299,9 +384,9 @@ This is the recommended approach since you cannot forget to dispose the heartbea
 
 ### How it works
 
-`keepAlive()` uses an in-memory reference count and the Durable Object alarm system directly. Each call increments the count; the disposer decrements it. While the count is above zero, `_scheduleNextAlarm()` ensures an alarm fires every 30 seconds, which resets the inactivity timer. No schedule rows are created and no observability events are emitted — the heartbeat is invisible to `listSchedules()` and the `agents:schedule` diagnostics channel.
+`keepAlive()` uses an in-memory reference count. Each call increments the count; the disposer decrements it. While the count is above zero, Agent contributes a wake time every 30 seconds to Lifecycle. No schedule rows are created and no observability events are emitted, so the heartbeat is invisible to `listSchedules()` and the scheduling diagnostics channel.
 
-The heartbeat does not conflict with your own schedules — the alarm system multiplexes all schedules and the keepAlive heartbeat through a single alarm slot.
+The heartbeat does not conflict with scheduled work. Lifecycle selects one physical alarm from both contributions.
 
 Inside sub-agents, `keepAlive()` delegates that heartbeat ref to the top-level parent because facets do not have independent alarm slots. `keepAliveWhile()` works the same way because it calls `keepAlive()` and automatically disposes the delegated ref when the scoped work completes.
 
@@ -642,14 +727,14 @@ class TimezoneAgent extends Agent {
 
 ## AI-Assisted Scheduling
 
-The SDK includes utilities for parsing natural language scheduling requests with AI.
+The SDK includes utilities for parsing natural language scheduling requests with AI. Import them from `agents/schedules/parser`.
 
 ### getSchedulePrompt()
 
 Returns a system prompt for parsing natural language into scheduling parameters:
 
 ```typescript
-import { getSchedulePrompt, scheduleSchema } from "agents";
+import { getSchedulePrompt, scheduleSchema } from "agents/schedules/parser";
 import { generateObject } from "ai";
 import { openai } from "@ai-sdk/openai";
 
@@ -703,7 +788,7 @@ class SmartScheduler extends Agent {
 A Zod schema for validating parsed scheduling data:
 
 ```typescript
-import { scheduleSchema } from "agents";
+import { scheduleSchema } from "agents/schedules/parser";
 
 // The schema uses a discriminated union on `when.type`:
 // {
@@ -751,7 +836,81 @@ When using this schema with OpenAI models via the AI SDK, you must pass `provide
 
 ## API Reference
 
-### schedule()
+Two surfaces share these semantics: the experimental `Scheduler` primitive
+(`agents/schedules`, methods on the scheduler instance) and the stable `Agent`
+methods (on the Agent class, delegating to `this.scheduler`).
+
+### Scheduler primitive
+
+#### `new Scheduler(options?)`
+
+```typescript
+new Scheduler({
+  callbacks?,
+  retry?,
+  hungScheduleTimeoutSeconds?,
+  onError?
+});
+```
+
+- `callbacks` registers scheduled callbacks by name. `set()` and `every()`
+  type both the name and the payload against this map, and dispatch runs the
+  registered function — the typed scheduling surface and the runtime dispatch
+  target are the same object.
+- Lifecycle supplies storage, readiness, startup state, alarm coordination,
+  the host invocation boundary, events, and routing.
+- `retry` supplies callback retry defaults. The defaults are three attempts,
+  100 ms base delay, and 3,000 ms maximum delay.
+- `hungScheduleTimeoutSeconds` defaults to 30 seconds.
+- `onError` observes terminal callback failures outside ambient host context.
+
+Install the constructed object with `Lifecycle.use()` before use. Scheduler
+starts Lifecycle automatically when its asynchronous API is entered. It
+publishes `schedule:*` events through Lifecycle's best-effort event bus. A plain
+Lifecycle Object writes them to the existing `agents:schedule` diagnostics
+channel; `Agent` sends them through its existing observability implementation.
+
+#### set()
+
+```typescript
+async set(when, callback, payload?, options?): Promise<Schedule<Payload>>
+```
+
+Create a one-shot or cron schedule. `when`, `options`, idempotency, and return
+value follow [`schedule()`](#schedule) below. `callback` must be a name
+registered in the constructor's `callbacks` map, and `payload` is typed
+against that callback's first parameter.
+
+#### every()
+
+```typescript
+async every(intervalSeconds, callback, payload?, options?): Promise<Schedule<Payload>>
+```
+
+Create a fixed-interval schedule. Semantics follow
+[`scheduleEvery()`](#scheduleevery) below, and `every()` also accepts
+`options.idempotent` to opt out of interval dedup.
+
+#### get() / list() / cancel()
+
+```typescript
+async get(id): Promise<Schedule<unknown> | undefined>
+async list(criteria?): Promise<Schedule<unknown>[]>
+async cancel(id): Promise<boolean>
+```
+
+Read and cancel schedules — the primitive's equivalents of
+[`getScheduleById()`](#getschedulebyid), [`listSchedules()`](#listschedules),
+and [`cancelSchedule()`](#cancelschedule) below. (Internal synchronous
+variants on the Scheduler back Agent's deprecated `getSchedule()` and
+`getSchedules()`; they are not part of the primitive's contract.)
+
+### Agent methods
+
+Methods on the `Agent` class, delegating to `this.scheduler`. Callback names
+resolve to methods on the Agent.
+
+#### schedule()
 
 ```typescript
 async schedule<T = string>(
@@ -789,7 +948,7 @@ class MyAgent extends Agent {
 }
 ```
 
-### scheduleEvery()
+#### scheduleEvery()
 
 ```typescript
 async scheduleEvery<T = string>(
@@ -800,7 +959,8 @@ async scheduleEvery<T = string>(
 ): Promise<Schedule<T>>
 ```
 
-Schedule a task to run repeatedly at a fixed interval.
+Schedule a task to run repeatedly at a fixed interval. Idempotent by design
+(the primitive's `every()` accepts `options.idempotent` to opt out).
 
 **Parameters:**
 
@@ -819,7 +979,7 @@ Schedule a task to run repeatedly at a fixed interval.
 - If callback throws an error, the interval continues
 - Cancel with `cancelSchedule(id)` to stop the entire interval
 
-### getScheduleById()
+#### getScheduleById()
 
 ```typescript
 async getScheduleById(id: string): Promise<Schedule<unknown> | undefined>
@@ -827,7 +987,7 @@ async getScheduleById(id: string): Promise<Schedule<unknown> | undefined>
 
 Get a scheduled task by ID. This method works in both top-level agents and sub-agents.
 
-### listSchedules()
+#### listSchedules()
 
 ```typescript
 async listSchedules(criteria?: {
@@ -839,7 +999,7 @@ async listSchedules(criteria?: {
 
 Get scheduled tasks matching the criteria. This method works in both top-level agents and sub-agents.
 
-### getSchedule()
+#### getSchedule()
 
 ```typescript
 getSchedule<T = string>(id: string): Schedule<T> | undefined
@@ -847,7 +1007,7 @@ getSchedule<T = string>(id: string): Schedule<T> | undefined
 
 Deprecated. Get a scheduled task by ID synchronously. This method only works in top-level agents; use `await this.getScheduleById(id)` instead.
 
-### getSchedules()
+#### getSchedules()
 
 ```typescript
 getSchedules<T = string>(criteria?: {
@@ -859,7 +1019,7 @@ getSchedules<T = string>(criteria?: {
 
 Deprecated. Get scheduled tasks matching the criteria synchronously. This method only works in top-level agents; use `await this.listSchedules(criteria)` instead.
 
-### cancelSchedule()
+#### cancelSchedule()
 
 ```typescript
 async cancelSchedule(id: string): Promise<boolean>
@@ -867,7 +1027,7 @@ async cancelSchedule(id: string): Promise<boolean>
 
 Cancel a scheduled task. Returns `true` if cancelled, `false` if not found.
 
-### keepAlive()
+#### keepAlive()
 
 ```typescript
 async keepAlive(): Promise<() => void>
@@ -877,7 +1037,7 @@ Create an alarm-backed heartbeat that prevents the Durable Object from being evi
 
 See [Keeping the Agent Alive](#keeping-the-agent-alive) for usage details.
 
-### keepAliveWhile()
+#### keepAliveWhile()
 
 ```typescript
 async keepAliveWhile<T>(fn: () => Promise<T>): Promise<T>

package/docs/server-driven-messages.md

@@ -457,7 +457,7 @@ Pre-aborted signals short-circuit before any model work runs.
 ### Limitations
 
 - **Signals cannot cross Durable Object boundaries.** `AbortSignal` is not an RPC-serializable type. Construct the controller inside the DO that calls `saveMessages`. For Think child-agent orchestration, use [Agent Tools](./agent-tools.md); `runAgentTool()` bridges parent aborts into the child run. For lower-level custom RPC, return a `ReadableStream` from the child and let the parent cancel it — workerd propagates the cancel back to the source's `cancel` callback.
-- **Hibernation drops the listener.** The signal lives in memory. If the DO hibernates mid-turn and `chatRecovery` is enabled, the recovered turn usually calls `continueLastTurn()` internally without the original signal — an abort fired after restart has no effect on the recovered turn. For pre-stream interruptions, recovery can instead retry the latest unanswered user message automatically. This is true for top-level agents and sub-agents; sub-agent recovery still works, but the original caller's in-memory signal is gone. Override `onChatRecovery` (Think) or set `chatRecovery = false` for callers that need stronger guarantees.
+- **Hibernation drops the listener.** The signal lives in memory. After the DO restarts, durable recovery usually calls `continueLastTurn()` without the original signal, so an abort fired after restart has no effect. For pre-stream interruptions, recovery can instead retry the latest unanswered user message automatically. This is true for top-level agents and sub-agents. If cancellation must survive restart, persist the cancellation intent in agent state or SQL, check it in `onChatRecovery()`, and return `{ continue: false }`. Durable recovery cannot be disabled.
 
 This is the integration point for agent-tool orchestration where the parent's AI SDK abort signal needs to propagate into a child DO's `saveMessages` call. See [`cloudflare/agents#1406`](https://github.com/cloudflare/agents/issues/1406) for the original use case.
 

package/docs/sub-agents.md

@@ -316,7 +316,7 @@ The Worker must pass the incoming request to `routeAgentRequest()`. Each ancesto
 
 `buildAgentUrl()` accepts an HTTP(S) or WS(S) origin without a pathname, query, fragment, or credentials. Set callback query parameters through the returned URL's `searchParams`. If you use a custom routing prefix, pass the same value to both `buildAgentPath()` and `routeAgentRequest()`.
 
-Root Agent names follow PartyServer's existing raw pathname-segment behavior and must already be externally routable. The `sub` segment is reserved in routing prefixes, class and binding names, and root Agent names. Descendant names are URL-encoded by the helper, so names containing spaces, Unicode, `/`, or URL-reserved characters round-trip safely.
+Root Agent names follow `routeAgentRequest`'s raw pathname-segment behavior and must already be externally routable. The `sub` segment is reserved in routing prefixes, class and binding names, and root Agent names. Descendant names are URL-encoded by the helper, so names containing spaces, Unicode, `/`, or URL-reserved characters round-trip safely.
 
 ### Custom routing
 

package/package.json

@@ -9,16 +9,13 @@
     "durable objects"
   ],
   "type": "module",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "license": "MIT",
   "repository": {
     "directory": "packages/agents",
     "type": "git",
     "url": "git+https://github.com/cloudflare/agents.git"
   },
-  "bin": {
-    "agents": "dist/cli/index.js"
-  },
   "author": "Cloudflare Inc.",
   "bugs": {
     "url": "https://github.com/cloudflare/agents/issues"
@@ -31,10 +28,8 @@
     "esbuild": "^0.28.1",
     "mimetext": "^3.0.28",
     "nanoid": "^5.1.16",
-    "partyserver": "^0.5.9",
     "partysocket": "1.3.0",
-    "yaml": "^2.9.0",
-    "yargs": "^18.0.0"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@ai-sdk/react": "^4.0.0",
@@ -46,7 +41,6 @@
     "@modelcontextprotocol/server": "2.0.0",
     "@tanstack/ai": "0.38.0",
     "@types/react": "^19.2.17",
-    "@types/yargs": "^17.0.35",
     "@valibot/to-json-schema": "1.3.0",
     "@x402/core": "^2.17.0",
     "@x402/evm": "^2.17.0",
@@ -123,6 +117,11 @@
       "import": "./dist/client.js",
       "require": "./dist/client.js"
     },
+    "./lifecycle": {
+      "types": "./dist/lifecycle/index.d.ts",
+      "import": "./dist/lifecycle/index.js",
+      "require": "./dist/lifecycle/index.js"
+    },
     "./agent-tools": {
       "types": "./dist/agent-tools.d.ts",
       "import": "./dist/agent-tools.js",
@@ -139,19 +138,19 @@
       "require": "./dist/mcp/index.js"
     },
     "./mcp/client": {
-      "types": "./dist/mcp/client.d.ts",
-      "import": "./dist/mcp/client.js",
-      "require": "./dist/mcp/client.js"
+      "types": "./dist/mcp/client/index.d.ts",
+      "import": "./dist/mcp/client/index.js",
+      "require": "./dist/mcp/client/index.js"
     },
     "./mcp/server": {
-      "types": "./dist/mcp/server.d.ts",
-      "import": "./dist/mcp/server.js",
-      "require": "./dist/mcp/server.js"
+      "types": "./dist/mcp/server/index.d.ts",
+      "import": "./dist/mcp/server/index.js",
+      "require": "./dist/mcp/server/index.js"
     },
     "./mcp/do-oauth-client-provider": {
-      "types": "./dist/mcp/do-oauth-client-provider.d.ts",
-      "import": "./dist/mcp/do-oauth-client-provider.js",
-      "require": "./dist/mcp/do-oauth-client-provider.js"
+      "types": "./dist/mcp/client/do-oauth-client-provider.d.ts",
+      "import": "./dist/mcp/client/do-oauth-client-provider.js",
+      "require": "./dist/mcp/client/do-oauth-client-provider.js"
     },
     "./observability": {
       "types": "./dist/observability/index.d.ts",
@@ -173,6 +172,16 @@
       "import": "./dist/schedule.js",
       "require": "./dist/schedule.js"
     },
+    "./schedules": {
+      "types": "./dist/schedules/index.d.ts",
+      "import": "./dist/schedules/index.js",
+      "require": "./dist/schedules/index.js"
+    },
+    "./schedules/parser": {
+      "types": "./dist/schedules/parser.d.ts",
+      "import": "./dist/schedules/parser.js",
+      "require": "./dist/schedules/parser.js"
+    },
     "./workflows": {
       "types": "./dist/workflows.d.ts",
       "import": "./dist/workflows.js",
@@ -194,9 +203,9 @@
       "require": "./dist/experimental/webmcp.js"
     },
     "./x402": {
-      "types": "./dist/mcp/x402.d.ts",
-      "import": "./dist/mcp/x402.js",
-      "require": "./dist/mcp/x402.js"
+      "types": "./dist/mcp/client/x402.d.ts",
+      "import": "./dist/mcp/client/x402.js",
+      "require": "./dist/mcp/client/x402.js"
     },
     "./chat": {
       "types": "./dist/chat/index.d.ts",
@@ -308,7 +317,7 @@
     "build": "tsx ./scripts/build.ts",
     "evals": "(cd evals; evalite)",
     "test": "vitest --run",
-    "test:cli": "vitest --project cli",
+    "test:node": "vitest --project node",
     "test:react": "vitest --project react",
     "test:browser": "vitest run --config src/browser-tests/vitest.config.ts",
     "test:workers": "vitest --project workers",

package/dist/cli/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/index.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-//#region src/cli/create.ts
-function createCli(argv = process.argv) {
-	return yargs(hideBin(argv)).scriptName("agents").usage("$0 <command> [options]").command(["init", "create"], "Initialize an agents project", (cmd) => cmd, async () => {
-		console.log("agents init: not implemented yet");
-		process.exit(0);
-	}).command("dev", "Start development server", (cmd) => cmd, async () => {
-		console.log("agents dev: not implemented yet");
-		process.exit(0);
-	}).command("deploy", "Deploy agents to Cloudflare", (cmd) => cmd, async () => {
-		console.log("agents deploy: not implemented yet");
-		process.exit(0);
-	}).command("mcp", "The agents mcp server", (cmd) => cmd, async () => {
-		console.log("agents mcp: not implemented yet");
-		process.exit(0);
-	}).demandCommand(1, "Please provide a command").strict().help();
-}
-//#endregion
-//#region src/cli/index.ts
-createCli().parse();
-//#endregion
-export {};
-
-//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/cli/create.ts","../../src/cli/index.ts"],"sourcesContent":["import yargs from \"yargs\";\nimport { hideBin } from \"yargs/helpers\";\n\nexport function createCli(argv = process.argv) {\n  return yargs(hideBin(argv))\n    .scriptName(\"agents\")\n    .usage(\"$0 <command> [options]\")\n    .command(\n      [\"init\", \"create\"],\n      \"Initialize an agents project\",\n      (cmd) => cmd,\n      async () => {\n        console.log(\"agents init: not implemented yet\");\n        process.exit(0);\n      }\n    )\n    .command(\n      \"dev\",\n      \"Start development server\",\n      (cmd) => cmd,\n      async () => {\n        console.log(\"agents dev: not implemented yet\");\n        process.exit(0);\n      }\n    )\n    .command(\n      \"deploy\",\n      \"Deploy agents to Cloudflare\",\n      (cmd) => cmd,\n      async () => {\n        console.log(\"agents deploy: not implemented yet\");\n        process.exit(0);\n      }\n    )\n    .command(\n      \"mcp\",\n      \"The agents mcp server\",\n      (cmd) => cmd,\n      async () => {\n        console.log(\"agents mcp: not implemented yet\");\n        process.exit(0);\n      }\n    )\n    .demandCommand(1, \"Please provide a command\")\n    .strict()\n    .help();\n}\n","#!/usr/bin/env node\n\nimport { createCli } from \"./create\";\n\nvoid createCli().parse();\n"],"mappings":";;;;AAGA,SAAgB,UAAU,OAAO,QAAQ,MAAM;CAC7C,OAAO,MAAM,QAAQ,IAAI,CAAC,CAAC,CACxB,WAAW,QAAQ,CAAC,CACpB,MAAM,wBAAwB,CAAC,CAC/B,QACC,CAAC,QAAQ,QAAQ,GACjB,iCACC,QAAQ,KACT,YAAY;EACV,QAAQ,IAAI,kCAAkC;EAC9C,QAAQ,KAAK,CAAC;CAChB,CACF,CAAC,CACA,QACC,OACA,6BACC,QAAQ,KACT,YAAY;EACV,QAAQ,IAAI,iCAAiC;EAC7C,QAAQ,KAAK,CAAC;CAChB,CACF,CAAC,CACA,QACC,UACA,gCACC,QAAQ,KACT,YAAY;EACV,QAAQ,IAAI,oCAAoC;EAChD,QAAQ,KAAK,CAAC;CAChB,CACF,CAAC,CACA,QACC,OACA,0BACC,QAAQ,KACT,YAAY;EACV,QAAQ,IAAI,iCAAiC;EAC7C,QAAQ,KAAK,CAAC;CAChB,CACF,CAAC,CACA,cAAc,GAAG,0BAA0B,CAAC,CAC5C,OAAO,CAAC,CACR,KAAK;AACV;;;AC1CK,UAAU,CAAC,CAAC,MAAM"}

package/dist/client-invoker-VNZ7X0nn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client-invoker-VNZ7X0nn.js","names":[],"sources":["../src/mcp/client-invoker.ts"],"sourcesContent":["import type {\n  CallToolRequest,\n  CallToolRequestOptions,\n  CallToolResult,\n  Client,\n  ListToolsResult\n} from \"@modelcontextprotocol/client\";\nimport type { Client as LegacyClient } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport type {\n  CallToolResult as LegacyCallToolResult,\n  CallToolResultSchema,\n  CompatibilityCallToolResultSchema,\n  ListToolsRequest\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport type { RequestOptions as LegacyRequestOptions } from \"@modelcontextprotocol/sdk/shared/protocol.js\";\n\nexport type LegacyCallToolResultSchema =\n  | typeof CallToolResultSchema\n  | typeof CompatibilityCallToolResultSchema;\n\nexport type CallToolSchemaOrOptions =\n  | LegacyCallToolResultSchema\n  | CallToolRequestOptions;\n\nexport type CompatibleMcpClient = Client | LegacyClient;\n\nexport interface BoundMcpClientInvoker {\n  listTools(\n    params?: ListToolsRequest[\"params\"],\n    options?: CallToolRequestOptions\n  ): Promise<ListToolsResult>;\n  callTool(\n    params: CallToolRequest[\"params\"],\n    schemaOrOptions?: CallToolSchemaOrOptions,\n    options?: CallToolRequestOptions\n  ): Promise<LegacyCallToolResult>;\n}\n\nfunction isLegacyResultSchema(\n  value: CallToolSchemaOrOptions | undefined\n): value is LegacyCallToolResultSchema {\n  return (\n    typeof (value as { parse?: unknown } | undefined)?.parse === \"function\"\n  );\n}\n\nfunction normalizeCallToolArguments(\n  schemaOrOptions?: CallToolSchemaOrOptions,\n  options?: CallToolRequestOptions\n): {\n  schema?: LegacyCallToolResultSchema;\n  options?: CallToolRequestOptions;\n} {\n  return isLegacyResultSchema(schemaOrOptions)\n    ? { schema: schemaOrOptions, options }\n    : { options: schemaOrOptions ?? options };\n}\n\n/**\n * Invoke SDK v2 while preserving the deprecated v1 result-schema overload.\n * The v2 request funnel still owns decoding and automatic MRTR.\n */\nexport function callV2Tool(\n  client: Client,\n  params: CallToolRequest[\"params\"],\n  schemaOrOptions?: CallToolSchemaOrOptions,\n  options?: CallToolRequestOptions\n): Promise<CallToolResult> {\n  const normalized = normalizeCallToolArguments(schemaOrOptions, options);\n  if (normalized.schema) {\n    return client.request(\n      { method: \"tools/call\", params },\n      normalized.schema as never,\n      normalized.options\n    ) as Promise<CallToolResult>;\n  }\n  return client.callTool(params, normalized.options);\n}\n\n/**\n * Bind the original methods before decorators such as x402 replace them. All\n * generation-specific calling conventions stay behind this small interface.\n */\nexport function bindMcpClient(\n  client: CompatibleMcpClient\n): BoundMcpClientInvoker {\n  const isV2 =\n    \"getProtocolEra\" in client &&\n    typeof (client as { getProtocolEra?: unknown }).getProtocolEra ===\n      \"function\";\n\n  if (isV2) {\n    const v2Client = client as Client;\n    const listTools = v2Client.listTools.bind(v2Client);\n    const callTool = v2Client.callTool.bind(v2Client);\n    return {\n      listTools: (params, options) => listTools(params, options),\n      callTool: (params, schemaOrOptions, options) => {\n        const normalized = normalizeCallToolArguments(schemaOrOptions, options);\n        const pending = normalized.schema\n          ? v2Client.request(\n              { method: \"tools/call\", params },\n              normalized.schema as never,\n              normalized.options\n            )\n          : callTool(params, normalized.options);\n        return pending as Promise<LegacyCallToolResult>;\n      }\n    };\n  }\n\n  const legacy = client as LegacyClient;\n  const listTools = legacy.listTools.bind(legacy);\n  const callTool = legacy.callTool.bind(legacy);\n  return {\n    listTools: (params, options) =>\n      listTools(\n        params,\n        options as LegacyRequestOptions\n      ) as Promise<ListToolsResult>,\n    callTool: (params, schemaOrOptions, options) => {\n      const normalized = normalizeCallToolArguments(schemaOrOptions, options);\n      return callTool(\n        params as Parameters<LegacyClient[\"callTool\"]>[0],\n        normalized.schema,\n        normalized.options as LegacyRequestOptions\n      ) as Promise<LegacyCallToolResult>;\n    }\n  };\n}\n"],"mappings":";AAsCA,SAAS,qBACP,OACqC;CACrC,OACE,OAAQ,OAA2C,UAAU;AAEjE;AAEA,SAAS,2BACP,iBACA,SAIA;CACA,OAAO,qBAAqB,eAAe,IACvC;EAAE,QAAQ;EAAiB;CAAQ,IACnC,EAAE,SAAS,mBAAmB,QAAQ;AAC5C;;;;;AAMA,SAAgB,WACd,QACA,QACA,iBACA,SACyB;CACzB,MAAM,aAAa,2BAA2B,iBAAiB,OAAO;CACtE,IAAI,WAAW,QACb,OAAO,OAAO,QACZ;EAAE,QAAQ;EAAc;CAAO,GAC/B,WAAW,QACX,WAAW,OACb;CAEF,OAAO,OAAO,SAAS,QAAQ,WAAW,OAAO;AACnD;;;;;AAMA,SAAgB,cACd,QACuB;CAMvB,IAJE,oBAAoB,UACpB,OAAQ,OAAwC,mBAC9C,YAEM;EACR,MAAM,WAAW;EACjB,MAAM,YAAY,SAAS,UAAU,KAAK,QAAQ;EAClD,MAAM,WAAW,SAAS,SAAS,KAAK,QAAQ;EAChD,OAAO;GACL,YAAY,QAAQ,YAAY,UAAU,QAAQ,OAAO;GACzD,WAAW,QAAQ,iBAAiB,YAAY;IAC9C,MAAM,aAAa,2BAA2B,iBAAiB,OAAO;IAQtE,OAPgB,WAAW,SACvB,SAAS,QACP;KAAE,QAAQ;KAAc;IAAO,GAC/B,WAAW,QACX,WAAW,OACb,IACA,SAAS,QAAQ,WAAW,OAAO;GAEzC;EACF;CACF;CAEA,MAAM,SAAS;CACf,MAAM,YAAY,OAAO,UAAU,KAAK,MAAM;CAC9C,MAAM,WAAW,OAAO,SAAS,KAAK,MAAM;CAC5C,OAAO;EACL,YAAY,QAAQ,YAClB,UACE,QACA,OACF;EACF,WAAW,QAAQ,iBAAiB,YAAY;GAC9C,MAAM,aAAa,2BAA2B,iBAAiB,OAAO;GACtE,OAAO,SACL,QACA,WAAW,QACX,WAAW,OACb;EACF;CACF;AACF"}