modality-kit 0.12.10 → 0.12.12

package/dist/index.js

@@ -5485,6 +5485,10 @@ class JSONRPCCall {
 // src/jsonrpc-manager.ts
 var logger2 = getLoggerInstance("JSON-RPC-Manager");
 
+class ERROR_METHOD_NOT_FOUND extends ErrorCode {
+  code = -32601 /* METHOD_NOT_FOUND */;
+}
+
 class JSONRPCManager extends JSONRPCCall {
   methods = new Map;
   config;
@@ -5506,16 +5510,14 @@ class JSONRPCManager extends JSONRPCCall {
         case "request":
           return await this.processRequest(validation.message, options);
         case "notification":
-          this.processNotification(validation.message, options);
-          return;
+          return this.processNotification(validation.message, options);
         case "response":
           const response = validation.message;
           logger2.info("Received response message, handling internally", [
             response,
             response.id
           ]);
-          this.handleResponse(response);
-          return;
+          return this.handleResponse(response);
         case "batch":
           return await this.processBatchRequest(validation.message, options);
         default:
@@ -5535,11 +5537,7 @@ class JSONRPCManager extends JSONRPCCall {
     try {
       const methodConfig = this.methods.get(request.method);
       if (!methodConfig) {
-        const error = JSONRPCUtils.createError(-32601 /* METHOD_NOT_FOUND */, `Method '${request.method}' not found`);
-        if (this.eventHandlers.onMethodError) {
-          this.eventHandlers.onMethodError(request.method, error, context);
-        }
-        return JSONRPCUtils.createErrorResponse(error, request.id);
+        throw new ERROR_METHOD_NOT_FOUND(`Method '${request.method}' not found`);
       }
       if (this.eventHandlers.onMethodCall) {
         this.eventHandlers.onMethodCall(request.method, request.params, context);
@@ -5567,15 +5565,15 @@ class JSONRPCManager extends JSONRPCCall {
     try {
       const methodConfig = this.methods.get(notification.method);
       if (!methodConfig) {
-        console.warn(`Notification method '${notification.method}' not found`);
-        return;
+        throw new ERROR_METHOD_NOT_FOUND(`Notification method '${notification.method}' not found`);
       }
       if (this.eventHandlers.onMethodCall) {
         this.eventHandlers.onMethodCall(notification.method, notification.params, context);
       }
-      await methodConfig.handler(notification.params, context);
+      return await methodConfig.handler(notification.params, context);
     } catch (error) {
       console.error(`Error executing notification '${notification.method}':`, error);
+      throw error;
     }
   }
   async processBatchRequest(batchRequest, options = {}) {
@@ -5601,21 +5599,21 @@ class JSONRPCManager extends JSONRPCCall {
     if (error.message.includes("connection")) {
       return JSONRPCUtils.createError(-32002 /* CONNECTION_ERROR */, STANDARD_ERROR_MESSAGES[-32002 /* CONNECTION_ERROR */]);
     }
-    return JSONRPCUtils.createError(-32603 /* INTERNAL_ERROR */, STANDARD_ERROR_MESSAGES[-32603 /* INTERNAL_ERROR */], { originalError: error.message });
+    return JSONRPCUtils.createError(error?.code || -32603 /* INTERNAL_ERROR */, STANDARD_ERROR_MESSAGES[-32603 /* INTERNAL_ERROR */], { originalError: error.message });
   }
   sendMessage(message, options) {
-    console.warn("JSONRPCManager.sendMessage not implemented - message not sent:", message, options);
+    console.warn("JSONRPCManager.sendMessage not implemented - message not sent:");
+    console.dir({ message, options }, { depth: null, color: true });
   }
   sendNotification(method, params, options) {
     const notification = JSONRPCUtils.createNotification(method, params);
-    this.sendMessage(notification, options);
+    return this.sendMessage(notification, options);
   }
   registerMethod(methodName, config) {
     if (this.methods.has(methodName)) {
       throw new Error(`Method '${methodName}' is already registered`);
     }
     this.methods.set(methodName, config);
-    console.log(`Registered JSON-RPC method: ${methodName}`);
   }
   unregisterMethod(methodName) {
     const removed = this.methods.delete(methodName);
@@ -5629,8 +5627,8 @@ class JSONRPCManager extends JSONRPCCall {
   }
   handleRequest(method, params, options = {}) {
     const { promise, request } = super.handleRequest(method, params, options);
-    this.sendMessage(request, options);
-    return { promise, request };
+    const result = this.sendMessage(request, options);
+    return { promise, request, result };
   }
   async validateMessage(data, options = {}) {
     try {
@@ -5639,24 +5637,22 @@ class JSONRPCManager extends JSONRPCCall {
       if (!message) {
         console.error("Failed to parse JSON-RPC message:", messageStr);
         const errorResponse = JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32700 /* PARSE_ERROR */, "Parse error"), null);
-        this.sendMessage(errorResponse, options);
-        return;
+        return this.sendMessage(errorResponse, options);
       }
       const validation = JSONRPCUtils.validateMessage(message);
       if (!validation.valid) {
         const errorResponse = JSONRPCUtils.createErrorResponse(validation.error, message.id || null);
-        this.sendMessage(errorResponse, options);
-        return;
+        return this.sendMessage(errorResponse, options);
       }
       const response = await this.processMessage(validation, options);
       if (response && (!Array.isArray(response) || response.length > 0)) {
-        this.sendMessage(response, options);
+        return this.sendMessage(response, options);
       }
     } catch (err) {
       const error = err;
       console.error("Error handling WebSocket message:", error);
       const errorResponse = JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32603 /* INTERNAL_ERROR */, "Internal error"), null);
-      this.sendMessage(errorResponse, options);
+      return this.sendMessage(errorResponse, options);
     }
   }
   getStats() {

package/dist/types/jsonrpc-manager.d.ts

@@ -1,9 +1,3 @@
-/**
- * JSON-RPC Manager
- *
- * Clean JSON-RPC 2.0 implementation for WebSocket communication.
- * Provides method registration, routing, and lifecycle management.
- */
 import { JSONRPCCall } from "./util_pending";
 import type { JSONRPCRequest, JSONRPCMessage, JSONRPCError, JSONRPCParams } from "./schemas/jsonrpc";
 /**
@@ -78,13 +72,13 @@ export declare class JSONRPCManager<TContext> extends JSONRPCCall {
      */
     private defaultErrorHandler;
     /**
-     * Send a message (to be overridden by WebSocket implementation)
+     * Send a message (to be overridden by implementation)
      */
-    protected sendMessage(message: JSONRPCMessage, options: TContext): void;
+    protected sendMessage(message: JSONRPCMessage, options: TContext): any;
     /**
      * Send a JSON-RPC notification (no response expected)
      */
-    sendNotification(method: string, params: any, options: TContext): void;
+    protected sendNotification(method: string, params: any, options: TContext): void;
     /**
      * Register a JSON-RPC method
      */
@@ -103,6 +97,7 @@ export declare class JSONRPCManager<TContext> extends JSONRPCCall {
     handleRequest(method: string, params?: any, options?: any): {
         promise: Promise<any>;
         request: JSONRPCRequest;
+        result: any;
     };
     /**
      * Process incoming WebSocket message

package/dist/types/schemas/jsonrpc.d.ts

@@ -62,24 +62,6 @@ export interface NotificationSendParams {
  * JSON-RPC 2.0 version identifier
  */
 export declare const JSONRPC_VERSION: "2.0";
-/**
- * Standard JSON-RPC 2.0 error codes as defined in the specification
- */
-export declare enum JSONRPCErrorCode {
-    PARSE_ERROR = -32700,
-    INVALID_REQUEST = -32600,
-    METHOD_NOT_FOUND = -32601,
-    INVALID_PARAMS = -32602,
-    INTERNAL_ERROR = -32603,
-    SERVER_ERROR_START = -32099,
-    SERVER_ERROR_END = -32000,
-    TIMEOUT_ERROR = -32001,
-    CONNECTION_ERROR = -32002,
-    AUTHENTICATION_ERROR = -32003,
-    AUTHORIZATION_ERROR = -32004,
-    RATE_LIMIT_ERROR = -32005,
-    VALIDATION_ERROR = -32006
-}
 /**
  * JSON-RPC 2.0 parameter types - can be object, array, or null
  *
@@ -153,6 +135,24 @@ export interface JSONRPCValidationResult {
     /** Parsed message type */
     messageType?: "request" | "notification" | "response" | "batch";
 }
+/**
+ * Standard JSON-RPC 2.0 error codes as defined in the specification
+ */
+export declare enum JSONRPCErrorCode {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    SERVER_ERROR_START = -32099,
+    SERVER_ERROR_END = -32000,
+    TIMEOUT_ERROR = -32001,
+    CONNECTION_ERROR = -32002,
+    AUTHENTICATION_ERROR = -32003,
+    AUTHORIZATION_ERROR = -32004,
+    RATE_LIMIT_ERROR = -32005,
+    VALIDATION_ERROR = -32006
+}
 /**
  * Standard error messages for common JSON-RPC errors
  */

package/dist/types/util_error.d.ts

@@ -2,7 +2,7 @@
  * Base class for task-related errors
  */
 export declare abstract class ErrorCode extends Error {
-    abstract readonly code: string;
+    abstract readonly code: string | number;
     cause?: Error;
     constructor(message: string, originalError?: unknown);
 }

package/dist/types/util_response.d.ts

@@ -11,8 +11,8 @@ export interface McpSuccessResponse {
 }
 export interface McpErrorResponse {
     success: boolean;
+    code?: string | number;
     error: string;
-    code?: string;
     operation?: string;
     reason?: string;
     meta?: Record<string, any>;
@@ -26,8 +26,8 @@ interface SuccessData extends Record<string, any> {
  */
 interface ErrorData extends Record<string, any> {
     success?: boolean;
+    code?: string | number;
     message: string;
-    code?: string;
     operation?: string;
 }
 /**

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.10",
+  "version": "0.12.12",
   "name": "modality-kit",
   "repository": {
     "type": "git",