@wakeshift/sdk 0.6.0 → 0.7.0

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

package/dist/toolcall.js

@@ -224,8 +224,8 @@ function sameJSON(a, b) {
 function detailOf(err) {
     return err instanceof WakeshiftError ? err.detail : String(err?.message ?? err);
 }
-/** One tools/call of a wrapped tool: what its handler subscribed, for the block and the rollback. */
-class CallScope {
+/** @internal One tools/call of a wrapped tool: what its handler subscribed, for the block and the rollback. */
+export class CallScope {
     at;
     args;
     user;
@@ -441,6 +441,9 @@ function isRecord(v) {
  * _meta's). conversation is ChatGPT's conversation, when it names one.
  */
 export function nativeOf(at, extra, identified) {
+    // A server that doesn't serve MCP Events (an xmcp app's) has no native callers.
+    if (!at.host.servesEvents)
+        return { native: false, conversation: null };
     const req = at.host.req(extra);
     const meta = (req.meta ?? {});
     const conversation = typeof meta["openai/session"] === "string" && meta["openai/session"] ? meta["openai/session"] : null;
@@ -532,24 +535,49 @@ export class Attached {
             }
             outputSchema = tool.outputSchema;
         }
-        else {
+        else if (!host.framework) {
             this.at.warnOnce("internals", "wakeshift: this MCP SDK keeps its tools where Wakeshift can't read them, so wrapped tools' registration and output aren't checked");
         }
-        const str = (k) => (typeof input[k] === "string" && input[k] ? input[k] : undefined);
-        const call = new CallScope(this.at, name, extra, { session: str(SESSION_ARG), harness: str(HARNESS_ARG), conversation: str(CONVERSATION_ARG) });
-        const appArgs = {};
-        for (const [k, v] of Object.entries(input))
-            if (!WAKE_KEYS.includes(k))
-                appArgs[k] = v;
+        const { call, appArgs } = this.begin(name, input, extra);
         let result;
         try {
             result = await handler(appArgs, call);
         }
         catch (err) {
-            await call.end();
-            await call.rollback();
+            await this.fail(call);
             throw err;
         }
+        return this.finish(call, result, outputSchema);
+    }
+    /**
+     * @internal The first half of a wrapped call: the call's scope, from the
+     * tool's arguments (Wakeshift's three among them) and the request's
+     * context, and the app's own arguments. finish (or fail) ends it.
+     */
+    begin(name, input, extra) {
+        const str = (k) => (typeof input[k] === "string" && input[k] ? input[k] : undefined);
+        const call = new CallScope(this.at, name, extra, { session: str(SESSION_ARG), harness: str(HARNESS_ARG), conversation: str(CONVERSATION_ARG) });
+        const appArgs = {};
+        for (const [k, v] of Object.entries(input ?? {}))
+            if (!WAKE_KEYS.includes(k))
+                appArgs[k] = v;
+        return { call, appArgs };
+    }
+    /** @internal Ends a call whose handler threw: what it subscribed is rolled back. */
+    async fail(call) {
+        await call.end();
+        await call.rollback();
+    }
+    /**
+     * @internal The second half of a wrapped call: the handler's result with
+     * Wakeshift's block, or rolled back (a failed result, a canceled call, an
+     * output its schema refuses). outputSchema is the tool's, as its MCP SDK
+     * checks it (undefined: not checked here).
+     */
+    async finish(call, result, outputSchema) {
+        const host = this.at.host;
+        const name = call.tool;
+        const extra = call.extra;
         await call.end();
         // Rollback is decided from the final result, the one the client would
         // receive: MCP validates the output after this callback returns, so
@@ -589,6 +617,11 @@ export class Attached {
      * sets the handler when the first tool is registered, perhaps after
      * attach, so a later set is wrapped too (as tasks.ts does).
      */
+    /** @internal Marks name as a wrapped tool, for tools/list (a framework adapter's tool, wrapped outside this handle). */
+    markWrapped(name) {
+        if (!this.wrapped.has(name))
+            this.wrapped.set(name, true);
+    }
     amendToolsList() {
         const handlers = this.at.host.handlers();
         if (!handlers)
@@ -616,4 +649,3 @@ export class Attached {
         }
     }
 }
-//# sourceMappingURL=toolcall.js.map

package/dist/wakeshift.js

@@ -304,6 +304,15 @@ export class Wakeshift {
         this.serving = true; // the manifest is sent automatically from now on
         return attached;
     }
+    /**
+     * @internal For a framework adapter (@wakeshift/sdk/mastra, /xmcp): the
+     * defined events, and from now on this process serves the app's tools,
+     * so the manifest is sent automatically, as after attach.
+     */
+    serveEvents() {
+        this.serving = true;
+        return [...this.events.values()];
+    }
     /**
      * @internal Sends the manifest with the defined events, once (again after
      * a defineEvent), from a process that serves the app's tools (attach). A
@@ -410,4 +419,3 @@ export class Wakeshift {
         return new WakeshiftError(0, "unreachable", `can't reach Wakeshift at ${this.core} (${why}). Check that WAKESHIFT_CORE, or the core option, is the address of the console your key came from`, { cause: err });
     }
 }
-//# sourceMappingURL=wakeshift.js.map

package/dist/xmcp.d.ts

@@ -0,0 +1,73 @@
+import type { AuthInfo, CallToolResult } from "./mcp.js";
+import type { ZodRawShapeCompat } from "./zod.js";
+import { BUILTIN_TOOLS, type BuiltinTool, type Identity } from "./events.js";
+import { type ToolCall, 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. */
+export interface XmcpExtra {
+    signal?: AbortSignal;
+    authInfo?: AuthInfo;
+    sessionId?: string;
+    _meta?: Record<string, unknown>;
+    requestId?: string | number;
+    requestInfo?: {
+        headers?: Record<string, string | string[] | undefined>;
+    };
+    clientInfo?: {
+        name?: string;
+        version?: string;
+    };
+    [k: string]: any;
+}
+/** attachXmcp's options. */
+export interface XmcpAttachOptions {
+    /**
+     * Who is behind a request: { user }, your own ID for the person, from your
+     * own sign-in (the verified token is extra.authInfo). Without it, requests
+     * 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[];
+}
+/** One of attach's own tools as an xmcp tool file exports it. */
+export interface XmcpTool {
+    /** The tool's input, a zod 4 shape: `export const schema = tool.schema`. */
+    schema: ZodRawShapeCompat;
+    /** Its name, description and annotations: `export const metadata = tool.metadata`. */
+    metadata: {
+        name: string;
+        description: string;
+        annotations?: Record<string, unknown>;
+    };
+    /** Its handler: `export default tool.handler`. */
+    handler: (args: Record<string, unknown>, extra: XmcpExtra) => Promise<CallToolResult>;
+}
+/** Wakeshift in an xmcp app: what your tool files use. Make it with attachXmcp. */
+export declare class XmcpAttached {
+    private readonly attached;
+    private readonly own;
+    /**
+     * A tool's schema plus Wakeshift's three optional arguments (session_key,
+     * harness and conversation_id): `export const schema = attached.inputs({ … })`.
+     */
+    inputs<S extends ZodRawShapeCompat>(shape: S): S & WakeInputs;
+    /**
+     * Wraps a tool's handler, for the tool file whose metadata names the same
+     * tool: `export default attached.events("watch_ci", async (args, call) => …)`.
+     * handler gets your own arguments and a ToolCall, and returns a string or
+     * a CallToolResult; the reply gets what Wakeshift adds for the
+     * conversation, and a call that fails ends the subscriptions it made. Its
+     * schema must come from attached.inputs.
+     */
+    events<P extends Record<string, any> = Record<string, any>>(name: string, handler: (args: P, call: ToolCall<XmcpExtra>) => WrappedResult | Promise<WrappedResult>): (args: P & WakeArgs, extra: XmcpExtra) => Promise<CallToolResult>;
+    /** One of attach's own tools, for a tool file of its own (src/tools/<name>.ts): its schema, metadata and handler. */
+    tool(name: BuiltinTool): XmcpTool;
+}
+/**
+ * Attaches Wakeshift to an xmcp app, after your last defineEvent. Returns
+ * what your tool files use: attached.inputs and attached.events for your
+ * 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 };

package/dist/xmcp.js

@@ -0,0 +1,125 @@
+// @wakeshift/sdk/xmcp: Wakeshift in an xmcp app (https://xmcp.dev).
+//
+// xmcp builds its MCP server itself, from the files in src/tools, and never
+// hands it to the app, so there's nothing for attach to take. What it does
+// hand the app is each tool: a file's schema, metadata and default-exported
+// handler. So the adapter works through tools alone, xmcp's supported way
+// in:
+//
+//   - a tool that subscribes is a tool file whose schema comes from
+//     attached.inputs and whose handler is attached.events(name, handler),
+//     which returns the result with Wakeshift's block in it (text and
+//     _meta), as attach's wrapper does;
+//   - attach's own tools (subscribe_events, unsubscribe_events,
+//     list_subscriptions) are tool files too, one line each from
+//     attached.tool(name);
+//   - who's calling is identify(extra), xmcp's handler context.
+//
+// xmcp's middleware sees only the methods it lists (tools/*, prompts/*,
+// resources/*), and only tools it has, so a server can't answer MCP Events
+// (events/*) or the wait tool's tasks/get here: clients that subscribe
+// natively (ChatGPT) aren't served, and Claude Code gets its usual wake
+// path instead of wakeshift_wait. Nothing here imports xmcp.
+//
+//   // src/wake.ts
+//   export const wake = new Wakeshift({ key: process.env.WAKESHIFT_KEY! })
+//   export const ciFinished = wake.defineEvent("ci.finished", { … })
+//   export const attached = attachXmcp(wake, { identify: (extra) => ({ user: userOf(extra.authInfo) }) })
+//
+//   // src/tools/watch_ci.ts
+//   export const schema = attached.inputs({ owner: z.string(), repo: z.string() })
+//   export const metadata = { name: "watch_ci", description: "Watch CI on a repo" }
+//   export default attached.events("watch_ci", async ({ owner, repo }, call) => { … })
+//
+//   // src/tools/subscribe_events.ts (and the same for the other two)
+//   const tool = attached.tool("subscribe_events")
+//   export const schema = tool.schema
+//   export const metadata = tool.metadata
+//   export default tool.handler
+import { BUILTIN_TOOLS, attachHost, checkAttach } from "./events.js";
+import { toolsOnlyHost, v1Req } from "./host.js";
+import { WAKESHIFT_FIELD } from "./toolcall.js";
+const CLIENT_INFO_META = "io.modelcontextprotocol/clientInfo";
+// xmcpReq reads xmcp's handler context: 1.x-shaped (_meta, requestInfo's
+// headers, authInfo, signal), with the client's info beside it rather than
+// in _meta, where Wakeshift looks for it.
+function xmcpReq(raw) {
+    const req = v1Req(raw);
+    const info = raw?.clientInfo;
+    if (!info?.name || (req.meta && CLIENT_INFO_META in req.meta))
+        return req;
+    return { ...req, meta: { ...(req.meta ?? {}), [CLIENT_INFO_META]: info } };
+}
+/** Wakeshift in an xmcp app: what your tool files use. Make it with attachXmcp. */
+export class XmcpAttached {
+    attached;
+    own;
+    /** @internal */
+    constructor(attached, own) {
+        this.attached = attached;
+        this.own = own;
+    }
+    /**
+     * A tool's schema plus Wakeshift's three optional arguments (session_key,
+     * harness and conversation_id): `export const schema = attached.inputs({ … })`.
+     */
+    inputs(shape) {
+        return this.attached.inputs(shape);
+    }
+    /**
+     * Wraps a tool's handler, for the tool file whose metadata names the same
+     * tool: `export default attached.events("watch_ci", async (args, call) => …)`.
+     * handler gets your own arguments and a ToolCall, and returns a string or
+     * a CallToolResult; the reply gets what Wakeshift adds for the
+     * conversation, and a call that fails ends the subscriptions it made. Its
+     * schema must come from attached.inputs.
+     */
+    events(name, handler) {
+        const cb = this.attached.events(name, handler);
+        return async (args, extra) => {
+            const out = (await cb(args, extra));
+            // xmcp checks structuredContent against the tool's output schema after
+            // the handler, refusing fields it doesn't name: the block stays in the
+            // content and _meta only.
+            const sc = out?.structuredContent;
+            if (sc && typeof sc === "object" && !Array.isArray(sc) && WAKESHIFT_FIELD in sc) {
+                const { [WAKESHIFT_FIELD]: _block, ...rest } = sc;
+                return { ...out, structuredContent: rest };
+            }
+            return out;
+        };
+    }
+    /** One of attach's own tools, for a tool file of its own (src/tools/<name>.ts): its schema, metadata and handler. */
+    tool(name) {
+        const t = this.own.get(name);
+        if (!t) {
+            throw new Error(BUILTIN_TOOLS.includes(name)
+                ? `wakeshift: attachXmcp's tools leave out ${name}`
+                : `wakeshift: attached.tool("${name}"): attach's own tools are ${BUILTIN_TOOLS.join(", ")}`);
+        }
+        return t;
+    }
+}
+/**
+ * Attaches Wakeshift to an xmcp app, after your last defineEvent. Returns
+ * what your tool files use: attached.inputs and attached.events for your
+ * own tools that subscribe, and attached.tool for attach's own three.
+ */
+export function attachXmcp(wake, opts = {}) {
+    const events = wake.serveEvents();
+    checkAttach(events, opts, "attachXmcp");
+    const own = new Map();
+    const host = toolsOnlyHost({
+        framework: "xmcp",
+        req: xmcpReq,
+        registerTool(name, config, cb) {
+            const metadata = { name, description: config.description };
+            if (config.annotations)
+                metadata.annotations = config.annotations;
+            own.set(name, { schema: config.inputSchema, metadata, handler: (args, extra) => cb(args ?? {}, extra) });
+        },
+    });
+    const attached = attachHost(wake, host, events, { identify: opts.identify, tools: opts.tools });
+    return new XmcpAttached(attached, own);
+}
+export { BUILTIN_TOOLS };

package/dist/zod.js

@@ -92,4 +92,3 @@ export function toJsonSchema(schema) {
     }
     return v1JsonSchema.toJsonSchemaCompat(schema);
 }
-//# sourceMappingURL=zod.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wakeshift/sdk",
-  "version": "0.6.0",
+  "version": "0.7.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>",
@@ -11,7 +11,9 @@
     "agents",
     "events",
     "webhooks",
-    "wakeshift"
+    "wakeshift",
+    "mastra",
+    "xmcp"
   ],
   "homepage": "https://github.com/wakeshift/wakeshift-node#readme",
   "repository": {
@@ -28,6 +30,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./mastra": {
+      "types": "./dist/mastra.d.ts",
+      "import": "./dist/mastra.js"
+    },
+    "./xmcp": {
+      "types": "./dist/xmcp.d.ts",
+      "import": "./dist/xmcp.js"
     }
   },
   "files": [
@@ -42,7 +52,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.test.json --noEmit",
     "test": "tsc -p tsconfig.test.json && node --test 'build-test/test/*.test.js' && npm run examples",
     "examples": "node scripts/check-examples.mjs",
@@ -54,7 +64,9 @@
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.23.0",
     "@modelcontextprotocol/server": "^2.0.0",
-    "zod": "^3.25.0 || ^4.0.0"
+    "zod": "^3.25.0 || ^4.0.0",
+    "@mastra/mcp": "^2.7.0",
+    "xmcp": "^1.9.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -62,6 +74,12 @@
     },
     "@modelcontextprotocol/server": {
       "optional": true
+    },
+    "@mastra/mcp": {
+      "optional": true
+    },
+    "xmcp": {
+      "optional": true
     }
   },
   "devDependencies": {