build: enable no-explicit-any in eslint (#190)

# Description

The purpose of this PR is removing all the references to keyword 'any'
present in the repository, as it is considered a bad practice. Future
adoptions will be triggered by the linter automatic checks


Fixes #184  🦕

Author: guglielmo-san

eslint.config.mjs

@@ -15,7 +15,6 @@ export default defineConfig(
   },
   {
     rules: {
-      '@typescript-eslint/no-explicit-any': 'off', // Allow the usage of `any` in the project
       '@typescript-eslint/no-unused-vars': [
         'error',
         {
@@ -27,8 +26,9 @@ export default defineConfig(
     },
   },
   {
-    files: ['test/**/*.spec.ts'],
+    files: ['test/**/*.ts', 'src/samples/**/*.ts'],
     rules: {
+      '@typescript-eslint/no-explicit-any': 'off', // Allow the usage of `any` in the test files and in samples
       '@typescript-eslint/no-unused-expressions': 'off', // Allow unused expressions in test files, for compatibility with 'chai'
     },
   },

src/client/client.ts

@@ -19,6 +19,7 @@ import {
   TaskArtifactUpdateEvent,
   TaskStatusUpdateEvent,
   A2ARequest,
+  JSONRPCErrorResponse,
 } from '../types.js'; // Assuming schema.ts is in the same directory or appropriately pathed
 import { AGENT_CARD_PATH } from '../constants.js';
 import { JsonRpcTransport } from './transports/json_rpc_transport.js';
@@ -283,11 +284,12 @@ export class A2AClient {
         params,
         this.requestIdCounter++
       );
-    } catch (e: any) {
+    } catch (e) {
       // For compatibility, return JSON-RPC errors as errors instead of throwing transport-agnostic errors
       // produced by JsonRpcTransport.
-      if (isJSONRPCError(e)) {
-        return e.errorResponse as TExtensionResponse;
+      const errorResponse = extractJSONRPCError(e);
+      if (errorResponse) {
+        return errorResponse as TExtensionResponse;
       }
       throw e;
     }
@@ -442,24 +444,32 @@ export class A2AClient {
         jsonrpc: '2.0',
         result: result ?? null, // JSON-RPC requires result property on success, it will be null for "void" methods.
       } as TResponse;
-    } catch (e: any) {
+    } catch (e) {
       // For compatibility, return JSON-RPC errors as response objects instead of throwing transport-agnostic errors
       // produced by JsonRpcTransport.
-      if (isJSONRPCError(e)) {
-        return e.errorResponse as TResponse;
+      const errorResponse = extractJSONRPCError(e);
+      if (errorResponse) {
+        return errorResponse as TResponse;
       }
       throw e;
     }
   }
 }
 
-function isJSONRPCError(error: any): boolean {
-  return (
+function extractJSONRPCError(error: unknown): JSONRPCErrorResponse {
+  if (
+    error instanceof Object &&
     'errorResponse' in error &&
-    error.errorResponse &&
+    error.errorResponse instanceof Object &&
+    'jsonrpc' in error.errorResponse &&
     error.errorResponse.jsonrpc === '2.0' &&
-    error.errorResponse.error
-  );
+    'error' in error.errorResponse &&
+    error.errorResponse.error !== null
+  ) {
+    return error.errorResponse as JSONRPCErrorResponse;
+  } else {
+    return undefined;
+  }
 }
 
 // Utility unexported types to properly factor out common "compatibility" logic via invokeJsonRpc.

src/client/transports/json_rpc_transport.ts

@@ -152,6 +152,7 @@ export class JsonRpcTransport implements A2ATransport {
   }
 
   private async _sendRpcRequest<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     TParams extends { [key: string]: any },
     TResponse extends JSONRPCResponse,
   >(method: string, params: TParams, idOverride: number | undefined): Promise<TResponse> {
@@ -168,11 +169,11 @@ export class JsonRpcTransport implements A2ATransport {
 
     if (!httpResponse.ok) {
       let errorBodyText = '(empty or non-JSON response)';
-      let errorJson: any = {};
+      let errorJson: JSONRPCErrorResponse;
       try {
         errorBodyText = await httpResponse.text();
         errorJson = JSON.parse(errorBodyText);
-      } catch (e: any) {
+      } catch (e) {
         throw new Error(
           `HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`,
           { cause: e }
@@ -218,25 +219,25 @@ export class JsonRpcTransport implements A2ATransport {
 
   private async *_sendStreamingRequest(
     method: string,
-    params: any
+    params: unknown
   ): AsyncGenerator<A2AStreamEventData, void, undefined> {
     const clientRequestId = this.requestIdCounter++;
     const rpcRequest: JSONRPCRequest = {
       jsonrpc: '2.0',
       method,
-      params: params as { [key: string]: any },
+      params: params as { [key: string]: unknown },
       id: clientRequestId,
     };
 
     const response = await this._fetchRpc(rpcRequest, 'text/event-stream');
 
     if (!response.ok) {
       let errorBody = '';
-      let errorJson: any = {};
+      let errorJson: JSONRPCErrorResponse;
       try {
         errorBody = await response.text();
         errorJson = JSON.parse(errorBody);
-      } catch (e: any) {
+      } catch (e) {
         throw new Error(
           `HTTP error establishing stream for ${method}: ${response.status} ${response.statusText}. Response: ${errorBody || '(empty)'}`,
           { cause: e }
@@ -305,8 +306,11 @@ export class JsonRpcTransport implements A2ATransport {
           }
         }
       }
-    } catch (error: any) {
-      console.error('Error reading or parsing SSE stream:', error.message);
+    } catch (error) {
+      console.error(
+        'Error reading or parsing SSE stream:',
+        (error instanceof Error && error.message) || 'Error unknown'
+      );
       throw error;
     } finally {
       reader.releaseLock();
@@ -342,10 +346,11 @@ export class JsonRpcTransport implements A2ATransport {
       }
 
       return a2aStreamResponse.result as TStreamItem;
-    } catch (e: any) {
+    } catch (e) {
       if (
-        e.message.startsWith('SSE event contained an error') ||
-        e.message.startsWith("SSE event JSON-RPC response is missing 'result' field")
+        e instanceof Error &&
+        (e.message.startsWith('SSE event contained an error') ||
+          e.message.startsWith("SSE event JSON-RPC response is missing 'result' field"))
       ) {
         throw e;
       }
@@ -355,7 +360,7 @@ export class JsonRpcTransport implements A2ATransport {
         e
       );
       throw new Error(
-        `Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e.message}`
+        `Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${(e instanceof Error && e.message) || 'Unknown error'}`
       );
     }
   }

src/server/express/agent_card_handler.ts

@@ -27,7 +27,7 @@ export function agentCardHandler(options: AgentCardHandlerOptions): RequestHandl
     try {
       const agentCard = await provider();
       res.json(agentCard);
-    } catch (error: any) {
+    } catch (error) {
       console.error('Error fetching agent card:', error);
       res.status(500).json({ error: 'Failed to retrieve agent card' });
     }

src/server/express/json_rpc_handler.ts

@@ -43,7 +43,7 @@ export function jsonRpcHandler(options: JsonRpcHandlerOptions): RequestHandler {
         res.setHeader(HTTP_EXTENSION_HEADER, Array.from(context.activatedExtensions));
       }
       // Check if it's an AsyncGenerator (stream)
-      if (typeof (rpcResponseOrStream as any)?.[Symbol.asyncIterator] === 'function') {
+      if (typeof (rpcResponseOrStream as AsyncGenerator)?.[Symbol.asyncIterator] === 'function') {
         const stream = rpcResponseOrStream as AsyncGenerator<
           JSONRPCSuccessResponse,
           void,
@@ -62,13 +62,17 @@ export function jsonRpcHandler(options: JsonRpcHandlerOptions): RequestHandler {
             res.write(`id: ${new Date().getTime()}\n`);
             res.write(`data: ${JSON.stringify(event)}\n\n`);
           }
-        } catch (streamError: any) {
+        } catch (streamError) {
           console.error(`Error during SSE streaming (request ${req.body?.id}):`, streamError);
           // If the stream itself throws an error, send a final JSONRPCErrorResponse
-          const a2aError =
-            streamError instanceof A2AError
-              ? streamError
-              : A2AError.internalError(streamError.message || 'Streaming error.');
+          let a2aError: A2AError;
+          if (streamError instanceof A2AError) {
+            a2aError = streamError;
+          } else {
+            a2aError = A2AError.internalError(
+              (streamError instanceof Error && streamError.message) || 'Streaming error.'
+            );
+          }
           const errorResponse: JSONRPCErrorResponse = {
             jsonrpc: '2.0',
             id: req.body?.id || null, // Use original request ID if available
@@ -93,7 +97,7 @@ export function jsonRpcHandler(options: JsonRpcHandlerOptions): RequestHandler {
         const rpcResponse = rpcResponseOrStream as JSONRPCResponse;
         res.status(200).json(rpcResponse);
       }
-    } catch (error: any) {
+    } catch (error) {
       // Catch errors from jsonRpcTransportHandler.handle itself (e.g., initial parse error)
       console.error('Unhandled error in JSON-RPC POST handler:', error);
       const a2aError =
@@ -116,7 +120,7 @@ export function jsonRpcHandler(options: JsonRpcHandlerOptions): RequestHandler {
 }
 
 export const jsonErrorHandler: ErrorRequestHandler = (
-  err: any,
+  err: unknown,
   _req: Request,
   res: Response,
   next: NextFunction

src/server/request_handler/default_request_handler.ts

@@ -159,7 +159,7 @@ export class DefaultRequestHandler implements A2ARequestHandler {
     eventQueue: ExecutionEventQueue,
     options?: {
       firstResultResolver?: (value: Message | Task | PromiseLike<Message | Task>) => void;
-      firstResultRejector?: (reason?: any) => void;
+      firstResultRejector?: (reason?: unknown) => void;
     }
   ): Promise<void> {
     let firstResultSent = false;
@@ -191,7 +191,7 @@ export class DefaultRequestHandler implements A2ARequestHandler {
           A2AError.internalError('Execution finished before a message or task was produced.')
         );
       }
-    } catch (error: any) {
+    } catch (error) {
       console.error(`Event processing loop failed for task ${taskId}:`, error);
       this._handleProcessingError(
         error,
@@ -629,11 +629,11 @@ export class DefaultRequestHandler implements A2ARequestHandler {
   }
 
   private async _handleProcessingError(
-    error: any,
+    error: unknown,
     resultManager: ResultManager,
     firstResultSent: boolean,
     taskId: string,
-    firstResultRejector?: (reason: any) => void
+    firstResultRejector?: (reason: unknown) => void
   ): Promise<void> {
     // Non-blocking case with with first result not sent
     if (firstResultRejector && !firstResultSent) {
@@ -648,6 +648,7 @@ export class DefaultRequestHandler implements A2ARequestHandler {
 
     // Non-blocking case with first result already sent
     const currentTask = resultManager.getCurrentTask();
+    const errorMessage = (error instanceof Error && error.message) || 'Unknown error';
     if (currentTask) {
       const statusUpdateFailed: TaskStatusUpdateEvent = {
         taskId: currentTask.id,
@@ -658,7 +659,7 @@ export class DefaultRequestHandler implements A2ARequestHandler {
             kind: 'message',
             role: 'agent',
             messageId: uuidv4(),
-            parts: [{ kind: 'text', text: `Event processing loop failed: ${error.message}` }],
+            parts: [{ kind: 'text', text: `Event processing loop failed: ${errorMessage}` }],
             taskId: currentTask.id,
             contextId: currentTask.contextId,
           },
@@ -671,10 +672,12 @@ export class DefaultRequestHandler implements A2ARequestHandler {
       try {
         await resultManager.processEvent(statusUpdateFailed);
       } catch (error) {
-        console.error(`Event processing loop failed for task ${taskId}: ${error.message}`);
+        console.error(
+          `Event processing loop failed for task ${taskId}: ${(error instanceof Error && error.message) || 'Unknown error'}`
+        );
       }
     } else {
-      console.error(`Event processing loop failed for task ${taskId}: ${error.message}`);
+      console.error(`Event processing loop failed for task ${taskId}: ${errorMessage}`);
     }
   }
 }

src/server/transports/jsonrpc_transport_handler.ts

@@ -25,6 +25,8 @@ export class JsonRpcTransportHandler {
    * For non-streaming methods, it returns a Promise of a single JSONRPCMessage (Result or ErrorResponse).
    */
   public async handle(
+    // TODO: remove the eslint disable and replace the any (https://github.com/a2aproject/a2a-js/issues/179)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     requestBody: any,
     context?: ServerCallContext
   ): Promise<JSONRPCResponse | AsyncGenerator<JSONRPCResponse, void, undefined>> {
@@ -42,11 +44,13 @@ export class JsonRpcTransportHandler {
       if (!this.isRequestValid(rpcRequest)) {
         throw A2AError.invalidRequest('Invalid JSON-RPC Request.');
       }
-    } catch (error: any) {
+    } catch (error) {
       const a2aError =
         error instanceof A2AError
           ? error
-          : A2AError.parseError(error.message || 'Failed to parse JSON request.');
+          : A2AError.parseError(
+              (error instanceof SyntaxError && error.message) || 'Failed to parse JSON request.'
+            );
       return {
         jsonrpc: '2.0',
         id: rpcRequest?.id !== undefined ? rpcRequest.id : null,
@@ -94,7 +98,7 @@ export class JsonRpcTransportHandler {
                 result: event,
               };
             }
-          } catch (streamError: any) {
+          } catch (streamError) {
             // If the underlying agent stream throws an error, we need to yield a JSONRPCErrorResponse.
             // However, an AsyncGenerator is expected to yield JSONRPCResult.
             // This indicates an issue with how errors from the agent's stream are propagated.
@@ -111,7 +115,7 @@ export class JsonRpcTransportHandler {
         })();
       } else {
         // Handle non-streaming methods
-        let result: any;
+        let result: unknown;
         switch (method) {
           case 'message/send':
             result = await this.requestHandler.sendMessage(rpcRequest.params, context);
@@ -153,11 +157,15 @@ export class JsonRpcTransportHandler {
           result: result,
         } as JSONRPCResponse;
       }
-    } catch (error: any) {
-      const a2aError =
-        error instanceof A2AError
-          ? error
-          : A2AError.internalError(error.message || 'An unexpected error occurred.');
+    } catch (error) {
+      let a2aError: A2AError;
+      if (error instanceof A2AError) {
+        a2aError = error;
+      } else {
+        a2aError = A2AError.internalError(
+          (error instanceof Error && error.message) || 'An unexpected error occurred.'
+        );
+      }
       return {
         jsonrpc: '2.0',
         id: requestId,
@@ -189,7 +197,7 @@ export class JsonRpcTransportHandler {
   }
 
   // Validates that params is an object with non-empty string keys
-  private paramsAreValid(params: any): boolean {
+  private paramsAreValid(params: unknown): boolean {
     if (typeof params !== 'object' || params === null || Array.isArray(params)) {
       return false;
     }

src/server/utils.ts

@@ -13,15 +13,15 @@ export function getCurrentTimestamp(): string {
  * @param value The value to check.
  * @returns True if the value is a plain object, false otherwise.
  */
-export function isObject(value: unknown): value is Record<string, any> {
+export function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
 /**
  * Type guard to check if an object is a TaskStatus update (lacks 'parts').
  * Used to differentiate yielded updates from the handler.
  */
-export function isTaskStatusUpdate(update: any): update is Omit<TaskStatus, 'timestamp'> {
+export function isTaskStatusUpdate(update: unknown): update is Omit<TaskStatus, 'timestamp'> {
   // Check if it has 'state' and NOT 'parts' (which Artifacts have)
   return isObject(update) && 'state' in update && !('parts' in update);
 }
@@ -30,7 +30,7 @@ export function isTaskStatusUpdate(update: any): update is Omit<TaskStatus, 'tim
  * Type guard to check if an object is an Artifact update (has 'parts').
  * Used to differentiate yielded updates from the handler.
  */
-export function isArtifactUpdate(update: any): update is Artifact {
+export function isArtifactUpdate(update: unknown): update is Artifact {
   // Check if it has 'parts'
   return isObject(update) && 'parts' in update;
 }