@wakeshift/sdk 0.5.2 → 0.7.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 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
+
+- Both MCP SDKs are optional peer dependencies: install the one you use. npm no longer installs `@modelcontextprotocol/sdk` for you, so list it in your app's own dependencies if your code imports it (as the install line has always said).
+
+### Added
+
+- **`@modelcontextprotocol/server` 2.x.** `attach` now takes an `McpServer` from the MCP TypeScript SDK 2.x (2.0 or later) as well as from `@modelcontextprotocol/sdk` 1.x, and tells them apart by the server you pass. Everything works the same on both: wrapped tools (Wakeshift's block in text and in `structuredContent`, rollback, `call.subscribe`), the built-in tools, MCP Events (`events/list`, `events/subscribe`, `events/unsubscribe`, `events/poll`), Claude Code's `wakeshift_wait` with `tasks/get` and `tasks/cancel`, and who's calling. 2.x speaks protocol 2026-07-28 itself, so with `createMcpHandler` clients on either revision connect with nothing more to set up. See [Using @modelcontextprotocol/server 2.x](README.md#using-modelcontextprotocolserver-2x).
+- On 2.x, `identify`, `events.native` and a wrapped tool's `call.extra` get 2.x's request context (`ctx`: the token in `ctx.http?.authInfo`), and are typed as it. On 1.x they get `extra`, as before.
+- `attached.inputs` and `attached.output` take a zod object as well as a shape (`attached.inputs(z.object({ table: z.string() }))`), as 2.x's `registerTool` does. Shapes work as before.
+
+### Changed
+
+- The SDK's published types no longer import either MCP SDK, so they load with only one installed. `attached.events` returns a callback typed from your tool's arguments and your MCP SDK's context; `ToolCallExtra` is now the parts of a request's context Wakeshift reads, whichever SDK serves it (a wrapped tool's `call.extra` is still your MCP SDK's own type). If you passed a `ToolCallExtra` where 1.x's `RequestHandlerExtra` is expected, use `call.extra` instead.
+- A JSON-RPC error from `attach`'s own methods (for example `events/subscribe` for an event your app doesn't offer) carries just its message, without the MCP SDK 1.x's `MCP error <code>: ` prefix in front of it.
+
 ## 0.5.2 (2026-10-30)
 
 ### Added

package/README.md

@@ -2,7 +2,7 @@
 
 Let agents subscribe to things in your app. You define the events your app offers, serve them on your MCP server, and emit them when they happen; Wakeshift wakes every subscribed agent, whether it's Claude Code, Codex, ChatGPT or another. Your events follow MCP Events: clients that speak it subscribe natively, and Wakeshift bridges every other agent. You don't deal with harnesses.
 
