@wakeshift/sdk 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 What changed in each release of `@wakeshift/sdk`. 0.4.0 is the first published release: to start with it, read the [README](README.md). Its notes below, and the earlier releases', are for apps that ran the preview builds.
 
+## 0.10.0 (2026-11-03)
+
+### Changed
+
+- **`wakeshift_wait` is opt-in.** `attach` (and `attachMastra`) no longer serves Claude Code's wait tool unless you turn it on: `wake.attach(server, { tools: { wait: { enabled: true } } })`. While a conversation waits on it, Claude Code keeps a request open to your server for about 20 seconds at a time and sends the next about a second later, for as long as it waits, whether or not anything arrives: on a serverless host, a function invocation per waiting conversation, all the time. This changes behavior for apps on today's defaults: a recent Claude Code in the terminal whose user declines Wakeshift's plugin now waits with a background monitor, as every other Claude Code does, rather than on your server. In manual permission mode that means approving the monitor, and each restart every 25 minutes, instead of one approval of `wakeshift_wait`; and the wait no longer carries on through `claude --continue`. Users who install the plugin see no difference. To keep the wait tool, add `tools: { wait: { enabled: true } }`, on a stateless server, and on a serverless host give the function a timeout of at least 30 seconds. Without it, `server/discover` no longer offers the tasks extension, tools/list no longer lists `wakeshift_wait`, and Wakeshift's `tasks/get` and `tasks/cancel` go on to your MCP SDK.
+- **`tools` takes an object, each tool `{ enabled }`**: `subscribe`, `list` and `unsubscribe` (on unless disabled, as before) and `wait` (off unless enabled). `tools: { subscribe: { enabled: false } }` replaces `tools: ["unsubscribe_events", "list_subscriptions"]`. New types: `AttachTools`, `ToolOptions`, `WaitToolOptions`.
+
+### Deprecated
+
+- **`tools` as a list of names** (`BUILTIN_TOOLS`). It still works in this release, adding the tools it names and never the wait tool, and warns once through `onWarning`.
+
 ## 0.9.0 (2026-11-03)
 
 ### Added

package/README.md

