@johpaz/hive-agents 0.0.38 → 0.0.40

package/packages/core/src/gateway/server.ts

@@ -41,7 +41,7 @@ import { handleSetupStatus, handleVerifyProvider, handleCompleteSetup, handleSet
 import { handleAuthStatus, handleLogin, handleSetupCredentials, handleChangePassword, handleRecover, handleDisableAuth, handleRecoveryKey } from "./routes/auth";
 import { resolveUserId } from "../storage/onboarding";
 import { handleGetAgents, handleCreateAgent, handleUpdateAgent, handleDeleteAgent } from "./routes/agents";
-import { handleGetProviders, handleCreateProvider, handleToggleProvider, handleUpdateProvider, handleSyncProviderModels } from "./routes/providers";
+import { handleGetProviders, handleCreateProvider, handleToggleProvider, handleUpdateProvider, handleSyncProviderModels, handleLoadHiveAgentsModel, handleGetHiveAgentsModelStatus } from "./routes/providers";
 import { handleGetUsers, handleCreateUser, handleUpdateUserSettings, handleGetUserChannels, handleLinkUserChannel } from "./routes/users";
 import { handleGetSkills, handleActivateSkill, handleUpdateSkill, handleDeleteSkill, handleCreateSkill } from "./routes/skills";
 import { handleGetEthics, handleActivateEthics, handleDeleteEthics } from "./routes/ethics";
@@ -73,12 +73,13 @@ import { handleGetModels, handleCreateModel, handleToggleModel, handleGetModelsC
 import { handleGetVoiceProviders, handleGetConfiguredVoiceProviders, handleSaveVoiceProviderKey, handleTestVoice, handleGetChannelVoice, handleUpdateChannelVoice, handleGetVoiceProviderVoices } from "./routes/voice";
 import { handleGetVisionProviders, handleGetChannelVision, handleUpdateChannelVision, handleOcrImage } from "./routes/multimodal";
 import { handleGetLocalTTSStatus, handleGetLocalTTSLogs, handleInstallLocalTTS, handleStartLocalTTS, handleStopLocalTTS, handleSpeakLocalTTS, handleGetAvailableModels, handleGetInstalledVoices, handleDownloadModel, handleGetDownloadLogs, initializeLocalTTS } from "./routes/tts-local";
-import { handleGetLocalLLMStatus, handleGetLocalLLMLogs, handleInstallLocalLLM, handleStartLocalLLM, handleStopLocalLLM, handleDownloadLLMModel, initializeLocalLLM } from "./routes/llm-local";
+import { handleGetLocalLLMStatus, handleGetLocalLLMLogs, handleInstallLocalLLM, handleStartLocalLLM, handleStopLocalLLM, handleDownloadLLMModel, handleGetDownloadProgress, initializeLocalLLM } from "./routes/llm-local";
 import { handleCreateMeeting, handleListMeetings, handleGetMeeting, handleAddMeetingSegment, handleStopMeeting } from "./routes/meeting";
 import { handleGetActivityStats, handleGetSystemStats, handleGetUsageStats, handleSystemReload, handleApiReload, handleGetVersion, handleTriggerUpdate } from "./routes/system";
 import { handleGetChatHistory, handleGetCanvas, handleGetNotes, handleUpdateNote } from "./routes/chat";
 import { handleChat as handlePostChat } from "./routes/chat";
 import { handleGetConfig } from "./routes/config";
+import { handleHttpRequest } from "./routes/http-client";
 import { handleGetWorkspace, handleUpdateWorkspace, handleValidateWorkspace, handleCreateWorkspace, handleOpenWorkspace } from "./routes/workspace";
 import { getNarration, expandPath, addCorsHeaders, CORS_ORIGINS } from "./helpers";
 import { redactConfig } from "./helpers";
@@ -256,6 +257,82 @@ export async function startGateway(config: Config): Promise<void> {
     return undefined;
   }
 
+  type WebChatProcessKind = "analysis" | "tool" | "observation" | "writing";
+  type WebChatProcessStatus = "thinking" | "done" | "error";
+
+  function createWebChatProcessReporter(ws: { send: (payload: string) => void }, sessionId: string, messageId: string) {
+    const sent = new Set<string>();
+
+    const send = (event: {
+      kind?: WebChatProcessKind;
+      label?: string;
+      detail?: string;
+      status?: WebChatProcessStatus;
+      summary?: string;
+    }) => {
+      ws.send(JSON.stringify({
+        type: "process",
+        sessionId,
+        id: messageId,
+        messageId,
+        processKind: event.kind,
+        processStatus: event.status,
+        label: event.label,
+        detail: event.detail,
+        summary: event.summary,
+        timestamp: new Date().toISOString(),
+      } as OutboundMessage));
+    };
+
+    const sendOnce = (key: string, event: Parameters<typeof send>[0]) => {
+      if (sent.has(key)) return;
+      sent.add(key);
+      send(event);
+    };
+
+    return {
+      start(label = "Revisando tu solicitud") {
+        sendOnce("start", { kind: "analysis", label, status: "thinking" });
+      },
+      writing() {
+        sendOnce("writing", { kind: "writing", label: "Preparando la respuesta", status: "thinking" });
+      },
+      step(step: { type: string; message?: string; toolName?: string }) {
+        if (step.type === "tool_call" && step.toolName) {
+          sendOnce(`tool:${step.toolName}`, {
+            kind: "tool",
+            label: getNarration(step.toolName),
+            status: "thinking",
+          });
+          return;
+        }
+
+        if (step.type === "tool_result") {
+          sendOnce(`tool_result:${sent.size}`, {
+            kind: "observation",
+            label: "Revisando la informacion obtenida",
+            status: "thinking",
+          });
+          return;
+        }
+
+        if (step.type === "text") {
+          sendOnce("analysis:text", {
+            kind: "analysis",
+            label: "Organizando la informacion",
+            status: "thinking",
+          });
+        }
+      },
+      done(summary = "Proceso completado") {
+        send({ status: "done", summary });
+      },
+      error(summary = "No se pudo completar el proceso") {
+        send({ status: "error", summary });
+      },
+    };
+  }
+
   // Set up hot reload watchers
   const watchers: Array<() => void> = [];
 
@@ -961,6 +1038,11 @@ export async function startGateway(config: Config): Promise<void> {
           }
         }
 
+        // ── HTTP Client API ────────────────────────────────────────────────
+        if ((url.pathname === "/api/http-request" || url.pathname === "/api/http-request/") && req.method === "POST") {
+          return await handleHttpRequest(req, addCorsHeaders)
+        }
+
         // ── Tasks API ─────────────────────────────────────────────────────
         if ((url.pathname === "/api/tasks" || url.pathname === "/api/tasks/") && req.method === "GET") {
           return await handleGetTasks(req, addCorsHeaders)
@@ -1156,6 +1238,14 @@ export async function startGateway(config: Config): Promise<void> {
           return await handleUpdateProvider(req, addCorsHeaders)
         }
 
+        // ── HiveAgents model loading ───────────────────────────────────────
+        if (url.pathname === "/api/providers/hiveagents/load-model" && req.method === "POST") {
+          return await handleLoadHiveAgentsModel(req, addCorsHeaders)
+        }
+        if (url.pathname === "/api/providers/hiveagents/model-status" && req.method === "GET") {
+          return await handleGetHiveAgentsModelStatus(req, addCorsHeaders)
+        }
+
         // ── Models API ───────────────────────────────────────────────────
         // GET /api/models?provider_id=xxx - Get models filtered by provider
         if (url.pathname === "/api/models" && req.method === "GET") {
@@ -1626,6 +1716,9 @@ export async function startGateway(config: Config): Promise<void> {
         if (url.pathname === "/api/llm-local/download-model" && req.method === "POST") {
           return await handleDownloadLLMModel(req, addCorsHeaders)
         }
+        if (url.pathname === "/api/llm-local/download-progress" && req.method === "GET") {
+          return await handleGetDownloadProgress(req, addCorsHeaders)
+        }
 
         // ── Meeting Transcription API ────────────────────────────────────────
         if (url.pathname === "/api/meetings" && req.method === "POST") {
@@ -2150,6 +2243,7 @@ export async function startGateway(config: Config): Promise<void> {
             } as OutboundMessage));
 
             laneQueue.enqueue(msg.sessionId, async (_task, signal) => {
+              let processReporter: ReturnType<typeof createWebChatProcessReporter> | null = null;
               if (signal.aborted) {
                 ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: msg.sessionId } as OutboundMessage));
                 ws.send(JSON.stringify({ type: "error", sessionId: msg.sessionId, error: "Task cancelled" } as OutboundMessage));
@@ -2164,11 +2258,14 @@ export async function startGateway(config: Config): Promise<void> {
                 const unifiedSessionId = conversationThreadId;
                 const routingSessionId = msg.sessionId;
                 const messages = [{ role: "user" as const, content: messageContent }];
+                const messageId = crypto.randomUUID();
+                processReporter = createWebChatProcessReporter(ws, routingSessionId, messageId);
+                processReporter.start("Revisando la transcripcion");
                 log.info(`Generating response for session ${unifiedSessionId}...`);
 
                 // Streaming: send tokens as they arrive
                 let streamedContent = "";
-                let messageId = crypto.randomUUID();
+                let reportedWriting = false;
 
                 const response = await runner.generate({
                   provider: dbProvider as any,
@@ -2180,6 +2277,10 @@ export async function startGateway(config: Config): Promise<void> {
                   userId,
                   onToken: async (token: string) => {
                     if (signal.aborted) return;
+                    if (!reportedWriting && token.trim()) {
+                      reportedWriting = true;
+                      processReporter?.writing();
+                    }
                     streamedContent += token;
                     // Send chunk to client
                     ws.send(JSON.stringify({
@@ -2193,30 +2294,7 @@ export async function startGateway(config: Config): Promise<void> {
                   },
                   onStep: async (step) => {
                     if (signal.aborted) return;
-
-                    // "text" = el agente narra lo que esta pensando/haciendo
-                    if (step.type === "text" && step.message) {
-                      const trimmedMessage = (typeof step.message === "string" ? step.message : "").trim();
-                      if (trimmedMessage) {
-                        ws.send(JSON.stringify({
-                          type: "progress",
-                          sessionId: routingSessionId,
-                          content: trimmedMessage,
-                        } as OutboundMessage));
-                      }
-                      return;
-                    }
-
-                    // "tool_call" = el agente va a ejecutar una herramienta → narrar al usuario
-                    if (step.type === "tool_call" && step.toolName) {
-                      const narration = getNarration(step.toolName);
-                      ws.send(JSON.stringify({
-                        type: "progress",
-                        sessionId: routingSessionId,
-                        content: narration,
-                      } as OutboundMessage));
-                      return;
-                    }
+                    processReporter?.step(step);
 
                     // "tool_result" = resultado de herramienta → solo si pide enviarse al usuario
                     if (step.type === "tool_result" && step.message) {
@@ -2258,6 +2336,7 @@ export async function startGateway(config: Config): Promise<void> {
                     if (!voiceCfg.ttsProvider) {
                       ws.send(JSON.stringify({
                         type: "message",
+                        id: messageId,
                         sessionId: routingSessionId,
                         content: `${content}\n\n🔊 Para recibir respuestas en audio, configura el proveedor TTS en Configuración > Canales > WebChat (ej: elevenlabs)`,
                         isStep: false,
@@ -2273,6 +2352,7 @@ export async function startGateway(config: Config): Promise<void> {
                         log.info(`Audio generated: ${base64Audio.length} bytes, mimeType: ${audioOutput.mimeType}`);
                         ws.send(JSON.stringify({
                           type: "message",
+                          id: messageId,
                           sessionId: routingSessionId,
                           content,
                           audio: base64Audio,
@@ -2281,11 +2361,11 @@ export async function startGateway(config: Config): Promise<void> {
                         } as OutboundMessage));
                       } catch (ttsError) {
                         log.error(`TTS failed: ${(ttsError as Error).message}), sending text instead`);
-                        ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
+                        ws.send(JSON.stringify({ type: "message", id: messageId, sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                       }
                     }
                   } else {
-                    ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
+                    ws.send(JSON.stringify({ type: "message", id: messageId, sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                   }
                 } else if (alreadyStreamed && shouldSpeak && voiceCfg.ttsProvider) {
                   try {
@@ -2295,6 +2375,7 @@ export async function startGateway(config: Config): Promise<void> {
                     log.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
                     ws.send(JSON.stringify({
                       type: "message",
+                      id: messageId,
                       sessionId: routingSessionId,
                       content,
                       audio: base64Audio,
@@ -2305,7 +2386,9 @@ export async function startGateway(config: Config): Promise<void> {
                     log.error(`TTS after streaming failed: ${(ttsError as Error).message}), skipping audio`);
                   }
                 }
+                processReporter.done("Listo");
               } catch (error) {
+                processReporter?.error("No se pudo completar la respuesta");
                 ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: msg.sessionId } as OutboundMessage));
                 ws.send(JSON.stringify({
                   type: "error",
@@ -2342,6 +2425,7 @@ export async function startGateway(config: Config): Promise<void> {
           } as OutboundMessage));
 
           laneQueue.enqueue(msg.sessionId, async (_task, signal) => {
+            let processReporter: ReturnType<typeof createWebChatProcessReporter> | null = null;
             if (signal.aborted) {
               ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: msg.sessionId } as OutboundMessage));
               ws.send(JSON.stringify({ type: "error", sessionId: msg.sessionId, error: "Task cancelled" } as OutboundMessage));
@@ -2355,6 +2439,9 @@ export async function startGateway(config: Config): Promise<void> {
               });
               const unifiedSessionId = conversationThreadId;
               const routingSessionId = msg.sessionId;
+              const messageId = crypto.randomUUID();
+              processReporter = createWebChatProcessReporter(ws, routingSessionId, messageId);
+              processReporter.start(msg.image || msg.document ? "Revisando tu solicitud y adjuntos" : "Revisando tu solicitud");
 
               // Multimodal: process image/document if present
               let finalMessageContent = msg.content;
@@ -2363,6 +2450,7 @@ export async function startGateway(config: Config): Promise<void> {
 
               if (msg.image || msg.document) {
                 log.info(`🖼️ Multimodal content detected from WebChat session ${unifiedSessionId}`);
+                processReporter.step({ type: "tool_result" });
 
                 if (msg.image) {
                   try {
@@ -2425,7 +2513,7 @@ export async function startGateway(config: Config): Promise<void> {
 
               // Streaming: send tokens as they arrive
               let streamedContent = "";
-              let messageId = crypto.randomUUID();
+              let reportedWriting = false;
 
               const response = await runner.generate({
                 provider: dbProvider as any,
@@ -2438,6 +2526,10 @@ export async function startGateway(config: Config): Promise<void> {
                 signal,
                 onToken: async (token: string) => {
                   if (signal.aborted) return;
+                  if (!reportedWriting && token.trim()) {
+                    reportedWriting = true;
+                    processReporter?.writing();
+                  }
                   streamedContent += token;
                   // Send chunk to client
                   ws.send(JSON.stringify({
@@ -2451,30 +2543,7 @@ export async function startGateway(config: Config): Promise<void> {
                 },
                 onStep: async (step) => {
                   if (signal.aborted) return;
-
-                  // "text" = el agente narra lo que esta pensando/haciendo
-                  if (step.type === "text" && step.message) {
-                    const trimmedMessage = (typeof step.message === "string" ? step.message : "").trim();
-                    if (trimmedMessage) {
-                      ws.send(JSON.stringify({
-                        type: "progress",
-                        sessionId: routingSessionId,
-                        content: trimmedMessage,
-                      } as OutboundMessage));
-                    }
-                    return;
-                  }
-
-                  // "tool_call" = el agente va a ejecutar una herramienta → narrar al usuario
-                  if (step.type === "tool_call" && step.toolName) {
-                    const narration = getNarration(step.toolName);
-                    ws.send(JSON.stringify({
-                      type: "progress",
-                      sessionId: routingSessionId,
-                      content: narration,
-                    } as OutboundMessage));
-                    return;
-                  }
+                  processReporter?.step(step);
 
                   // "tool_result" = resultado de herramienta → solo si pide enviarse al usuario
                   if (step.type === "tool_result" && step.message) {
@@ -2516,6 +2585,7 @@ export async function startGateway(config: Config): Promise<void> {
                   if (!voiceConfig.ttsProvider) {
                     ws.send(JSON.stringify({
                       type: "message",
+                      id: messageId,
                       sessionId: routingSessionId,
                       content: `${content}\n\n🔊 Para recibir respuestas en audio, configura el proveedor TTS en Configuración > Canales > WebChat (ej: elevenlabs)`,
                       isStep: false
@@ -2530,6 +2600,7 @@ export async function startGateway(config: Config): Promise<void> {
                       const base64Audio = (audioOutput.data as Buffer).toString("base64");
                       ws.send(JSON.stringify({
                         type: "message",
+                        id: messageId,
                         sessionId: routingSessionId,
                         content,
                         audio: base64Audio,
@@ -2538,11 +2609,11 @@ export async function startGateway(config: Config): Promise<void> {
                       } as OutboundMessage));
                     } catch (ttsError) {
                       log.error(`TTS failed: ${(ttsError as Error).message}), sending text instead`);
-                      ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
+                      ws.send(JSON.stringify({ type: "message", id: messageId, sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                     }
                   }
                 } else {
-                  ws.send(JSON.stringify({ type: "message", sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
+                  ws.send(JSON.stringify({ type: "message", id: messageId, sessionId: routingSessionId, content, isStep: false } as OutboundMessage));
                 }
               } else if (alreadyStreamed && shouldSpeak && voiceConfig.ttsProvider) {
                 try {
@@ -2552,6 +2623,7 @@ export async function startGateway(config: Config): Promise<void> {
                   log.info(`Audio generated after streaming: ${base64Audio.length} bytes`);
                   ws.send(JSON.stringify({
                     type: "message",
+                    id: messageId,
                     sessionId: routingSessionId,
                     content,
                     audio: base64Audio,
@@ -2562,7 +2634,9 @@ export async function startGateway(config: Config): Promise<void> {
                   log.error(`TTS after streaming failed: ${(ttsError as Error).message}), skipping audio`);
                 }
               }
+              processReporter.done("Listo");
             } catch (error) {
+              processReporter?.error("No se pudo completar la respuesta");
               // Detener typing aunque falle — nunca dejar el spinner infinito
               ws.send(JSON.stringify({ type: "typing", isTyping: false, sessionId: msg.sessionId } as OutboundMessage));
               ws.send(JSON.stringify({
@@ -2729,7 +2803,7 @@ export async function startGateway(config: Config): Promise<void> {
     process.exit(0);
   });
 
-  process.on("SIGHUP", async () => {
+  if (process.platform !== "win32") process.on("SIGHUP", async () => {
     log.info("Received SIGHUP, reloading configuration...");
     try {
       const newConfig = await loadConfig();

package/packages/core/src/gateway/slash-commands.ts

@@ -27,15 +27,21 @@ export interface InboundMessage {
 }
 
 export interface OutboundMessage {
-  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "joined" | "typing" | "audio" | "welcome" | "progress";
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "joined" | "typing" | "audio" | "welcome" | "progress" | "process";
   sessionId: string;
   id?: string; // Message ID for streaming
+  messageId?: string;
   content?: string;
   chunk?: string;
   isChunk?: boolean; // True if this is a streaming chunk
   isLast?: boolean;
   isTyping?: boolean;
   isStep?: boolean;
+  processKind?: "analysis" | "tool" | "observation" | "writing";
+  processStatus?: "thinking" | "done" | "error";
+  label?: string;
+  detail?: string;
+  summary?: string;
   stepType?: "plan" | "tool_call" | "tool_result" | "text";
   status?: {
     state: string;

package/packages/core/src/gateway/tts/src/install.ts

@@ -4,7 +4,7 @@
  * Los datos se guardan en $HIVE_HOME/tts/ (por defecto ~/.hive/tts/).
  */
 
-import { existsSync, mkdirSync, readdirSync, renameSync } from "fs"
+import { existsSync, mkdirSync, readdirSync, renameSync, unlinkSync, rmSync } from "fs"
 import { join } from "path"
 import { homedir } from "os"
 import {
@@ -37,16 +37,24 @@ async function extractTarGz(archivePath: string, destDir: string): Promise<void>
     stderr: "inherit",
   }).exited
   if (code !== 0) throw new Error(`tar falló con código ${code}`)
-  await Bun.spawn(["rm", "-f", archivePath]).exited
+  unlinkSync(archivePath)
 }
 
 async function extractZip(archivePath: string, destDir: string): Promise<void> {
-  const code = await Bun.spawn(["unzip", "-q", archivePath, "-d", destDir], {
-    stdout: "inherit",
-    stderr: "inherit",
-  }).exited
-  if (code !== 0) throw new Error(`unzip falló con código ${code}`)
-  await Bun.spawn(["rm", "-f", archivePath]).exited
+  let code: number
+  if (process.platform === "win32") {
+    code = await Bun.spawn(
+      ["powershell", "-Command", `Expand-Archive -Path "${archivePath}" -DestinationPath "${destDir}" -Force`],
+      { stdout: "inherit", stderr: "inherit" }
+    ).exited
+  } else {
+    code = await Bun.spawn(["unzip", "-q", archivePath, "-d", destDir], {
+      stdout: "inherit",
+      stderr: "inherit",
+    }).exited
+  }
+  if (code !== 0) throw new Error(`Extracción ZIP falló con código ${code}`)
+  unlinkSync(archivePath)
 }
 
 /**
@@ -86,7 +94,7 @@ export async function runInstall(ttsRoot: string): Promise<void> {
       for (const entry of readdirSync(tempDir)) {
         renameSync(join(tempDir, entry), join(BIN_DIR, entry))
       }
-      await Bun.spawn(["rm", "-rf", tempDir]).exited
+      rmSync(tempDir, { recursive: true, force: true })
     }
 
     if (!existsSync(binaryPath)) {