@wakeshift/sdk 0.6.0 → 0.7.1

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 };

package/dist/mastra.js

@@ -0,0 +1,248 @@
+// @wakeshift/sdk/mastra: Wakeshift in a Mastra MCPServer (@mastra/mcp 2.x).
+//
+// MCPServer builds a low-level MCP Server (@modelcontextprotocol/server
+// 2.x) for each request and fills it in itself; it never hands it to the
+// app, and its public extension points (Mastra tools, its own events) can't
+// carry what Wakeshift needs: a tool's result is Mastra's conversion of
+// what the tool returned, without _meta, which Codex's and Claude Code's
+// hooks read Wakeshift's beacon from; and there's no way to add a method
+// (tasks/get for the wait tool) or answer a tool's call another way.
+//
+// So serve() takes the one seam there is: MCPServer's createServerInstance,
+// a private method every transport (HTTP, stdio) builds its servers with.
+// Each server it builds gets what attach gives an McpServer, on that
+// server's request handlers (host.ts's lowServerHost): attach's own tools,
+// MCP Events, the wait tool and the 2026-07-28 tools/list changes; and the
+// tools wrapped with attached.events get Wakeshift's block in their results.
+// serve() checks @mastra/mcp's version and that the seam is there, and the
+// compatibility suite (sdk/compat, ts-mastra) runs it against Mastra's
+// newest release nightly, so a Mastra release that moves it shows up there.
+//
+// Mastra's own MCP Events (MCPServer's events option) keep working beside
+// Wakeshift's: events/list lists both, and every other events/* request
+// goes to whichever serves the event it names (Wakeshift's, if both do).
+//
+//   const attached = attachMastra(wake, { identify: (ctx) => ({ user: userOf(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 }, call) => {
+//       await call.subscribe(ciFinished, { owner, repo })
+//       return `Watching CI on ${owner}/${repo}.`
+//     }),
+//   })
+//   const server = attached.serve(new MCPServer({ id: "ci", name: "CI", version: "1.0.0", tools: { watch_ci: watchCi } }))
+import { createRequire } from "node:module";
+import { attachHost, checkAttach } from "./events.js";
+import { lowServerHost, toolsOnlyHost, v2Req } from "./host.js";
+import { Attached, CallEnded } from "./toolcall.js";
+/** The @mastra/mcp releases serve() is built for: 2.x, from 2.7. */
+export const MASTRA_MCP_RANGE = ">=2.7.0 <3.0.0";
+const EVENTS_METHODS = ["events/list", "events/subscribe", "events/unsubscribe", "events/poll", "events/stream"];
+/** @internal Whether a version of @mastra/mcp is one serve() is built for. */
+export function supportedMastra(version) {
+    const m = /^(\d+)\.(\d+)\./.exec(version);
+    return !!m && Number(m[1]) === 2 && Number(m[2]) >= 7;
+}
+// installedMastra is the @mastra/mcp version this process loads, if it can
+// tell (a bundled app may not ship package.json files).
+function installedMastra() {
+    try {
+        return createRequire(import.meta.url)("@mastra/mcp/package.json").version;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Wakeshift in a Mastra MCPServer: make it with attachMastra, then serve your MCPServer with it. */
+export class MastraAttached {
+    wake;
+    opts;
+    wrapped = new Set();
+    // The call each wrapped tool's execute belongs to, by its request (ctx.mcpReq,
+    // which Mastra passes the tool as context.mcp.extra.mcpReq).
+    scopes = new WeakMap();
+    // Only for inputs and output, which need no server.
+    shapes;
+    served = new WeakSet();
+    /** @internal Use attachMastra. */
+    constructor(wake, opts) {
+        this.wake = wake;
+        this.opts = opts;
+        const host = toolsOnlyHost({ framework: "mastra", req: v2Req, registerTool: () => { } });
+        this.shapes = new Attached({ wake, host, identify: () => undefined, clientOf: () => "", events: {}, warnOnce: () => { } });
+    }
+    inputs(schema) {
+        return this.shapes.inputs(schema);
+    }
+    output(schema) {
+        return this.shapes.output(schema);
+    }
+    /**
+     * 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(name, handler) {
+        if (!name || typeof name !== "string")
+            throw new Error("wakeshift: attached.events needs the tool's name, as your MCPServer serves it");
+        if (typeof handler !== "function")
+            throw new Error("wakeshift: attached.events needs a handler");
+        this.wrapped.add(name);
+        return async (input, context) => {
+            const key = context?.mcp?.extra?.mcpReq;
+            const scope = key && typeof key === "object" ? this.scopes.get(key) : undefined;
+            const args = {};
+            for (const [k, v] of Object.entries((input ?? {}))) {
+                if (k !== "session_key" && k !== "harness" && k !== "conversation_id")
+                    args[k] = v;
+            }
+            const call = scope && scope.call.tool === name ? scope.call : detachedCall(name, context);
+            return handler(args, call, context ?? {});
+        };
+    }
+    /**
+     * 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(server) {
+        const version = installedMastra();
+        if (version && !supportedMastra(version)) {
+            throw new Error(`wakeshift: attachMastra serves @mastra/mcp ${MASTRA_MCP_RANGE}, and this is ${version}: check for an @wakeshift/sdk that supports it`);
+        }
+        const s = server;
+        if (typeof s.createServerInstance !== "function") {
+            throw new Error(`wakeshift: attached.serve takes Mastra's MCPServer (@mastra/mcp ${MASTRA_MCP_RANGE}), and this one has no createServerInstance${version ? ` (@mastra/mcp ${version})` : ""}: check for a newer @wakeshift/sdk`);
+        }
+        if (this.served.has(server))
+            return server;
+        this.served.add(server);
+        const build = s.createServerInstance;
+        const self = this;
+        s.createServerInstance = function (...args) {
+            const low = build.apply(this, args);
+            self.attachTo(low);
+            return low;
+        };
+        return server;
+    }
+    // attachTo gives one server MCPServer built what attach gives an McpServer.
+    // A failure leaves the request served without Wakeshift, and says why once.
+    attachTo(low) {
+        try {
+            const host = lowServerHost(low, "Mastra's MCPServer");
+            const handlers = host.handlers();
+            const theirs = new Map();
+            for (const m of EVENTS_METHODS) {
+                const h = handlers.get(m);
+                if (h)
+                    theirs.set(m, h);
+            }
+            const events = this.wake.serveEvents();
+            const attached = attachHost(this.wake, host, events, this.opts);
+            for (const name of this.wrapped)
+                attached.markWrapped(name);
+            if (theirs.size > 0)
+                shareEvents(handlers, theirs, new Set(events.map((e) => e.name)));
+            this.wrapCalls(handlers, attached);
+        }
+        catch (err) {
+            this.wake.warnOnce("mastra-attach", `wakeshift: couldn't attach to the server Mastra's MCPServer built, so its requests are served without Wakeshift: ${String(err?.message ?? err)}`);
+        }
+    }
+    // wrapCalls runs each wrapped tool's call in a scope its execute finds, and
+    // adds Wakeshift's block to the result Mastra makes of what it returned.
+    wrapCalls(handlers, attached) {
+        const inner = handlers.get("tools/call");
+        if (!inner)
+            return;
+        Map.prototype.set.call(handlers, "tools/call", async (request, ctx) => {
+            const name = request?.params?.name;
+            if (typeof name !== "string" || !this.wrapped.has(name))
+                return inner(request, ctx);
+            const { call } = attached.begin(name, (request?.params?.arguments ?? {}), ctx);
+            const key = ctx?.mcpReq && typeof ctx.mcpReq === "object" ? ctx.mcpReq : undefined;
+            if (key)
+                this.scopes.set(key, { call });
+            let result;
+            try {
+                result = await inner(request, ctx);
+            }
+            catch (err) {
+                await attached.fail(call);
+                throw err;
+            }
+            finally {
+                if (key)
+                    this.scopes.delete(key);
+            }
+            if (!result || typeof result !== "object" || !Array.isArray(result.content)) {
+                // Not a tool's answer (a task handle, an input request): no block to
+                // add, so nothing the call subscribed stays.
+                await attached.fail(call);
+                this.wake.warnOnce("mastra-result:" + name, `wakeshift: ${name} answered with something other than a tool result (a Mastra task, or a request for input), so what it subscribed was rolled back: a wrapped tool must answer in one call`);
+                return result;
+            }
+            return attached.finish(call, result, undefined);
+        });
+    }
+}
+// shareEvents serves Mastra's own MCP Events beside Wakeshift's: events/list
+// lists both (Wakeshift's first, on the first page), and every other method
+// goes to whichever serves the event it names.
+function shareEvents(handlers, theirs, ours) {
+    for (const [method, their] of theirs) {
+        const mine = handlers.get(method);
+        if (!mine || mine === their)
+            continue;
+        if (method === "events/list") {
+            Map.prototype.set.call(handlers, method, async (request, ctx) => {
+                if (request?.params?.cursor !== undefined)
+                    return their(request, ctx);
+                const [a, b] = await Promise.all([mine(request, ctx), their(request, ctx)]);
+                const listed = [...(a?.events ?? []), ...(b?.events ?? []).filter((e) => !ours.has(e?.name ?? ""))];
+                return { ...b, ...a, events: listed, ...(b?.nextCursor !== undefined ? { nextCursor: b.nextCursor } : {}) };
+            });
+            continue;
+        }
+        Map.prototype.set.call(handlers, method, (request, ctx) => (ours.has(request?.params?.name) ? mine(request, ctx) : their(request, ctx)));
+    }
+}
+// detachedCall is the call a wrapped tool's handler gets outside an MCP
+// tools/call (an agent, a workflow or Studio ran the tool): nothing to subscribe.
+function detachedCall(tool, context) {
+    const refuse = () => Promise.reject(new Error(`wakeshift: ${tool} ran outside an MCP client's call to a server attachMastra serves (from an agent, a workflow or Studio?), so there's no conversation to subscribe`));
+    return {
+        user: undefined,
+        tool,
+        native: false,
+        nativeConversation: null,
+        session: null,
+        recognized: null,
+        extra: (context?.mcp?.extra ?? {}),
+        subscribe: refuse,
+        unsubscribe: refuse,
+        resolveSession: refuse,
+    };
+}
+/**
+ * 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 function attachMastra(wake, opts = {}) {
+    checkAttach(wake.serveEvents(), opts, "attachMastra");
+    return new MastraAttached(wake, opts);
+}
+export { CallEnded };

package/dist/mcp.js

@@ -19,4 +19,3 @@ export class RpcError extends Error {
             this.data = data;
     }
 }
-//# sourceMappingURL=mcp.js.map

package/dist/retry.js

@@ -55,4 +55,3 @@ function pause(ms, signal) {
         signal?.addEventListener("abort", stop, { once: true });
     });
 }
-//# sourceMappingURL=retry.js.map

package/dist/spec.js

@@ -42,4 +42,3 @@ export function headerValue(h) {
         return null;
     }
 }
-//# sourceMappingURL=spec.js.map

package/dist/tasks.js

@@ -156,4 +156,3 @@ export function serveTasks(wake, host, callerOf) {
 function detailOf(err) {
     return err instanceof WakeshiftError ? err.detail : String(err?.message ?? err);
 }
-//# sourceMappingURL=tasks.js.map

package/dist/toolcall.d.ts

@@ -202,5 +202,6 @@ export declare class Attached<C = any> {
      */
     events<A extends WakeArgs>(name: string, handler: (args: Omit<A, WakeKey>, call: ToolCall<C>) => WrappedResult | Promise<WrappedResult>): WrappedCallback<A, C>;
     private run;
+    amendToolsList(): void;
     private amendTools;
 }