aicq-chat-plugin 2.4.0 → 2.4.1

package/index.js

@@ -350,6 +350,48 @@ app.delete('/api/chat/:messageId', (req, res) => {
   res.json({ success: true });
 });
 
+// Streaming endpoints — for external systems / OpenClaw agent output
+app.post('/api/chat/stream-chunk', (req, res) => {
+  try {
+    const { targetId, friend_id, chunk_type, chunkType, data } = req.body;
+    const streamTarget = targetId || friend_id;
+    if (!streamTarget) return res.status(400).json({ error: 'targetId or friend_id is required' });
+    if (!data) return res.status(400).json({ error: 'data is required' });
+    const type = chunk_type || chunkType || 'text';
+    if (!['text', 'reasoning', 'tool_call', 'tool_result'].includes(type)) {
+      return res.status(400).json({ error: `Invalid chunk_type: ${type}` });
+    }
+    const sent = serverClient.sendWS({
+      type: 'stream_chunk',
+      to: streamTarget,
+      chunkType: type,
+      data: data,
+    });
+    if (!sent) return res.status(503).json({ error: 'Not connected to server', success: false });
+    res.json({ success: true });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+app.post('/api/chat/stream-end', (req, res) => {
+  try {
+    const { targetId, friend_id, message_id, messageId } = req.body;
+    const streamTarget = targetId || friend_id;
+    if (!streamTarget) return res.status(400).json({ error: 'targetId or friend_id is required' });
+    const msgId = message_id || messageId || ('msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 6));
+    const sent = serverClient.sendWS({
+      type: 'stream_end',
+      to: streamTarget,
+      messageId: msgId,
+    });
+    if (!sent) return res.status(503).json({ error: 'Not connected to server', success: false });
+    res.json({ success: true, messageId: msgId });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
 // File upload
 app.post('/api/upload', upload.single('file'), async (req, res) => {
   try {
@@ -575,6 +617,33 @@ async function handleGatewayCall(method, kwargs = {}) {
       return await chat.sendMessage(currentAgentId, kwargs.targetId, kwargs.content, { isGroup: kwargs.isGroup });
     case 'aicq.chat.history':
       return { messages: db.getChatHistory(currentAgentId, kwargs.targetId, { limit: kwargs.limit || 50 }) };
+    case 'aicq.chat.streamChunk': {
+      if (!kwargs.friend_id && !kwargs.targetId) return { error: 'friend_id or targetId is required' };
+      if (!kwargs.data) return { error: 'data is required' };
+      const chunkType = kwargs.chunk_type || kwargs.chunkType || 'text';
+      if (!['text', 'reasoning', 'tool_call', 'tool_result'].includes(chunkType)) return { error: `Invalid chunk_type: ${chunkType}` };
+      const streamTarget = kwargs.friend_id || kwargs.targetId;
+      const sent = serverClient.sendWS({
+        type: 'stream_chunk',
+        to: streamTarget,
+        chunkType: chunkType,
+        data: kwargs.data,
+      });
+      if (!sent) return { error: 'Not connected to server', success: false };
+      return { success: true };
+    }
+    case 'aicq.chat.streamEnd': {
+      if (!kwargs.friend_id && !kwargs.targetId) return { error: 'friend_id or targetId is required' };
+      const endTarget = kwargs.friend_id || kwargs.targetId;
+      const msgId = kwargs.message_id || kwargs.messageId || ('msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 6));
+      const endSent = serverClient.sendWS({
+        type: 'stream_end',
+        to: endTarget,
+        messageId: msgId,
+      });
+      if (!endSent) return { error: 'Not connected to server', success: false };
+      return { success: true, messageId: msgId };
+    }
     default:
       return { error: `Unknown method: ${method}` };
   }

package/lib/chat.js

@@ -21,6 +21,8 @@ class ChatManager {
     this.server.onMessage('handshake_initiate', (data) => this._handleHandshakeRequest(data));
     this.server.onMessage('presence', (data) => this._handlePresence(data));
     this.server.onMessage('file_chunk', (data) => this._handleFileChunk(data));
+    this.server.onMessage('stream_chunk', (data) => this._handleStreamChunk(data));
+    this.server.onMessage('stream_end', (data) => this._handleStreamEnd(data));
   }
 
   setOnNewMessage(callback) {
@@ -208,6 +210,46 @@ class ChatManager {
     console.log('[Chat] File chunk from', data.from);
   }
 
+  _handleStreamChunk(data) {
+    // Incoming streaming chunk from another agent
+    const agentId = this.server.currentAgentId;
+    if (!agentId) return;
+
+    const fromId = data.from;
+    const chunkType = data.chunkType || 'text';
+    const chunkData = data.data;
+
+    // Notify callback so OpenClaw agent can process streaming input
+    if (this._onNewMessage) {
+      this._onNewMessage({
+        type: 'stream_chunk',
+        from_id: fromId,
+        chunk_type: chunkType,
+        data: chunkData,
+      });
+    }
+    console.log('[Chat] Stream chunk from', fromId, 'type:', chunkType);
+  }
+
+  _handleStreamEnd(data) {
+    // Incoming stream end signal from another agent
+    const agentId = this.server.currentAgentId;
+    if (!agentId) return;
+
+    const fromId = data.from;
+    const messageId = data.messageId || '';
+
+    // Notify callback so OpenClaw agent knows stream is complete
+    if (this._onNewMessage) {
+      this._onNewMessage({
+        type: 'stream_end',
+        from_id: fromId,
+        message_id: messageId,
+      });
+    }
+    console.log('[Chat] Stream end from', fromId, 'messageId:', messageId);
+  }
+
   // ─── Chat History ─────────────────────────────────────────────────
 
   getHistory(agentId, targetId, { limit = 50, before = null } = {}) {

package/lib/crypto.js

@@ -31,13 +31,7 @@ function generateExchangeKeypair() {
 
 function signMessage(message, secretKeyHex) {
   const secretKey = Buffer.from(secretKeyHex, 'hex');
-  // If message looks like hex (64 chars), treat as raw bytes to match server's bytes.fromhex()
-  let messageBytes;
-  if (/^[0-9a-fA-F]{64}$/.test(message)) {
-    messageBytes = Buffer.from(message, 'hex');
-  } else {
-    messageBytes = naclUtil.decodeUTF8(message);
-  }
+  const messageBytes = naclUtil.decodeUTF8(message);
   const signature = nacl.sign.detached(messageBytes, secretKey);
   return Buffer.from(signature).toString('hex');
 }
@@ -45,13 +39,7 @@ function signMessage(message, secretKeyHex) {
 function verifySignature(message, signatureHex, publicKeyHex) {
   try {
     const publicKey = Buffer.from(publicKeyHex, 'hex');
-    // If message looks like hex (64 chars), treat as raw bytes to match server
-    let messageBytes;
-    if (/^[0-9a-fA-F]{64}$/.test(message)) {
-      messageBytes = Buffer.from(message, 'hex');
-    } else {
-      messageBytes = naclUtil.decodeUTF8(message);
-    }
+    const messageBytes = naclUtil.decodeUTF8(message);
     const signature = Buffer.from(signatureHex, 'hex');
     return nacl.sign.detached.verify(messageBytes, signature, publicKey);
   } catch (e) {

package/lib/server-client.js

@@ -53,13 +53,9 @@ class ServerClient {
       public_key: identity.signing_public_key,
       agent_name: identity.nickname || agentId,
     });
-    if (data.access_token || data.accessToken) {
-      this.jwtToken = data.access_token || data.accessToken;
+    if (data.accessToken) {
+      this.jwtToken = data.accessToken;
       this.currentAgentId = agentId;
-      // Store server-side account ID for WS auth (nodeId must match JWT sub)
-      if (data.account && data.account.id) {
-        this.serverAccountId = data.account.id;
-      }
     }
     return data;
   }
@@ -87,13 +83,9 @@ class ServerClient {
       challenge,
     });
 
-    if (loginData.access_token || loginData.accessToken) {
-      this.jwtToken = loginData.access_token || loginData.accessToken;
+    if (loginData.accessToken) {
+      this.jwtToken = loginData.accessToken;
       this.currentAgentId = agentId;
-      // Store server-side account ID for WS auth (nodeId must match JWT sub)
-      if (loginData.account && loginData.account.id) {
-        this.serverAccountId = loginData.account.id;
-      }
     }
     return loginData;
   }
@@ -206,7 +198,7 @@ class ServerClient {
         console.log('[WS] Connected, sending auth...');
         this.ws.send(JSON.stringify({
           type: 'online',
-          nodeId: this.serverAccountId || this.currentAgentId,
+          nodeId: this.currentAgentId,
           token: this.jwtToken,
         }));
       });

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "aicq-chat",
   "name": "AICQ Encrypted Chat",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "End-to-end encrypted chat plugin for OpenClaw agents — Node.js implementation with full UI",
   "entry": "index.js",
   "activation": {
@@ -25,6 +25,8 @@
       "aicq.chat.history",
       "aicq.chat.send",
       "aicq.chat.delete",
+      "aicq.chat.streamChunk",
+      "aicq.chat.streamEnd",
       "aicq.groups.list",
       "aicq.groups.create",
       "aicq.groups.join",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicq-chat-plugin",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "AICQ End-to-end Encrypted Chat Plugin for OpenClaw — Full UI with friend management, group chat, file transfer, and AI agent communication",
   "main": "index.js",
   "bin": {