chore: resolve remaining as any casts

Author: dclark27

src/client/v3/index.v3.test.ts

@@ -630,6 +630,7 @@ test('should typecheck', () => {
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const WeatherRequestSchema = (GetWeatherRequestSchema as unknown as z.ZodObject<any>).or(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         GetForecastRequestSchema as unknown as z.ZodObject<any>
     ) as AnyObjectSchema;
     const WeatherNotificationSchema = WeatherForecastNotificationSchema as AnyObjectSchema;

src/server/completable.ts

@@ -21,10 +21,7 @@ export type CompletableSchema<T extends AnySchema> = T & {
  * Wraps a Zod type to provide autocompletion capabilities. Useful for, e.g., prompt arguments in MCP.
  * Works with both Zod v3 and v4 schemas.
  */
-export function completable<T extends AnySchema>(
-    schema: T,
-    complete: CompleteCallback<T>
-): CompletableSchema<T> {
+export function completable<T extends AnySchema>(schema: T, complete: CompleteCallback<T>): CompletableSchema<T> {
     Object.defineProperty(schema as object, COMPLETABLE_SYMBOL, {
         value: { complete } as CompletableMeta<T>,
         enumerable: false,
@@ -45,7 +42,7 @@ export function isCompletable(schema: unknown): schema is CompletableSchema<AnyS
  * Gets the completer callback from a completable schema, if it exists.
  */
 export function getCompleter<T extends AnySchema>(schema: T): CompleteCallback<T> | undefined {
-    const meta = (schema as any)[COMPLETABLE_SYMBOL] as CompletableMeta<T> | undefined;
+    const meta = (schema as unknown as { [COMPLETABLE_SYMBOL]?: CompletableMeta<T> })[COMPLETABLE_SYMBOL];
     return meta?.complete as CompleteCallback<T> | undefined;
 }
 

src/server/mcp.ts

@@ -7,9 +7,12 @@ import {
     ShapeOutput,
     normalizeObjectSchema,
     safeParseAsync,
-    isZ4Schema,
     getObjectShape,
-    objectFromShape
+    objectFromShape,
+    getParseErrorMessage,
+    getSchemaDescription,
+    isSchemaOptional,
+    getLiteralValue
 } from './zod-compat.js';
 import { toJsonSchemaCompat } from './zod-json-schema-compat.js';
 import {
@@ -169,7 +172,7 @@ export class McpServer {
                     if (!parseResult.success) {
                         throw new McpError(
                             ErrorCode.InvalidParams,
-                            `Input validation error: Invalid arguments for tool ${request.params.name}: ${(parseResult as any).error.message}`
+                            `Input validation error: Invalid arguments for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`
                         );
                     }
 
@@ -195,7 +198,7 @@ export class McpServer {
                     if (!parseResult.success) {
                         throw new McpError(
                             ErrorCode.InvalidParams,
-                            `Output validation error: Invalid structured content for tool ${request.params.name}: ${(parseResult as any).error.message}`
+                            `Output validation error: Invalid structured content for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`
                         );
                     }
                 }
@@ -441,7 +444,7 @@ export class McpServer {
                 if (!parseResult.success) {
                     throw new McpError(
                         ErrorCode.InvalidParams,
-                        `Invalid arguments for prompt ${request.params.name}: ${(parseResult as any).error.message}`
+                        `Invalid arguments for prompt ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`
                     );
                 }
 
@@ -1079,10 +1082,7 @@ export class ResourceTemplate {
  * - Both fields are optional but typically one should be provided
  */
 export type ToolCallback<Args extends undefined | ZodRawShapeCompat | AnySchema = undefined> = Args extends ZodRawShapeCompat
-    ? (
-          args: ShapeOutput<Args>,
-          extra: RequestHandlerExtra<ServerRequest, ServerNotification>
-      ) => CallToolResult | Promise<CallToolResult>
+    ? (args: ShapeOutput<Args>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => CallToolResult | Promise<CallToolResult>
     : Args extends AnySchema
       ? (
             args: SchemaOutput<Args>,
@@ -1228,10 +1228,7 @@ export type RegisteredResourceTemplate = {
 type PromptArgsRawShape = ZodRawShapeCompat;
 
 export type PromptCallback<Args extends undefined | PromptArgsRawShape = undefined> = Args extends PromptArgsRawShape
-    ? (
-          args: ShapeOutput<Args>,
-          extra: RequestHandlerExtra<ServerRequest, ServerNotification>
-      ) => GetPromptResult | Promise<GetPromptResult>
+    ? (args: ShapeOutput<Args>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => GetPromptResult | Promise<GetPromptResult>
     : (extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => GetPromptResult | Promise<GetPromptResult>;
 
 export type RegisteredPrompt = {
@@ -1258,9 +1255,9 @@ function promptArgumentsFromSchema(schema: AnyObjectSchema): PromptArgument[] {
     if (!shape) return [];
     return Object.entries(shape).map(([name, field]): PromptArgument => {
         // Get description - works for both v3 and v4
-        const description = (field as any).description ?? (field as any)._def?.description;
+        const description = getSchemaDescription(field);
         // Check if optional - works for both v3 and v4
-        const isOptional = (field as any).isOptional?.() ?? (field as any)._def?.typeName === 'ZodOptional';
+        const isOptional = isSchemaOptional(field);
         return {
             name,
             description,
@@ -1277,21 +1274,9 @@ function getMethodValue(schema: AnyObjectSchema): string {
     }
 
     // Extract literal value - works for both v3 and v4
-    const v4Def = isZ4Schema(methodSchema) ? (methodSchema as any)._zod?.def : undefined;
-    const legacyDef = (methodSchema as any)._def;
-
-    const candidates = [
-        v4Def?.value,
-        legacyDef?.value,
-        Array.isArray(v4Def?.values) ? v4Def.values[0] : undefined,
-        Array.isArray(legacyDef?.values) ? legacyDef.values[0] : undefined,
-        (methodSchema as any).value
-    ];
-
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string') {
-            return candidate;
-        }
+    const value = getLiteralValue(methodSchema);
+    if (typeof value === 'string') {
+        return value;
     }
 
     throw new Error('Schema method literal must be a string');

src/server/v3/index.v3.test.ts

@@ -661,6 +661,7 @@ test('should typecheck', () => {
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const WeatherRequestSchema = (GetWeatherRequestSchema as unknown as z.ZodObject<any>).or(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         GetForecastRequestSchema as unknown as z.ZodObject<any>
     ) as AnyObjectSchema;
     const WeatherNotificationSchema = WeatherForecastNotificationSchema as AnyObjectSchema;

src/server/zod-compat.ts

@@ -188,3 +188,93 @@ export function normalizeObjectSchema(schema: AnySchema | ZodRawShapeCompat | un
 
     return undefined;
 }
+
+// --- Error message extraction ---
+/**
+ * Safely extracts an error message from a parse result error.
+ * Zod errors can have different structures, so we handle various cases.
+ */
+export function getParseErrorMessage(error: unknown): string {
+    if (error && typeof error === 'object') {
+        // Try common error structures
+        if ('message' in error && typeof error.message === 'string') {
+            return error.message;
+        }
+        if ('issues' in error && Array.isArray(error.issues) && error.issues.length > 0) {
+            const firstIssue = error.issues[0];
+            if (firstIssue && typeof firstIssue === 'object' && 'message' in firstIssue) {
+                return String(firstIssue.message);
+            }
+        }
+        // Fallback: try to stringify the error
+        try {
+            return JSON.stringify(error);
+        } catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
+
+// --- Schema metadata access ---
+/**
+ * Gets the description from a schema, if available.
+ * Works with both Zod v3 and v4.
+ */
+export function getSchemaDescription(schema: AnySchema): string | undefined {
+    if (isZ4Schema(schema)) {
+        const v4Schema = schema as unknown as ZodV4Internal;
+        return v4Schema._zod?.def?.description;
+    }
+    const v3Schema = schema as unknown as ZodV3Internal;
+    // v3 may have description on the schema itself or in _def
+    return (schema as { description?: string }).description ?? v3Schema._def?.description;
+}
+
+/**
+ * Checks if a schema is optional.
+ * Works with both Zod v3 and v4.
+ */
+export function isSchemaOptional(schema: AnySchema): boolean {
+    if (isZ4Schema(schema)) {
+        const v4Schema = schema as unknown as ZodV4Internal;
+        return v4Schema._zod?.def?.typeName === 'ZodOptional';
+    }
+    const v3Schema = schema as unknown as ZodV3Internal;
+    // v3 has isOptional() method
+    if (typeof (schema as { isOptional?: () => boolean }).isOptional === 'function') {
+        return (schema as { isOptional: () => boolean }).isOptional();
+    }
+    return v3Schema._def?.typeName === 'ZodOptional';
+}
+
+/**
+ * Gets the literal value from a schema, if it's a literal schema.
+ * Works with both Zod v3 and v4.
+ * Returns undefined if the schema is not a literal or the value cannot be determined.
+ */
+export function getLiteralValue(schema: AnySchema): unknown {
+    if (isZ4Schema(schema)) {
+        const v4Schema = schema as unknown as ZodV4Internal;
+        const def = v4Schema._zod?.def;
+        if (def) {
+            // Try various ways to get the literal value
+            if (def.value !== undefined) return def.value;
+            if (Array.isArray(def.values) && def.values.length > 0) {
+                return def.values[0];
+            }
+        }
+    }
+    const v3Schema = schema as unknown as ZodV3Internal;
+    const def = v3Schema._def;
+    if (def) {
+        if (def.value !== undefined) return def.value;
+        if (Array.isArray(def.values) && def.values.length > 0) {
+            return def.values[0];
+        }
+    }
+    // Fallback: check for direct value property (some Zod versions)
+    const directValue = (schema as { value?: unknown }).value;
+    if (directValue !== undefined) return directValue;
+    return undefined;
+}