-Node 22 or later. The package is ESM-only: load it with `import`, from an ES module (`"type": "module"`, or a `.mjs` or `.mts` file). It has no CommonJS build, so `require("@wakeshift/sdk")` works only where Node can require ES modules. Peer dependencies: `@modelcontextprotocol/sdk` (1.23 or later: the first that takes zod 4) and `zod` (3.25 or later, or 4). Import `z` from `"zod"`, not `"zod/v4"`: the SDK's schemas are built from `"zod"`, and the MCP SDK refuses a schema that mixes the two.
+Node 22 or later. The package is ESM-only: load it with `import`, from an ES module (`"type": "module"`, or a `.mjs` or `.mts` file). It has no CommonJS build, so `require("@wakeshift/sdk")` works only where Node can require ES modules. It works with either MCP TypeScript SDK: `@modelcontextprotocol/sdk` 1.x (1.23 or later: the first that takes zod 4) or `@modelcontextprotocol/server` 2.x ([below](#using-modelcontextprotocolserver-2x)). Its peer dependencies are the one you use and `zod` (3.25 or later, or 4; 4.2 or later with 2.x). Import `z` from `"zod"`, not `"zod/v4"`: the SDK's schemas are built from `"zod"`, and the MCP SDK refuses a schema that mixes the two.
 
 ## Install
 
@@ -10,6 +10,8 @@ Node 22 or later. The package is ESM-only: load it with `import`, from an ES mod
 npm install @wakeshift/sdk @modelcontextprotocol/sdk zod
 ```
 
+On `@modelcontextprotocol/server` 2.x, install that instead of `@modelcontextprotocol/sdk`.
+
 Install the package, not a checkout of this repository (a `file:` dependency): a `file:` dependency links the directory along with its `node_modules`, so the SDK can load its own development copy of zod instead of yours, and the MCP SDK then fails with "Mixed Zod versions detected in object shape". To try a change of your own, `npm pack` and install the tarball it writes.
 
 ## Quickstart: a CI bot
@@ -153,6 +155,134 @@ server.registerTool(
 
 A wrapped tool that subscribes to nothing, like `look`, still gets what Wakeshift has for the conversation calling it: occurrences held for an agent Wakeshift can't wake, or what it needs to reconnect. Usually that's nothing.
 
+## Using @modelcontextprotocol/server 2.x
+
+`attach` takes an `McpServer` from either MCP TypeScript SDK: `@modelcontextprotocol/sdk` 1.x or `@modelcontextprotocol/server` 2.x (2.0 or later). It tells them apart by the server you pass, and everything on this page works the same on both.
+
+```sh
+npm install @wakeshift/sdk @modelcontextprotocol/server @modelcontextprotocol/node zod
+```
+
+2.x serves HTTP with `createMcpHandler`, which makes a server for each request, so attach in the function that makes it. Define your events once, outside it:
+
+```ts
+import { createServer } from "node:http"
+import { McpServer, createMcpHandler } from "@modelcontextprotocol/server"
+import { toNodeHandler } from "@modelcontextprotocol/node"
+import { z } from "zod"
+import { Wakeshift } from "@wakeshift/sdk"
+
+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}`,
+})
+
+const mcp = createMcpHandler(() => {
+  const server = new McpServer({ name: "ci-bot", version: "1.0.0" })
+  // identify gets 2.x's request context: your auth middleware's verified token is ctx.http?.authInfo.
+  const attached = wake.attach(server, { identify: (ctx) => ({ user: myUser(ctx.http?.authInfo) }) })
+  server.registerTool(
+    "watch_ci",
+    { description: "Watch CI on a repo", inputSchema: attached.inputs(z.object({ owner: z.string(), repo: z.string() })) },
+    attached.events("watch_ci", async ({ owner, repo }, call) => {
+      await call.subscribe(ciFinished, { owner, repo }, { reason: `Watching ${owner}/${repo}` })
+      return `Watching CI on ${owner}/${repo}.`
+    }),
+  )
+  return server
+})
+
+createServer(toNodeHandler(mcp)).listen(3000)
+```
+
+What's different on 2.x:
+
+- `identify`, `events.native` and a wrapped tool's `call.extra` get 2.x's request context (`ctx`) instead of 1.x's `extra`: the verified token is `ctx.http?.authInfo`, and the HTTP request is `ctx.http?.req`.
+- `attached.inputs` and `attached.output` take a zod object, as 2.x's `registerTool` does: `attached.inputs(z.object({ … }))`. A bare shape works too.
+- 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? })`
@@ -201,7 +331,8 @@ The guides and the full reference are at [wakeshift.ai/docs](https://wakeshift.a
 ```sh
 npm ci
 npm run typecheck
