@eyeclaw/eyeclaw 2.0.7 → 2.0.9

package/index.ts

@@ -1,6 +1,6 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
 import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk'
-import { eyeclawPlugin } from './src/channel.js'
+import { eyeclawPlugin, setRuntime } from './src/channel.js'
 
 /**
  * EyeClaw SDK - OpenClaw Channel Plugin
@@ -14,6 +14,10 @@ const plugin = {
   configSchema: emptyPluginConfigSchema(),
   
   register(api: OpenClawPluginApi) {
+    // Save runtime for message processing (like WeCom plugin does)
+    // This allows channel.ts to access runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher
+    setRuntime(api.runtime)
+    
     // Register EyeClaw as a channel plugin
     api.registerChannel({ plugin: eyeclawPlugin })
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeclaw/eyeclaw",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "EyeClaw channel plugin for OpenClaw - Connect your local OpenClaw instance to EyeClaw platform",
   "type": "module",
   "main": "./index.ts",
@@ -32,7 +32,9 @@
   },
   "homepage": "https://eyeclaw.io",
   "openclaw": {
-    "extensions": ["./index.ts"],
+    "extensions": [
+      "./index.ts"
+    ],
     "channel": {
       "id": "eyeclaw",
       "label": "EyeClaw",

package/src/channel.ts

@@ -6,6 +6,20 @@ import { EyeClawClient } from './client.js'
 // Active clients map (accountId -> client)
 const clients = new Map<string, EyeClawClient>()
 
+// Store runtime for use in gateway.startAccount (set during plugin registration)
+let _runtime: any = null
+
+/**
+ * Set the plugin runtime (called during plugin registration)
+ */
+function setRuntime(runtime: any) {
+  _runtime = runtime
+}
+
+function getRuntime() {
+  return _runtime
+}
+
 /**
  * Resolve EyeClaw account configuration
  */
@@ -138,9 +152,9 @@ export const eyeclawPlugin: ChannelPlugin<ResolvedEyeClawAccount> = {
       probe,
     }),
   },
