@reititin/client 0.0.9 → 0.0.10

package/index.js

@@ -1,71 +1,154 @@
 import http2 from 'http2';
-import axios from 'axios';
 
-export const ReititinClient = ({host, token, onMessage }) => {
+export const ReititinClient = ({ host, token, onMessage }) => {
   const MESSAGE_ENDPOINT = `/api/agents/messages`;
-  const FINALIZE_URL = `https://${host}/api/finalizeMessage`;
-  let buffer = "";
+
+  let client;
+  let req;
+  let reconnectTimer;
+  const RECONNECT_DELAY = 1000;
 
   const connectSSE = () => {
-    if (buffer) return;
-    
-    console.log("Waiting for messages.");
-
-    const client = http2.connect(`https://${host}`);
-    const req = client.request({ 
-      ':method': 'GET', 
-      ':path': MESSAGE_ENDPOINT, 
+    console.log(`Connecting to SSE at ${host}...`);
+
+    client = http2.connect(`http://${host}`);
+
+    client.on('error', (err) => {
+      console.error('Client error:', err);
+      cleanup();
+      scheduleReconnect();
+    });
+
+    req = client.request({
+      ':method': 'GET',
+      ':path': MESSAGE_ENDPOINT,
       'accept': 'text/event-stream',
       'authorization': `Bearer ${token}`
-    }).setEncoding('utf8');
-
-    req.on('data', chunk => buffer += chunk);
-
-    req.on('end', async () => {
-      try {
-        const lines = buffer.split('\n').map(line => line.trim());
-        const chat_id = lines.find(line => line.startsWith('chat_id:'))?.split(': ')[1];
-        const agent_id = lines.find(line => line.startsWith('agent_id:'))?.split(': ')[1];
-        const rawData = lines.find(line => line.startsWith('data:'))?.replace('data: ', '');
-        if (onMessage && rawData && agent_id && chat_id) {
-          console.log("Message received. Processing.");
-          const processedMessage = await onMessage(JSON.parse(rawData));
-          await axios.post(
-            FINALIZE_URL, 
-            { chat_id, agent_id, message: processedMessage }, 
-            {
-              headers: {
-                Authorization: `Bearer ${token}`
+    });
+
+    req.setEncoding('utf8');
+
+    let buffer = '';
+
+    req.on('data', async (chunk) => {
+      // console.log("Received chunk:", chunk); 
+      // Uncomment for debugging
+
+      buffer += chunk;
+
+      // SSE events are separated by double newline
+      const parts = buffer.split('\n\n');
+      buffer = parts.pop(); // Keep the incomplete part in the buffer
+
+      for (const part of parts) {
+        if (!part.trim()) continue;
+
+        // Skip comments like ": connected"
+        if (part.startsWith(':')) continue;
+
+        const lines = part.split('\n');
+
+        const dataLine = lines.find(line => line.startsWith('data: '));
+        if (dataLine) {
+          const rawData = dataLine.substring(6); // remove "data: "
+          try {
+            const payload = JSON.parse(rawData);
+
+            const { agent_id, chat_id, content } = payload;
+
+            if (onMessage && agent_id && chat_id && content) {
+              console.log("Message received. Processing payload:", payload);
+
+              // The content from backend is a stringified JSON array of messages
+              let messages = [];
+              try {
+                messages = JSON.parse(content);
+              } catch (err) {
+                console.error("Failed to parse message content:", err);
+              }
+
+              const processedMessage = await onMessage(messages);
+
+              // Send response via HTTP/2 stream
+              try {
+                const responseBody = JSON.stringify({
+                  chat_id,
+                  agent_id,
+                  message: processedMessage
+                });
+                const responseBuffer = Buffer.from(responseBody);
+
+                const postReq = client.request({
+                  ':method': 'POST',
+                  ':path': '/api/inference/finalize',
+                  'authorization': `Bearer ${token}`,
+                  'content-type': 'application/json',
+                  'content-length': responseBuffer.length
+                });
+
+                postReq.setEncoding('utf8');
+                postReq.on('response', (headers) => {
+                  // console.log("Finalize response headers:", headers);
+                  const status = headers[':status'];
+                  if (status && status !== 200) {
+                    console.error(`Error sending response: Status ${status}`);
+                    // We can read body to see error message
+                  }
+                });
+                postReq.on('data', (d) => {
+                  // console.log("Finalize response data:", d);
+                });
+                postReq.on('end', () => {
+                  console.log("Response sent successfully.");
+                });
+                postReq.on('error', (e) => {
+                  console.error("Error sending response:", e);
+                });
+
+                postReq.write(responseBuffer);
+                postReq.end();
+
+              } catch (e) {
+                console.error("Error creating response request:", e);
               }
             }
-          );
-          console.log(`Response sent.`);
+          } catch (e) {
+            console.error("Error processing message:", e);
+          }
         }
-        buffer = "";
-      } catch(err) {
-        console.log("Reconnecting.");
       }
-      scheduleReconnect();
     });
 
-    req.on('error', err => {
-      console.error('Connection closed. Reconnecting.');
-      req.close();
-      client.close();
+    req.on('end', () => {
+      console.log('Stream ended.');
+      cleanup();
       scheduleReconnect();
     });
 
-    req.on('timeout', err => {
-      console.error('Connection timedout. Reconnecting.');
-      req.close();
-      client.close();
+    req.on('error', (err) => {
+      console.error('Stream error:', err);
+      cleanup();
       scheduleReconnect();
     });
 
     req.end();
   };
 
-  const scheduleReconnect = () => setTimeout(connectSSE, 1000);
+  const cleanup = () => {
+    if (req) {
+      try { req.close(); } catch (e) { }
+      req = null;
+    }
+    if (client) {
+      try { client.close(); } catch (e) { }
+      client = null;
+    }
+  };
+
+  const scheduleReconnect = () => {
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    reconnectTimer = setTimeout(connectSSE, RECONNECT_DELAY);
+  };
 
   connectSSE();
 };

package/package.json

@@ -1,28 +1,28 @@
-{
-  "name": "@reititin/client",
-  "version": "0.0.9",
-  "description": "Reititin client allows you to connect your LLM system to Reititin platform.",
-  "keywords": [
-    "AI",
-    "LLM",
-    "message",
-    "broker"
-  ],
-  "license": "ISC",
-  "author": "Reititin",
-  "type": "module",
-  "main": "index.js",
-  "files": [
-    "index.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/reititin/reititin-client.git"
-  },
-  "dependencies": {
-    "axios": "1.8.2"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@reititin/client",
+  "version": "0.0.10",
+  "description": "Reititin client allows you to connect your LLM system to Reititin platform.",
+  "keywords": [
+    "AI",
+    "LLM",
+    "message",
+    "broker"
+  ],
+  "license": "ISC",
+  "author": "Reititin",
+  "type": "module",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reititin/reititin-client.git"
+  },
+  "dependencies": {
+    "axios": "1.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}