-npm test          # unit tests (node:test) and the README's examples
+npm test          # unit tests (node:test) on @modelcontextprotocol/sdk 1.x, and the README's examples
+npm run test:v2   # the same unit tests on @modelcontextprotocol/server 2.x
 npm run build     # dist/
 ```
 

package/dist/discover.d.ts

@@ -1,4 +1,4 @@
-/** The protocol revision that has server/discover and MCP Events. */
-export declare const STATELESS_VERSION = "2026-07-28";
+import { STATELESS_VERSION } from "./host.js";
+export { STATELESS_VERSION };
 /** The MCP tasks extension's capability key. */
 export declare const TASKS_EXTENSION = "io.modelcontextprotocol/tasks";

package/dist/discover.js

@@ -1,6 +1,11 @@
-// Protocol 2026-07-28 for an app on the MCP TypeScript SDK 1.x, which
-// doesn't have it: MCP Events is defined only for 2026-07-28 and later, and
-// some clients speak nothing older (OpenClaw). With attach, a server whose
+// Protocol 2026-07-28. MCP Events is defined only for 2026-07-28 and later,
+// and some clients speak nothing older (OpenClaw).
+//
+// @modelcontextprotocol/server 2.x speaks it itself: server/discover,
+// resultType, and ttlMs and cacheScope on the lists. attach only varies
+// tools/list per request (below), so it marks that list private.
+//
+// @modelcontextprotocol/sdk 1.x doesn't. With attach, a 1.x server whose
 // transport is stateless (no sessions) also answers those clients:
 //
 //   - server/discover, with the server's capabilities (the events keys
@@ -10,36 +15,37 @@
 //   - resultType: "complete" on every result of a 2026-07-28 request, as
 //     that revision requires (clients on the official 2.x SDKs refuse a
 //     result without it), and ttlMs and cacheScope on server/discover and
-//     the lists (Claude Code connects the old way without them);
-//   - tools/list without subscribe_events for a request that declares the
-//     events extension in its own capabilities (2026-07-28 has no
-//     initialize, so each request carries them).
+//     the lists (Claude Code connects the old way without them).
 //
-// A stateful transport refuses a request without a session before any
+// A stateful 1.x transport refuses a request without a session before any
 // handler runs, so a server with sessions is unchanged: its clients fall
-// back to initialize, as they do today. The MCP TypeScript SDK 2.x speaks
-// 2026-07-28 itself.
+// back to initialize, as they do today.
+//
+// On both, tools/list leaves out subscribe_events for a request that
+// declares the events extension in its own capabilities (2026-07-28 has no
+// initialize, so each request carries them).
 import { z } from "zod";
-import { SUPPORTED_PROTOCOL_VERSIONS } from "@modelcontextprotocol/sdk/types.js";
 import { EXTENSION_KEY, RESULT_TYPE } from "./spec.js";
-/** The protocol revision that has server/discover and MCP Events. */
-export const STATELESS_VERSION = "2026-07-28";
-const VERSION_META = "io.modelcontextprotocol/protocolVersion";
+import { STATELESS_VERSION, is2026, v1Req } from "./host.js";
+export { STATELESS_VERSION };
 const CAPABILITIES_META = "io.modelcontextprotocol/clientCapabilities";
 const SERVER_INFO_META = "io.modelcontextprotocol/serverInfo";
+// The MCP SDK 1.x's list of supported versions, which its transport checks
+// the MCP-Protocol-Version header against: the same module the app's own
+// copy of the SDK loaded (loaded only if it's installed).
+const v1Types = await import(
+/* webpackIgnore: true */ String("@modelcontextprotocol/sdk/types.js")).catch(() => undefined);
 // The list methods whose 2026-07-28 results carry ttlMs and cacheScope.
 const LISTS = new Set(["tools/list", "prompts/list", "resources/list", "resources/templates/list"]);
-// is2026 reports whether a request is a 2026-07-28 one: its _meta names the
-// version, or its MCP-Protocol-Version header does.
-function is2026(request, extra) {
-    if (request?.params?._meta?.[VERSION_META] === STATELESS_VERSION)
-        return true;
-    const h = extra?.requestInfo?.headers;
-    const v = h?.["mcp-protocol-version"] ?? h?.["MCP-Protocol-Version"];
-    return (Array.isArray(v) ? v[0] : v) === STATELESS_VERSION;
-}
 /** The MCP tasks extension's capability key. */
 export const TASKS_EXTENSION = "io.modelcontextprotocol/tasks";
+// reqOf reads meta, and extra's headers (an already-read request's, or
+// 1.x's requestInfo), as one request.
+function reqOf(meta, extra) {
+    if (extra && typeof extra.header === "function")
+        return { ...extra, meta };
+    return v1Req({ ...(extra ?? {}), _meta: meta });
+}
 /**
  * @internal Whether a request (its _meta, as a tool callback's extra has
  * it, and its headers) is protocol 2026-07-28 and declares the tasks
@@ -47,35 +53,45 @@ export const TASKS_EXTENSION = "io.modelcontextprotocol/tasks";
  * (tasks.ts).
  */
 export function takesTasks(meta, extra) {
-    if (!is2026({ params: { _meta: meta } }, extra))
+    if (!is2026(reqOf(meta, extra)))
         return false;
     const ext = meta?.[CAPABILITIES_META]?.extensions;
     return !!ext && typeof ext === "object" && !Array.isArray(ext) && TASKS_EXTENSION in ext;
 }
-function declaresEvents(request) {
-    const ext = request?.params?._meta?.[CAPABILITIES_META]?.extensions;
+function declaresEvents(meta) {
+    const ext = meta?.[CAPABILITIES_META]?.extensions;
     return !!ext && typeof ext === "object" && EXTENSION_KEY in ext;
 }
 /** @internal Makes server answer 2026-07-28 requests (see the file's comment). */
-export function serveStateless(server, opts = {}) {
-    // The SDK's own list, which its transport checks the header against.
-    // Mutating it is how 1.x can be taught a version; 2.x already has it.
-    const versions = SUPPORTED_PROTOCOL_VERSIONS;
-    if (!versions.includes(STATELESS_VERSION))
-        versions.unshift(STATELESS_VERSION);
-    const low = server.server;
-    const handlers = low._requestHandlers;
-    if (!(handlers instanceof Map))
-        return; // a future SDK without it: it speaks 2026-07-28 itself
+export function serveStateless(host, opts = {}) {
+    const handlers = host.handlers();
+    if (!handlers)
+        return; // a future SDK without it: nothing to vary
     const hidden = new Set(opts.bridgedOnly ?? []);
-    const wrap = (method, h) => (async (request, extra) => {
-        const result = await h(request, extra);
-        if (!is2026(request, extra) || !result || typeof result !== "object")
+    const v1 = host.version === 1;
+    if (v1) {
+        // Mutating the SDK's own list is how 1.x can be taught a version.
+        const versions = v1Types?.SUPPORTED_PROTOCOL_VERSIONS;
+        if (Array.isArray(versions) && !versions.includes(STATELESS_VERSION))
+            versions.unshift(STATELESS_VERSION);
+    }
+    const wrap = (method, h) => (async (request, raw) => {
+        const result = await h(request, raw);
+        const req = host.req(raw);
+        if (!is2026(req) || !result || typeof result !== "object")
             return result;
-        if (method === "tools/list" && hidden.size > 0 && declaresEvents(request) && Array.isArray(result.tools)) {
-            result.tools = result.tools.filter((t) => !hidden.has(t?.name));
+        let out = result;
+        if (method === "tools/list" && hidden.size > 0 && declaresEvents(req.meta) && Array.isArray(out.tools)) {
+            out = { ...out, tools: out.tools.filter((t) => !hidden.has(t?.name)) };
+        }
+        if (!v1) {
+            // tools/list differs by what each request declares (this filter,
+            // the wait tool), so it's cached by this client only, whatever
+            // cache hint the app set; 2.x fills in the rest.
+            return method === "tools/list" ? { ...out, cacheScope: "private" } : out;
         }
-        const out = result.resultType === undefined ? { ...result, resultType: RESULT_TYPE } : result;
+        if (out.resultType === undefined)
+            out = { ...out, resultType: RESULT_TYPE };
         // A list's result says how long a client may cache it, as 2026-07-28
         // requires (Claude Code falls back to initialize without it): not at
         // all, and for this client only, since tools/list differs by what
@@ -84,14 +100,19 @@ export function serveStateless(server, opts = {}) {
             return { ...out, ttlMs: 0, cacheScope: "private" };
         return out;
     });
+    const wraps = (method) => v1 || method === "tools/list";
     for (const [method, h] of handlers)
-        handlers.set(method, wrap(method, h));
+        if (wraps(method))
+            handlers.set(method, wrap(method, h));
     const set = handlers.set.bind(handlers);
-    handlers.set = (method, h) => set(method, wrap(method, h));
-    server.server.setRequestHandler(z.object({ method: z.literal("server/discover"), params: z.any().optional() }), async () => {
+    handlers.set = (method, h) => set(method, wraps(method) ? wrap(method, h) : h);
+    if (!v1)
+        return;
+    const low = host.server.server;
+    low.setRequestHandler(z.object({ method: z.literal("server/discover"), params: z.any().optional() }), async () => {
         const out = {
             resultType: RESULT_TYPE,
-            supportedVersions: [...versions],
+            supportedVersions: [...(v1Types?.SUPPORTED_PROTOCOL_VERSIONS ?? [STATELESS_VERSION])],
             // Cacheable results carry these on 2026-07-28 (Claude Code refuses a
             // server/discover without them, and connects the old way).
             ttlMs: 0,
@@ -104,4 +125,3 @@ export function serveStateless(server, 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.d.ts

@@ -1,8 +1,7 @@
-import type { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
-import { type AnySchema, type SchemaInput, type SchemaOutput, type ZodRawShapeCompat } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import { type AnySchema, type SchemaInput, type SchemaOutput, type ZodRawShapeCompat } from "./zod.js";
 import { WakeshiftError } from "./errors.js";
 import { type Dialect } from "./spec.js";
-import { type Emitted, type PublishUrl, type Recipient, type ToolExtra, type Via, type Wakeshift } from "./wakeshift.js";
+import { type Emitted, type PublishUrl, type Recipient, type Via, type Wakeshift } from "./wakeshift.js";
 import { type EventsOptions } from "./toolcall.js";
 /** Who is subscribing: what authorize decides on. */
 export interface Subscriber {
@@ -174,16 +173,21 @@ export interface Identity {
      */
     client?: string;
 }
-export interface AttachOptions {
+/**
+ * attach's options. C is the request context your MCP SDK's handlers get:
+ * @modelcontextprotocol/server 2.x's ServerContext (`ctx`), or
+ * @modelcontextprotocol/sdk 1.x's RequestHandlerExtra (`extra`).
+ */
+export interface AttachOptions<C = any> {
     /**
      * Who is behind a request. The app passes identify, returning { user }:
      * its own ID for the person, from its own sign-in (and, on a stateless
      * server, the client's name as `client`). Without it, requests have no
-     * user, so personal events and list_subscriptions refuse.
+     * user, so personal events and list_subscriptions refuse. It gets the
+     * request's context as your MCP SDK passes it to handlers: 2.x's ctx
+     * (the token in ctx.http?.authInfo), 1.x's extra (extra.authInfo).
      */
-    identify?: (extra: ToolExtra & {
-        authInfo?: AuthInfo;
-    }) => Identity | undefined;
+    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; `[]`
@@ -192,7 +196,7 @@ export interface AttachOptions {
      */
     tools?: readonly BuiltinTool[];
     /** The event features' options: events.native overrides native detection for wrapped tools (attached.events). */
-    events?: EventsOptions;
+    events?: EventsOptions<C>;
 }
 /** The tools attach adds, unless AttachOptions.tools names fewer. */
 export declare const BUILTIN_TOOLS: readonly ["subscribe_events", "unsubscribe_events", "list_subscriptions"];