modality-kit 0.8.0 → 0.8.2

package/dist/index.js

@@ -4991,14 +4991,6 @@ async function compressWithLanguageDetection(text, maxTokens = DEFAULT_CONFIG.ma
   });
 }
 // src/schemas/jsonrpc.ts
-var exports_jsonrpc = {};
-__export(exports_jsonrpc, {
-  generateId: () => generateId,
-  STANDARD_ERROR_MESSAGES: () => STANDARD_ERROR_MESSAGES,
-  JSONRPC_VERSION: () => JSONRPC_VERSION,
-  JSONRPCUtils: () => JSONRPCUtils,
-  JSONRPCErrorCode: () => JSONRPCErrorCode
-});
 var JSONRPC_VERSION = "2.0";
 var JSONRPCErrorCode;
 ((JSONRPCErrorCode2) => {
@@ -5463,6 +5455,196 @@ class JSONRPCCall {
     this.pendingRequests.destroy("JSONRPCManager destroyed");
   }
 }
+// src/jsonrpc-manager.ts
+var logger2 = getLoggerInstance("JSON-RPC-Manager");
+
+class JSONRPCManager extends JSONRPCCall {
+  methods = new Map;
+  config;
+  eventHandlers;
+  constructor(config = {}, eventHandlers = {}) {
+    super();
+    this.config = {
+      strictValidation: true,
+      defaultTimeout: 30000,
+      maxBatchSize: 10,
+      errorHandler: this.defaultErrorHandler.bind(this),
+      ...config
+    };
+    this.eventHandlers = eventHandlers;
+  }
+  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);
+    if (removed) {
+      console.log(`Unregistered JSON-RPC method: ${methodName}`);
+    }
+    return removed;
+  }
+  getRegisteredMethods() {
+    return Array.from(this.methods.keys());
+  }
+  handleRequest(method, params, options = {}) {
+    const { promise, request } = super.handleRequest(method, params, options);
+    this.sendMessage(request, options);
+    return { promise, request };
+  }
+  sendNotification(method, params, options) {
+    const notification = JSONRPCUtils.createNotification(method, params);
+    this.sendMessage(notification, options);
+  }
+  sendMessage(message, options) {
+    console.warn("JSONRPCManager.sendMessage not implemented - message not sent:", message, options);
+  }
+  async validateMessage(data, options = {}) {
+    try {
+      const messageStr = typeof data === "string" ? data : data.toString();
+      const message = JSONRPCUtils.deserialize(messageStr);
+      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;
+      }
+      const validation = JSONRPCUtils.validateMessage(message);
+      if (!validation.valid) {
+        const errorResponse = JSONRPCUtils.createErrorResponse(validation.error, message.id || null);
+        this.sendMessage(errorResponse, options);
+        return;
+      }
+      const response = await this.processMessage(validation, options);
+      if (response) {
+        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);
+    }
+  }
+  async processMessage(validation, options = {}) {
+    try {
+      switch (validation.messageType) {
+        case "request":
+          return await this.processRequest(validation.message, options);
+        case "notification":
+          this.processNotification(validation.message, options);
+          return;
+        case "response":
+          const response = validation.message;
+          logger2.info("Received response message, handling internally", [
+            response,
+            response.id
+          ]);
+          this.handleResponse(response);
+          return;
+        case "batch":
+          return await this.processBatchRequest(validation.message, options);
+        default:
+          return JSONRPCUtils.createErrorResponse(JSONRPCUtils.createError(-32600 /* INVALID_REQUEST */, "Unknown message type"), validation.message.id || null);
+      }
+    } catch (error) {
+      console.error("Error processing JSON-RPC message:", error);
+      return JSONRPCUtils.createErrorResponse(this.config.errorHandler(error), validation.message.id || null);
+    }
+  }
+  async processRequest(request, options = {}) {
+    const context = {
+      ...options,
+      request,
+      metadata: {}
+    };
+    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);
+      }
+      if (this.eventHandlers.onMethodCall) {
+        this.eventHandlers.onMethodCall(request.method, request.params, context);
+      }
+      const result = await methodConfig.handler(request.params, context);
+      if (this.eventHandlers.onMethodResponse) {
+        this.eventHandlers.onMethodResponse(request.method, result, context);
+      }
+      return JSONRPCUtils.createSuccessResponse(result, request.id);
+    } catch (error) {
+      console.error(`Error executing method '${request.method}':`, error);
+      const jsonrpcError = this.config.errorHandler(error, context);
+      if (this.eventHandlers.onMethodError) {
+        this.eventHandlers.onMethodError(request.method, jsonrpcError, context);
+      }
+      return JSONRPCUtils.createErrorResponse(jsonrpcError, request.id);
+    }
+  }
+  async processNotification(notification, options = {}) {
+    const context = {
+      ...options,
+      request: notification,
+      metadata: {}
+    };
+    try {
+      const methodConfig = this.methods.get(notification.method);
+      if (!methodConfig) {
+        console.warn(`Notification method '${notification.method}' not found`);
+        return;
+      }
+      if (this.eventHandlers.onMethodCall) {
+        this.eventHandlers.onMethodCall(notification.method, notification.params, context);
+      }
+      await methodConfig.handler(notification.params, context);
+    } catch (error) {
+      console.error(`Error executing notification '${notification.method}':`, error);
+    }
+  }
+  async processBatchRequest(batchRequest, options = {}) {
+    if (batchRequest.length > this.config.maxBatchSize) {
+      const error = JSONRPCUtils.createError(-32600 /* INVALID_REQUEST */, `Batch size ${batchRequest.length} exceeds maximum allowed size ${this.config.maxBatchSize}`);
+      return [JSONRPCUtils.createErrorResponse(error, null)];
+    }
+    const promises = batchRequest.map((item) => {
+      if (JSONRPCUtils.isRequest(item)) {
+        return this.processRequest(item, options);
+      } else if (JSONRPCUtils.isNotification(item)) {
+        return this.processNotification(item, options);
+      }
+      return Promise.resolve();
+    });
+    const results = await Promise.all(promises);
+    return results.filter((result) => !!result);
+  }
+  defaultErrorHandler(error) {
+    if (error.message.includes("timeout")) {
+      return JSONRPCUtils.createError(-32001 /* TIMEOUT_ERROR */, STANDARD_ERROR_MESSAGES[-32001 /* TIMEOUT_ERROR */]);
+    }
+    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 });
+  }
+  getStats() {
+    const parentStats = super.getStats();
+    return {
+      ...parentStats,
+      registeredMethods: this.methods.size,
+      methodNames: this.getRegisteredMethods()
+    };
+  }
+  destroy() {
+    super.destroy();
+    this.methods.clear();
+  }
+}
 export {
   withErrorHandling,
   setupAITools,
@@ -5474,7 +5656,9 @@ export {
   createDataPendingOperations,
   compressWithLanguageDetection as compressText,
   exports_schemas_symbol as SymbolTypes,
-  exports_jsonrpc as JSONRPCTypes,
+  JSONRPCUtils,
+  JSONRPCManager,
+  JSONRPCErrorCode,
   JSONRPCCall,
   ErrorCode
 };

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export { loadVersion } from "./util_version";
 export { compressWithLanguageDetection as compressText } from "./util_text_compression";
 export { JSONRPCCall, createDataPendingOperations } from "./util_pending";
 export type { DataPendingOperation, PendingOperation } from "./util_pending";
-export * as JSONRPCTypes from "./schemas/jsonrpc";
-export type { JSONRPCMessage, JSONRPCRequest, JSONRPCNotification, JSONRPCResponse, JSONRPCBatchRequest, JSONRPCBatchResponse, JSONRPCErrorResponse, JSONRPCValidationResult, CommandExecuteParams, NotificationSendParams, JSONRPCError, JSONRPCParams, } from "./schemas/jsonrpc";
-export type { JSONRPCManagerEvents } from "./jsonrpc-manager";
+export { JSONRPCUtils, JSONRPCErrorCode } from "./schemas/jsonrpc";
+export type { JSONRPCMessage, JSONRPCRequest, JSONRPCNotification, JSONRPCResponse, JSONRPCBatchRequest, JSONRPCBatchResponse, JSONRPCErrorResponse, JSONRPCValidationResult, JSONRPCError, JSONRPCParams, CommandExecuteParams, NotificationSendParams, } from "./schemas/jsonrpc";
+export { JSONRPCManager } from "./jsonrpc-manager";
+export type { JSONRPCManagerEvents, JSONRPCManagerConfig, } from "./jsonrpc-manager";

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

@@ -31,7 +31,7 @@ interface JSONRPCMethodConfig<TContext, T = JSONRPCParams> {
 /**
  * JSON-RPC Manager configuration
  */
-interface JSONRPCManagerConfig<TContext> {
+export interface JSONRPCManagerConfig<TContext> {
     /** Enable strict JSON-RPC 2.0 validation */
     strictValidation?: boolean;
     /** Default timeout for requests */

package/package.json

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