agentgui 1.0.268 → 1.0.270

package/lib/claude-runner.js

@@ -626,6 +626,7 @@ registry.register({
               type: 'tool_use',
               id: update.toolCallId,
               name: update.title || update.kind || 'tool',
+              kind: update.kind || 'other',
               input: update.rawInput || update.input || {}
             }]
           },
@@ -644,6 +645,8 @@ registry.register({
             type: 'tool_status',
             tool_use_id: update.toolCallId,
             status: status,
+            kind: update.kind || 'other',
+            locations: update.locations || [],
             session_id: params.sessionId
           };
         }
@@ -904,193 +907,6 @@ function createACPProtocolHandler() {
   };
 }
 
-    // Handle prompt response (end of turn)
-    if (message.id && message.result && message.result.stopReason) {
-      return {
-        type: 'result',
-        result: '',
-        stopReason: message.result.stopReason,
-        usage: message.result.usage,
-        session_id: context.sessionId
-      };
-    }
-
-    if (message.method === 'error' || message.error) {
-      return {
-        type: 'error',
-        error: message.error || message.params || { message: 'Unknown error' }
-      };
-    }
-
-    return null;
-  }
-});
-
-/**
- * Common ACP protocol handler for all ACP agents
- */
-function createACPProtocolHandler() {
-  return function(message, context) {
-    if (!message || typeof message !== 'object') return null;
-
-    // Handle ACP session/update notifications
-    if (message.method === 'session/update') {
-      const params = message.params || {};
-      const update = params.update || {};
-      
-      // Agent message chunk (text response)
-      if (update.sessionUpdate === 'agent_message_chunk' && update.content) {
-        let contentBlock;
-        
-        // Handle different content formats
-        if (typeof update.content === 'string') {
-          contentBlock = { type: 'text', text: update.content };
-        } else if (update.content.type === 'text' && update.content.text) {
-          contentBlock = update.content;
-        } else if (update.content.text) {
-          contentBlock = { type: 'text', text: update.content.text };
-        } else if (update.content.content) {
-          const inner = update.content.content;
-          if (typeof inner === 'string') {
-            contentBlock = { type: 'text', text: inner };
-          } else if (inner.type === 'text' && inner.text) {
-            contentBlock = inner;
-          } else {
-            contentBlock = { type: 'text', text: JSON.stringify(inner) };
-          }
-        } else {
-          contentBlock = { type: 'text', text: JSON.stringify(update.content) };
-        }
-        
-        return {
-          type: 'assistant',
-          message: {
-            role: 'assistant',
-            content: [contentBlock]
-          },
-          session_id: params.sessionId
-        };
-      }
-      
-      // Tool call
-      if (update.sessionUpdate === 'tool_call') {
-        return {
-          type: 'assistant',
-          message: {
-            role: 'assistant',
-            content: [{
-              type: 'tool_use',
-              id: update.toolCallId,
-              name: update.title || update.kind || 'tool',
-              input: update.rawInput || update.input || {}
-            }]
-          },
-          session_id: params.sessionId
-        };
-      }
-      
-      // Tool call update (result) - handle all statuses
-      if (update.sessionUpdate === 'tool_call_update') {
-        const status = update.status;
-        const isError = status === 'failed';
-        const isCompleted = status === 'completed';
-        
-        if (!isCompleted && !isError) {
-          return {
-            type: 'tool_status',
-            tool_use_id: update.toolCallId,
-            status: status,
-            session_id: params.sessionId
-          };
-        }
-        
-        const contentParts = [];
-        if (update.content && Array.isArray(update.content)) {
-          for (const item of update.content) {
-            if (item.type === 'content' && item.content) {
-              const innerContent = item.content;
-              if (innerContent.type === 'text' && innerContent.text) {
-                contentParts.push(innerContent.text);
-              } else if (innerContent.type === 'resource' && innerContent.resource) {
-                contentParts.push(innerContent.resource.text || JSON.stringify(innerContent.resource));
-              } else {
-                contentParts.push(JSON.stringify(innerContent));
-              }
-            } else if (item.type === 'diff') {
-              const diffText = item.oldText 
-                ? `--- ${item.path}\n+++ ${item.path}\n${item.oldText}\n---\n${item.newText}`
-                : `+++ ${item.path}\n${item.newText}`;
-              contentParts.push(diffText);
-            } else if (item.type === 'terminal') {
-              contentParts.push(`[Terminal: ${item.terminalId}]`);
-            }
-          }
-        }
-        
-        const combinedContent = contentParts.join('\n') || (update.rawOutput ? JSON.stringify(update.rawOutput) : '');
-        
-        return {
-          type: 'user',
-          message: {
-            role: 'user',
-            content: [{
-              type: 'tool_result',
-              tool_use_id: update.toolCallId,
-              content: combinedContent,
-              is_error: isError
-            }]
-          },
-          session_id: params.sessionId
-        };
-      }
-      
-      // Usage update
-      if (update.sessionUpdate === 'usage_update') {
-        return {
-          type: 'usage',
-          usage: {
-            used: update.used,
-            size: update.size,
-            cost: update.cost
-          },
-          session_id: params.sessionId
-        };
-      }
-      
-      // Plan update
-      if (update.sessionUpdate === 'plan') {
-        return {
-          type: 'plan',
-          entries: update.entries || [],
-          session_id: params.sessionId
-        };
-      }
-      
-      return null;
-    }
-
-    // Handle prompt response (end of turn)
-    if (message.id && message.result && message.result.stopReason) {
-      return {
-        type: 'result',
-        result: '',
-        stopReason: message.result.stopReason,
-        usage: message.result.usage,
-        session_id: context.sessionId
-      };
-    }
-
-    if (message.method === 'error' || message.error) {
-      return {
-        type: 'error',
-        error: message.error || message.params || { message: 'Unknown error' }
-      };
-    }
-
-    return null;
-  };
-}
-
 // Shared ACP handler
 const acpProtocolHandler = createACPProtocolHandler();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.268",