@@ -106,7 +106,7 @@ await turn.emit({ table: "juniper" }, { hole: ["As", "Kd"], toCall: 2 }, { to: "
 
 - **`wake.defineEvent(name, { description, args, payload, text, authorize?, personal?, deleteOnDelivery? })`** returns the event. `args` is what a subscriber picks; its required string, integer and boolean fields route occurrences, so their values are lowercase IDs (a-z 0-9 . _ -), and an optional one filters on the payload field of the same name. `authorize(subscriber, args)` decides who may subscribe. With `deleteOnDelivery: true`, Wakeshift deletes each occurrence's text and payload once it's delivered. Define every event before `attach`, which throws with none.
 - **`event.emit(args, payload, { id?, to? })`** checks the payload against its schema and sends it to everyone subscribed with those arguments. A personal event goes to its recipients, `to`: users (the `user` attach's `identify` gives for them), `{ user, subscription }` (exactly one conversation's subscription, the `id` `call.subscribe` returned) and `{ native: user }` (only that user's own MCP Events subscriptions), mixable, up to 1,000. It returns `{ matched, duplicate, unmatched, ended }`: `matched` counts the conversations reached, `unmatched` the users with nothing subscribed, `ended` the subscriptions no longer live (forget them). `id` makes retries emit once: a retry of the same emit returns the first's result with `duplicate: true`, and the same `id` on a different emit (other arguments, recipients or payload) throws `IdReusedError` (`id_reused`) and sends nothing.
-- **`wake.attach(server, { identify?, tools?, events? })`** attaches Wakeshift to your MCP server and returns the handle your own tools use (below). It serves `events/list`, `events/subscribe` and `events/unsubscribe` to clients that speak MCP Events, and adds `subscribe_events` (for everyone else), `unsubscribe_events` and `list_subscriptions` (for every client, so a person can always see and stop what they're subscribed to); `tools` names fewer of them (`BUILTIN_TOOLS`; `[]` for none). `identify(ctx)` says who is behind a request, as `{ user, client? }`: `user` is your app's ID for the person, from your own sign-in; without it, requests have no user, so personal events and `list_subscriptions` refuse. On a stateless server, which never sees `initialize` (`createMcpHandler`'s is one), `client` is the MCP client's name as your sign-in knows it (an OAuth registration's `client_name`, say): Wakeshift reads it to tell which program the agent runs in. A name the request carries wins. On a stateless server it also serves `wakeshift_wait` to clients that take MCP tasks (a recent Claude Code in the terminal): Wakeshift tells those conversations to call it, and it wakes them when your events arrive, with nothing to install; other clients don't see it. Once it has run, the first call about events sends your app's manifest, with your events: it adds them and never removes one. An emit before `attach` has run (`createMcpHandler` runs it on the first request), or from a separate process that only emits, sends the manifest only if Wakeshift answers with `unknown_event`, then emits again (see [emitting before any agent connects](#emitting-before-any-agent-connects)).
+- **`wake.attach(server, { identify?, tools?, events? })`** attaches Wakeshift to your MCP server and returns the handle your own tools use (below). It serves `events/list`, `events/subscribe` and `events/unsubscribe` to clients that speak MCP Events, and adds `subscribe_events` (for everyone else), `unsubscribe_events` and `list_subscriptions` (for every client, so a person can always see and stop what they're subscribed to). `tools` picks them, each `{ enabled }`: `subscribe`, `list` and `unsubscribe` are on unless disabled (`tools: { subscribe: { enabled: false } }`); a list of names (`BUILTIN_TOOLS`) still works, but is deprecated. `identify(ctx)` says who is behind a request, as `{ user, client? }`: `user` is your app's ID for the person, from your own sign-in; without it, requests have no user, so personal events and `list_subscriptions` refuse. On a stateless server, which never sees `initialize` (`createMcpHandler`'s is one), `client` is the MCP client's name as your sign-in knows it (an OAuth registration's `client_name`, say): Wakeshift reads it to tell which program the agent runs in. A name the request carries wins. With `tools: { wait: { enabled: true } }`, on a stateless server, it also serves `wakeshift_wait` to clients that take MCP tasks (a recent Claude Code in the terminal): Wakeshift tells those conversations to call it, after the user declines Wakeshift's plugin, instead of starting a background monitor; other clients don't see it. It's off by default, because each waiting conversation then keeps a request open to your server (about 20 seconds at a time, the next a second later, for as long as it waits): on a serverless host, that's a function invocation per waiting conversation, which needs a timeout of at least 30 seconds. Once it has run, the first call about events sends your app's manifest, with your events: it adds them and never removes one. An emit before `attach` has run (`createMcpHandler` runs it on the first request), or from a separate process that only emits, sends the manifest only if Wakeshift answers with `unknown_event`, then emits again (see [emitting before any agent connects](#emitting-before-any-agent-connects)).
 - **`event.end(user, id)`** ends one of a user's subscriptions by its ID, outside a tool (a player who timed out, a member removed).
 - **`event.status(args, { to? })`** counts the conversations subscribed with those arguments (a personal event: one user's), how many are connected now, and how: `{ subscriptions, connected, via: { stream, poll, hooks, webhook } }`. **`event.statusOf([{ user, subscription }, …])`** reads up to 1,000 subscriptions by ID: `[{ id, user, live, connected, via? }]`. Both only read.
 - **`event.publishUrl(args, { to? })`** returns `{ id, event, url }`, a capability URL that emits the event with those arguments (a personal event: to one user) for services that only send webhooks. A POST's JSON body is the payload, checked against the event's schema. `wake.revokePublishUrl(id)` stops it.
@@ -255,7 +255,7 @@ const watchCi = createTool({
 const server = attached.serve(new MCPServer({ id: "ci-bot", name: "CI bot", version: "1.0.0", tools: { watch_ci: watchCi } }))
 ```
 
-Serve it as Mastra's docs do (`server.startHTTP`, `server.startStdio`, or registered on your `Mastra` instance). It gets everything `attach` gives: the built-in tools, MCP Events for clients that speak it, Claude Code's `wakeshift_wait`, and Wakeshift's addition in your wrapped tools' results.
+Serve it as Mastra's docs do (`server.startHTTP`, `server.startStdio`, or registered on your `Mastra` instance). It gets everything `attach` gives: the built-in tools, MCP Events for clients that speak it, Claude Code's `wakeshift_wait` (with `tools: { wait: { enabled: true } }`), and Wakeshift's addition in your wrapped tools' results.
 
 - `attached.events(name, { subscribes }, handler)` wraps a tool's `execute` for the tool your `MCPServer` serves under `name` (its key in `tools`); `subscribes` is as on `attach`'s handle. `handler(args, call, context)` returns what a Mastra tool returns: a string, or your output. Run outside an MCP client's call (by an agent, a workflow or Studio), `call.subscribe` throws.
 - Wrapped tools answer in one call: a Mastra task or a request for input from one ends what it subscribed.

package/dist/events.d.ts

@@ -194,19 +194,53 @@ export interface AttachOptions<C = any> {
      */
     identify?(extra: C): Identity | undefined;
     /**
-     * Which of attach's own tools it adds (BUILTIN_TOOLS): subscribe_events,
-     * unsubscribe_events and list_subscriptions. Default: all three; `[]`
-     * adds none. Leave out unsubscribe_events or list_subscriptions only if
-     * your own tools let a person see and stop their subscriptions.
+     * Which of attach's own tools it adds, each `{ enabled }` (AttachTools):
+     * `subscribe` (subscribe_events), `list` (list_subscriptions) and
+     * `unsubscribe` (unsubscribe_events), on unless disabled, and `wait`
+     * (wakeshift_wait, Claude Code's wait tool), off unless enabled:
+     * `tools: { wait: { enabled: true } }`. Disable `list` or `unsubscribe`
+     * only if your own tools let a person see and stop their subscriptions.
+     *
+     * Deprecated: a list of names (BUILTIN_TOOLS) still works for now, adding
+     * only the tools it names, and never the wait tool.
      */
-    tools?: readonly BuiltinTool[];
+    tools?: AttachTools | readonly BuiltinTool[];
     /** The event features' options: events.native overrides native detection for wrapped tools (attached.events). */
     events?: EventsOptions<C>;
 }
-/** The tools attach adds, unless AttachOptions.tools names fewer. */
+/** The tools attach adds by default (deprecated as AttachOptions.tools' list form). */
 export declare const BUILTIN_TOOLS: readonly ["subscribe_events", "unsubscribe_events", "list_subscriptions"];
-/** One of attach's own tools. */
+/** One of attach's own tools, by name (AttachOptions.tools' deprecated list form). */
 export type BuiltinTool = (typeof BUILTIN_TOOLS)[number];
+/** One of attach's own tools' options (AttachTools). */
+export interface ToolOptions {
+    /** Whether attach adds it. Default: on, except the wait tool. */
+    enabled?: boolean;
+}
+/**
+ * The wait tool's options (AttachTools.wait): Wakeshift's wait tool,
+ * wakeshift_wait, Claude Code's wake path with nothing installed, where
+ * its client takes MCP tasks (protocol 2026-07-28, on a stateless server).
+ * Off by default: Claude Code is then woken by its plugin or, after a no, a
+ * background Monitor, as every other server's is. On, a waiting
+ * conversation's Claude Code holds a request to this server (tasks/get,
+ * about 20 seconds) and sends the next about a second later, for as long as
+ * it waits: on a serverless host, give the function a timeout of at least
+ * 30 seconds, and expect one held invocation per waiting conversation.
+ */
+export interface WaitToolOptions extends ToolOptions {
+}
+/** Which of attach's own tools it adds (AttachOptions.tools). */
+export interface AttachTools {
+    /** wakeshift_wait, Claude Code's wait tool: off unless enabled. */
+    wait?: WaitToolOptions;
+    /** subscribe_events, for clients that don't speak MCP Events: on unless disabled. */
+    subscribe?: ToolOptions;
+    /** list_subscriptions: on unless disabled. */
+    list?: ToolOptions;
+    /** unsubscribe_events: on unless disabled. */
+    unsubscribe?: ToolOptions;
+}
 export declare const EVENT_TOOL_TEXT: {
     readonly a_webhook: "a webhook";
     readonly arguments_argument: "The event's arguments, as an object: see the event's list above";

package/dist/events.js

@@ -326,8 +326,51 @@ export class ArgsError extends WakeshiftError {
         this.name = "ArgsError";
     }
 }
-/** The tools attach adds, unless AttachOptions.tools names fewer. */
+/** The tools attach adds by default (deprecated as AttachOptions.tools' list form). */
 export const BUILTIN_TOOLS = ["subscribe_events", "unsubscribe_events", "list_subscriptions"];
+const TOOL_KEYS = { subscribe: "subscribe_events", list: "list_subscriptions", unsubscribe: "unsubscribe_events" };
+/**
+ * @internal AttachOptions.tools as the tools to add: each `{ enabled }` of
+ * the object form, or the names of the deprecated list form (never the
+ * wait tool). Throws on a key, name or value it doesn't know.
+ */
+export function toolChoice(tools, what = "attach") {
+    if (tools === undefined)
+        return { builtin: new Set(BUILTIN_TOOLS), wait: false };
+    if (Array.isArray(tools)) {
+        for (const t of tools) {
+            if (!BUILTIN_TOOLS.includes(t))
+                throw new Error(`wakeshift: ${what}'s tools names "${t}": its own tools are ${BUILTIN_TOOLS.join(", ")}`);
+        }
+        return { builtin: new Set(tools), wait: false };
+    }
+    if (!tools || typeof tools !== "object")
+        throw new Error(`wakeshift: ${what}'s tools is { wait, subscribe, list, unsubscribe }, each { enabled }`);
+    const o = tools;
+    for (const [k, v] of Object.entries(o)) {
+        if (k !== "wait" && !(k in TOOL_KEYS))
+            throw new Error(`wakeshift: ${what}'s tools has "${k}": its own tools are wait, subscribe, list and unsubscribe`);
+        if (v === undefined)
+            continue;
+        if (!v || typeof v !== "object" || Array.isArray(v))
+            throw new Error(`wakeshift: ${what}'s tools.${k} is an object, { enabled }`);
+        for (const [ok, ov] of Object.entries(v)) {
+            if (ok !== "enabled")
+                throw new Error(`wakeshift: ${what}'s tools.${k} has "${ok}": its options are { enabled }`);
+            if (ov !== undefined && typeof ov !== "boolean")
+                throw new Error(`wakeshift: ${what}'s tools.${k}.enabled is true or false`);
+        }
+    }
+    const builtin = new Set();
+    for (const [k, name] of Object.entries(TOOL_KEYS))
+        if (o[k]?.enabled !== false)
+            builtin.add(name);
+    return { builtin, wait: o.wait?.enabled === true };
+}
+/** @internal The warning for AttachOptions.tools' deprecated list form. */
+export function toolsListWarning(what = "attach") {
+    return `wakeshift: ${what}'s tools as a list of names is deprecated: pass { subscribe, list, unsubscribe }, each { enabled } (and wait: { enabled: true } for Claude Code's wait tool)`;
+}
 // What a client says about itself on initialize (2.x: or the request's
 // envelope), or a request's _meta; else the name identify gave (identified).
 function clientInfoName(host, meta, identified) {
@@ -484,18 +527,21 @@ export function attachEvents(wake, server, events, opts = {}) {
     checkAttach(events, opts);
     return attachHost(wake, hostOf(server), events, opts);
 }
-/** @internal What attach refuses before it touches a server: no events, or an own tool it doesn't have. */
+/** @internal What attach refuses before it touches a server: no events, or tools it doesn't know. */
 export function checkAttach(events, opts, what = "attach") {
     if (events.length === 0)
         throw new Error(`wakeshift: ${what} needs at least one event (wake.defineEvent) defined first`);
-    for (const t of opts.tools ?? []) {
-        if (!BUILTIN_TOOLS.includes(t))
-            throw new Error(`wakeshift: ${what}'s tools names "${t}": its own tools are ${BUILTIN_TOOLS.join(", ")}`);
-    }
+    toolChoice(opts.tools, what);
 }
 /** @internal attach on a Host: an McpServer's, or a framework adapter's (mastra.ts, xmcp.ts). */
 export function attachHost(wake, host, events, opts = {}) {
-    const tools = new Set(opts.tools ?? BUILTIN_TOOLS);
+    const choice = toolChoice(opts.tools);
+    if (Array.isArray(opts.tools))
+        wake.warnOnce("tools-list", toolsListWarning());
+    const tools = choice.builtin;
+    // The wait tool, only if the app turns it on and the MCP SDK's request
+    // handlers can be reached (tasks.ts): otherwise no call says it takes tasks.
+    const wait = choice.wait && !!host.handlers();
     // raw is the MCP SDK's own request context (1.x's extra, 2.x's ctx): what identify gets.
     const identityOf = (raw) => opts.identify?.(raw) ?? undefined;
     // Who's calling: the user, and the client's name (the request's, else identify's).
@@ -510,6 +556,7 @@ export function attachHost(wake, host, events, opts = {}) {
         clientOf: (meta, identified) => clientInfoName(host, meta, identified),
         events: opts.events ?? {},
         warnOnce: (key, message) => wake.warnOnce(key, message),
+        wait,
     });
     const byName = new Map(events.map((e) => [e.name, e]));
     try {
@@ -521,15 +568,16 @@ export function attachHost(wake, host, events, opts = {}) {
     if (!host.handlers() && !host.framework) {
         // An MCP SDK release that keeps its request handlers elsewhere: the native
         // events and the built-in tools still work, but not what wraps the SDK's own methods.
-        wake.warnOnce("handlers", "wakeshift: this MCP SDK keeps its request handlers where Wakeshift can't reach them, so wakeshift_wait, the 2026-07-28 tools/list changes and wrapped tools' output schemas are off: check for a newer @wakeshift/sdk");
+        wake.warnOnce("handlers", `wakeshift: this MCP SDK keeps its request handlers where Wakeshift can't reach them, so ${choice.wait ? "wakeshift_wait, " : ""}the 2026-07-28 tools/list changes and wrapped tools' output schemas are off: check for a newer @wakeshift/sdk`);
     }
     // Clients that speak only protocol 2026-07-28 (OpenClaw): on the MCP SDK
     // 1.x, on a stateless transport, server/discover and resultType
     // (discover.ts); on 2.x, its own.
     serveStateless(host, { bridgedOnly: ["subscribe_events"] });
     // Clients that take MCP tasks there (Claude Code): Wakeshift's wait tool,
-    // answered with a task (tasks.ts).
-    serveTasks(wake, host, callerOf);
+    // answered with a task (tasks.ts), if the app turns it on (wait).
+    if (wait)
+        serveTasks(wake, host, callerOf);
     // tools/list: a wrapped tool's output schema names wakeshift, which its
     // structured results carry (toolcall.ts).
     attached.amendToolsList();
@@ -665,7 +713,7 @@ export function attachHost(wake, host, events, opts = {}) {
         }
         try {
             const out = await wake.requestApp("POST", "/event-subscriptions", {
-                call: toolCallOf(host.req(raw), client, user, rest, "subscribe_events"),
+                call: toolCallOf(host.req(raw), client, user, rest, "subscribe_events", wait),
                 name: ev.name,
                 arguments: args,
             });
@@ -700,7 +748,7 @@ export function attachHost(wake, host, events, opts = {}) {
                 return fail(fill("need"));
             const args = ev.parseArgs(rawArgs ?? {});
             const out = await wake.requestApp("POST", "/event-subscriptions/unsubscribe", {
-                call: toolCallOf(host.req(raw), client, user, rest, "unsubscribe_events"),
+                call: toolCallOf(host.req(raw), client, user, rest, "unsubscribe_events", wait),
                 name: ev.name,
                 arguments: args,
             });

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { Wakeshift, DEFAULT_CORE, SESSION_ARG, HARNESS_ARG, CONVERSATION_ARG, ty
 export { harnessAgent } from "./harness.js";
 export { IdReusedError, WakeshiftError, isCode } from "./errors.js";
 export { parseKey, signAssertion, type AppKey } from "./key.js";
-export { WakeEvent, ArgsError, EVENT_TOOL_TEXT, notifies, type NotifiesOptions, SUBSCRIBE_TOOL_DESCRIPTION, UNSUBSCRIBE_TOOL_DESCRIPTION, LIST_TOOL_DESCRIPTION, BUILTIN_TOOLS, type BuiltinTool, type EventOptions, type EmitOptions, type EventStatus, type EventSubscriptionStatus, MAX_STATUS_SUBSCRIPTIONS, type EventTypeManifest, type AttachOptions, type Identity, type Subscriber, } from "./events.js";
+export { WakeEvent, ArgsError, EVENT_TOOL_TEXT, notifies, type NotifiesOptions, SUBSCRIBE_TOOL_DESCRIPTION, UNSUBSCRIBE_TOOL_DESCRIPTION, LIST_TOOL_DESCRIPTION, BUILTIN_TOOLS, type BuiltinTool, type EventOptions, type EmitOptions, type EventStatus, type EventSubscriptionStatus, MAX_STATUS_SUBSCRIPTIONS, type EventTypeManifest, type AttachOptions, type AttachTools, type ToolOptions, type WaitToolOptions, type Identity, type Subscriber, } from "./events.js";
 export { CallEnded, type AnyWakeEvent, type EventArgs, type ToolCallBase, type ToolCallSubscribe, type ToolEventsOptions, type Attached, type AppArgs, type EventsOptions, type Subscription, type ToolCall, type ToolCallExtra, type ToolSubscribeOptions, type WakeArgs, type WakeInputs, type WakeInputsV3, type WakeInputsV4, type WakeKey, type WakeOutputShape, type WakeOutputV3, type WakeOutputV4, type WakeShape, type WrappedCallback, type WrappedResult, } from "./toolcall.js";
 export type { AuthInfo, CallToolResult, ContentBlock, HostContext, McpServerLike } from "./mcp.js";
 export { EXTENSION_KEY, TEXT_META, REVISION as EVENTS_REVISION } from "./spec.js";

package/dist/mastra.d.ts

@@ -2,7 +2,7 @@ import type * as z3 from "zod/v3";
 import type * as z4 from "zod/v4";
 import type { ToolCallExtra } from "./mcp.js";
 import type { ZodRawShapeCompat } from "./zod.js";
-import { type AttachOptions, type BuiltinTool, type Identity } from "./events.js";
+import { type AttachOptions, type AttachTools, type BuiltinTool, type Identity } from "./events.js";
 import { CallEnded, type AnyWakeEvent, type ToolCall, type ToolEventsOptions, type WakeArgs, type WakeInputs, type WakeInputsV3, type WakeInputsV4, type WakeOutputShape, type WakeOutputV3, type WakeOutputV4 } from "./toolcall.js";
 import type { Wakeshift } from "./wakeshift.js";
 /** The @mastra/mcp releases serve() is built for: 2.x, from 2.7. */
@@ -83,4 +83,4 @@ export declare class MastraAttached {
  * ctx.http?.authInfo).
  */
 export declare function attachMastra(wake: Wakeshift, opts?: MastraAttachOptions): MastraAttached;
-export { CallEnded, type BuiltinTool, type Identity, type ToolCall, type WakeArgs };
+export { CallEnded, type AttachTools, type BuiltinTool, type Identity, type ToolCall, type WakeArgs };

package/dist/tasks.js

@@ -1,6 +1,7 @@
 // MCP Tasks as a wake path (docs/harnesses.md, "Claude Code: MCP tasks as a
 // wake path"): for a client that takes MCP tasks, on protocol 2026-07-28
-// (discover.ts), attach serves Wakeshift's wait tool, wakeshift_wait. Its
+// (discover.ts), attach with wait: true serves Wakeshift's wait tool,
+// wakeshift_wait (off by default: AttachOptions.wait). Its
 // call is answered with a task that completes when the conversation's next
 // Wakeshift messages arrive; the client follows it in the background
 // (tasks/get), and a completed task wakes an idle conversation. Wakeshift
@@ -58,7 +59,7 @@ export function serveTasks(wake, host, callerOf) {
     }
     const call = (raw, args) => {
         const { user, client } = callerOf(raw);
-        return toolCallOf(host.req(raw), client, user, args, WAIT_TOOL);
+        return toolCallOf(host.req(raw), client, user, args, WAIT_TOOL, true);
     };
     const takes = (raw) => {
         const req = host.req(raw);

package/dist/toolcall.js

@@ -300,7 +300,7 @@ export class CallScope {
             harness: this.args.harness,
             conversation: this.args.conversation,
             tool: this.tool,
-            tasks: takesTasks(meta, req),
+            tasks: !!this.at.wait && takesTasks(meta, req),
         });
     }
     // request runs one request of the call to Wakeshift, after any before it

package/dist/wakeshift.js

@@ -64,7 +64,7 @@ export function packCall(c) {
  * others): its _meta and User-Agent, the client's name, the user, and
  * session_key, harness and conversation_id from its arguments.
  */
-export function toolCallOf(extra, client, user, args, tool) {
+export function toolCallOf(extra, client, user, args, tool, wait) {
     const req = v1Req(extra); // a request already read passes through
     return packCall({
         meta: req.meta,
@@ -75,7 +75,7 @@ export function toolCallOf(extra, client, user, args, tool) {
         harness: str(args, HARNESS_ARG),
         conversation: str(args, CONVERSATION_ARG),
         tool,
-        tasks: takesTasks(req.meta, req),
+        tasks: wait && takesTasks(req.meta, req),
     });
 }
 // str is a tool argument's value if it's a string.

package/dist/xmcp.d.ts

@@ -1,6 +1,6 @@
 import type { AuthInfo, CallToolResult } from "./mcp.js";
 import type { ZodRawShapeCompat } from "./zod.js";
-import { BUILTIN_TOOLS, type BuiltinTool, type Identity } from "./events.js";
+import { BUILTIN_TOOLS, type AttachTools, type BuiltinTool, type Identity } from "./events.js";
 import { type AnyWakeEvent, type ToolCall, type ToolEventsOptions, type WakeArgs, type WakeInputs, type WrappedResult } from "./toolcall.js";
 import type { Wakeshift } from "./wakeshift.js";
 /** The request context xmcp passes a tool's handler, its second argument: what Wakeshift reads of it. */
@@ -27,8 +27,12 @@ export interface XmcpAttachOptions {
      * have no user, so personal events and list_subscriptions refuse.
      */
     identify?(extra: XmcpExtra): Identity | undefined;
-    /** Which of attach's own tools attached.tool gives (default: all three). */
-    tools?: readonly BuiltinTool[];
+    /**
+     * Which of attach's own tools attached.tool gives, each `{ enabled }`
+     * (default: all three). xmcp can't serve the wait tool. Deprecated: a
+     * list of names.
+     */
+    tools?: Omit<AttachTools, "wait"> | readonly BuiltinTool[];
 }
 /** One of attach's own tools as an xmcp tool file exports it. */
 export interface XmcpTool {
@@ -88,4 +92,4 @@ export declare class XmcpAttached {
  * own tools that subscribe, and attached.tool for attach's own three.
  */
 export declare function attachXmcp(wake: Wakeshift, opts?: XmcpAttachOptions): XmcpAttached;
-export { BUILTIN_TOOLS, type BuiltinTool, type Identity, type ToolCall, type WakeArgs, type WrappedResult };
+export { BUILTIN_TOOLS, type AttachTools, type BuiltinTool, type Identity, type ToolCall, type WakeArgs, type WrappedResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wakeshift/sdk",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Let agents subscribe to things in your app: Wakeshift wakes them when you emit an event.",
   "license": "Apache-2.0",
   "author": "Clawvisor Inc. <support@wakeshift.ai>",