-  
+
   gateway: {
-    startAccount: async (ctx) => {
+    startAccount: async (ctx: any) => {
       const account = resolveEyeClawAccount(ctx.cfg, ctx.accountId)
       
       if (!account.configured || !account.config) {
@@ -174,129 +188,76 @@ export const eyeclawPlugin: ChannelPlugin<ResolvedEyeClawAccount> = {
         error: (msg: string) => ctx.log?.error(msg),
       }
       
+      // Get runtime from module-level storage (set during register)
+      const runtime = getRuntime()
+      if (!runtime) {
+        throw new Error('OpenClaw runtime not available - did you install the plugin correctly?')
+      }
+      
       // Create and connect client
       const client = new EyeClawClient(clientConfig, logger)
       clients.set(ctx.accountId, client)
       
       // Register OpenClaw Agent callback for chat messages
+      // Use runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher for true streaming
       client.setSendAgentCallback(async (message: string) => {
-        const { spawn } = await import('child_process')
         const streamId = Date.now().toString()
+        const streamKey = 'eyeclaw-web-chat'
         
         try {
-          ctx.log?.info(`🤖 Sending message to OpenClaw Agent: ${message}`)
+          ctx.log?.info(`🤖 Processing message via OpenClaw dispatchReply: ${message}`)
           
-          // Spawn openclaw agent process for streaming output
-          const agentProcess = spawn('openclaw', [
-            'agent',
-            '--session-id', 'eyeclaw-web-chat',
-            '--message', message,
-            '--json'
-          ])
-          
-          let outputBuffer = ''
-          
-          // Send stream_start event
+          // 发送 stream_start
           client.sendStreamChunk('stream_start', streamId, '')
           
-          // Handle stdout (streaming response)
-          agentProcess.stdout?.on('data', (data: Buffer) => {
-            try {
-              const text = data.toString()
-              outputBuffer += text
-              
-              // For streaming text output, send each chunk immediately
-              // Try to parse as JSON first
-              try {
-                const parsed = JSON.parse(outputBuffer)
-                // If we can parse the complete JSON, extract the text
-                const response = parsed.result?.payloads?.[0]?.text
-                if (response) {
-                  // Send the text in chunks
-                  const chunkSize = 50 // Send ~50 chars at a time
-                  for (let i = 0; i < response.length; i += chunkSize) {
-                    const chunk = response.substring(i, i + chunkSize)
-                    client.sendStreamChunk('stream_chunk', streamId, chunk)
-                  }
-                }
-                outputBuffer = '' // Clear buffer after successful parse
-              } catch (e) {
-                // Not valid JSON yet, check if we have complete lines to send
-                const lines = outputBuffer.split('\n')
-                // Keep last incomplete line in buffer
-                if (lines.length > 1) {
-                  for (let i = 0; i < lines.length - 1; i++) {
-                    if (lines[i].trim()) {
-                      client.sendStreamChunk('stream_chunk', streamId, lines[i] + '\n')
-                    }
-                  }
-                  outputBuffer = lines[lines.length - 1]
-                }
-              }
-            } catch (error) {
-              // Catch any errors in data processing to prevent WebSocket disconnect
-              const errorMsg = error instanceof Error ? error.message : String(error)
-              ctx.log?.error(`Error processing stdout data: ${errorMsg}`)
-            }
-          })
-          
-          // Handle stderr (errors)
-          agentProcess.stderr?.on('data', (data: Buffer) => {
-            const errorText = data.toString()
-            ctx.log?.error(`Agent stderr: ${errorText}`)
-          })
-          
-          // Wait for process to complete
-          await new Promise<void>((resolve, reject) => {
-            // Handle process completion
-            agentProcess.on('close', (code: number) => {
-              try {
-                // Send any remaining buffered content
-                if (outputBuffer.trim()) {
-                  try {
-                    const parsed = JSON.parse(outputBuffer)
-                    const response = parsed.result?.payloads?.[0]?.text || outputBuffer.trim()
-                    client.sendStreamChunk('stream_chunk', streamId, response)
-                  } catch (e) {
-                    client.sendStreamChunk('stream_chunk', streamId, outputBuffer.trim())
-                  }
+          // 使用 OpenClaw 的 dispatchReplyWithBufferedBlockDispatcher 实现真正的流式
+          // 这和 WeCom 插件使用的方式完全相同
+          // API 路径: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher
+          await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: {
+              // Inbound message context
+              sessionKey: `eyeclaw:${streamKey}`,
+              messageKey: `eyeclaw:${streamKey}:${streamId}`,
+              peerKey: streamKey,
+              message: {
+                role: 'user',
+                content: message,
+                roleDetail: 'user',
+              },
+            },
+            cfg: ctx.cfg,
+            dispatcherOptions: {
+              // 流式回调 - LLM 每生成一块文本就实时调用
+              deliver: async (payload: any, info: any) => {
+                const text = payload.text || ''
+                if (text) {
+                  ctx.log?.debug(`Delivering chunk: ${text.substring(0, 50)}...`)
+                  client.sendStreamChunk('stream_chunk', streamId, text)
                 }
                 
-                // Send stream_end event
-                client.sendStreamChunk('stream_end', streamId, '')
-                
-                if (code === 0) {
-                  ctx.log?.info(`✅ Agent completed successfully`)
-                  resolve()
-                } else {
-                  ctx.log?.error(`Agent exited with code ${code}`)
-                  client.sendLog('error', `❌ Agent error: process exited with code ${code}`)
-                  reject(new Error(`Agent exited with code ${code}`))
+                // 当主响应完成时记录
+                if (info.kind === 'final') {
+                  ctx.log?.info('Main response complete')
                 }
-              } catch (error) {
-                // Prevent errors in close handler from crashing
-                const errorMsg = error instanceof Error ? error.message : String(error)
-                ctx.log?.error(`Error in close handler: ${errorMsg}`)
-                reject(error)
-              }
-            })
-            
-            // Handle process errors
-            agentProcess.on('error', (error: Error) => {
-              ctx.log?.error(`Failed to start agent process: ${error.message}`)
-              client.sendStreamChunk('stream_error', streamId, error.message)
-              client.sendLog('error', `❌ Failed to start agent: ${error.message}`)
-              reject(error)
-            })
+              },
+              onError: async (error: any, info: any) => {
+                ctx.log?.error(`Reply failed: ${error.message}`)
+                client.sendStreamChunk('stream_error', streamId, error.message)
+              },
+            },
           })
           
+          // 发送 stream_end
+          client.sendStreamChunk('stream_end', streamId, '')
+          ctx.log?.info(`✅ Message processed successfully`)
+          
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error)
-          ctx.log?.error(`Failed to call OpenClaw Agent: ${errorMsg}`)
-          // Send error notification but don't crash the WebSocket connection
+          ctx.log?.error(`Failed to process message: ${errorMsg}`)
+          // 发送错误通知
           try {
             client.sendStreamChunk('stream_error', streamId, errorMsg)
-            client.sendLog('error', `❌ Agent error: ${errorMsg}`)
+            client.sendLog('error', `❌ Error: ${errorMsg}`)
           } catch (sendError) {
             ctx.log?.error(`Failed to send error notification: ${sendError}`)
           }