clean up old Zod references and some lint warnings

Author: m-parkhill

src/index.ts

@@ -42,9 +42,11 @@ for (const tool of tools) {
       {
         title: tool.title ?? tool.name,
         description: tool.description,
-        inputSchema: tool.inputSchema ?? {},
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        inputSchema: (tool.inputSchema ?? {}) as any,
       },
-      handler
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      handler as any
     );
   } else {
     console.error(`No handler found for tool: ${tool.name}`);

src/tools/composeTools.ts

@@ -84,7 +84,7 @@ export function buildToolList(): ToolDef[] {
     const copy: ToolDef = { ...t };
     if (copy.inputSchema && typeof copy.inputSchema === "object") {
       // If top-level is a $ref only, replace it; otherwise recursively resolve nested refs
-      copy.inputSchema = resolveRefObject(JSON.parse(JSON.stringify(copy.inputSchema)));
+      copy.inputSchema = resolveRefObject(JSON.parse(JSON.stringify(copy.inputSchema))) as Record<string, unknown>;
     }
     return copy;
   });

src/tools/tests/unit/tools-resolver.test.ts

@@ -2,10 +2,10 @@ import { describe, it, expect } from "vitest";
 import { buildToolList } from "../../composeTools.js";
 
 // Helper to recursively check if a schema contains any $ref entries (except within oneOf/anyOf/allOf arrays)
