@johpaz/hive-agents 0.0.38 → 0.0.40

package/packages/core/src/agent/llm-providers/openai-compat-base.ts

@@ -17,6 +17,12 @@ export abstract class OpenAICompatBase implements LLMProvider {
   /** Override to true for providers running on localhost. */
   protected isLocalProvider(): boolean { return false }
 
+  /** Override to customize the OpenAI client (e.g. strip unwanted headers, add custom fetch). */
+  protected async resolveOpenAIClient(apiKey: string, baseURL: string | undefined): Promise<any> {
+    const { default: OpenAI } = await import("openai")
+    return new OpenAI({ apiKey, baseURL })
+  }
+
   /** Hook called before each request. Override for e.g. auto-starting a local server. */
   protected async beforeCall(_options: LLMCallOptions): Promise<void> {}
 
@@ -27,6 +33,9 @@ export abstract class OpenAICompatBase implements LLMProvider {
    */
   protected injectToolsIntoPrompt(_body: any, _preparedTools: any[]): void {}
 
+  /** Override to add provider-specific fields to the request body (e.g. extra_body for llama.cpp chat_template_kwargs). */
+  protected modifyRequestBody(body: any, _options: LLMCallOptions): any { return body }
+
   private _convertContentPart(part: ContentPart): any {
     switch (part.type) {
       case "text":
@@ -51,8 +60,6 @@ export abstract class OpenAICompatBase implements LLMProvider {
   }
 
   async call(options: LLMCallOptions): Promise<LLMResponse> {
-    const { default: OpenAI } = await import("openai")
-
     const baseURL = options.baseUrl?.trim() || OPENAI_COMPAT_BASE_URLS[this.providerName] || undefined
     const isLocal = this.isLocalProvider()
 
@@ -63,7 +70,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
       throw new Error(`API key missing for provider: ${this.providerName}. Configure it in Settings → Providers.`)
     }
 
-    const client = new OpenAI({ apiKey, baseURL })
+    const client = await this.resolveOpenAIClient(apiKey, baseURL)
 
     const sanitized = sanitizeMessages(options.messages)
     const rawMessages = this.needsReasoningRoundtrip()
@@ -121,7 +128,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
 
     let response
     try {
-      response = await client.chat.completions.create(body)
+      response = await client.chat.completions.create(this.modifyRequestBody(body, options))
     } catch (err: any) {
       const status = err?.status ?? err?.response?.status
       const errMsg = (err?.error?.message ?? err?.message ?? "").toLowerCase()
@@ -133,7 +140,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
         delete bodyNoTools.tools
         delete bodyNoTools.tool_choice
         delete bodyNoTools.parallel_tool_calls
-        response = await client.chat.completions.create(bodyNoTools)
+        response = await client.chat.completions.create(this.modifyRequestBody(bodyNoTools, options))
       }
       // Retry 2: context overflow — compact messages and retry
       else if (status === 400 && (errMsg.includes("context length") || errMsg.includes("input_tokens") || errMsg.includes("maximum input length"))) {
@@ -153,7 +160,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
         if (body.max_tokens) body.max_tokens = Math.min(body.max_tokens, 4096)
 
         log.info(`[llm-client] ${this.providerName}: compacted ${compacted.length} msgs → ${body.messages.length} msgs, max_tokens=${body.max_tokens}`)
-        response = await client.chat.completions.create(body)
+        response = await client.chat.completions.create(this.modifyRequestBody(body, options))
       }
       else {
         throw err
@@ -207,7 +214,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
   ): Promise<LLMResponse> {
     let stream
     try {
-      stream = await client.chat.completions.create({ ...body, stream: true })
+      stream = await client.chat.completions.create({ ...this.modifyRequestBody(body, options), stream: true })
     } catch (err: any) {
       const status = err?.status ?? err?.response?.status
       const errMsg = (err?.error?.message ?? err?.message ?? "").toLowerCase()
@@ -218,7 +225,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
         delete bodyNoTools.tools
         delete bodyNoTools.tool_choice
         delete bodyNoTools.parallel_tool_calls
-        stream = await client.chat.completions.create({ ...bodyNoTools, stream: true })
+        stream = await client.chat.completions.create({ ...this.modifyRequestBody(bodyNoTools, options), stream: true })
       } else if (status === 400 && (errMsg.includes("context length") || errMsg.includes("input_tokens") || errMsg.includes("maximum input length"))) {
         log.warn(`[llm-client] ${this.providerName}: context overflow — compacting messages and retrying stream`)
         const compacted = [...body.messages]
@@ -233,7 +240,7 @@ export abstract class OpenAICompatBase implements LLMProvider {
         body.messages = systemMsg ? [systemMsg, ...trimmed] : trimmed
         if (body.max_tokens) body.max_tokens = Math.min(body.max_tokens, 4096)
         log.info(`[llm-client] ${this.providerName}: compacted ${compacted.length} msgs → ${body.messages.length} msgs, max_tokens=${body.max_tokens}`)
-        stream = await client.chat.completions.create({ ...body, stream: true })
+        stream = await client.chat.completions.create({ ...this.modifyRequestBody(body, options), stream: true })
       } else {
         throw err
       }
@@ -325,6 +332,7 @@ export function extractToolCallsFromText(
   const tool_calls: LLMToolCall[] = []
   let extractedContent = content
 
+  // Regexes for wrapped tool-call blocks.
   const regexes = [
     /<tool_call>\s*({[\s\S]*?})\s*<\/tool_call>/g,
     /<function_call>\s*({[\s\S]*?})\s*<\/function_call>/g,
@@ -336,13 +344,20 @@ export function extractToolCallsFromText(
     while ((match = regex.exec(content)) !== null) {
       try {
         const json = JSON.parse(match[1])
-        if (json.name) {
+        const calls = Array.isArray(json) ? json : [json]
+        for (const call of calls) {
+          if (!call) continue
+          // Accept both { name, arguments } and { function: { name, arguments } }
+          const fn = call.function || call
+          const name = fn.name ?? call.name
+          let args = fn.arguments ?? call.arguments ?? call.parameters
+          if (!name) continue
           tool_calls.push({
             id: crypto.randomUUID(),
             type: "function",
             function: {
-              name: toolNameMap.get(json.name) ?? json.name,
-              arguments: typeof json.arguments === "object" ? JSON.stringify(json.arguments) : (json.arguments || "{}"),
+              name: toolNameMap.get(name) ?? name,
+              arguments: typeof args === "object" ? JSON.stringify(args) : (args || "{}"),
             },
           })
           extractedContent = extractedContent.replace(match[0], "").trim()
@@ -356,19 +371,28 @@ export function extractToolCallsFromText(
   // Fallback: entire output is a bare JSON tool call — only if name matches a known tool
   if (tool_calls.length === 0 && knownToolNames && knownToolNames.size > 0) {
     try {
-      const json = JSON.parse(content.trim())
-      const resolvedName = toolNameMap.get(json.name) ?? json.name
-      if (json.name && knownToolNames.has(resolvedName) && (json.arguments || json.parameters)) {
-        const args = json.arguments || json.parameters
-        tool_calls.push({
-          id: crypto.randomUUID(),
-          type: "function",
-          function: {
-            name: resolvedName,
-            arguments: typeof args === "object" ? JSON.stringify(args) : (args || "{}"),
-          },
-        })
-        extractedContent = ""
+      const trimmed = content.trim()
+      // Strip common markdown fences before parsing.
+      const jsonText = trimmed.replace(/^```(?:json|tool_call)?\s*|\s*```$/g, "").trim()
+      const json = JSON.parse(jsonText)
+      const calls = Array.isArray(json) ? json : [json]
+      for (const call of calls) {
+        if (!call) continue
+        const fn = call.function || call
+        const name = fn.name ?? call.name
+        let args = fn.arguments ?? call.arguments ?? call.parameters
+        const resolvedName = toolNameMap.get(name) ?? name
+        if (name && knownToolNames.has(resolvedName) && (args !== undefined || calls.length === 1)) {
+          tool_calls.push({
+            id: crypto.randomUUID(),
+            type: "function",
+            function: {
+              name: resolvedName,
+              arguments: typeof args === "object" ? JSON.stringify(args) : (args || "{}"),
+            },
+          })
+          extractedContent = ""
+        }
       }
     } catch {
       // not valid JSON

package/packages/core/src/agent/llm-providers/opencode-go.ts

@@ -0,0 +1,9 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class OpenCodeGoProvider extends OpenAICompatBase {
+  static readonly secretKey = "OPENCODE_GO_API_KEY"
+
+  constructor() {
+    super("opencode-go")
+  }
+}

package/packages/core/src/agent/providers/index.ts

@@ -11,7 +11,7 @@ import { getAgentLoop } from "../agent-loop"
 import { resolveUserId, resolveAgentId } from "../../storage/onboarding"
 import type { ContentPart } from "../../multimodal/types"
 
-export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia"
+export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia" | "hiveagents"
 
 export interface StepEvent {
   type: "text" | "plan" | "tool_call" | "tool_result"
@@ -96,6 +96,7 @@ export class AgentRunner {
             raw_user_message: options.rawUserMessage,
           },
           signal: options.signal,
+          onToken: options.onToken,
         }
       )
 
@@ -126,7 +127,7 @@ export class AgentRunner {
             } else {
               logger.debug(`[STREAM] Content empty or whitespace only, skipping accumulation`)
             }
-            if (options.onToken) options.onToken(content)
+            if (options.onToken && !chunk.agent.streamed) options.onToken(content)
           } else {
             logger.debug(`[STREAM] No content in chunk, lastMsg.content is falsy`)
           }

package/packages/core/src/agent/stuck-loop.ts

@@ -9,18 +9,26 @@ interface ToolCallRecord {
   timestamp: number;
 }
 
-interface StuckLoopState {
+interface ProgressRecord {
+  hash: string;
+  timestamp: number;
+}
+
+export interface StuckLoopState {
   detected: boolean;
   toolName: string;
   count: number;
   lastError?: string;
+  kind: "loop" | "stall";
 }
 
 export class StuckLoopDetector {
   private log = logger.child("stuck-loop");
   private history: Map<string, ToolCallRecord[]> = new Map();
+  private progressHistory: Map<string, ProgressRecord[]> = new Map();
   private readonly maxHistoryPerSession = 50;
   private readonly triggerThreshold = 3;
+  private readonly progressThreshold = 3;
 
   constructor(_config: Config) {}
 
@@ -54,9 +62,9 @@ export class StuckLoopDetector {
 
   check(sessionId: string): StuckLoopState {
     const sessionHistory = this.history.get(sessionId) ?? [];
-    
+
     if (sessionHistory.length < this.triggerThreshold) {
-      return { detected: false, toolName: "", count: 0 };
+      return { detected: false, toolName: "", count: 0, kind: "loop" };
     }
 
     const recent = sessionHistory.slice(-10);
@@ -65,7 +73,7 @@ export class StuckLoopDetector {
     for (const record of recent) {
       const key = `${record.toolName}:${record.argsHash}`;
       const existing = counts.get(key);
-      
+
       if (existing) {
         existing.count++;
         if (record.errorMessage) {
@@ -79,33 +87,73 @@ export class StuckLoopDetector {
     for (const [key, data] of counts) {
       if (data.count >= this.triggerThreshold && data.error) {
         const toolName = key.split(":")[0] ?? "unknown";
-        
+
         this.log.warn(`Stuck loop detected: ${toolName} called ${data.count} times with same args and error`);
-        
+
         return {
           detected: true,
           toolName,
           count: data.count,
           lastError: data.error,
+          kind: "loop",
         };
       }
     }
 
-    return { detected: false, toolName: "", count: 0 };
+    return { detected: false, toolName: "", count: 0, kind: "loop" };
+  }
+
+  /**
+   * Record a progress snapshot hash. Use this to detect when the agent is not
+   * advancing even though no tool errors are occurring.
+   */
+  recordProgress(sessionId: string, progressHash: string): void {
+    let sessionProgress = this.progressHistory.get(sessionId);
+    if (!sessionProgress) {
+      sessionProgress = [];
+      this.progressHistory.set(sessionId, sessionProgress);
+    }
+
+    sessionProgress.push({ hash: progressHash, timestamp: Date.now() });
+
+    if (sessionProgress.length > this.maxHistoryPerSession) {
+      sessionProgress.shift();
+    }
+
+    this.log.debug(`Recorded progress hash for session ${sessionId}: ${progressHash}`);
   }
 
-  getInterventionMessage(state: StuckLoopState): string | null {
-    if (!state.detected) return null;
+  /**
+   * Detect lack of progress when the same hash appears repeatedly.
+   */
+  checkProgress(sessionId: string, threshold?: number): StuckLoopState {
+    const sessionProgress = this.progressHistory.get(sessionId) ?? [];
+    const required = threshold ?? this.progressThreshold;
+
+    if (sessionProgress.length < required) {
+      return { detected: false, toolName: "", count: 0, kind: "stall" };
+    }
 
-    if (state.count >= this.triggerThreshold + 1) {
-      return `CRITICAL: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing with: "${state.lastError}". The user has been notified. You MUST try a completely different approach or ask the user for guidance.`;
+    const recent = sessionProgress.slice(-required);
+    const firstHash = recent[0]?.hash;
+    const allSame = recent.every((r) => r.hash === firstHash);
+
+    if (allSame && firstHash) {
+      this.log.warn(`Stall detected: no progress for ${required} checks (hash ${firstHash})`);
+      return {
+        detected: true,
+        toolName: "NO_PROGRESS",
+        count: required,
+        kind: "stall",
+      };
     }
 
-    return `WARNING: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing. You MUST try a completely different approach instead of repeating the same action.`;
+    return { detected: false, toolName: "", count: 0, kind: "stall" };
   }
 
   clear(sessionId: string): void {
     this.history.delete(sessionId);
+    this.progressHistory.delete(sessionId);
     this.log.debug(`Cleared stuck loop history for session ${sessionId}`);
   }
 
@@ -114,8 +162,8 @@ export class StuckLoopDetector {
     let pruned = 0;
 
     for (const [sessionId, history] of this.history) {
-      const filtered = history.filter(r => now - r.timestamp < maxAgeMs);
-      
+      const filtered = history.filter((r) => now - r.timestamp < maxAgeMs);
+
       if (filtered.length === 0) {
         this.history.delete(sessionId);
         pruned++;
@@ -124,6 +172,17 @@ export class StuckLoopDetector {
       }
     }
 
+    for (const [sessionId, history] of this.progressHistory) {
+      const filtered = history.filter((r) => now - r.timestamp < maxAgeMs);
+
+      if (filtered.length === 0) {
+        this.progressHistory.delete(sessionId);
+        pruned++;
+      } else if (filtered.length !== history.length) {
+        this.progressHistory.set(sessionId, filtered);
+      }
+    }
+
     return pruned;
   }
 }
@@ -131,3 +190,20 @@ export class StuckLoopDetector {
 export function createStuckLoopDetector(config: Config): StuckLoopDetector {
   return new StuckLoopDetector(config);
 }
+
+/**
+ * Build a human-readable intervention message for the model.
+ */
+export function getInterventionMessage(state: StuckLoopState): string {
+  if (!state.detected) return "";
+
+  if (state.kind === "stall") {
+    return `WARNING: Has estado sin avanzar durante ${state.count} ciclos consecutivos. Revisa tu plan, intenta una herramienta diferente o pide aclaración al usuario en lugar de repetir la misma secuencia.`;
+  }
+
+  if (state.count >= 4) {
+    return `CRITICAL: Has llamado ${state.toolName} ${state.count} veces con los mismos argumentos y sigue fallando con: "${state.lastError}". El usuario será notificado. Debes cambiar completamente de estrategia o pedir ayuda.`;
+  }
+
+  return `WARNING: Has llamado ${state.toolName} ${state.count} veces con los mismos argumentos y sigue fallando. Debes probar un enfoque diferente en lugar de repetir la misma acción.`;
+}

package/packages/core/src/channels/base.ts

@@ -1,12 +1,18 @@
 export interface OutboundMessage {
-  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "log" | "typing" | "audio";
+  type: "message" | "stream" | "status" | "error" | "pong" | "command_result" | "log" | "typing" | "audio" | "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;
   isStep?: boolean;
+  processKind?: "analysis" | "tool" | "observation" | "writing";
+  processStatus?: "thinking" | "done" | "error";
+  label?: string;
+  detail?: string;
+  summary?: string;
   stepType?: "plan" | "tool_call" | "tool_result" | "text";
   audio?: {
     buffer?: Buffer;

package/packages/core/src/channels/whatsapp.ts

@@ -11,6 +11,7 @@ import type { ChannelConfig, IncomingMessage, OutboundMessage } from "./base.ts"
 import { BaseChannel } from "./base.ts";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import * as path from "node:path";
+import { homedir } from "node:os";
 import { logger } from "../utils/logger.ts";
 import { getDb } from "../storage/sqlite.ts";
 // @ts-ignore — no type definitions for qrcode-terminal
@@ -69,7 +70,7 @@ export class WhatsAppChannel extends BaseChannel {
   }
 
   private getAuthPath(agentId: string, accountId: string): string {
-    const baseDir = process.env.HOME ?? "";
+    const baseDir = homedir();
     const authDir = path.join(baseDir, ".hive", "agents", agentId, "whatsapp", accountId);
 
     if (!existsSync(authDir)) {
@@ -117,11 +118,22 @@ export class WhatsAppChannel extends BaseChannel {
       this.connectionState.waVersion = version.join(".");
       this.log.info(`Using WhatsApp Web v${version.join(".")}`);
 
+      const baileysLogger = {
+        level: "silent",
+        child: () => baileysLogger,
+        trace: () => {},
+        debug: () => {},
+        info:  (msg: unknown) => { if (typeof msg === "object" && msg !== null) this.log.debug((msg as any).msg ?? JSON.stringify(msg)); },
+        warn:  (msg: unknown) => { if (typeof msg === "object" && msg !== null) this.log.warn((msg as any).msg ?? JSON.stringify(msg)); },
+        error: (msg: unknown) => { if (typeof msg === "object" && msg !== null) this.log.error((msg as any).msg ?? JSON.stringify(msg)); },
+      };
+
       this.socket = makeWASocket({
         version,
         auth: state,
         printQRInTerminal: false,
         syncFullHistory: false,
+        logger: baileysLogger as any,
         getMessage: async () => ({ conversation: "" }),
       });
 

package/packages/core/src/config/loader.ts

@@ -1,7 +1,7 @@
 import * as z from "zod";
 import { mkdirSync, existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
-import { availableParallelism } from "node:os";
+import { availableParallelism, homedir } from "node:os";
 
 const LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
 const DMPolicySchema = z.enum(["open", "pairing", "allowlist"]);
@@ -33,7 +33,7 @@ export function getHiveDir(): string {
   // Priority 1: HIVE_HOME explicitly set
   if (process.env.HIVE_HOME) {
     const hiveDir = process.env.HIVE_HOME.startsWith("~")
-      ? path.join(process.env.HOME || "", process.env.HIVE_HOME.slice(1))
+      ? path.join(homedir(), process.env.HIVE_HOME.slice(1))
       : process.env.HIVE_HOME;
     loadEnv(hiveDir);
     return hiveDir;
@@ -49,7 +49,7 @@ export function getHiveDir(): string {
   }
 
   // Priority 3: Default ~/.hive
-  const defaultDir = path.join(process.env.HOME || "", ".hive");
+  const defaultDir = path.join(homedir(), ".hive");
   loadEnv(defaultDir);
   return defaultDir;
 }
@@ -60,7 +60,7 @@ const expandPath = (p: string): string => {
     return p.replace("~/.hive", hiveDir);
   }
   if (p.startsWith("~")) {
-    return path.join(process.env.HOME || "", p.slice(1));
+    return path.join(homedir(), p.slice(1));
   }
   return p;
 };
@@ -117,9 +117,9 @@ const WebConfigSchema = z.object({
 
 const BrowserConfigSchema = z.object({
   enabled: z.boolean().optional(),
-  cdpUrl: z.string().optional(),
   headless: z.boolean().optional(),
   timeoutMs: z.number().optional(),
+  sessionName: z.string().optional(),
 });
 
 const CanvasConfigSchema = z.object({
@@ -290,7 +290,7 @@ const GatewayConfigSchema = z.object({
 });
 
 const ModelsConfigSchema = z.object({
-  defaultProvider: z.enum(["openai", "anthropic", "gemini", "mistral", "kimi", "ollama", "openrouter", "deepseek"]).optional(),
+  defaultProvider: z.enum(["openai", "anthropic", "gemini", "mistral", "kimi", "ollama", "openrouter", "deepseek", "hiveagents"]).optional(),
   defaults: z.record(z.string(), z.string()).optional(),
   providers: z.record(z.string(), ProviderConfigSchema).optional(),
 });
@@ -437,7 +437,7 @@ function buildDefaultConfig(): Config {
         allowlist: [],
         denylist: ["rm -rf /", "sudo", "chmod 777", "> /dev/", "mkfs"],
         timeoutSeconds: 30,
-        workDir: path.join(process.env.HOME || "", "exec"), // Points to home for exec by default
+        workDir: path.join(homedir(), "exec"), // Points to home for exec by default
       },
       web: {
         allowlist: [],
@@ -446,9 +446,9 @@ function buildDefaultConfig(): Config {
       },
       browser: {
         enabled: true,
-        cdpUrl: "ws://127.0.0.1:9222",
         headless: true,
         timeoutMs: 30000,
+        sessionName: "hive",
       },
       canvas: {
         enabled: true,

package/packages/core/src/gateway/helpers/path.ts

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { homedir } from "node:os";
 
 /**
  * Expands a path that starts with ~ to the user's home directory.
@@ -7,7 +8,7 @@ import * as path from "node:path";
  */
 export function expandPath(p: string): string {
   if (p.startsWith("~")) {
-    return path.join(process.env.HOME ?? "", p.slice(1));
+    return path.join(homedir(), p.slice(1));
   }
   return p;
 }

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

@@ -250,11 +250,11 @@ export async function initializeGateway(
     const agent = createAgentService();
     await agent.initialize();
 
-    // 5b. Initialize Browser Service (Chrome via Bun.WebView nativo)
+    // 5b. Initialize Browser Service (agent-browser CLI)
     let browserAvailable = false;
 
     try {
-      log.info("Detecting browser (lazy launch — will open on first agent use)...");
+      log.info("Initializing browser automation (agent-browser)...");
 
       const browserService = initializeBrowserService(config);
       browserAvailable = await browserService.start();
@@ -262,8 +262,8 @@ export async function initializeGateway(
       if (browserAvailable) {
         activateBrowserTools();
       } else {
-        log.warn("⚠️  No se encontró Chrome/Chromium - browser tools desactivadas");
-        log.warn("   Linux: sudo dnf install chromium  |  macOS: brew install --cask google-chrome");
+        log.warn("⚠️  agent-browser no disponible - browser tools desactivadas");
+        log.warn("   Se instalará automáticamente en primer uso o manual: bun add -g agent-browser");
       }
     } catch (error) {
       log.warn(`Browser Service initialization skipped: ${(error as Error).message}`);