@wakeshift/sdk 0.5.2 → 0.6.0

package/dist/events.js

@@ -6,14 +6,13 @@
 // extension, and through Wakeshift's wake paths for everyone else, who
 // subscribe with the subscribe_events tool attach adds.
 // https://wakeshift.ai/docs/events has the guide.
-import { z } from "zod";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
-import { objectFromShape, safeParse } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import { RpcError } from "./mcp.js";
+import { isSchema, objectFromShape, safeParse, toJsonSchema } from "./zod.js";
+import { 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 } from "./wakeshift.js";
-import { Attached, toolArgs } from "./toolcall.js";
+import { toolCallOf, userAgentOf } from "./wakeshift.js";
+import { Attached, wakeInputsFor } from "./toolcall.js";
 import { serveStateless } from "./discover.js";
 import { serveTasks } from "./tasks.js";
 const nameRE = /^[a-z][a-z0-9_-]*(\.[a-z][a-z0-9_-]*){0,4}$/;
@@ -21,7 +20,7 @@ const argNameRE = /^[a-z][a-z0-9_]{0,63}$/;
 // jsonSchemaOf is a zod schema as JSON Schema, without $schema (Wakeshift
 // reads it as 2020-12).
 function jsonSchemaOf(s) {
-    const out = toJsonSchemaCompat(s);
+    const out = toJsonSchema(s);
     delete out.$schema;
     normalize(out);
     return out;
@@ -59,9 +58,6 @@ function canonical(v) {
     const sortKeys = (x) => Array.isArray(x) ? x.map(sortKeys) : x && typeof x === "object" ? Object.fromEntries(Object.keys(x).sort().map((k) => [k, sortKeys(x[k])])) : x;
     return JSON.stringify(sortKeys(v) ?? {});
 }
-function isSchema(v) {
-    return !!v && typeof v === "object" && ("_def" in v || "_zod" in v);
-}
 // detailOf is an error's message for an agent: Wakeshift's own words.
 function detailOf(err) {
     return err instanceof WakeshiftError ? err.detail : String(err?.message ?? err);
@@ -332,10 +328,10 @@ export class ArgsError extends WakeshiftError {
 }
 /** The tools attach adds, unless AttachOptions.tools names fewer. */
 export const BUILTIN_TOOLS = ["subscribe_events", "unsubscribe_events", "list_subscriptions"];
-// What a client says about itself on initialize, or a request's _meta;
-// else the name identify gave (identified).
-function clientInfoName(server, meta, identified) {
-    const fromInit = server.server.getClientVersion()?.name;
+// What a client says about itself on initialize (2.x: or the request's
+// envelope), or a request's _meta; else the name identify gave (identified).
+function clientInfoName(host, meta, identified) {
+    const fromInit = host.clientName();
     if (fromInit)
         return fromInit;
     const info = meta?.["io.modelcontextprotocol/clientInfo"];
@@ -343,13 +339,6 @@ function clientInfoName(server, meta, identified) {
         return info.name;
     return identified ?? "";
 }
-function header(extra, name) {
-    const h = extra?.requestInfo?.headers;
-    if (!h)
-        return "";
-    const v = h[name] ?? h[name.toLowerCase()];
-    return (Array.isArray(v) ? v[0] : v) ?? "";
-}
 /** A client that speaks MCP Events: it declared the extension, or it's one known to (ChatGPT). */
 /** @internal */
 export function speaksEvents(capabilities, clientName) {
@@ -412,79 +401,85 @@ export function attachEvents(wake, server, events, opts = {}) {
         if (!BUILTIN_TOOLS.includes(t))
             throw new Error(`wakeshift: attach's tools names "${t}": its own tools are ${BUILTIN_TOOLS.join(", ")}`);
     }
+    const host = hostOf(server);
     const tools = new Set(opts.tools ?? BUILTIN_TOOLS);
-    const identityOf = (extra) => opts.identify?.(extra) ?? undefined;
+    // raw is the MCP SDK's own request context (1.x's extra, 2.x's ctx): what identify gets.
+    const identityOf = (raw) => opts.identify?.(raw) ?? undefined;
     // Who's calling: the user, and the client's name (the request's, else identify's).
-    const callerOf = (extra) => {
-        const id = extra ? identityOf(extra) : undefined;
-        return { user: id?.user, client: clientInfoName(server, extra?._meta, id?.client) };
+    const callerOf = (raw) => {
+        const id = raw ? identityOf(raw) : undefined;
+        return { user: id?.user, client: clientInfoName(host, raw ? host.req(raw).meta : undefined, id?.client) };
     };
     const attached = new Attached({
         wake,
-        server,
-        identify: (extra) => identityOf(extra),
-        clientOf: (meta, identified) => clientInfoName(server, meta, identified),
+        host,
+        identify: (raw) => identityOf(raw),
+        clientOf: (meta, identified) => clientInfoName(host, meta, identified),
         events: opts.events ?? {},
         warnOnce: (key, message) => wake.warnOnce(key, message),
     });
     const byName = new Map(events.map((e) => [e.name, e]));
-    const low = server.server;
     try {
-        low.registerCapabilities({ [TOP_LEVEL_KEY]: { listChanged: false }, extensions: { [EXTENSION_KEY]: { listChanged: false } } });
+        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 });
     }
-    // Clients that speak only protocol 2026-07-28 (OpenClaw), on a stateless
-    // transport: server/discover and resultType (discover.ts).
-    serveStateless(server, { bridgedOnly: ["subscribe_events"] });
+    if (!host.handlers()) {
+        // 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");
+    }
+    // Clients that speak only protocol 2026-07-28 (OpenClaw): on the MCP SDK
+    // 1.x, on a stateless transport, server/discover and resultType
+    // (discover.ts); on 2.x, its own.
+    serveStateless(host, { bridgedOnly: ["subscribe_events"] });
     // Clients that take MCP tasks there (Claude Code): Wakeshift's wait tool,
     // answered with a task (tasks.ts).
-    serveTasks(wake, server, (extra) => callerOf(extra));
+    serveTasks(wake, host, callerOf);
     // tools/list: a wrapped tool's output schema names wakeshift, which its
     // structured results carry (toolcall.ts).
     attached.amendToolsList();
     // ── Native: events/list, events/subscribe, events/unsubscribe ─────────
-    const method = (m) => z.object({ method: z.literal(m), params: z.any().optional() });
-    low.setRequestHandler(method("events/list"), async () => ({ resultType: RESULT_TYPE, events: events.map((e) => e.definition()) }));
-    low.setRequestHandler(method("events/stream"), async (_req, extra) => {
-        const codes = codesFor(dialectOf(clientInfoName(server, undefined), header(extra, "user-agent")));
-        throw new McpError(codes.unsupported, "push delivery isn't offered: use a webhook (events/subscribe) or poll (events/poll)", { feature: "deliveryMode", value: "stream" });
+    host.setMethod("events/list", async () => ({ resultType: RESULT_TYPE, events: events.map((e) => e.definition()) }));
+    host.setMethod("events/stream", async (_params, raw) => {
+        const codes = codesFor(dialectOf(clientInfoName(host, undefined), userAgentOf(host.req(raw))));
+        throw new RpcError(codes.unsupported, "push delivery isn't offered: use a webhook (events/subscribe) or poll (events/poll)", { feature: "deliveryMode", value: "stream" });
     });
-    const native = async (req, extra, m) => {
+    const native = async (p, raw, m) => {
         const unsubscribe = m === "unsubscribe";
-        const p = (req.params ?? {});
-        const meta = (p._meta ?? {});
-        const id = identityOf(extra);
-        const client = clientInfoName(server, meta, id?.client);
-        const ua = header(extra, "user-agent");
+        const req = host.req(raw);
+        const meta = (req.meta ?? {});
+        const id = identityOf(raw);
+        const client = clientInfoName(host, meta, id?.client);
+        const ua = userAgentOf(req);
         const dialect = dialectOf(client, ua);
         const codes = codesFor(dialect);
-        const nameHeader = header(extra, NAME_HEADER);
+        const nameHeader = req.header(NAME_HEADER);
         if (nameHeader && headerValue(nameHeader) !== p.name) {
-            throw new McpError(HEADER_MISMATCH, "Header mismatch: Mcp-Name doesn't match params.name");
+            throw new RpcError(HEADER_MISMATCH, "Header mismatch: Mcp-Name doesn't match params.name");
         }
         const ev = byName.get(p.name);
         if (!ev)
-            throw new McpError(codes.notFound, fill("native_unknown_event", { event: JSON.stringify(p.name) }), { kind: "event" });
+            throw new RpcError(codes.notFound, fill("native_unknown_event", { event: JSON.stringify(p.name) }), { kind: "event" });
         if (m === "subscribe" && p.delivery?.mode !== "webhook") {
-            throw new McpError(codes.unsupported, 'delivery.mode must be "webhook": the only delivery offered', { feature: "deliveryMode", value: p.delivery?.mode });
+            throw new RpcError(codes.unsupported, 'delivery.mode must be "webhook": the only delivery offered', { feature: "deliveryMode", value: p.delivery?.mode });
         }
         let args;
         try {
             args = ev.parseArgs(p.arguments ?? {});
         }
         catch (err) {
-            throw new McpError(INVALID_PARAMS, err instanceof WakeshiftError ? err.detail : err.message);
+            throw new RpcError(INVALID_PARAMS, err instanceof WakeshiftError ? err.detail : err.message);
         }
         const user = id?.user;
         if (!user)
-            throw new McpError(codes.forbidden, fill("native_no_user"));
+            throw new RpcError(codes.forbidden, fill("native_no_user"));
         const call = { user, client, meta, ...(ua ? { user_agent: ua } : {}) };
         // A poll has no subscribe step (each poll can start the subscription),
         // so every poll asks authorize: access is checked again each time.
         if (!unsubscribe && !(await ev.allows({ user, client, native: true }, args))) {
-            throw new McpError(codes.forbidden, fill("native_refused", { event: ev.name }));
+            throw new RpcError(codes.forbidden, fill("native_refused", { event: ev.name }));
         }
         if (m === "poll") {
             const body = { call, name: ev.name, arguments: args };
@@ -506,7 +501,7 @@ export function attachEvents(wake, server, events, opts = {}) {
             if (unsubscribe) {
                 const out = await wake.requestApp("POST", "/events/unsubscribe", body);
                 if (!out.ended && dialect !== "chatgpt") {
-                    throw new McpError(codes.notFound, "no subscription matches that event, arguments and delivery URL", { kind: "subscription" });
+                    throw new RpcError(codes.notFound, "no subscription matches that event, arguments and delivery URL", { kind: "subscription" });
                 }
                 return { resultType: RESULT_TYPE };
             }
@@ -533,10 +528,13 @@ export function attachEvents(wake, server, events, opts = {}) {
             throw rpcErrorOf(err, codes);
         }
     };
-    low.setRequestHandler(method("events/subscribe"), (req, extra) => native(req, extra, "subscribe"));
-    low.setRequestHandler(method("events/unsubscribe"), (req, extra) => native(req, extra, "unsubscribe"));
-    low.setRequestHandler(method("events/poll"), (req, extra) => native(req, extra, "poll"));
+    host.setMethod("events/subscribe", (p, raw) => native(p, raw, "subscribe"));
+    host.setMethod("events/unsubscribe", (p, raw) => native(p, raw, "unsubscribe"));
+    host.setMethod("events/poll", (p, raw) => native(p, raw, "poll"));
     // ── Bridged: subscribe_events, unsubscribe_events, list_subscriptions ─
+    // Written in the zod the MCP SDK takes (2.x: zod 4 only).
+    const z = host.zod;
+    const toolArgs = wakeInputsFor(host);
     const names = events.map((e) => e.name);
     const listed = events
         .slice(0, MAX_LISTED_EVENTS)
@@ -550,23 +548,23 @@ export function attachEvents(wake, server, events, opts = {}) {
     const result = (text, addition) => withAddition(text, addition ?? {});
     const fail = (text) => ({ isError: true, content: [{ type: "text", text }] });
     // register adds one of the tools, if the app wants it (attach's tools).
-    const register = (name, config, cb) => (tools.has(name) ? server.registerTool(name, config, cb) : undefined);
+    const register = (name, config, cb) => tools.has(name) ? host.registerTool(name, config, cb) : undefined;
     const subscribeTool = register("subscribe_events", {
         description: `${EVENT_TOOL_TEXT.subscribe_description}${EVENT_TOOL_TEXT.events_heading}${listed}${more}`,
         inputSchema: { event: z.enum(names).describe(EVENT_TOOL_TEXT.event_argument), arguments: argsInput, ...toolArgs },
-    }, async (input, extra) => {
-        const { event, arguments: raw, ...rest } = input;
+    }, async (input, raw) => {
+        const { event, arguments: rawArgs, ...rest } = input;
         const ev = byName.get(event);
         if (!ev)
             return fail(fill("unknown_event", { event }));
         let args;
         try {
-            args = ev.parseArgs(raw ?? {});
+            args = ev.parseArgs(rawArgs ?? {});
         }
         catch (err) {
             return fail(err instanceof WakeshiftError ? err.detail : err.message);
         }
-        const { user, client } = callerOf(extra);
+        const { user, client } = callerOf(raw);
         if (ev.personal && !user)
             return fail(fill("personal_no_user", { event: ev.name }));
         if (!(await ev.allows({ user, client, native: false }, args))) {
@@ -574,7 +572,7 @@ export function attachEvents(wake, server, events, opts = {}) {
         }
         try {
             const out = await wake.requestApp("POST", "/event-subscriptions", {
-                call: toolCallOf(extra, client, user, rest, "subscribe_events"),
+                call: toolCallOf(host.req(raw), client, user, rest, "subscribe_events"),
                 name: ev.name,
                 arguments: args,
             });
@@ -594,9 +592,9 @@ export function attachEvents(wake, server, events, opts = {}) {
             id: z.string().optional().describe(EVENT_TOOL_TEXT.id_argument),
             ...toolArgs,
         },
-    }, async (input, extra) => {
-        const { event, arguments: raw, id, ...rest } = input;
-        const { user, client } = callerOf(extra);
+    }, async (input, raw) => {
+        const { event, arguments: rawArgs, id, ...rest } = input;
+        const { user, client } = callerOf(raw);
         try {
             if (id) {
                 if (!user)
@@ -607,9 +605,9 @@ export function attachEvents(wake, server, events, opts = {}) {
             const ev = event ? byName.get(event) : undefined;
             if (!ev)
                 return fail(fill("need"));
-            const args = ev.parseArgs(raw ?? {});
+            const args = ev.parseArgs(rawArgs ?? {});
             const out = await wake.requestApp("POST", "/event-subscriptions/unsubscribe", {
-                call: toolCallOf(extra, client, user, rest, "unsubscribe_events"),
+                call: toolCallOf(host.req(raw), client, user, rest, "unsubscribe_events"),
                 name: ev.name,
                 arguments: args,
             });
@@ -622,8 +620,8 @@ export function attachEvents(wake, server, events, opts = {}) {
     // list_subscriptions only reads: marked so (readOnlyHint), clients that
     // approve read-only tools without asking (Codex, by default) don't ask; and
     // idempotent, as in every SDK (test/events-list.json).
-    register("list_subscriptions", { description: EVENT_TOOL_TEXT.list_description, inputSchema: { ...toolArgs }, annotations: { readOnlyHint: true, idempotentHint: true } }, async (_input, extra) => {
-        const user = identityOf(extra)?.user;
+    register("list_subscriptions", { description: EVENT_TOOL_TEXT.list_description, inputSchema: { ...toolArgs }, annotations: { readOnlyHint: true, idempotentHint: true } }, async (_input, raw) => {
+        const user = identityOf(raw)?.user;
         if (!user)
             return fail(fill("list_no_user"));
         try {
@@ -647,15 +645,13 @@ export function attachEvents(wake, server, events, opts = {}) {
     // Per-connection negotiation: a client that speaks MCP Events subscribes
     // natively, so it isn't offered subscribe_events (a server made per
     // request never sees initialize, and keeps offering it).
-    const prev = low.oninitialized;
-    low.oninitialized = () => {
+    host.onInitialized(() => {
         // Set both ways: a server reconnected to another client decides again.
-        if (speaksEvents(low.getClientCapabilities(), low.getClientVersion()?.name ?? ""))
+        if (speaksEvents(host.clientCapabilities(), host.clientName() ?? ""))
             subscribeTool?.disable();
         else
             subscribeTool?.enable();
-        prev?.();
-    };
+    });
     return attached;
 }
 // withAddition is one of attach's own tools' results: its text, then
@@ -683,29 +679,29 @@ export function pollResult(out) {
 // Forbidden, whether it exists or not.
 /** @internal */
 export function rpcErrorOf(err, codes) {
-    if (err instanceof McpError)
+    if (err instanceof RpcError)
         return err;
     if (!(err instanceof WakeshiftError) || err.code === "unreachable")
-        return new McpError(INTERNAL_ERROR, "Wakeshift couldn't be reached");
+        return new RpcError(INTERNAL_ERROR, "Wakeshift couldn't be reached");
     switch (err.code) {
         case "callback_failed":
-            return new McpError(codes.callbackEndpoint, err.detail, { reason: err.reason ?? "" });
+            return new RpcError(codes.callbackEndpoint, err.detail, { reason: err.reason ?? "" });
         case "unknown_event":
-            return new McpError(codes.notFound, err.detail, { kind: "event" });
+            return new RpcError(codes.notFound, err.detail, { kind: "event" });
         case "unsupported":
-            return new McpError(codes.unsupported, err.detail, { feature: "deliveryMode" });
+            return new RpcError(codes.unsupported, err.detail, { feature: "deliveryMode" });
         case "subscription_limit":
-            return new McpError(codes.resourceExhausted, err.detail, { limit: "subscriptions" });
+            return new RpcError(codes.resourceExhausted, err.detail, { limit: "subscriptions" });
         case "subscription_stopped":
-            return new McpError(codes.forbidden, err.detail, { reason: "stopped" });
+            return new RpcError(codes.forbidden, err.detail, { reason: "stopped" });
         case "bad_request":
         case "bad_arguments":
-            return new McpError(INVALID_PARAMS, err.detail);
+            return new RpcError(INVALID_PARAMS, err.detail);
         case "unknown_session":
         case "other_client":
         case "unknown_conversation":
-            return new McpError(codes.forbidden, "another client of yours holds that subscription");
+            return new RpcError(codes.forbidden, "another client of yours holds that subscription");
     }
-    return new McpError(INTERNAL_ERROR, "Wakeshift refused the subscription: " + err.detail);
+    return new RpcError(INTERNAL_ERROR, "Wakeshift refused the subscription: " + err.detail);
 }
 //# sourceMappingURL=events.js.map