omnimind-sdk 1.0.0

package/README.md

@@ -0,0 +1,43 @@
+# OmniMind NodeJS SDK
+
+NodeJS SDK for the OmniMind Protocol, supporting real-time voice streaming, text messaging, and hardware capability registration (MCP).
+
+## Installation
+
+```bash
+npm install omnimind-sdk
+```
+
+## Quick Start
+
+```javascript
+const { OmniMindClient } = require('omnimind-sdk');
+
+const client = new OmniMindClient(
+    "ws://127.0.0.1:8082/v1/ws",
+    "YOUR_DEVICE_SN",
+    "YOUR_TOKEN"
+);
+
+client.setTextCallback((text, isFinal) => {
+    console.log(`[AI] ${text}`);
+});
+
+client.setOnOpenCallback(() => {
+    console.log("Connected!");
+    client.sendText("Hello, what is the weather today?");
+});
+
+client.connect();
+```
+
+## Features
+
+- **Protobuf-based**: Efficient binary communication.
+- **Voice Streaming**: High-quality audio chunk transmission.
+- **Tool Registration**: Easily register hardware functions for the AI to call.
+- **Automatic Heartbeat**: Reliable long-term connection management.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "omnimind-sdk",
+  "version": "1.0.0",
+  "description": "OmniMind Protocol NodeJS SDK for AIoT Devices",
+  "main": "src/omnimind/index.js",
+  "files": [
+    "src/omnimind"
+  ],
+  "author": "XiaoRGEEK",
+  "license": "MIT",
+  "keywords": [
+    "omnimind",
+    "aiot",
+    "protocol",
+    "sdk",
+    "voice-streaming",
+    "protobuf"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xiaorgeek/omnimind-sdk"
+  },
+  "dependencies": {
+    "ws": "^8.16.0",
+    "protobufjs": "^7.2.5"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10",
+    "protobufjs-cli": "^1.1.1"
+  },
+  "scripts": {
+    "start": "node examples/client_example.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/src/omnimind/client.js

@@ -0,0 +1,258 @@
+const WebSocket = require('ws');
+const omnimind_pb = require('./generated/omnimind_pb');
+
+// Using the root namespace generated by protobufjs
+const omnimind = omnimind_pb.omnimind;
+
+class OmniMindClient {
+    constructor(serverUrl, sn, token = "", config = {}) {
+        this.serverUrl = serverUrl;
+        this.sn = sn;
+        this.token = token;
+        this.inputAudioFormat = config.inputAudioFormat || null;
+        this.outputAudioFormat = config.outputAudioFormat || null;
+        this.enableTTS = config.enableTTS || false;
+        
+        this.ws = null;
+        this.running = false;
+        this.heartbeatInterval = 30000;
+        this.heartbeatTimer = null;
+        
+        // Callbacks
+        this.onVoiceCallback = null;
+        this.onTextCallback = null;
+        this.onToolCallCallback = null;
+        this.onOpenCallback = null;
+        this.onCloseCallback = null;
+        this.onErrorCallback = null;
+        
+        this.toolHandlers = new Map();
+    }
+
+    setVoiceCallback(callback) {
+        this.onVoiceCallback = callback;
+    }
+
+    setTextCallback(callback) {
+        this.onTextCallback = callback;
+    }
+
+    setToolCallCallback(callback) {
+        this.onToolCallCallback = callback;
+    }
+
+    setOnOpenCallback(callback) {
+        this.onOpenCallback = callback;
+    }
+
+    setOnCloseCallback(callback) {
+        this.onCloseCallback = callback;
+    }
+
+    setOnErrorCallback(callback) {
+        this.onErrorCallback = callback;
+    }
+
+    connect() {
+        this.ws = new WebSocket(this.serverUrl);
+        this.ws.binaryType = 'arraybuffer';
+
+        this.ws.on('open', () => {
+            console.log(`[Client ${this.sn}] Connected to ${this.serverUrl}`);
+            this.running = true;
+            this._handleOpen();
+        });
+
+        this.ws.on('message', (data) => {
+            this._handleMessage(data);
+        });
+
+        this.ws.on('error', (err) => {
+            console.error(`[Client ${this.sn}] WebSocket Error:`, err);
+            if (this.onErrorCallback) this.onErrorCallback(err);
+        });
+
+        this.ws.on('close', (code, reason) => {
+            console.log(`[Client ${this.sn}] Connection closed. Code: ${code}, Reason: ${reason}`);
+            this.running = false;
+            this._stopHeartbeat();
+            if (this.onCloseCallback) this.onCloseCallback(code, reason);
+        });
+    }
+
+    close() {
+        this.running = false;
+        this._stopHeartbeat();
+        if (this.ws) {
+            this.ws.close();
+        }
+    }
+
+    _handleOpen() {
+        // Send AUTH
+        const auth = {
+            firmwareVersion: "1.0.0",
+            token: this.token,
+            enableTts: this.enableTTS
+        };
+
+        if (this.inputAudioFormat) {
+            auth.inputAudioFormat = this.inputAudioFormat;
+        }
+        if (this.outputAudioFormat) {
+            auth.outputAudioFormat = this.outputAudioFormat;
+        }
+
+        const msg = {
+            sn: this.sn,
+            type: omnimind.MessageType.AUTH,
+            payload: omnimind.AuthPayload.encode(auth).finish(),
+            timestamp: Date.now()
+        };
+
+        this.ws.send(omnimind.OmniMessage.encode(msg).finish());
+        this._startHeartbeat();
+        if (this.onOpenCallback) this.onOpenCallback();
+    }
+
+    _handleMessage(data) {
+        try {
+            const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+            const msg = omnimind.OmniMessage.decode(buffer);
+            
+            switch (msg.type) {
+                case omnimind.MessageType.VOICE_STREAM:
+                    if (this.onVoiceCallback) this.onVoiceCallback(msg.payload);
+                    break;
+                case omnimind.MessageType.TEXT_MSG:
+                    const textMsg = omnimind.TextMessage.decode(msg.payload);
+                    if (this.onTextCallback) this.onTextCallback(textMsg.content, textMsg.role);
+                    break;
+                case omnimind.MessageType.TOOL_CALL:
+                    this._handleToolCall(msg.payload);
+                    break;
+                case omnimind.MessageType.PONG:
+                    // Heartbeat response
+                    break;
+                default:
+                    // console.log(`[Client ${this.sn}] Message type: ${msg.type}`);
+            }
+        } catch (err) {
+            console.error(`[Client ${this.sn}] Message decode error:`, err);
+        }
+    }
+
+    _handleToolCall(payload) {
+        try {
+            const toolCall = omnimind.ToolCall.decode(payload);
+            const handler = this.toolHandlers.get(toolCall.functionName);
+            
+            if (handler) {
+                const args = JSON.parse(toolCall.argsJson);
+                const result = handler(args);
+                
+                const response = {
+                    callId: toolCall.callId,
+                    resultJson: JSON.stringify(result)
+                };
+
+                const msg = {
+                    sn: this.sn,
+                    type: omnimind.MessageType.TOOL_RESP,
+                    payload: omnimind.ToolResponse.encode(response).finish(),
+                    timestamp: Date.now()
+                };
+
+                this.ws.send(omnimind.OmniMessage.encode(msg).finish());
+            } else if (this.onToolCallCallback) {
+                this.onToolCallCallback(toolCall.functionName, toolCall.argsJson, toolCall.callId);
+            }
+        } catch (err) {
+            console.error(`[Client ${this.sn}] Tool call error:`, err);
+        }
+    }
+
+    sendVoice(audioData) {
+        if (!this.running || !this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+        
+        const msg = {
+            sn: this.sn,
+            type: omnimind.MessageType.VOICE_STREAM,
+            payload: audioData,
+            timestamp: Date.now()
+        };
+
+        this.ws.send(omnimind.OmniMessage.encode(msg).finish());
+    }
+
+    sendText(text) {
+        if (!this.running || !this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+        
+        const textMsg = {
+            content: text,
+            role: "user"
+        };
+        const msg = {
+            sn: this.sn,
+            type: omnimind.MessageType.TEXT_MSG,
+            payload: omnimind.TextMessage.encode(textMsg).finish(),
+            timestamp: Date.now()
+        };
+
+        this.ws.send(omnimind.OmniMessage.encode(msg).finish());
+    }
+
+    registerTool(name, description, argsSchema, handler) {
+        this.toolHandlers.set(name, handler);
+        // Note: In current protocol, tool registration can be done via MCP_REG
+    }
+
+    sendToolManifest(tools, events = []) {
+        if (!this.running || !this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+
+        const manifest = {
+            tools: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                argsSchema: JSON.stringify(t.argsSchema || {})
+            })),
+            events: events.map(e => ({
+                name: e.name,
+                description: e.description,
+                payloadSchema: JSON.stringify(e.payloadSchema || {})
+            }))
+        };
+
+        const msg = {
+            sn: this.sn,
+            type: omnimind.MessageType.MCP_REG,
+            payload: omnimind.ToolManifest.encode(manifest).finish(),
+            timestamp: Date.now()
+        };
+
+        this.ws.send(omnimind.OmniMessage.encode(msg).finish());
+    }
+
+    _startHeartbeat() {
+        this._stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.running && this.ws && this.ws.readyState === WebSocket.OPEN) {
+                const msg = {
+                    sn: this.sn,
+                    type: omnimind.MessageType.PING,
+                    timestamp: Date.now()
+                };
+                this.ws.send(omnimind.OmniMessage.encode(msg).finish());
+            }
+        }, this.heartbeatInterval);
+    }
+
+    _stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+}
+
+module.exports = OmniMindClient;