@johpaz/hive-agents 0.0.39 → 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/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/config/loader.ts

@@ -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(),
 });

package/packages/core/src/gateway/routes/providers.ts

@@ -5,6 +5,10 @@ import {
   loadProviderHeaders, storeProviderHeaders,
 } from "../../storage/crypto"
 import { listLocalModels } from "../llm-local/downloader"
+import { loadHiveAgentsModel, getHiveAgentsModelStatus } from "../../agent/llm-providers/hiveagents"
+import { logger } from "../../utils/logger"
+
+const log = logger.child("gateway")
 
 export async function handleGetProviders(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
   const rawProviders = getDb().query(`
@@ -259,3 +263,55 @@ export async function handleSyncProviderModels(
     }, { status: 502 }), req)
   }
 }
+
+export async function handleLoadHiveAgentsModel(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response
+): Promise<Response> {
+  const body = await req.json().catch(() => ({}))
+  const modelId = body.model_id || body.modelId
+  const ctx = typeof body.ctx === "number" && body.ctx > 0 ? body.ctx : 50000
+  if (!modelId) {
+    return addCorsHeaders(Response.json({ error: "model_id is required" }, { status: 400 }), req)
+  }
+
+  const providerRow = getDb().query("SELECT * FROM providers WHERE id = ?").get("hiveagents") as Record<string, unknown> | undefined
+  if (!providerRow) {
+    return addCorsHeaders(Response.json({ error: "Provider not found" }, { status: 404 }), req)
+  }
+
+  const apiKey = await loadProviderApiKey("hiveagents")
+  if (!apiKey) {
+    return addCorsHeaders(Response.json({ error: "API key not configured for hiveagents" }, { status: 400 }), req)
+  }
+
+  const baseUrl = providerRow.base_url as string | undefined
+  log.info(`[gateway] Loading hiveagents model ${modelId} with ctx=${ctx} via ${baseUrl || "https://llm.hiveagents.io"}`)
+
+  const result = await loadHiveAgentsModel(modelId as string, apiKey, baseUrl, ctx)
+  if (!result.success) {
+    log.error(`[gateway] Failed to load hiveagents model ${modelId}: ${result.error}`)
+    return addCorsHeaders(Response.json({ error: result.error }, { status: 502 }), req)
+  }
+  const isLoading = (result as any).loading === true
+  log.info(`[gateway] hiveagents load request accepted for ${modelId} with ctx=${ctx}${isLoading ? " (timeout/backend still loading)" : ""}`)
+  return addCorsHeaders(Response.json({ success: true, loading: isLoading, model_id: modelId, ctx }), req)
+}
+
+export async function handleGetHiveAgentsModelStatus(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response
+): Promise<Response> {
+  const providerRow = getDb().query("SELECT * FROM providers WHERE id = ?").get("hiveagents") as Record<string, unknown> | undefined
+  if (!providerRow) {
+    return addCorsHeaders(Response.json({ error: "Provider not found" }, { status: 404 }), req)
+  }
+
+  const apiKey = await loadProviderApiKey("hiveagents")
+  if (!apiKey) {
+    return addCorsHeaders(Response.json({ error: "API key not configured for hiveagents" }, { status: 400 }), req)
+  }
+
+  const status = await getHiveAgentsModelStatus(apiKey, providerRow.base_url as string | undefined)
+  return addCorsHeaders(Response.json({ success: true, ...status }), req)
+}