-function hasUnresolvedRefs(obj: any, path = ""): { found: boolean; paths: string[] } {
+function hasUnresolvedRefs(obj: unknown, path = ""): { found: boolean; paths: string[] } {
   const paths: string[] = [];
 
-  function traverse(val: any, p: string) {
+  function traverse(val: unknown, p: string) {
     if (!val || typeof val !== "object") return;
 
     if (Array.isArray(val)) {
@@ -39,32 +39,21 @@ describe("unit: tool list resolver", () => {
     // specific checks for presentations tools
     const createTemplate = tools.find((t) => t.name === "create_proof_template");
     expect(createTemplate).toBeDefined();
-    const s1 = createTemplate!.inputSchema as any;
-    const isZod = (x: any) => x && typeof x.safeParse === 'function';
-    if (isZod(s1)) {
-      expect(isZod(s1)).toBe(true);
-    } else {
-      expect(s1.$ref).toBeUndefined();
-      expect(s1.type).toBe("object");
-    }
+    const s1 = createTemplate!.inputSchema as Record<string, unknown>;
+    expect(s1.$ref).toBeUndefined();
+    expect(s1.type).toBe("object");
 
     const createRequest = tools.find((t) => t.name === "create_proof_request");
     expect(createRequest).toBeDefined();
-    const s2 = createRequest!.inputSchema as any;
-    if (isZod(s2)) {
-      expect(isZod(s2)).toBe(true);
-    } else {
-      expect(s2.$ref).toBeUndefined();
-      expect(s2.properties).toBeDefined();
-    }
+    const s2 = createRequest!.inputSchema as Record<string, unknown>;
+    expect(s2.$ref).toBeUndefined();
+    expect(s2.properties).toBeDefined();
 
     // generic assertion: no tool should expose a top-level $ref-only inputSchema
     for (const t of tools) {
-      const s = t.inputSchema as any;
-      const isZod = (x: any) => x && typeof x.safeParse === 'function';
+      const s = t.inputSchema;
       if (s && typeof s === 'object') {
-        if (isZod(s)) continue;
-        expect(s.$ref).toBeUndefined();
+        expect((s as Record<string, unknown>).$ref).toBeUndefined();
       }
     }
   });
@@ -77,42 +66,37 @@ describe("unit: tool list resolver", () => {
     const createIssuer = tools.find((t) => t.name === "create_issuer");
     expect(createIssuer).toBeDefined();
 
-    const schema = createIssuer!.inputSchema as any;
-    const isZod = (x: any) => x && typeof x.safeParse === 'function';
-    if (isZod(schema)) {
-      expect(isZod(schema)).toBe(true);
-      return;
-    }
+    const schema = createIssuer!.inputSchema as Record<string, unknown>;
 
     // Should have resolved credentialOptions from a $ref to an actual object
     expect(schema.properties).toBeDefined();
-    expect(schema.properties.credentialOptions).toBeDefined();
-    expect((schema.properties.credentialOptions as any).$ref).toBeUndefined();
+    expect((schema.properties as Record<string, unknown>).credentialOptions).toBeDefined();
+    expect(((schema.properties as Record<string, unknown>).credentialOptions as Record<string, unknown>).$ref).toBeUndefined();
 
     // credentialOptions should have credential property (from CredentialIssueRequest)
-    const credentialOptions = schema.properties.credentialOptions as any;
+    const credentialOptions = (schema.properties as Record<string, unknown>).credentialOptions as Record<string, unknown>;
     expect(credentialOptions.properties).toBeDefined();
-    expect(credentialOptions.properties.credential).toBeDefined();
+    expect((credentialOptions.properties as Record<string, unknown>).credential).toBeDefined();
 
     // credential property should also be resolved (from Credential schema)
-    const credentialProp = credentialOptions.properties.credential as any;
+    const credentialProp = (credentialOptions.properties as Record<string, unknown>).credential as Record<string, unknown>;
     expect(credentialProp.$ref).toBeUndefined();
     expect(credentialProp.type).toBe("object");
     expect(credentialProp.properties).toBeDefined();
 
     // The credential should have subject property (not credentialSubject)
-    expect(credentialProp.properties.subject).toBeDefined();
-    expect(credentialProp.properties.credentialSubject).toBeUndefined();
+    expect((credentialProp.properties as Record<string, unknown>).subject).toBeDefined();
+    expect((credentialProp.properties as Record<string, unknown>).credentialSubject).toBeUndefined();
   });
 
   it("ensures no tool has bare $ref-only top-level inputSchema", () => {
     const tools = buildToolList();
 
     for (const tool of tools) {
-      const schema = tool.inputSchema as any;
+      const schema = tool.inputSchema;
       if (schema && typeof schema === "object") {
         // Top-level should never be a bare $ref
-        expect(schema.$ref).toBeUndefined();
+        expect((schema as Record<string, unknown>).$ref).toBeUndefined();
       }
     }
   });
@@ -121,10 +105,8 @@ describe("unit: tool list resolver", () => {
     const tools = buildToolList();
 
     for (const tool of tools) {
-      const schema = tool.inputSchema as any;
+      const schema = tool.inputSchema;
       if (!schema) continue;
-      const isZod = (x: any) => x && typeof x.safeParse === 'function';
-      if (isZod(schema)) continue; // Zod schemas don't use $ref
 
       if (schema && typeof schema === "object") {
         const { found, paths } = hasUnresolvedRefs(schema, tool.name);

src/tools/types.ts

@@ -1,8 +1,8 @@
 export type ToolDef = {
   name: string;
   description: string;
-  inputSchema?: any; // JSON Schema is inherently dynamic
-  outputSchema?: any; // JSON Schema is inherently dynamic
+  inputSchema?: Record<string, unknown>; // JSON Schema is inherently dynamic
+  outputSchema?: Record<string, unknown>; // JSON Schema is inherently dynamic
   title?: string;
 };
 

src/transport/http/index.ts

@@ -22,7 +22,7 @@ export function startHTTPTransport({
   const transports: { [key: string]: StreamableHTTPServerTransport } = {};
 
   function isInitializeRequest(body: unknown): boolean {
-    return !!body && typeof body === "object" && (body as any).method === "initialize";
+    return !!body && typeof body === "object" && "method" in body && (body as Record<string, unknown>).method === "initialize";
   }
 
   const httpServer = http.createServer(async (req, res) => {

tests/integration/tools-integration.test.ts

@@ -4,43 +4,8 @@ import { TruveraClient } from '../../src/clients/index.js';
 
 function constructArgsFromSchema(schema: any) {
   const args: any = {};
-  if (!schema) return args;
-
-  const isZod = (s: any) => s && typeof s.safeParse === 'function';
-  if (isZod(schema)) {
-    const shape = (schema as any)._def?.shape || (schema as any).shape || {};
-    for (const [key, val] of Object.entries(shape)) {
-      // determine if optional
-      const inner = (val as any)._def?.innerType || (val as any);
-      const isOptional = (val as any)?._def?.type === 'optional' || (val as any).isOptional;
-      if (isOptional) continue;
-      const t = inner?._def?.type || inner?._def?.typeName || typeof inner;
-      switch (t) {
-        case 'number':
-        case 'ZodNumber':
-          args[key] = 1;
-          break;
-        case 'ZodBoolean':
-        case 'boolean':
-          args[key] = true;
-          break;
-        case 'ZodObject':
-        case 'object':
-          args[key] = {};
-          break;
-        case 'ZodArray':
-        case 'array':
-          args[key] = [];
-          break;
-        default:
-          args[key] = 'test';
-      }
-    }
-    return args;
-  }
-
-  // Fallback: JSON Schema style
   if (!schema || !schema.required) return args;
+  
   for (const key of schema.required) {
     const prop = schema.properties && schema.properties[key];
     if (!prop) {