@wakeshift/sdk 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 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.7.0 (2026-10-31)
+
+### Added
+
+- **Mastra.** `@wakeshift/sdk/mastra` serves Wakeshift from a Mastra `MCPServer` (`@mastra/mcp` 2.7 or later): `attachMastra(wake, opts)`, then `attached.inputs` and `attached.events` for the Mastra tools that subscribe, and `attached.serve(new MCPServer({ … }))`. Everything `attach` gives an `McpServer` works there: Wakeshift's block (text and `_meta`) in your wrapped tools' results, the built-in tools, MCP Events, Claude Code's `wakeshift_wait`, and who's calling (`identify` gets the request's `ctx`). Mastra's own MCP Events keep working beside Wakeshift's: `events/list` lists both. See [Mastra](README.md#mastra).
+- **xmcp.** `@wakeshift/sdk/xmcp` brings Wakeshift into an xmcp app through its tool files: `attachXmcp(wake, opts)`, then `attached.inputs` and `attached.events` in the tools that subscribe, and `attached.tool("subscribe_events")` (and the other two) for a tool file each. xmcp offers no way to add MCP methods, so clients that subscribe natively (ChatGPT) and Claude Code's `wakeshift_wait` aren't served there; Claude Code and every other agent are woken their usual ways. See [xmcp](README.md#xmcp).
+- Both are subpath exports, so an app that uses neither loads neither, and `@mastra/mcp` and `xmcp` are optional peer dependencies.
+
+### Changed
+
+- **A smaller package.** It no longer ships source maps (`dist/*.js.map`), which carried the SDK's TypeScript source inline: about half the unpacked size. Stack traces point at the compiled JavaScript in `dist/`, which is readable as it is.
+- **A clearer error from `attach`.** Given something other than an `McpServer`, `attach` says what it got and what it takes, and, for a framework it recognizes (Mastra's `MCPServer`, punkpeye's `fastmcp`, a low-level `Server`, a Cloudflare `McpAgent`), what to do instead (for Mastra, `attachMastra`), with a link to [the frameworks Wakeshift works with](https://wakeshift.ai/docs/frameworks). It says to call `attach` before connecting only when the server is already connected.
+
 ## 0.6.0 (2026-10-31)
 
 ### Breaking

package/README.md

@@ -206,6 +206,83 @@ What's different on 2.x:
 - Write your schemas, events' included, with zod 4 (4.2 or later), which 2.x requires.
 - 2.x speaks MCP protocol 2026-07-28 itself, and `createMcpHandler` answers older clients too, so clients on either revision connect with nothing more to set up. Wakeshift lists its tools for each request's client, so `tools/list` is cached by that client only, whatever cache hint you set for it.
 
+## Mastra
+
+Mastra's `MCPServer` (`@mastra/mcp` 2.7 or later) builds its MCP server itself, so it has its own entry point, `@wakeshift/sdk/mastra` (0.7.0 or later). Wrap the `execute` of each Mastra tool that subscribes, and serve your `MCPServer` with it:
+
+```ts
+import { createTool } from "@mastra/core/tools"
+import { MCPServer } from "@mastra/mcp"
+import { z } from "zod"
+import { Wakeshift } from "@wakeshift/sdk"
+import { attachMastra } from "@wakeshift/sdk/mastra"
+
+const wake = new Wakeshift({ key: process.env.WAKESHIFT_KEY! })
+const ciFinished = wake.defineEvent("ci.finished", {
+  description: "CI finished on a GitHub repo",
+  args: z.object({ owner: z.string(), repo: z.string() }),
+  payload: z.object({ branch: z.string(), conclusion: z.string() }),
+  text: (run, { owner, repo }) => `CI ${run.conclusion} on ${owner}/${repo} ${run.branch}`,
+})
+
+// identify gets the request's MCP context: the verified token is ctx.http?.authInfo.
+const attached = attachMastra(wake, { identify: (ctx) => ({ user: myUser(ctx.http?.authInfo) }) })
+
+const watchCi = createTool({
+  id: "watch_ci",
+  description: "Watch CI on a repo",
+  inputSchema: attached.inputs(z.object({ owner: z.string(), repo: z.string() })),
+  execute: attached.events("watch_ci", async ({ owner, repo }: { owner: string; repo: string }, call) => {
+    await call.subscribe(ciFinished, { owner, repo }, { reason: `Watching ${owner}/${repo}` })
+    return `Watching CI on ${owner}/${repo}.`
+  }),
+})
+
+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.
+
+- `attached.events(name, handler)` wraps a tool's `execute` for the tool your `MCPServer` serves under `name` (its key in `tools`). `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.
+- Your own MCP Events (`MCPServer`'s `events`) keep working: `events/list` lists yours and Wakeshift's, and each request goes to whichever serves the event it names.
+- `attached.serve` checks your `@mastra/mcp` version and throws for one outside 2.7–2.x.
+
+## xmcp
+
+xmcp builds its MCP server from your tool files, so Wakeshift comes in through them, with `@wakeshift/sdk/xmcp` (0.7.0 or later):
+
+```ts
+import { z } from "zod"
+import { Wakeshift } from "@wakeshift/sdk"
+import { attachXmcp } from "@wakeshift/sdk/xmcp"
+
+// src/wake.ts
+const wake = new Wakeshift({ key: process.env.WAKESHIFT_KEY! })
+const ciFinished = wake.defineEvent("ci.finished", {
+  description: "CI finished on a GitHub repo",
+  args: z.object({ owner: z.string(), repo: z.string() }),
+  payload: z.object({ branch: z.string(), conclusion: z.string() }),
+  text: (run, { owner, repo }) => `CI ${run.conclusion} on ${owner}/${repo} ${run.branch}`,
+})
+// identify gets xmcp's tool context: the verified token is extra.authInfo.
+const attached = attachXmcp(wake, { identify: (extra) => ({ user: myUser(extra.authInfo) }) })
+
+// src/tools/watch_ci.ts: export these three
+const schema = attached.inputs({ owner: z.string(), repo: z.string() })
+const metadata = { name: "watch_ci", description: "Watch CI on a repo" }
+const handler = attached.events("watch_ci", async ({ owner, repo }: { owner: string; repo: string }, call) => {
+  await call.subscribe(ciFinished, { owner, repo }, { reason: `Watching ${owner}/${repo}` })
+  return `Watching CI on ${owner}/${repo}.`
+})
+
+// src/tools/subscribe_events.ts, and the same for unsubscribe_events and list_subscriptions
+const tool = attached.tool("subscribe_events")
+// export const schema = tool.schema; export const metadata = tool.metadata; export default tool.handler
+```
+
+Each wrapped tool's result gets Wakeshift's addition in its content and `_meta` (not in `structuredContent`, which xmcp checks strictly against your output schema). xmcp can't serve MCP methods of an app's own, so on xmcp there are no MCP Events (ChatGPT and other clients that subscribe natively can't subscribe) and no `wakeshift_wait`: Claude Code is woken its other ways, and every other agent as usual.
+
 ## Reference
 
 ### `new Wakeshift({ key, core?, fetch?, timeoutMs?, onWarning? })`

package/dist/discover.js

@@ -125,4 +125,3 @@ export function serveStateless(host, opts = {}) {
         return out;
     });
 }
-//# sourceMappingURL=discover.js.map

package/dist/errors.js

@@ -25,4 +25,3 @@ export class WakeshiftError extends Error {
 export function isCode(err, code) {
     return err instanceof WakeshiftError && err.code === code;
 }
-//# sourceMappingURL=errors.js.map

package/dist/events.js

@@ -8,7 +8,7 @@
 // https://wakeshift.ai/docs/events has the guide.
 import { RpcError } from "./mcp.js";
 import { isSchema, objectFromShape, safeParse, toJsonSchema } from "./zod.js";
-import { hostOf } from "./host.js";
+import { capabilitiesError, hostOf } from "./host.js";
 import { WakeshiftError } from "./errors.js";
 import { DELIVERY, EXTENSION_KEY, HEADER_MISMATCH, INTERNAL_ERROR, INVALID_PARAMS, TOP_LEVEL_KEY, NAME_HEADER, RESULT_TYPE, codesFor, dialectOf, headerValue, } from "./spec.js";
 import { toolCallOf, userAgentOf } from "./wakeshift.js";
@@ -395,13 +395,20 @@ export const LIST_TOOL_DESCRIPTION = EVENT_TOOL_TEXT.list_description;
 const MAX_LISTED_EVENTS = 20;
 /** @internal The events part of Wakeshift.attach. */
 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. */
+export function checkAttach(events, opts, what = "attach") {
     if (events.length === 0)
-        throw new Error("wakeshift: attach needs at least one event (wake.defineEvent) defined first");
+        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: attach's tools names "${t}": its own tools are ${BUILTIN_TOOLS.join(", ")}`);
+            throw new Error(`wakeshift: ${what}'s tools names "${t}": its own tools are ${BUILTIN_TOOLS.join(", ")}`);
     }
-    const host = hostOf(server);
+}
+/** @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);
     // 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;
@@ -423,9 +430,9 @@ export function attachEvents(wake, server, events, opts = {}) {
         host.registerCapabilities({ [TOP_LEVEL_KEY]: { listChanged: false }, extensions: { [EXTENSION_KEY]: { listChanged: false } } });
     }
     catch (err) {
-        throw new Error("wakeshift: call attach before connecting the server to a transport", { cause: err });
+        throw capabilitiesError(host, err);
     }
-    if (!host.handlers()) {
+    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");
@@ -704,4 +711,3 @@ export function rpcErrorOf(err, codes) {
     }
     return new RpcError(INTERNAL_ERROR, "Wakeshift refused the subscription: " + err.detail);
 }
-//# sourceMappingURL=events.js.map

package/dist/harness.js

@@ -75,4 +75,3 @@ function slug(name) {
         id = id.slice(0, 40).replace(/^-+|-+$/g, "");
     return id.length < 2 ? "agent" : id;
 }
-//# sourceMappingURL=harness.js.map

package/dist/host.d.ts

@@ -1,2 +1,4 @@
+/** Where the docs list the MCP server frameworks Wakeshift works with, and how. */
+export declare const FRAMEWORKS_DOCS = "https://wakeshift.ai/docs/frameworks";
 /** The protocol revision that has server/discover, MCP Events and the tasks extension. */
 export declare const STATELESS_VERSION = "2026-07-28";

package/dist/host.js

@@ -37,11 +37,83 @@ function lowOf(server) {
  * Server has projectCallToolResult, which 1.x's lacks.
  */
 export function hostOf(server) {
+    if (!isMcpServer(server))
+        throw new Error(unsupportedServer(server));
+    const low = server.server;
+    return typeof low.projectCallToolResult === "function" ? new V2Host(server) : new V1Host(server);
+}
+/** Where the docs list the MCP server frameworks Wakeshift works with, and how. */
+export const FRAMEWORKS_DOCS = "https://wakeshift.ai/docs/frameworks";
+// isMcpServer: an McpServer from either MCP SDK (its low-level server, and registerTool).
+function isMcpServer(server) {
     const low = server?.server;
-    if (!low || typeof low.setRequestHandler !== "function" || typeof server.registerTool !== "function") {
-        throw new Error("wakeshift: attach takes an McpServer, from @modelcontextprotocol/server 2.x or @modelcontextprotocol/sdk 1.x (@modelcontextprotocol/sdk/server/mcp.js)");
+    return !!low && typeof low.setRequestHandler === "function" && typeof server.registerTool === "function";
+}
+const TAKES = "wakeshift: attach takes an McpServer, from @modelcontextprotocol/server 2.x or @modelcontextprotocol/sdk 1.x (@modelcontextprotocol/sdk/server/mcp.js)";
+/**
+ * @internal What attach says when it's given something other than an
+ * McpServer: what it got, what it takes, and, for a framework it knows,
+ * what to do instead.
+ */
+export function unsupportedServer(server) {
+    const got = describe(server);
+    const hint = frameworkHint(server);
+    return `${TAKES}, and got ${got}.${hint ? " " + hint : ""} Frameworks Wakeshift works with, and how: ${FRAMEWORKS_DOCS}`;
+}
+function has(o, ...fns) {
+    return !!o && (typeof o === "object" || typeof o === "function") && fns.every((f) => typeof o[f] === "function");
+}
+function ctorName(o) {
+    const name = o?.constructor?.name;
+    return typeof name === "string" && name && name !== "Object" ? name : "";
+}
+// describe names what attach was given: its class, else its type.
+function describe(server) {
+    if (server === null)
+        return "null";
+    if (server === undefined)
+        return "undefined";
+    if (typeof server !== "object")
+        return `a ${typeof server}`;
+    const name = ctorName(server);
+    return name ? `a ${name}` : "an object";
+}
+// frameworkHint says what to do for a server from a framework attach knows
+// but can't take: "" for any other.
+function frameworkHint(server) {
+    if (!server || typeof server !== "object")
+        return "";
+    // Mastra's MCPServer (@mastra/mcp): builds its MCP server per request, inside.
+    if (has(server, "startHTTP", "convertTools") || (has(server, "startHTTP", "startStdio") && "toolActions" in server)) {
+        return "This looks like Mastra's MCPServer (@mastra/mcp), which builds its MCP server inside: use attachMastra from @wakeshift/sdk/mastra.";
     }
-    return typeof low.projectCallToolResult === "function" ? new V2Host(server) : new V1Host(server);
+    // punkpeye's fastmcp: its FastMCP, or a session of it.
+    if (has(server, "addTool", "start") && ctorName(server) === "FastMCP") {
+        return "This looks like fastmcp's FastMCP (punkpeye), which Wakeshift doesn't support: it refuses MCP protocol 2026-07-28.";
+    }
+    if (ctorName(server) === "FastMCPSession") {
+        return "This looks like a fastmcp session (punkpeye), which Wakeshift doesn't support: fastmcp refuses MCP protocol 2026-07-28.";
+    }
+    // A low-level Server, not the McpServer around it.
+    if (has(server, "setRequestHandler", "connect") && !has(server, "registerTool")) {
+        return "This is a low-level MCP Server: pass the McpServer instead (new McpServer(…), whose .server it is).";
+    }
+    // Cloudflare's McpAgent: its server is the McpServer.
+    if ("server" in server && has(server, "init") && isMcpServer(server.server)) {
+        return "This looks like a Cloudflare McpAgent: pass its McpServer (this.server).";
+    }
+    return "";
+}
+/**
+ * @internal attach's error when the server refused Wakeshift's
+ * capabilities: an McpServer already connected to a transport, or
+ * whatever else its MCP SDK said.
+ */
+export function capabilitiesError(host, err) {
+    const low = host.server.server;
+    if (low?.transport)
+        return new Error("wakeshift: call attach before connecting the server to a transport", { cause: err });
+    return new Error(`wakeshift: attach couldn't add Wakeshift's capabilities to this server: ${String(err?.message ?? err)}`, { cause: err });
 }
 // headerOf reads a header from a plain record (1.x's requestInfo.headers).
 function headerOf(headers, name) {
@@ -85,6 +157,7 @@ export function v2Req(raw) {
 }
 class BaseHost {
     server;
+    servesEvents = true;
     constructor(server) {
         this.server = server;
     }
@@ -192,6 +265,111 @@ function objectFromV4Shape(shape) {
         return z4.object({});
     return z4.object(shape);
 }
+// ── Framework adapters (mastra.ts, xmcp.ts) ─────────────────────────────
+/**
+ * @internal The Host for a low-level Server from @modelcontextprotocol/server
+ * 2.x, as a framework builds one for each request and fills in itself
+ * (Mastra's MCPServer). It has no McpServer to register attach's own
+ * tools on, so they're kept here and served from its handler map, beneath
+ * every other wrapper attach adds: tools/list lists them after the
+ * framework's own, and tools/call answers them. Everything else is
+ * V2Host's, on the same map.
+ */
+export function lowServerHost(low, framework) {
+    if (!low || typeof low.setRequestHandler !== "function" || !(low._requestHandlers instanceof Map)) {
+        throw new Error(`wakeshift: ${framework} built an MCP server Wakeshift can't serve (no request handlers it can wrap): check for a newer @wakeshift/sdk`);
+    }
+    return new LowV2Host(new ToolRegistry(low), framework);
+}
+// ToolRegistry stands in for an McpServer around a low-level Server: what
+// attach registers on it is listed and called through the server's handlers.
+class ToolRegistry {
+    server;
+    tools = new Map();
+    constructor(server) {
+        this.server = server;
+        const handlers = server._requestHandlers;
+        const list = handlers.get("tools/list");
+        const call = handlers.get("tools/call");
+        if (list) {
+            Map.prototype.set.call(handlers, "tools/list", async (request, raw) => {
+                const out = await list(request, raw);
+                const own = [...this.tools].filter(([, t]) => t.enabled);
+                if (own.length === 0 || !out || !Array.isArray(out.tools))
+                    return out;
+                const listed = new Set(out.tools.map((t) => t?.name));
+                return { ...out, tools: [...out.tools, ...own.filter(([name]) => !listed.has(name)).map(([name, t]) => listedTool(name, t))] };
+            });
+        }
+        if (call) {
+            Map.prototype.set.call(handlers, "tools/call", async (request, raw) => {
+                const t = this.tools.get(request?.params?.name);
+                if (!t || !t.enabled)
+                    return call(request, raw);
+                const parsed = await t.schema.safeParseAsync(request?.params?.arguments ?? {});
+                if (!parsed.success) {
+                    return { isError: true, content: [{ type: "text", text: `Invalid arguments for tool ${request.params.name}: ${parsed.error.message}` }] };
+                }
+                return t.cb(parsed.data, raw);
+            });
+        }
+    }
+    registerTool(name, config, cb) {
+        const t = { description: config.description, annotations: config.annotations, schema: config.inputSchema, cb, enabled: true };
+        this.tools.set(name, t);
+        return {
+            enable: () => void (t.enabled = true),
+            disable: () => void (t.enabled = false),
+        };
+    }
+}
+function listedTool(name, t) {
+    const out = { name, description: t.description, inputSchema: z4.toJSONSchema(t.schema, { io: "input" }) };
+    if (t.annotations)
+        out.annotations = t.annotations;
+    return out;
+}
+class LowV2Host extends V2Host {
+    framework;
+    constructor(registry, framework) {
+        super(registry);
+        this.framework = framework;
+    }
+    registeredTool() {
+        return null; // the framework's own tools are its own
+    }
+}
+/**
+ * @internal The Host for a framework that keeps its MCP server to itself
+ * (xmcp): attach's own tools go to the adapter, the request is read its
+ * way, and there are no handlers to wrap, so no MCP Events, no wait tool
+ * and no tools/list changes. Its tools are on @modelcontextprotocol/server
+ * 2.x, so they're written in zod 4.
+ */
+export function toolsOnlyHost(opts) {
+    const noop = () => { };
+    return {
+        version: 2,
+        framework: opts.framework,
+        servesEvents: false,
+        server: { server: {}, registerTool: noop },
+        zod: z4,
+        req: opts.req,
+        registerCapabilities: noop,
+        registerTool(name, config, cb) {
+            opts.registerTool(name, config, cb);
+            return { enable: noop, disable: noop };
+        },
+        setMethod: noop,
+        setTaskMethod: noop,
+        handlers: () => null,
+        clientName: () => undefined,
+        clientCapabilities: () => undefined,
+        onInitialized: noop,
+        registeredTool: () => null,
+        validOutput: async () => true,
+    };
+}
 /** The protocol revision that has server/discover, MCP Events and the tasks extension. */
 export const STATELESS_VERSION = "2026-07-28";
 /** @internal Whether a request is protocol 2026-07-28: its _meta names it, or its MCP-Protocol-Version header does. */
@@ -200,4 +378,3 @@ export function is2026(req) {
         return true;
     return req.header("mcp-protocol-version") === STATELESS_VERSION;
 }
-//# sourceMappingURL=host.js.map

package/dist/index.js

@@ -5,4 +5,3 @@ export { parseKey, signAssertion } from "./key.js";
 export { WakeEvent, ArgsError, EVENT_TOOL_TEXT, SUBSCRIBE_TOOL_DESCRIPTION, UNSUBSCRIBE_TOOL_DESCRIPTION, LIST_TOOL_DESCRIPTION, BUILTIN_TOOLS, MAX_STATUS_SUBSCRIPTIONS, } from "./events.js";
 export { CallEnded, } from "./toolcall.js";
 export { EXTENSION_KEY, TEXT_META, REVISION as EVENTS_REVISION } from "./spec.js";
-//# sourceMappingURL=index.js.map

package/dist/key.js

@@ -108,4 +108,3 @@ export function signAssertion(k, core, now = Date.now(), appId) {
     const input = b64({ alg: "EdDSA", typ: "app+jwt", kid: k.kid }) + "." + b64(claims);
     return input + "." + sign(null, Buffer.from(input), k.privateKey).toString("base64url");
 }
-//# sourceMappingURL=key.js.map

package/dist/mastra.d.ts

@@ -0,0 +1,79 @@
+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 { CallEnded, type ToolCall, 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. */
+export declare const MASTRA_MCP_RANGE = ">=2.7.0 <3.0.0";
+/**
+ * The request context Wakeshift reads in Mastra: the MCP SDK 2.x's
+ * ServerContext (`ctx`) of the request, the verified token in
+ * `ctx.http?.authInfo`. A Mastra tool sees the same as `context.mcp.extra`.
+ */
+export type MastraContext = ToolCallExtra;
+/** attachMastra's options: attach's, with identify and events.native getting the request's ctx. */
+export type MastraAttachOptions = AttachOptions<MastraContext>;
+/** The second argument Mastra passes a tool's execute: what Wakeshift reads of it. */
+export interface MastraToolContext {
+    mcp?: {
+        extra?: {
+            mcpReq?: object;
+            [k: string]: any;
+        };
+        [k: string]: any;
+    };
+    [k: string]: any;
+}
+/** Wakeshift in a Mastra MCPServer: make it with attachMastra, then serve your MCPServer with it. */
+export declare class MastraAttached {
+    private readonly wake;
+    private readonly opts;
+    private readonly wrapped;
+    private readonly scopes;
+    private readonly shapes;
+    private readonly served;
+    /**
+     * A tool's input schema plus Wakeshift's three optional arguments
+     * (session_key, harness and conversation_id), for a wrapped tool's
+     * inputSchema: `inputSchema: attached.inputs(z.object({ … }))`.
+     */
+    inputs<O extends z4.ZodObject>(schema: O): z4.ZodObject<O["shape"] & WakeInputsV4, O["_zod"]["config"]>;
+    inputs<O extends z3.AnyZodObject>(schema: O): z3.ZodObject<O["shape"] & WakeInputsV3, O["_def"]["unknownKeys"], O["_def"]["catchall"]>;
+    inputs<S extends ZodRawShapeCompat>(shape: S): S & WakeInputs;
+    /** A tool's output schema plus an optional wakeshift string, for a wrapped tool's outputSchema. Optional: see attach's. */
+    output<O extends z4.ZodObject>(schema: O): z4.ZodObject<O["shape"] & WakeOutputV4, O["_zod"]["config"]>;
+    output<O extends z3.AnyZodObject>(schema: O): z3.ZodObject<O["shape"] & WakeOutputV3, O["_def"]["unknownKeys"], O["_def"]["catchall"]>;
+    output<S extends ZodRawShapeCompat>(shape: S): S & WakeOutputShape;
+    /**
+     * Wraps a Mastra tool's execute, for the tool your MCPServer serves under
+     * the same name (its key in `tools`): `execute: attached.events("watch_ci",
+     * async (args, call) => …)`. handler gets your own arguments, a ToolCall
+     * and Mastra's tool context, and returns what a Mastra tool returns (a
+     * string, or your output). The reply an MCP client gets carries what
+     * Wakeshift adds for the conversation; a call that fails ends the
+     * subscriptions it made. Its inputSchema must come from attached.inputs.
+     * Run outside an MCP request (by an agent, a workflow or Studio), the
+     * handler gets a call whose subscribe throws.
+     */
+    events<P extends Record<string, any> = Record<string, any>, R = unknown>(name: string, handler: (args: P, call: ToolCall<MastraContext>, context: MastraToolContext) => R | Promise<R>): (input: P & WakeArgs, context?: any) => Promise<R>;
+    /**
+     * Serves Wakeshift from your MCPServer (@mastra/mcp 2.7 or later, 2.x),
+     * after your last defineEvent: attach's own tools, MCP Events for clients
+     * that speak it, the wait tool, and your wrapped tools' blocks. Returns
+     * the server. Call it once, before the server takes requests.
+     */
+    serve<S extends object>(server: S): S;
+    private attachTo;
+    private wrapCalls;
+}
+/**
+ * Wakeshift for a Mastra MCPServer (@mastra/mcp 2.7 or later). Returns the
+ * handle your tools use (attached.inputs, attached.events) and that serves
+ * your MCPServer (attached.serve). Options are attach's; identify and
+ * events.native get the request's MCP context (ctx: the verified token is
+ * ctx.http?.authInfo).
+ */
+export declare function attachMastra(wake: Wakeshift, opts?: MastraAttachOptions): MastraAttached;
+export { CallEnded, type BuiltinTool, type Identity, type ToolCall, type WakeArgs };