fix(app): align registerTool runtime with declared types

- Handler reads registeredTool.{input,output}Schema so update() takes effect
- Call cb(extra) when no inputSchema, matching AppToolCallback<undefined>
- Throw on duplicate name; guard list_changed pre-connect; notify on register
- Drop misleading zod optional peer (still required by generated/schema.ts)
- examples: fix pdf search/find stale match count; threejs set-scene-source re-render
- spec: Zod → Standard Schema; clarify tools availability via tools/list after init

Author: ochafik

examples/pdf-server/src/mcp-app.ts

@@ -5136,7 +5136,7 @@ const PageIntervalSchema = z.object({
 /** Dispatch a command via processCommands and return a text result. */
 async function runCommand(
   cmd: PdfCommand,
-  okText: string,
+  okText: string | (() => string),
 ): Promise<CallToolResult> {
   if (!pdfDocument) {
     return {
@@ -5145,7 +5145,8 @@ async function runCommand(
     };
   }
   await processCommands([cmd]);
-  return { content: [{ type: "text" as const, text: okText }] };
+  const text = typeof okText === "function" ? okText() : okText;
+  return { content: [{ type: "text" as const, text }] };
 }
 
 app.registerTool(
@@ -5218,7 +5219,7 @@ app.registerTool(
   async ({ query }) =>
     runCommand(
       { type: "search", query },
-      `Searched for "${query}": ${allMatches.length} match(es)`,
+      () => `Searched for "${query}": ${allMatches.length} match(es)`,
     ),
 );
 
@@ -5235,7 +5236,7 @@ app.registerTool(
   async ({ query }) =>
     runCommand(
       { type: "find", query },
-      `Found ${allMatches.length} match(es) for "${query}"`,
+      () => `Found ${allMatches.length} match(es) for "${query}"`,
     ),
 );
 

examples/threejs-server/src/mcp-app-wrapper.tsx

@@ -71,6 +71,7 @@ export interface ViewProps<TToolInput = Record<string, unknown>> {
 function registerWidgetTools(
   app: App,
   sceneStateRef: React.RefObject<SceneState>,
+  setToolInputs: (args: Record<string, unknown>) => void,
 ): void {
   // Tool: set-scene-source - Update the scene source/configuration
   app.registerTool(
@@ -95,12 +96,12 @@ function registerWidgetTools(
       }),
     },
     async (args) => {
-      // Update scene state
       sceneStateRef.current.code = args.code;
       if (args.height !== undefined) {
         sceneStateRef.current.height = args.height;
       }
       sceneStateRef.current.error = null;
+      setToolInputs({ code: args.code, height: sceneStateRef.current.height });
 
       const result = {
         success: true,
@@ -179,7 +180,7 @@ function McpAppWrapper() {
       appRef.current = app;
 
       // Register widget interaction tools before connect()
-      registerWidgetTools(app, sceneStateRef);
+      registerWidgetTools(app, sceneStateRef, setToolInputs);
 
       // Complete tool input (streaming finished)
       app.ontoolinput = (params) => {

package.json

@@ -118,9 +118,6 @@
     },
     "react-dom": {
       "optional": true
-    },
-    "zod": {
-      "optional": true
     }
   },
   "overrides": {

specification/draft/apps.mdx

@@ -1775,8 +1775,8 @@ await app.connect(new PostMessageTransport(window.parent));
 |-------|------|----------|-------------|
 | `name` | string | Yes | Unique tool identifier |
 | `description` | string | No | Human-readable description for agent |
-| `inputSchema` | Zod schema or JSON Schema | No | Validates arguments |
-| `outputSchema` | Zod schema | No | Validates return value |
+| `inputSchema` | [Standard Schema](https://standardschema.dev/) | No | Validates arguments; serialized to JSON Schema for `tools/list` |
+| `outputSchema` | [Standard Schema](https://standardschema.dev/) | No | Validates `structuredContent` |
 | `annotations` | ToolAnnotations | No | MCP tool hints (e.g., `readOnlyHint`) |
 | `_meta` | object | No | Custom metadata |
 
@@ -2292,7 +2292,7 @@ This specification defines the Minimum Viable Product (MVP) for MCP Apps.
 - **App-Provided Tools:** Apps can register tools via `app.registerTool()` that agents can call
   - Bidirectional tool flow (Apps consume server tools AND provide app tools)
   - Full lifecycle management (enable/disable/update/remove)
-  - Schema validation with Zod
+  - Schema validation via [Standard Schema](https://standardschema.dev/) (Zod, ArkType, Valibot, …)
   - Tool list change notifications
 
 **Content Types (deferred from MVP):**
@@ -2602,7 +2602,7 @@ Hosts MAY implement different permission levels based on tool annotations:
 
 App tools MUST be tied to the app's lifecycle:
 
-- Tools become available only after app sends `notifications/tools/list_changed`
+- Tools become available once the app advertises the `tools` capability in `ui/initialize` and the host issues `tools/list`; subsequent changes are signaled via `notifications/tools/list_changed`
 - Tools automatically disappear when app iframe is torn down
 - Hosts MUST NOT persist app tool registrations across sessions
 - Calling a tool from a closed app MUST return an error

src/app-bridge.test.ts

@@ -772,6 +772,53 @@ describe("App <-> AppBridge integration", () => {
       // Tool should no longer be registered (internal check)
     });
 
+    it("registerTool throws on duplicate name", () => {
+      app.registerTool("dup", {}, async () => ({ content: [] }));
+      expect(() =>
+        app.registerTool("dup", {}, async () => ({ content: [] })),
+      ).toThrow(/already registered/);
+    });
+
+    it("enable/disable/update/remove pre-connect do not throw", () => {
+      const tool = app.registerTool("t", {}, async () => ({ content: [] }));
+      expect(() => tool.disable()).not.toThrow();
+      expect(() => tool.enable()).not.toThrow();
+      expect(() => tool.update({ description: "x" })).not.toThrow();
+      expect(() => tool.remove()).not.toThrow();
+    });
+
+    it("callback without inputSchema receives extra as first arg", async () => {
+      await app.connect(appTransport);
+      let receivedExtra: any;
+      app.registerTool("noargs", {}, async (extra: any) => {
+        receivedExtra = extra;
+        return { content: [] };
+      });
+      await bridge.callTool({ name: "noargs", arguments: {} });
+      expect(receivedExtra).toBeDefined();
+      expect(receivedExtra.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it("update({inputSchema}) is honored by handler validation", async () => {
+      await app.connect(appTransport);
+      const tool = app.registerTool(
+        "evolving",
+        { inputSchema: z.object({ a: z.string() }) as any },
+        async (args: any) => ({
+          content: [{ type: "text" as const, text: JSON.stringify(args) }],
+        }),
+      );
+      expect(
+        bridge.callTool({ name: "evolving", arguments: { a: 123 } }),
+      ).rejects.toThrow(/Invalid input/);
+      tool.update({ inputSchema: z.object({ a: z.number() }) as any });
+      const result = await bridge.callTool({
+        name: "evolving",
+        arguments: { a: 123 },
+      });
+      expect(result.content[0]).toEqual({ type: "text", text: '{"a":123}' });
+    });
+
     it("tool throws error when disabled and called", async () => {
       await app.connect(appTransport);
 

src/app.ts

@@ -377,7 +377,13 @@ export class App extends ProtocolWithEvents<
     },
     cb: AppToolCallback<InputArgs>,
   ): RegisteredAppTool {
+    if (this._registeredTools[name]) {
+      throw new Error(`Tool ${name} is already registered`);
+    }
     const app = this;
+    const notify = () => {
+      if (app.transport) void app.sendToolListChanged();
+    };
     const registeredTool: RegisteredAppTool = {
       title: config.title,
       description: config.description,
@@ -388,38 +394,41 @@ export class App extends ProtocolWithEvents<
       enabled: true,
       enable(): void {
         this.enabled = true;
-        app.sendToolListChanged();
+        notify();
       },
       disable(): void {
         this.enabled = false;
-        app.sendToolListChanged();
+        notify();
       },
       update(updates) {
         Object.assign(this, updates);
-        app.sendToolListChanged();
+        notify();
       },
       remove() {
         delete app._registeredTools[name];
-        app.sendToolListChanged();
+        notify();
       },
       handler: async (rawArgs, extra) => {
         if (!registeredTool.enabled) {
           throw new Error(`Tool ${name} is disabled`);
         }
-        const parsedArgs = config.inputSchema
-          ? await validateStandardSchema(
-              config.inputSchema,
-              rawArgs,
-              `Invalid input for tool ${name}: `,
-            )
-          : rawArgs;
-        const result = await (cb as AppToolCallback<StandardSchemaV1>)(
-          parsedArgs,
-          extra,
-        );
-        if (config.outputSchema) {
+        let result: CallToolResult;
+        if (registeredTool.inputSchema) {
+          const parsedArgs = await validateStandardSchema(
+            registeredTool.inputSchema,
+            rawArgs,
+            `Invalid input for tool ${name}: `,
+          );
+          result = await (cb as AppToolCallback<StandardSchemaV1>)(
+            parsedArgs,
+            extra,
+          );
+        } else {
+          result = await (cb as AppToolCallback<undefined>)(extra);
+        }
+        if (registeredTool.outputSchema) {
           result.structuredContent = (await validateStandardSchema(
-            config.outputSchema,
+            registeredTool.outputSchema,
             result.structuredContent,
             `Invalid output for tool ${name}: `,
           )) as CallToolResult["structuredContent"];
@@ -440,6 +449,7 @@ export class App extends ProtocolWithEvents<
     }
 
     this.ensureToolHandlersInitialized();
+    notify();
     return registeredTool;
   }