fix: generate concrete capability schemas from extracted types

Instead of using NonNullable<ParentType["property"]> which ts-to-zod can't
process, extract the actual type text from parent interfaces during pre-processing.

This allows ts-to-zod to generate proper schemas for:
- ClientTasksCapabilitySchema
- ServerTasksCapabilitySchema

These are now re-exported from generated instead of using .unwrap() extraction.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ochafik

scripts/generate-schemas.ts

@@ -113,11 +113,11 @@ const DISCRIMINATED_UNIONS: Record<string, string> = {
 /**
  * Derived capability types to add during pre-processing.
  * These are extracted from parent capability interfaces for convenience.
- * Format: { typeName: 'ParentType["property"]' }
+ * Format: { typeName: { parent: 'ParentInterface', property: 'propertyName' } }
  */
-const DERIVED_CAPABILITY_TYPES: Record<string, string> = {
-    'ClientTasksCapability': 'ClientCapabilities["tasks"]',
-    'ServerTasksCapability': 'ServerCapabilities["tasks"]',
+const DERIVED_CAPABILITY_TYPES: Record<string, { parent: string; property: string }> = {
+    'ClientTasksCapability': { parent: 'ClientCapabilities', property: 'tasks' },
+    'ServerTasksCapability': { parent: 'ServerCapabilities', property: 'tasks' },
 };
 
 // =============================================================================
@@ -280,27 +280,52 @@ function updateRequestParamsType(sourceFile: SourceFile): void {
 }
 
 /**
- * Add derived capability types that extract nested capabilities from parent types.
- * This allows reusing types like ClientCapabilities["tasks"] as standalone types.
+ * Add derived capability types by extracting nested properties from parent interfaces.
+ * This creates concrete interface definitions that ts-to-zod can generate schemas for.
  *
- * Adds type aliases like:
- *   export type ClientTasksCapability = NonNullable<ClientCapabilities["tasks"]>;
+ * Example: ClientCapabilities.tasks becomes a standalone ClientTasksCapability interface.
  */
 function injectDerivedCapabilityTypes(sourceFile: SourceFile): void {
-    for (const [typeName, sourceExpression] of Object.entries(DERIVED_CAPABILITY_TYPES)) {
+    for (const [typeName, { parent, property }] of Object.entries(DERIVED_CAPABILITY_TYPES)) {
         // Check if already exists
-        if (sourceFile.getTypeAlias(typeName)) {
+        if (sourceFile.getInterface(typeName) || sourceFile.getTypeAlias(typeName)) {
             console.log(`    - ${typeName} already exists`);
             continue;
         }
 
+        // Find the parent interface
+        const parentInterface = sourceFile.getInterface(parent);
+        if (!parentInterface) {
+            console.warn(`    ⚠️  Parent interface ${parent} not found for ${typeName}`);
+            continue;
+        }
+
+        // Find the property
+        const prop = parentInterface.getProperty(property);
+        if (!prop) {
+            console.warn(`    ⚠️  Property ${property} not found in ${parent} for ${typeName}`);
+            continue;
+        }
+
+        // Get the type text and remove the optional marker if present
+        const typeNode = prop.getTypeNode();
+        if (!typeNode) {
+            console.warn(`    ⚠️  No type node for ${parent}.${property}`);
+            continue;
+        }
+
+        let typeText = typeNode.getText();
+        // Remove trailing '?' or '| undefined' to get the non-optional type
+        typeText = typeText.replace(/\s*\|\s*undefined\s*$/, '').trim();
+
+        // Create the derived type alias
         sourceFile.addTypeAlias({
             name: typeName,
             isExported: true,
-            type: `NonNullable<${sourceExpression}>`,
-            docs: [`Derived from ${sourceExpression} for convenience.`]
+            type: typeText,
+            docs: [`Extracted from ${parent}["${property}"] for standalone use.`]
         });
-        console.log(`    ✓ Added derived type: ${typeName}`);
+        console.log(`    ✓ Added derived type: ${typeName} from ${parent}.${property}`);
     }
 }
 

src/generated/sdk.schemas.ts

@@ -1960,6 +1960,77 @@ export const ListToolsResultSchema = PaginatedResultSchema.extend({
     tools: z.array(ToolSchema)
 });
 
+/** Extracted from ClientCapabilities["tasks"] for standalone use. */
+export const ClientTasksCapabilitySchema = z.object({
+    /**
+     * Whether this client supports tasks/list.
+     */
+    list: z.record(z.string(), z.any()).optional(),
+    /**
+     * Whether this client supports tasks/cancel.
+     */
+    cancel: z.record(z.string(), z.any()).optional(),
+    /**
+     * Specifies which request types can be augmented with tasks.
+     */
+    requests: z
+        .object({
+            /**
+             * Task support for sampling-related requests.
+             */
+            sampling: z
+                .object({
+                    /**
+                     * Whether the client supports task-augmented sampling/createMessage requests.
+                     */
+                    createMessage: z.record(z.string(), z.any()).optional()
+                })
+                .optional(),
+            /**
+             * Task support for elicitation-related requests.
+             */
+            elicitation: z
+                .object({
+                    /**
+                     * Whether the client supports task-augmented elicitation/create requests.
+                     */
+                    create: z.record(z.string(), z.any()).optional()
+                })
+                .optional()
+        })
+        .optional()
+});
+
+/** Extracted from ServerCapabilities["tasks"] for standalone use. */
+export const ServerTasksCapabilitySchema = z.object({
+    /**
+     * Whether this server supports tasks/list.
+     */
+    list: z.record(z.string(), z.any()).optional(),
+    /**
+     * Whether this server supports tasks/cancel.
+     */
+    cancel: z.record(z.string(), z.any()).optional(),
+    /**
+     * Specifies which request types can be augmented with tasks.
+     */
+    requests: z
+        .object({
+            /**
+             * Task support for tool-related requests.
+             */
+            tools: z
+                .object({
+                    /**
+                     * Whether the server supports task-augmented tools/call requests.
+                     */
+                    call: z.record(z.string(), z.any()).optional()
+                })
+                .optional()
+        })
+        .optional()
+});
+
 /**
  * A request that expects a response.
  *

src/generated/sdk.schemas.zod.test.ts

@@ -239,6 +239,10 @@ export type ReadResourceResultSchemaInferredType = z.infer<typeof generated.Read
 
 export type ListToolsResultSchemaInferredType = z.infer<typeof generated.ListToolsResultSchema>;
 
+export type ClientTasksCapabilitySchemaInferredType = z.infer<typeof generated.ClientTasksCapabilitySchema>;
+
+export type ServerTasksCapabilitySchemaInferredType = z.infer<typeof generated.ServerTasksCapabilitySchema>;
+
 export type JSONRPCRequestSchemaInferredType = z.infer<typeof generated.JSONRPCRequestSchema>;
 
 export type URLElicitationRequiredErrorSchemaInferredType = z.infer<typeof generated.URLElicitationRequiredErrorSchema>;
@@ -529,6 +533,10 @@ expectType<spec.ReadResourceResult>({} as ReadResourceResultSchemaInferredType);
 expectType<ReadResourceResultSchemaInferredType>({} as spec.ReadResourceResult);
 expectType<spec.ListToolsResult>({} as ListToolsResultSchemaInferredType);
 expectType<ListToolsResultSchemaInferredType>({} as spec.ListToolsResult);
+expectType<spec.ClientTasksCapability>({} as ClientTasksCapabilitySchemaInferredType);
+expectType<ClientTasksCapabilitySchemaInferredType>({} as spec.ClientTasksCapability);
+expectType<spec.ServerTasksCapability>({} as ServerTasksCapabilitySchemaInferredType);
+expectType<ServerTasksCapabilitySchemaInferredType>({} as spec.ServerTasksCapability);
 expectType<spec.JSONRPCRequest>({} as JSONRPCRequestSchemaInferredType);
 expectType<JSONRPCRequestSchemaInferredType>({} as spec.JSONRPCRequest);
 expectType<spec.URLElicitationRequiredError>({} as URLElicitationRequiredErrorSchemaInferredType);