feat(app): type structuredContent from outputSchema in registerTool

AppToolCallback gains an Out param: when outputSchema is provided,
structuredContent is required and typed via StandardSchemaV1.InferOutput,
with an `isError: true` escape hatch. Without outputSchema, return type
is unchanged (CallToolResult). Uses intersection rather than Omit since
CallToolResult's index signature swallows Omit's known keys.

Also drops the `as any` casts on z.object(...) in tests — zod 4 satisfies
StandardSchemaV1 directly.

Author: ochafik

src/app-bridge.test.ts

@@ -698,8 +698,8 @@ describe("App <-> AppBridge integration", () => {
     });
 
     it("registerTool creates a registered tool", async () => {
-      const InputSchema = z.object({ name: z.string() }) as any;
-      const OutputSchema = z.object({ greeting: z.string() }) as any;
+      const InputSchema = z.object({ name: z.string() });
+      const OutputSchema = z.object({ greeting: z.string() });
 
       const tool = app.registerTool(
         "greet",
@@ -803,15 +803,15 @@ describe("App <-> AppBridge integration", () => {
       await app.connect(appTransport);
       const tool = app.registerTool(
         "evolving",
-        { inputSchema: z.object({ a: z.string() }) as any },
+        { inputSchema: z.object({ a: z.string() }) },
         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 });
+      tool.update({ inputSchema: z.object({ a: z.number() }) });
       const result = await bridge.callTool({
         name: "evolving",
         arguments: { a: 123 },
@@ -845,7 +845,7 @@ describe("App <-> AppBridge integration", () => {
     });
 
     it("tool validates input schema", async () => {
-      const InputSchema = z.object({ name: z.string() }) as any;
+      const InputSchema = z.object({ name: z.string() });
 
       const tool = app.registerTool(
         "greet",
@@ -877,7 +877,7 @@ describe("App <-> AppBridge integration", () => {
     });
 
     it("tool validates output schema", async () => {
-      const OutputSchema = z.object({ greeting: z.string() }) as any;
+      const OutputSchema = z.object({ greeting: z.string() });
 
       const tool = app.registerTool(
         "greet",
@@ -1031,7 +1031,7 @@ describe("App <-> AppBridge integration", () => {
         "greet",
         {
           description: "Greets user",
-          inputSchema: z.object({ name: z.string() }) as any,
+          inputSchema: z.object({ name: z.string() }),
         },
         async (args: any) => ({
           content: [{ type: "text" as const, text: `Hello, ${args.name}!` }],
@@ -1072,7 +1072,7 @@ describe("App <-> AppBridge integration", () => {
           "greet",
           {
             description: "Greets user",
-            inputSchema: z.object({ name: z.string() }) as any,
+            inputSchema: z.object({ name: z.string() }),
           },
           async (args: any) => ({
             content: [{ type: "text" as const, text: `Hello, ${args.name}!` }],
@@ -1119,7 +1119,7 @@ describe("App <-> AppBridge integration", () => {
           "add",
           {
             description: "Add two numbers",
-            inputSchema: z.object({ a: z.number(), b: z.number() }) as any,
+            inputSchema: z.object({ a: z.number(), b: z.number() }),
           },
           async (args: any) => ({
             content: [
@@ -1136,7 +1136,7 @@ describe("App <-> AppBridge integration", () => {
           "multiply",
           {
             description: "Multiply two numbers",
-            inputSchema: z.object({ a: z.number(), b: z.number() }) as any,
+            inputSchema: z.object({ a: z.number(), b: z.number() }),
           },
           async (args: any) => ({
             content: [

src/app.ts

@@ -175,23 +175,41 @@ type RequestHandlerExtra = Parameters<
   Parameters<App["setRequestHandler"]>[1]
 >[1];
 
+/**
+ * Result of an app-registered tool callback. When `Out` is provided,
+ * `structuredContent` is required and typed (unless `isError: true`).
+ */
+export type AppToolResult<
+  Out extends StandardSchemaV1 | undefined = undefined,
+> = Out extends StandardSchemaV1
+  ?
+      | (CallToolResult & {
+          structuredContent: StandardSchemaV1.InferOutput<Out>;
+          isError?: false;
+        })
+      | (CallToolResult & { isError: true })
+  : CallToolResult;
+
 /**
  * Callback for an app-registered tool. When `In` is provided, `args` is the
  * validated/parsed input; when `In` is `undefined`, the callback receives only
- * `extra`.
+ * `extra`. When `Out` is provided, the return's `structuredContent` is typed.
  *
  * Mirrors `ToolCallback` from `@modelcontextprotocol/sdk/server/mcp.js` but is
  * parameterized over {@link StandardSchemaV1} instead of zod, so any
  * Standard-Schema-compatible library (Zod, ArkType, Valibot, …) can be used.
  */
 export type AppToolCallback<
   In extends StandardSchemaV1 | undefined = undefined,
+  Out extends StandardSchemaV1 | undefined = undefined,
 > = In extends StandardSchemaV1
   ? (
       args: StandardSchemaV1.InferOutput<In>,
       extra: RequestHandlerExtra,
-    ) => CallToolResult | Promise<CallToolResult>
-  : (extra: RequestHandlerExtra) => CallToolResult | Promise<CallToolResult>;
+    ) => AppToolResult<Out> | Promise<AppToolResult<Out>>
+  : (
+      extra: RequestHandlerExtra,
+    ) => AppToolResult<Out> | Promise<AppToolResult<Out>>;
 
 /**
  * Handle returned by {@link App.registerTool}. Mirrors `RegisteredTool` from
@@ -363,7 +381,7 @@ export class App extends ProtocolWithEvents<
   }
 
   registerTool<
-    OutputArgs extends StandardSchemaV1,
+    OutputArgs extends undefined | StandardSchemaV1 = undefined,
     InputArgs extends undefined | StandardSchemaV1 = undefined,
   >(
     name: string,
@@ -375,7 +393,7 @@ export class App extends ProtocolWithEvents<
       annotations?: ToolAnnotations;
       _meta?: Record<string, unknown>;
     },
-    cb: AppToolCallback<InputArgs>,
+    cb: AppToolCallback<InputArgs, OutputArgs>,
   ): RegisteredAppTool {
     if (this._registeredTools[name]) {
       throw new Error(`Tool ${name} is already registered`);
@@ -419,12 +437,13 @@ export class App extends ProtocolWithEvents<
             rawArgs,
             `Invalid input for tool ${name}: `,
           );
-          result = await (cb as AppToolCallback<StandardSchemaV1>)(
-            parsedArgs,
+          result = await (
+            cb as AppToolCallback<StandardSchemaV1, StandardSchemaV1>
+          )(parsedArgs, extra);
+        } else {
+          result = await (cb as AppToolCallback<undefined, StandardSchemaV1>)(
             extra,
           );
-        } else {
-          result = await (cb as AppToolCallback<undefined>)(extra);
         }
         if (registeredTool.outputSchema) {
           result.structuredContent = (await validateStandardSchema(