modality-kit 0.9.4 → 0.10.0

package/dist/index.js

@@ -147,28 +147,35 @@ class ModalityLogger {
       case "debug":
         console.debug(payload);
         break;
-      case "info":
-        console.info(payload.message);
-        console.dir(payload.data, {
+      case "info": {
+        const { message, ...restPayload } = payload;
+        console.info(message);
+        console.dir(restPayload, {
           depth: null,
           colors: true,
           maxArrayLength: null
         });
         break;
-      case "warn":
+      }
+      case "warn": {
+        const { message, ...restPayload } = payload;
         console.warn(payload);
-        console.log(`
-`);
+        console.dir(restPayload, {
+          depth: null,
+          colors: true,
+          maxArrayLength: null
+        });
         break;
-      case "error":
+      }
+      case "error": {
         const error = payload.error;
         if (error instanceof Error || error.stack) {
           delete payload.error;
           const { message, stack, ...restError } = error;
           if (stack) {
             if (Object.keys(restError).length) {
-              console.error(restError, `
-`, stack);
+              console.error(restError);
+              console.log(stack);
             } else {
               console.error(stack);
             }
@@ -182,6 +189,7 @@ class ModalityLogger {
           console.error(payload);
         }
         break;
+      }
       case "success":
         console.log(payload);
         break;
@@ -5651,6 +5659,8 @@ var logger3 = getLoggerInstance("WebSocket-Client");
 
 class WebSocketClient {
   ws = null;
+  wsStream = null;
+  streamWriter = null;
   url;
   config = {
     initialReconnectDelay: 1000,
@@ -5734,24 +5744,60 @@ class WebSocketClient {
     const url = new URL(this.url);
     return url.searchParams.get("clientId") ?? (this.connectionId ? String(this.connectionId) : "");
   }
-  send(data) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+  async initializeWebSocketStream() {
+    if (typeof WebSocketStream === "undefined") {
+      logger3.warn("WebSocketStream not supported in this environment");
+      return false;
+    }
+    try {
+      this.wsStream = new WebSocketStream(this.url);
+      const { writable } = await this.wsStream.opened;
+      this.streamWriter = writable.getWriter();
+      logger3.info("WebSocketStream initialized successfully");
+      return true;
+    } catch (error) {
+      logger3.error("Failed to initialize WebSocketStream:", error);
+      this.wsStream = null;
+      this.streamWriter = null;
+      return false;
+    }
+  }
+  async send(data, useStream = false) {
+    const message = JSON.stringify({
+      ...data,
+      jsonrpc: "2.0",
+      timestamp: new Date().toISOString()
+    });
+    if (useStream) {
+      if (!this.streamWriter) {
+        const streamInitialized = await this.initializeWebSocketStream();
+        if (!streamInitialized) {
+          logger3.warn("WebSocketStream not available, cannot send with streaming");
+          return false;
+        }
+      }
       try {
-        const message = JSON.stringify({
-          ...data,
-          jsonrpc: "2.0",
-          timestamp: new Date().toISOString()
-        });
-        this.ws.send(message);
-        logger3.info("Message sent:", message);
+        await this.streamWriter.write(message);
+        logger3.info("Message sent via WebSocketStream:", message);
         return true;
       } catch (error) {
-        logger3.error("Error sending message:", error);
+        logger3.error("Error sending via WebSocketStream:", error);
         return false;
       }
     } else {
-      logger3.warn("WebSocket is not connected during send operation.");
-      return false;
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.send(message);
+          logger3.info("Message sent:", message);
+          return true;
+        } catch (error) {
+          logger3.error("Error sending message:", error);
+          return false;
+        }
+      } else {
+        logger3.warn("WebSocket is not connected during send operation.");
+        return false;
+      }
     }
   }
   isConnected() {

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

@@ -60,7 +60,6 @@ interface SymbolBase {
     id?: string;
     uri?: string;
     detail?: string;
-    content?: string;
     containerName?: string;
 }
 export interface Symbol extends SymbolBase {

package/dist/types/websocket-client.d.ts

@@ -1,4 +1,17 @@
 import type { JSONRPCValidationResult } from "./schemas/jsonrpc";
+declare global {
+    interface WebSocketStream {
+        readonly opened: Promise<{
+            readable: ReadableStream;
+            writable: WritableStream;
+        }>;
+        readonly closed: Promise<void>;
+        close(code?: number, reason?: string): void;
+    }
+    const WebSocketStream: {
+        new (url: string): WebSocketStream;
+    };
+}
 interface WebSocketConfig {
     maxReconnectAttempts: number;
     initialReconnectDelay: number;
@@ -18,6 +31,8 @@ interface WebSocketInfo {
 }
 export declare class WebSocketClient {
     private ws;
+    private wsStream;
+    private streamWriter;
     private url;
     private config;
     private connectionId;
@@ -35,7 +50,8 @@ export declare class WebSocketClient {
     private onOpen;
     private onClose;
     private getClientId;
-    send(data: any): boolean;
+    private initializeWebSocketStream;
+    send(data: any, useStream?: boolean): Promise<boolean>;
     isConnected(): boolean;
     getInfo(): WebSocketInfo;
     /**

package/package.json

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