@wakeshift/sdk 0.5.0 → 0.6.0

package/dist/toolcall.d.ts

@@ -1,15 +1,14 @@
 import { z } from "zod";
-import type { CallToolResult, ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types.js";
-import type { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { type AnySchema, type SchemaInput, type ShapeOutput, type ZodRawShapeCompat } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import * as z3 from "zod/v3";
+import * as z4 from "zod/v4";
+import type { CallToolResult, ToolCallExtra } from "./mcp.js";
+import { type AnySchema, type SchemaInput, type ShapeOutput, type ZodRawShapeCompat } from "./zod.js";
 import type { WakeEvent } from "./events.js";
 import { type Duration, type Recognized } from "./wakeshift.js";
 declare const SESSION_ARG = "session_key";
 declare const HARNESS_ARG = "harness";
 declare const CONVERSATION_ARG = "conversation_id";
-/** MCP's own extra for a tool call: the request's signal, auth, _meta, HTTP request. */
-export type ToolCallExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
+export type { ToolCallExtra };
 declare const wakeInputs: {
     session_key: z.ZodOptional<z.ZodString>;
     harness: z.ZodOptional<z.ZodString>;
@@ -18,10 +17,50 @@ declare const wakeInputs: {
 declare const wakeOutput: {
     wakeshift: z.ZodOptional<z.ZodString>;
 };
+declare const byVersion: {
+    v3: {
+        inputs: {
+            session_key: z3.ZodOptional<z3.ZodString>;
+            harness: z3.ZodOptional<z3.ZodString>;
+            conversation_id: z3.ZodOptional<z3.ZodString>;
+        };
+        output: {
+            wakeshift: z3.ZodOptional<z3.ZodString>;
+        };
+    };
+    v4: {
+        inputs: {
+            session_key: z.ZodOptional<z.ZodString>;
+            harness: z.ZodOptional<z.ZodString>;
+            conversation_id: z.ZodOptional<z.ZodString>;
+        };
+        output: {
+            wakeshift: z.ZodOptional<z.ZodString>;
+        };
+    };
+};
 /** Wakeshift's three arguments, as attached.inputs adds them. */
 export type WakeInputs = typeof wakeInputs;
 /** The optional wakeshift string attached.output adds. */
 export type WakeOutputShape = typeof wakeOutput;
+/** Wakeshift's three arguments in zod 4, as attached.inputs adds them to a zod 4 object. */
+export type WakeInputsV4 = typeof byVersion.v4.inputs;
+/** Wakeshift's three arguments in zod 3, as attached.inputs adds them to a zod 3 object. */
+export type WakeInputsV3 = typeof byVersion.v3.inputs;
+/** The optional wakeshift string in zod 4, as attached.output adds it to a zod 4 object. */
+export type WakeOutputV4 = typeof byVersion.v4.output;
+/** The optional wakeshift string in zod 3, as attached.output adds it to a zod 3 object. */
+export type WakeOutputV3 = typeof byVersion.v3.output;
+/** What a wrapped tool's arguments must include: Wakeshift's three (attached.inputs adds them). */
+export type WakeArgs = {
+    [K in WakeKey]?: string | undefined;
+};
+/**
+ * The callback attached.events returns, for `server.registerTool`: it takes
+ * the tool's arguments (A, Wakeshift's three included) and your MCP SDK's
+ * request context (C).
+ */
+export type WrappedCallback<A, C> = (args: A, extra: C) => Promise<any>;
 /** The names of Wakeshift's three arguments. */
 export type WakeKey = typeof SESSION_ARG | typeof HARNESS_ARG | typeof CONVERSATION_ARG;
 /** An input shape with Wakeshift's three arguments in it (attached.inputs'). */
@@ -63,7 +102,7 @@ export interface ToolSubscribeOptions {
  * calls that subscribe the calling conversation. Only the wrapper makes
  * one, and it works until the handler returns (then CallEnded).
  */
-export interface ToolCall {
+export interface ToolCall<C = any> {
     /** Who attach's identify says is calling (undefined for none). */
     readonly user: string | undefined;
     /** The tool being called. */
@@ -80,8 +119,8 @@ export interface ToolCall {
     readonly session: string | null;
     /** What Wakeshift recognized the agent's program as: null until a subscribe or resolveSession. */
     readonly recognized: Recognized | null;
-    /** MCP's own extra for the call. */
-    readonly extra: ToolCallExtra;
+    /** The call's request context, as your MCP SDK passes it to the tool's callback: 2.x's ctx, 1.x's extra. */
+    readonly extra: C;
     /**
      * Subscribes the calling conversation to event with args, or renews its
      * subscription. The reply then carries what the conversation needs to be
@@ -105,14 +144,14 @@ export declare class CallEnded extends Error {
     constructor();
 }
 /** attach's event options. */
-export interface EventsOptions {
+export interface EventsOptions<C = any> {
     /**
      * Asked first whether a wrapped tool's call comes from a client that
      * subscribes to the app's events itself (call.native), for callers the
      * SDK can't tell (an app's own house agents). False leaves it to the
-     * SDK's own checks.
+     * SDK's own checks. It gets the call's request context, as identify does.
      */
-    native?: (extra: ToolCallExtra) => boolean;
+    native?(extra: C): boolean;
 }
 /** /calls/addition's answer. */
 export interface CallAddition {
@@ -120,25 +159,38 @@ export interface CallAddition {
     trailer?: string;
     meta?: Record<string, unknown>;
 }
+/** The structuredContent field a wrapped tool's structured result carries Wakeshift's block in (the same in every SDK). */
+export declare const WAKESHIFT_FIELD = "wakeshift";
 /**
  * Wakeshift attached to an MCP server: the handle `wake.attach` returns.
  * Wrap a tool's callback with events, and give its input schema
- * Wakeshift's three arguments with inputs.
+ * Wakeshift's three arguments with inputs. C is your MCP SDK's request
+ * context (2.x's ctx, 1.x's extra), which a wrapped call carries as
+ * `call.extra`.
  */
-export declare class Attached {
+export declare class Attached<C = any> {
     private readonly at;
     /**
-     * shape plus Wakeshift's three optional arguments (session_key, harness
-     * and conversation_id), for a wrapped tool's inputSchema:
+     * A tool's input schema plus Wakeshift's three optional arguments
+     * (session_key, harness and conversation_id), for a wrapped tool's
+     * inputSchema: a zod object, `inputSchema: attached.inputs(z.object({ table: z.string() }))`
+     * (as @modelcontextprotocol/server 2.x takes it), or a shape,
      * `inputSchema: attached.inputs({ table: z.string() })`.
      */
+    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;
     /**
-     * shape plus an optional wakeshift string, for a wrapped tool's
-     * outputSchema: the wrapper sets it to the block's text (without the
-     * beacon line), for hosts that show the model only structuredContent.
-     * The block stays in the content too.
+     * A tool's output schema plus an optional wakeshift string, for a wrapped
+     * tool's outputSchema (a zod object or a shape, as inputs takes).
+     * Optional: every structured result of a wrapped tool gets the block's
+     * text (without the beacon line) in wakeshift, for hosts that show the
+     * model only structuredContent, and tools/list names it in the tool's
+     * output schema; this declares it in your own schema and types. The
+     * block stays in the content too.
      */
+    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 tool's callback, for `server.registerTool(name, …)` with the
@@ -148,7 +200,7 @@ export declare class Attached {
      * inputSchema must come from attached.inputs (a type error otherwise).
      * Register it on the server passed to attach.
      */
-    events<S extends WakeShape>(name: string, handler: (args: AppArgs<S>, call: ToolCall) => WrappedResult | Promise<WrappedResult>): ToolCallback<S>;
+    events<A extends WakeArgs>(name: string, handler: (args: Omit<A, WakeKey>, call: ToolCall<C>) => WrappedResult | Promise<WrappedResult>): WrappedCallback<A, C>;
     private run;
+    private amendTools;
 }
-export {};

package/dist/toolcall.js

@@ -18,10 +18,12 @@
 import { z } from "zod";
 import * as z3 from "zod/v3";
 import * as z4 from "zod/v4";
-import { getObjectShape, isZ4Schema, normalizeObjectSchema, safeParseAsync } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import * as z4mini from "zod/v4-mini";
+import { getObjectShape, isSchema, isZ4Schema, normalizeObjectSchema } from "./zod.js";
 import { WakeshiftError } from "./errors.js";
 import { EXTENSION_KEY, dialectOf } from "./spec.js";
-import { packCall } from "./wakeshift.js";
+import { takesTasks } from "./discover.js";
+import { packCall, userAgentOf } from "./wakeshift.js";
 // Wakeshift's three arguments (wakeshift.ts's SESSION_ARG, HARNESS_ARG and
 // CONVERSATION_ARG, repeated: that module imports this one).
 const SESSION_ARG = "session_key";
@@ -33,6 +35,8 @@ const SESSION_KEY_DESCRIPTION = "This conversation's session_key, from an earlie
 const HARNESS_DESCRIPTION = "The program you're running in: codex, claude-code, cursor (local CLI or IDE), cursor-cloud (Cursor cloud agent), grok-bot, copilot-cli, opencode, antigravity, openclaw (even when it runs your turns in Codex), hermes, chatgpt, or your program's name if it isn't listed";
 const CONVERSATION_DESCRIPTION = "Your own ID for this conversation, if your program gives you one. Cursor and Grok Bot: the output of `printenv CURSOR_CONVERSATION_ID`. Codex and Antigravity send it automatically; others leave it empty";
 const WAKESHIFT_OUTPUT_DESCRIPTION = "What Wakeshift adds for this conversation: how it's woken by this app's events";
+/** @internal Wakeshift's three arguments' descriptions, for a tool whose input schema is written out (the wait tool, tasks.ts). */
+export const WAKE_ARG_DESCRIPTIONS = { session_key: SESSION_KEY_DESCRIPTION, harness: HARNESS_DESCRIPTION, conversation_id: CONVERSATION_DESCRIPTION };
 const wakeInputs = {
     [SESSION_ARG]: z.string().optional().describe(SESSION_KEY_DESCRIPTION),
     [HARNESS_ARG]: z.string().optional().describe(HARNESS_DESCRIPTION),
@@ -63,12 +67,26 @@ const byVersion = {
     },
 };
 // fieldsFor is Wakeshift's fields in the zod API shape's own fields use
-// (the default import's for an empty shape).
-function fieldsFor(shape, kind) {
+// (for an empty shape, the default import's, or zod 4's for the MCP SDK
+// 2.x, which takes only zod 4).
+function fieldsFor(shape, kind, host) {
     const first = Object.values(shape ?? {})[0];
-    const fields = !first ? (kind === "inputs" ? wakeInputs : wakeOutput) : byVersion[isZ4Schema(first) ? "v4" : "v3"][kind];
+    const version = first ? (isZ4Schema(first) ? "v4" : "v3") : host?.version === 2 ? "v4" : null;
+    const fields = version ? byVersion[version][kind] : kind === "inputs" ? wakeInputs : wakeOutput;
     return fields;
 }
+/** @internal Wakeshift's three arguments as attach's own tools take them, in the zod the host's MCP SDK takes. */
+export function wakeInputsFor(host) {
+    return host.version === 2 ? byVersion.v4.inputs : wakeInputs;
+}
+// withFields is an object schema with fields added, in the schema's own zod
+// API (zod 3, zod 4 classic or mini).
+function withFields(schema, fields) {
+    const s = schema;
+    if (typeof s.extend === "function")
+        return s.extend(fields);
+    return z4mini.extend(schema, fields);
+}
 const WAKE_KEYS = [SESSION_ARG, HARNESS_ARG, CONVERSATION_ARG];
 /**
  * @internal The tools/call _meta keys a harness names its conversation in
@@ -114,15 +132,38 @@ function takeTrailer(content) {
         content[content.length - 1] = { ...last, text: rest };
     return line;
 }
+/** The structuredContent field a wrapped tool's structured result carries Wakeshift's block in (the same in every SDK). */
+export const WAKESHIFT_FIELD = "wakeshift";
+/**
+ * @internal An object output schema (JSON Schema, as tools/list gives it)
+ * with an optional wakeshift string added, as a copy, so a client that
+ * checks structuredContent against it takes the block. Anything else, or a
+ * schema that already names it, comes back as it was.
+ * test/wrapped-block.json (output_schemas) pins it.
+ */
+export function withWakeshiftField(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return schema;
+    const s = schema;
+    if (s.type !== "object")
+        return schema;
+    const props = s.properties;
+    if (props !== undefined && (!props || typeof props !== "object" || Array.isArray(props)))
+        return schema;
+    if (props && WAKESHIFT_FIELD in props)
+        return schema;
+    return { ...s, properties: { ...(props ?? {}), [WAKESHIFT_FIELD]: { type: "string", description: WAKESHIFT_OUTPUT_DESCRIPTION } } };
+}
 /**
  * @internal Adds the call's block to a wrapped handler's result: Wakeshift's
  * text as a block after the app's content, then a text-carried beacon last,
  * and _meta; a string result stays one text block. A result that already
- * carries a beacon keeps it, last, and gets no second one. With wakeOutput,
- * structuredContent's wakeshift is the block's text. test/wrapped-block.json
- * is the shape, shared with the other SDKs.
+ * carries a beacon keeps it, last, and gets no second one. A structured
+ * result (structuredContent an object) gets the block's text in its
+ * wakeshift field too. test/wrapped-block.json is the shape, shared with
+ * the other SDKs.
  */
-export function mergeBlock(result, add, wakeOutput) {
+export function mergeBlock(result, add) {
     const isString = typeof result === "string";
     const base = isString ? { content: [{ type: "text", text: result }] } : result;
     const out = { ...base, content: [...(base.content ?? [])] };
@@ -145,8 +186,8 @@ export function mergeBlock(result, add, wakeOutput) {
         const texts = out.content.map((c) => (c.type === "text" ? c.text : "")).filter((t) => t !== "");
         out.content = [{ type: "text", text: texts.join("\n\n") }];
     }
-    if (text && wakeOutput && out.structuredContent && typeof out.structuredContent === "object" && !Array.isArray(out.structuredContent)) {
-        out.structuredContent = { ...out.structuredContent, wakeshift: text };
+    if (text && out.structuredContent && typeof out.structuredContent === "object" && !Array.isArray(out.structuredContent)) {
+        out.structuredContent = { ...out.structuredContent, [WAKESHIFT_FIELD]: text };
     }
     return out;
 }
@@ -183,12 +224,6 @@ function sameJSON(a, b) {
 function detailOf(err) {
     return err instanceof WakeshiftError ? err.detail : String(err?.message ?? err);
 }
-function registeredTool(server, name) {
-    const tools = server._registeredTools;
-    if (!tools || typeof tools !== "object")
-        return null; // an MCP SDK that keeps them elsewhere
-    return tools[name];
-}
 /** One tools/call of a wrapped tool: what its handler subscribed, for the block and the rollback. */
 class CallScope {
     at;
@@ -226,16 +261,18 @@ class CallScope {
     // User-Agent, the agent's harness and conversation_id arguments, the
     // conversation's session, and who's calling.
     wire(session = this.session) {
-        const meta = this.extra._meta;
+        const req = this.at.host.req(this.extra);
+        const meta = req.meta;
         return packCall({
             meta,
             clientName: this.at.clientOf(meta, this.identified),
             user: this.user,
             session: session ?? undefined,
-            userAgent: userAgentOf(this.extra),
+            userAgent: userAgentOf(req),
             harness: this.args.harness,
             conversation: this.args.conversation,
             tool: this.tool,
+            tasks: takesTasks(meta, req),
         });
     }
     // request runs one request of the call to Wakeshift, after any before it
@@ -388,19 +425,12 @@ class CallScope {
 function recognizedOf(a) {
     return { harness: a?.harness ?? null, via: a?.via ?? null, claimed: a?.claimed ?? null };
 }
-function headerOf(extra, name) {
-    const h = extra?.requestInfo?.headers;
-    if (!h)
-        return "";
-    const v = h[name] ?? h[name.toLowerCase()];
-    return (Array.isArray(v) ? v[0] : v) ?? "";
-}
-function userAgentOf(extra) {
-    return headerOf(extra, "user-agent") || headerOf(extra, "User-Agent");
-}
 function hasKey(o, key) {
     return !!o && typeof o === "object" && !Array.isArray(o) && o[key] !== undefined;
 }
+function isRecord(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
 /**
  * @internal Whether a call comes from a client that subscribes to the app's
  * events itself, on stateless servers too (which never see initialize), in
@@ -411,15 +441,16 @@ function hasKey(o, key) {
  * _meta's). conversation is ChatGPT's conversation, when it names one.
  */
 export function nativeOf(at, extra, identified) {
-    const meta = (extra._meta ?? {});
+    const req = at.host.req(extra);
+    const meta = (req.meta ?? {});
     const conversation = typeof meta["openai/session"] === "string" && meta["openai/session"] ? meta["openai/session"] : null;
     if (at.events.native?.(extra))
         return { native: true, conversation };
     if (conversation)
         return { native: true, conversation };
-    if (dialectOf(at.clientOf(meta, identified), userAgentOf(extra)) === "chatgpt")
+    if (dialectOf(at.clientOf(meta, identified), userAgentOf(req)) === "chatgpt")
         return { native: true, conversation: null };
-    const caps = at.server.server.getClientCapabilities();
+    const caps = at.host.clientCapabilities();
     if (hasKey(caps?.extensions, EXTENSION_KEY))
         return { native: true, conversation: null };
     const metaCaps = meta["io.modelcontextprotocol/clientCapabilities"];
@@ -430,7 +461,9 @@ export function nativeOf(at, extra, identified) {
 /**
  * Wakeshift attached to an MCP server: the handle `wake.attach` returns.
  * Wrap a tool's callback with events, and give its input schema
- * Wakeshift's three arguments with inputs.
+ * Wakeshift's three arguments with inputs. C is your MCP SDK's request
+ * context (2.x's ctx, 1.x's extra), which a wrapped call carries as
+ * `call.extra`.
  */
 export class Attached {
     at;
@@ -440,27 +473,33 @@ export class Attached {
     constructor(at) {
         this.at = at;
     }
-    /**
-     * shape plus Wakeshift's three optional arguments (session_key, harness
-     * and conversation_id), for a wrapped tool's inputSchema:
-     * `inputSchema: attached.inputs({ table: z.string() })`.
-     */
     inputs(shape) {
+        if (isSchema(shape)) {
+            const own = getObjectShape(shape);
+            if (!own)
+                throw new Error("wakeshift: attached.inputs takes a zod object or a shape");
+            for (const k of WAKE_KEYS)
+                if (k in own)
+                    throw new Error(`wakeshift: attached.inputs adds ${k} itself: leave it out of the schema`);
+            return withFields(shape, byVersion[isZ4Schema(shape) ? "v4" : "v3"].inputs);
+        }
         for (const k of WAKE_KEYS)
             if (k in (shape ?? {}))
                 throw new Error(`wakeshift: attached.inputs adds ${k} itself: leave it out of the shape`);
-        return { ...shape, ...fieldsFor(shape, "inputs") };
+        return { ...shape, ...fieldsFor(shape, "inputs", this.at.host) };
     }
-    /**
-     * shape plus an optional wakeshift string, for a wrapped tool's
-     * outputSchema: the wrapper sets it to the block's text (without the
-     * beacon line), for hosts that show the model only structuredContent.
-     * The block stays in the content too.
-     */
     output(shape) {
+        if (isSchema(shape)) {
+            const own = getObjectShape(shape);
+            if (!own)
+                throw new Error("wakeshift: attached.output takes a zod object or a shape");
+            if (WAKESHIFT_FIELD in own)
+                throw new Error("wakeshift: attached.output adds wakeshift itself: leave it out of the schema");
+            return withFields(shape, byVersion[isZ4Schema(shape) ? "v4" : "v3"].output);
+        }
         if ("wakeshift" in (shape ?? {}))
             throw new Error("wakeshift: attached.output adds wakeshift itself: leave it out of the shape");
-        return { ...shape, ...fieldsFor(shape, "output") };
+        return { ...shape, ...fieldsFor(shape, "output", this.at.host) };
     }
     /**
      * Wraps a tool's callback, for `server.registerTool(name, …)` with the
@@ -480,11 +519,11 @@ export class Attached {
         return cb;
     }
     async run(name, cb, handler, input, extra) {
-        const tool = registeredTool(this.at.server, name);
+        const host = this.at.host;
+        const tool = host.registeredTool(name);
         if (tool === undefined || (tool && (tool.handler ?? tool.callback) !== cb)) {
             throw new Error(`wakeshift: attached.events("${name}", …) isn't the tool named ${name} on the server passed to attach: register it with the same name, on that server`);
         }
-        let wakeOutput = false;
         let outputSchema;
         if (tool) {
             const shape = getObjectShape(normalizeObjectSchema(tool.inputSchema));
@@ -492,8 +531,6 @@ export class Attached {
                 throw new Error(`wakeshift: the tool ${name} doesn't take Wakeshift's arguments: make its inputSchema with attached.inputs(…)`);
             }
             outputSchema = tool.outputSchema;
-            const out = getObjectShape(normalizeObjectSchema(outputSchema));
-            wakeOutput = !!out && "wakeshift" in out;
         }
         else {
             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");
@@ -521,7 +558,7 @@ export class Attached {
             await call.rollback();
             return result;
         }
-        if ((typeof result === "object" && result.isError) || extra?.signal?.aborted || !(await validOutput(outputSchema, result))) {
+        if ((typeof result === "object" && result.isError) || host.req(extra).signal?.aborted || !(await host.validOutput(outputSchema, result))) {
             await call.rollback();
             return typeof result === "string" ? { content: [{ type: "text", text: result }] } : result;
         }
@@ -536,23 +573,47 @@ export class Attached {
             this.at.wake.warn(`wakeshift: Wakeshift's block for a result of ${name} failed, so the call's subscriptions were rolled back: ${detailOf(err)}`);
             return { isError: true, content: [{ type: "text", text: `Wakeshift couldn't finish setting up this conversation's wakes (${detailOf(err)}). Try again.` }] };
         }
-        const out = mergeBlock(result, add ?? {}, wakeOutput);
-        if ((add?.text ?? "").trim() && !wakeOutput && out.structuredContent) {
-            this.at.warnOnce("output:" + name, `wakeshift: the wrapped tool ${name} returns structuredContent without attached.output: hosts that show only structuredContent won't see how this conversation is woken`);
+        const out = mergeBlock(result, add ?? {});
+        if (isRecord(out.structuredContent) && WAKESHIFT_FIELD in out.structuredContent && !(await host.validOutput(outputSchema, out))) {
+            // A schema that refuses fields it doesn't name (a strict object):
+            // MCP would refuse the result, so it goes without the field.
+            const { [WAKESHIFT_FIELD]: _dropped, ...own } = out.structuredContent;
+            out.structuredContent = own;
+            this.at.warnOnce("output:" + name, `wakeshift: the wrapped tool ${name}'s outputSchema refuses a wakeshift field, so hosts that show only structuredContent won't see how this conversation is woken: make it with attached.output`);
         }
         return out;
     }
-}
-// validOutput mirrors McpServer's own check of a result against the tool's
-// outputSchema (validateToolOutput): one it would refuse fails the call.
-async function validOutput(outputSchema, result) {
-    if (!outputSchema)
-        return true;
-    if (typeof result === "string" || !result.structuredContent)
-        return false;
-    const obj = normalizeObjectSchema(outputSchema);
-    if (!obj)
-        return true;
-    return (await safeParseAsync(obj, result.structuredContent)).success;
+    /**
+     * @internal Wraps the server's tools/list handler so each wrapped tool's
+     * object output schema names wakeshift (withWakeshiftField). McpServer
+     * sets the handler when the first tool is registered, perhaps after
+     * attach, so a later set is wrapped too (as tasks.ts does).
+     */
+    amendToolsList() {
+        const handlers = this.at.host.handlers();
+        if (!handlers)
+            return; // a future SDK: schemas stay as registered
+        const wrap = (h) => async (request, extra) => {
+            const out = await h(request, extra);
+            if (out && Array.isArray(out.tools))
+                this.amendTools(out.tools);
+            return out;
+        };
+        const h = handlers.get("tools/list");
+        if (h)
+            Map.prototype.set.call(handlers, "tools/list", wrap(h));
+        const set = handlers.set.bind(handlers);
+        handlers.set = (method, h) => set(method, method === "tools/list" ? wrap(h) : h);
+    }
+    amendTools(tools) {
+        for (let i = 0; i < tools.length; i++) {
+            const t = tools[i];
+            if (!t || typeof t !== "object" || typeof t.name !== "string" || !this.wrapped.has(t.name) || !t.outputSchema)
+                continue;
+            const schema = withWakeshiftField(t.outputSchema);
+            if (schema !== t.outputSchema)
+                tools[i] = { ...t, outputSchema: schema };
+        }
+    }
 }
 //# sourceMappingURL=toolcall.js.map