+  "version": "1.0.270",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -104,22 +104,100 @@ async function ensureModelsDownloaded() {
 
     if (!sttOk) {
       console.log('[MODELS] Downloading STT model...');
-      broadcastModelProgress({ started: true, done: false, downloading: true, type: 'stt', completedFiles, totalFiles });
+      broadcastModelProgress({ started: true, done: false, downloading: true, type: 'stt', source: 'ipfs-fallback', completedFiles, totalFiles });
+
+      let sttDownloaded = false;
+
+      // Try IPFS first with fallback to HuggingFace
       try {
-        await webtalkWhisper.ensureModel('onnx-community/whisper-base', config);
+        const ipfsCid = queries.getIpfsCidByModel('whisper-base', 'stt');
+        if (ipfsCid) {
+          console.log('[MODELS] Attempting IPFS download for STT model:', ipfsCid.cid);
+          const sttFile = path.join(sttDir, 'model.onnx');
+          fs.mkdirSync(sttDir, { recursive: true });
+          await IPFSDownloader.downloadWithProgress(
+            `https://ipfs.io/ipfs/${ipfsCid.cid}`,
+            sttFile,
+            (progress) => {
+              broadcastModelProgress({
+                started: true,
+                done: false,
+                downloading: true,
+                type: 'stt',
+                source: 'ipfs',
+                ...progress,
+                completedFiles,
+                totalFiles
+              });
+            }
+          );
+          sttDownloaded = true;
+          console.log('[MODELS] STT model downloaded via IPFS');
+        }
       } catch (err) {
-        console.warn('[MODELS] STT download failed, falling back to HuggingFace:', err.message);
+        console.warn('[MODELS] IPFS STT download failed:', err.message);
+      }
+
+      // Fall back to webtalk/HuggingFace if IPFS didn't work
+      if (!sttDownloaded) {
+        try {
+          console.log('[MODELS] Falling back to HuggingFace for STT model');
+          broadcastModelProgress({ started: true, done: false, downloading: true, type: 'stt', source: 'huggingface', completedFiles, totalFiles });
+          await webtalkWhisper.ensureModel('onnx-community/whisper-base', config);
+          console.log('[MODELS] STT model downloaded via HuggingFace');
+        } catch (err) {
+          console.warn('[MODELS] HuggingFace STT download also failed:', err.message);
+        }
       }
       completedFiles += 10;
     }
 
     if (!ttsOk) {
       console.log('[MODELS] Downloading TTS models...');
-      broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', completedFiles, totalFiles });
+      broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', source: 'ipfs-fallback', completedFiles, totalFiles });
+
+      let ttsDownloaded = false;
+
+      // Try IPFS first with fallback to HuggingFace
       try {
-        await webtalkTTS.ensureTTSModels(config);
+        const ipfsCid = queries.getIpfsCidByModel('tts', 'voice');
+        if (ipfsCid) {
+          console.log('[MODELS] Attempting IPFS download for TTS models:', ipfsCid.cid);
+          const ttsFile = path.join(ttsDir, 'models.tar.gz');
+          fs.mkdirSync(ttsDir, { recursive: true });
+          await IPFSDownloader.downloadWithProgress(
+            `https://ipfs.io/ipfs/${ipfsCid.cid}`,
+            ttsFile,
+            (progress) => {
+              broadcastModelProgress({
+                started: true,
+                done: false,
+                downloading: true,
+                type: 'tts',
+                source: 'ipfs',
+                ...progress,
+                completedFiles,
+                totalFiles
+              });
+            }
+          );
+          ttsDownloaded = true;
+          console.log('[MODELS] TTS models downloaded via IPFS');
+        }
       } catch (err) {
-        console.warn('[MODELS] TTS download failed, falling back to HuggingFace:', err.message);
+        console.warn('[MODELS] IPFS TTS download failed:', err.message);
+      }
+
+      // Fall back to webtalk/HuggingFace if IPFS didn't work
+      if (!ttsDownloaded) {
+        try {
+          console.log('[MODELS] Falling back to HuggingFace for TTS models');
+          broadcastModelProgress({ started: true, done: false, downloading: true, type: 'tts', source: 'huggingface', completedFiles, totalFiles });
+          await webtalkTTS.ensureTTSModels(config);
+          console.log('[MODELS] TTS models downloaded via HuggingFace');
+        } catch (err) {
+          console.warn('[MODELS] HuggingFace TTS download also failed:', err.message);
+        }
       }
       completedFiles += 6;
     }