@johpaz/hive-agents 0.0.38 → 0.0.40

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

@@ -28,9 +28,12 @@ import { resolveUserId, resolveAgentId } from "../storage/onboarding"
 import type { ContentPart } from "../multimodal/types"
 import { loadConfig } from "../config/loader"
 import { executeToolBatch } from "../tool-runtime"
+import { createStuckLoopDetector, getInterventionMessage, type StuckLoopState } from "./stuck-loop"
 
 const log = logger.child("agent-loop")
 
+const DEFAULT_MAX_WALL_CLOCK_MS = 5 * 60 * 1000
+
 // ─── Types ────────────────────────────────────────────────────────────────────
 
 export interface AgentLoopOptions {
@@ -45,14 +48,19 @@ export interface AgentLoopOptions {
   isolated?: boolean
   taskContext?: string | ContentPart[]
   onStep?: (step: StepEvent) => Promise<void>
+  onToken?: (token: string) => void
   /** User ID for context propagation */
   userId?: string
   /** Abort signal to stop generation mid-execution */
   signal?: AbortSignal
   /** Clean text for FTS5 and tracing (extracted from userMessage if multimodal) */
   rawUserMessage?: string
+  /** Extra tools to force into the LLM loadout (used by tests/evals). */
+  extraTools?: any[]
 }
 
+export type { StepEvent as AgentStepEvent }
+
 export interface StepEvent {
   type: "text" | "tool_call" | "tool_result"
   message: string
@@ -63,7 +71,7 @@ export interface StepEvent {
 // ─── Stream chunk types (compatible with providers/index.ts) ─────────────────
 
 export interface StreamChunk {
-  agent?: { messages: any[] }
+  agent?: { messages: any[]; streamed?: boolean }
   tools?: { messages: any[] }
   usage?: { input_tokens: number; output_tokens: number }
 }
@@ -82,6 +90,12 @@ export async function* runAgent(
 
   const agentName = agent.name || opts.agentId
   const maxIterations = agent.max_iterations || 10
+  const maxWallClockMs = agent.max_wall_clock_ms || DEFAULT_MAX_WALL_CLOCK_MS
+  const wallClockDeadline = Date.now() + maxWallClockMs
+
+  // Stuck-loop protection
+  const stuckDetector = createStuckLoopDetector(loadConfig())
+  let stuckState: StuckLoopState | undefined
 
   // Resolve LLM provider config
   const providerCfg = await resolveProviderConfig(
@@ -122,6 +136,19 @@ export async function* runAgent(
     userId: opts.userId,
   })
 
+  // Force extra tools into the loadout (tests/evals)
+  if (opts.extraTools?.length) {
+    const existingNames = new Set(ctx.tools.map((t: any) => t.function?.name))
+    for (const tool of opts.extraTools) {
+      const name = tool.function?.name || tool.name
+      if (name && !existingNames.has(name)) {
+        ctx.tools.push(tool)
+        existingNames.add(name)
+        log.info(`[agent-loop] Force-injected tool into loadout: ${name}`)
+      }
+    }
+  }
+
   const systemPrompt = opts.systemPromptOverride || ctx.systemPrompt
 
   // Build initial messages array for the model
@@ -143,6 +170,9 @@ export async function* runAgent(
   let lastToolSignature = ""
   let consecutiveRepeat = 0
   let loopDetected = false
+  // Stall detection: iterations without a forward-progress tool call (write/click/navigate)
+  let idleIterations = 0
+  const PROGRESS_TOOLS = new Set(["browser_type", "browser_click", "browser_navigate"])
 
   // ── The loop ────────────────────────────────────────────────────────────
   while (iterations < maxIterations) {
@@ -152,12 +182,25 @@ export async function* runAgent(
       break
     }
 
+    if (Date.now() > wallClockDeadline) {
+      log.warn(`[agent-loop] Wall-clock timeout exceeded (${maxWallClockMs}ms). Breaking.`)
+      finalContent = "La tarea tomó demasiado tiempo. Te sugiero dividirla en pasos más pequeños o darme más detalles para continuar."
+      break
+    }
+
     iterations++
 
+    let streamedThisCall = false
     const response = await callLLM({
       ...providerCfg,
       messages: clearOldToolResults(messages) as LLMMessage[],
       tools: ctx.tools.length > 0 ? ctx.tools : undefined,
+      onToken: opts.onToken
+        ? (token: string) => {
+          streamedThisCall = true
+          opts.onToken?.(token)
+        }
+        : undefined,
     })
 
     // Accumulate usage
@@ -169,7 +212,7 @@ export async function* runAgent(
     // Emit agent chunk (compatible with providers/index.ts)
     const agentMsg: any = { content: response.content }
     if (response.tool_calls?.length) agentMsg.tool_calls = response.tool_calls
-    yield { agent: { messages: [agentMsg] } }
+    yield { agent: { messages: [agentMsg], streamed: streamedThisCall } }
 
     // Notify onStep for narration text
     if (opts.onStep && response.content) {
@@ -287,6 +330,10 @@ export async function* runAgent(
         tool_call_id: tc.id,
       })
 
+      // Record tool call for stuck-loop detection
+      const errorMessage = toolResultLLM.startsWith("[Tool Error]") ? toolResultLLM : undefined
+      stuckDetector.recordToolCall(opts.threadId, toolName, tc.function.arguments as Record<string, unknown>, errorMessage)
+
       // Dynamic tool injection: when search_knowledge finds tools (native or MCP), add them to ctx.tools
       if (toolName === "search_knowledge") {
         // Use JS object directly (no parse needed)
@@ -463,6 +510,54 @@ export async function* runAgent(
 
     if (loopDetected) break
 
+    // Check for stuck loop after each iteration
+    stuckState = stuckDetector.check(opts.threadId)
+    if (stuckState.detected) {
+      const intervention = getInterventionMessage(stuckState)
+      log.warn(`[agent-loop] ${intervention}`)
+
+      if (stuckState.count >= 4) {
+        // Critical: break and notify user instead of looping forever
+        finalContent = intervention
+        loopDetected = true
+        emitCanvas("canvas:node_update", {
+          nodeId: opts.agentId,
+          changes: { status: "stuck", currentTool: stuckState.toolName },
+        })
+        break
+      } else {
+        // Warning: inject intervention message so the model changes strategy
+        messages.push({
+          role: "user",
+          content: intervention,
+        })
+      }
+    }
+
+    // Stall detection: no forward-progress tool for several iterations
+    const hadProgress = toolResults.some(
+      (r) => PROGRESS_TOOLS.has(r.toolName) && !String(r.result).startsWith("[Tool Error]")
+    )
+    if (hadProgress) {
+      idleIterations = 0
+    } else if (toolResults.length > 0) {
+      idleIterations++
+    }
+    if (idleIterations >= 3 && idleIterations < 5) {
+      const stallMsg = "ADVERTENCIA: Llevas varios pasos sin modificar la página. Si ya completaste el formulario, responde al usuario. Si no, avanza con browser_type/browser_click en lugar de seguir inspeccionando."
+      log.warn(`[agent-loop] ${stallMsg}`)
+      messages.push({ role: "user", content: stallMsg })
+    } else if (idleIterations >= 5) {
+      const stallMsg = "No logré avanzar en el formulario después de varios intentos. Puede que la página no sea compatible o que falten instrucciones. Te sugiero revisar la URL o darme más detalles."
+      log.warn(`[agent-loop] Stall break: ${stallMsg}`)
+      finalContent = stallMsg
+      emitCanvas("canvas:node_update", {
+        nodeId: opts.agentId,
+        changes: { status: "stuck", currentTool: "NO_PROGRESS" },
+      })
+      break
+    }
+
     emitCanvas("canvas:node_update", {
       nodeId: opts.agentId,
       changes: { status: "thinking", currentTool: null },
@@ -603,6 +698,10 @@ export class AgentLoop {
         raw_user_message?: string
       }
       signal?: AbortSignal
+      onToken?: (token: string) => void
+      onStep?: (step: StepEvent) => Promise<void>
+      /** Extra tools to force into the LLM loadout (tests/evals). */
+      extraTools?: any[]
     }
   ): AsyncIterable<StreamChunk> {
     // Resolve from database with priority: explicit param → DB lookup → single user/agent
@@ -647,6 +746,9 @@ export class AgentLoop {
       mcpManager: this.mcpManager,
       userId,
       signal: config.signal,
+      onToken: config.onToken,
+      onStep: config.onStep,
+      extraTools: config.extraTools,
     })
   }
 

package/packages/core/src/agent/context-compiler.ts

@@ -183,6 +183,12 @@ export async function compileContext(opts: {
             // Sanitized name valid for all LLM providers (no spaces, max 64 chars)
             const fullName = mcpToolFullName(server.name, mcpTool.name)
 
+            // Skip tools whose sanitized name is empty or fails provider validation
+            if (!fullName || !/^[a-zA-Z0-9_-]{1,64}$/.test(fullName)) {
+              log.warn(`[context-compiler] Skipping MCP tool with unsupported name: "${mcpTool.name}" (server: ${server.name}, sanitized: "${fullName}")`)
+              continue
+            }
+
             // Executor for agent-loop (has the real call)
             mcpToolExecutors.push({
               name: fullName,

package/packages/core/src/agent/llm-client.ts

@@ -24,6 +24,9 @@ import { KimiProvider } from "./llm-providers/kimi"
 import { LocalLlamaProvider } from "./llm-providers/local-llama"
 import { NvidiaProvider } from "./llm-providers/nvidia"
 import { QwenProvider } from "./llm-providers/qwen"
+import { MiniMaxProvider } from "./llm-providers/minimax"
+import { OpenCodeGoProvider } from "./llm-providers/opencode-go"
+import { HiveAgentsProvider } from "./llm-providers/hiveagents"
 import type { LLMProvider } from "./llm-providers/interface"
 
 const log = logger.child("llm-client")
@@ -109,6 +112,9 @@ function getProvider(provider: string): LLMProvider {
     case "local-llama": return new LocalLlamaProvider()
     case "nvidia":      return new NvidiaProvider()
     case "qwen":        return new QwenProvider()
+    case "minimax":     return new MiniMaxProvider()
+    case "opencode-go": return new OpenCodeGoProvider()
+    case "hiveagents":  return new HiveAgentsProvider()
     default:
       log.warn(`[llm-client] Unknown provider "${provider}" — falling back to OpenAI-compatible endpoint`)
       return new OpenAIProvider()

package/packages/core/src/agent/llm-providers/anthropic.ts

@@ -1,4 +1,5 @@
 import { logger } from "../../utils/logger"
+import { normalizeToolName } from "./interface"
 import type { LLMCallOptions, LLMProvider, LLMResponse, LLMToolCall } from "./interface"
 import type { ContentPart, LLMMessage } from "../llm-client"
 
@@ -55,6 +56,10 @@ export class AnthropicProvider implements LLMProvider {
     const Anthropic = await import("@anthropic-ai/sdk")
     const client = new Anthropic.default({ apiKey: options.apiKey })
 
+    // Anthropic requires tool names to match ^[a-zA-Z0-9_-]{1,128}$
+    // Native Hive tools use dots (e.g. cron.create) which violate this.
+    const toolNameMap = new Map<string, string>() // wireName -> originalName
+
     const systemText = options.messages
       .filter((m) => m.role === "system")
       .map((m) => m.content)
@@ -82,7 +87,9 @@ export class AnthropicProvider implements LLMProvider {
         for (const tc of msg.tool_calls) {
           let input: Record<string, unknown>
           try { input = JSON.parse(tc.function.arguments || "{}") } catch { input = {} }
-          content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input })
+          const wireName = normalizeToolName(tc.function.name, "_")
+          if (wireName !== tc.function.name) toolNameMap.set(wireName, tc.function.name)
+          content.push({ type: "tool_use", id: tc.id, name: wireName, input })
         }
         anthropicMessages.push({ role: "assistant", content })
         continue
@@ -91,11 +98,16 @@ export class AnthropicProvider implements LLMProvider {
       anthropicMessages.push({ role: msg.role, content: Array.isArray(msg.content) ? this._convertUserContent(msg) : msg.content })
     }
 
-    const tools: any[] = (options.tools ?? []).map((t) => ({
-      name: t.function.name,
-      description: t.function.description,
-      input_schema: t.function.parameters,
-    }))
+    const tools: any[] = (options.tools ?? []).map((t) => {
+      const originalName = t.function.name
+      const wireName = normalizeToolName(originalName, "_")
+      if (wireName !== originalName) toolNameMap.set(wireName, originalName)
+      return {
+        name: wireName,
+        description: t.function.description,
+        input_schema: t.function.parameters,
+      }
+    })
 
     const body: any = {
       model: options.model,
@@ -132,7 +144,9 @@ export class AnthropicProvider implements LLMProvider {
       for await (const event of stream) {
         if (event.type === "content_block_start") {
           if (event.content_block.type === "tool_use") {
-            toolMeta[event.index] = { id: event.content_block.id, name: event.content_block.name }
+            const wireName = event.content_block.name
+            const originalName = toolNameMap.get(wireName) ?? wireName
+            toolMeta[event.index] = { id: event.content_block.id, name: originalName }
             partialInputs[event.index] = ""
           }
         } else if (event.type === "content_block_delta") {
@@ -187,10 +201,11 @@ export class AnthropicProvider implements LLMProvider {
       if (block.type === "tool_use") {
         let args: string
         try { args = JSON.stringify(block.input) } catch { args = "{}" }
+        const originalName = toolNameMap.get(block.name) ?? block.name
         tool_calls.push({
           id: block.id,
           type: "function",
-          function: { name: block.name, arguments: args },
+          function: { name: originalName, arguments: args },
         })
       }
     }

package/packages/core/src/agent/llm-providers/hiveagents.ts

@@ -0,0 +1,248 @@
+import { logger } from "../../utils/logger"
+import { OpenAICompatBase } from "./openai-compat-base"
+import type { LLMCallOptions, LLMResponse } from "./interface"
+
+const log = logger.child("llm-client")
+
+const DEFAULT_BASE = "https://llm.hiveagents.io"
+
+/** Contexto por defecto que se solicita al backend de HiveAgents al cargar un modelo. */
+export const HIVEAGENTS_DEFAULT_LOAD_CTX = 50000
+
+// Cloudflare blocks requests with the OpenAI SDK User-Agent and x-stainless-* fingerprint headers.
+const BLOCKED_HEADERS = [
+  "user-agent",
+  "x-stainless-lang",
+  "x-stainless-package-version",
+  "x-stainless-runtime",
+  "x-stainless-runtime-version",
+  "x-stainless-arch",
+  "x-stainless-os",
+]
+
+export interface HiveAgentsLoadResult {
+  success: boolean
+  loading?: boolean
+  error?: string
+}
+
+export interface HiveAgentsStatusResult {
+  loaded: boolean
+  model?: { name?: string; ctx?: number; n_ctx?: number }
+}
+
+function getApiBase(baseUrl?: string): string {
+  return (baseUrl?.replace(/\/v1\/?$/, "") || DEFAULT_BASE)
+}
+
+function getAuthHeaders(apiKey: string): Record<string, string> {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  }
+}
+
+/**
+ * Solicita la carga de un modelo GGUF en el backend de HiveAgents.
+ * Siempre pide ctx=HIVEAGENTS_LOAD_CTX para maximizar la ventana de contexto disponible.
+ */
+/** Timeout para la petición de carga. Menor al límite de Cloudflare (100s) para evitar 524. */
+const HIVEAGENTS_LOAD_FETCH_TIMEOUT_MS = 90000
+
+export async function loadHiveAgentsModel(
+  modelId: string,
+  apiKey: string,
+  baseUrl?: string,
+  ctx = HIVEAGENTS_DEFAULT_LOAD_CTX
+): Promise<HiveAgentsLoadResult> {
+  const apiBase = getApiBase(baseUrl)
+  const headers = getAuthHeaders(apiKey)
+  const loadBody = {
+    model: modelId,
+    config: { ctx },
+  }
+
+  try {
+    log.info(`[hiveagents] → POST ${apiBase}/api/load`)
+    log.info(`[hiveagents] → Body: ${JSON.stringify(loadBody)}`)
+    const res = await fetch(`${apiBase}/api/load`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(loadBody),
+      signal: AbortSignal.timeout(HIVEAGENTS_LOAD_FETCH_TIMEOUT_MS),
+    })
+    const responseText = await res.text().catch(() => "")
+    if (!res.ok) {
+      // 524 = Cloudflare timeout. El backend puede seguir cargando, así que lo tratamos como "en progreso".
+      // 530 = Cloudflare Tunnel error (origen no resoluble); también puede ser transitorio.
+      const isTransientCloudflareError = [502, 503, 504, 524, 530].includes(res.status)
+      if (isTransientCloudflareError) {
+        log.warn(`[hiveagents] ← Load request hit transient error (HTTP ${res.status}); backend may still be loading`)
+        return { success: true, loading: true }
+      }
+      log.error(`[hiveagents] ← Load failed: HTTP ${res.status} ${res.statusText} — ${responseText}`)
+      return { success: false, error: `Load failed: HTTP ${res.status} — ${responseText || res.statusText}` }
+    }
+    log.info(`[hiveagents] ← Load accepted: ${responseText}`)
+    return { success: true }
+  } catch (err) {
+    const msg = (err as Error).message || ""
+    // AbortError por timeout interno: el backend puede seguir cargando.
+    if (msg.includes("timed out") || msg.includes("abort") || msg.includes("AbortError")) {
+      log.warn(`[hiveagents] ← Load request timed out after ${HIVEAGENTS_LOAD_FETCH_TIMEOUT_MS}ms; backend may still be loading`)
+      return { success: true, loading: true }
+    }
+    return { success: false, error: msg }
+  }
+}
+
+/**
+ * Consulta el estado actual del backend de HiveAgents.
+ */
+export async function getHiveAgentsModelStatus(
+  apiKey: string,
+  baseUrl?: string
+): Promise<HiveAgentsStatusResult> {
+  const apiBase = getApiBase(baseUrl)
+  const headers = getAuthHeaders(apiKey)
+
+  try {
+    const res = await fetch(`${apiBase}/api/status`, { headers })
+    if (!res.ok) return { loaded: false }
+    const data = await res.json() as any
+    return {
+      loaded: !!data.loaded,
+      model: data.model,
+    }
+  } catch {
+    return { loaded: false }
+  }
+}
+
+export class HiveAgentsProvider extends OpenAICompatBase {
+  private _currentModelId = ""
+
+  constructor() { super("hiveagents") }
+
+  private _isGemma4(modelId: string): boolean { return /^gemma-?4/i.test(modelId) }
+  private _isQwen3(modelId: string): boolean { return /^qwen3?/i.test(modelId) }
+
+  // Cloudflare WAF blocks requests carrying x-stainless-* headers from the OpenAI SDK.
+  // Strip them via a custom fetch wrapper so they never reach the WAF.
+  protected async resolveOpenAIClient(apiKey: string, baseURL: string | undefined): Promise<any> {
+    const { default: OpenAI } = await import("openai")
+    return new OpenAI({
+      apiKey,
+      baseURL,
+      fetch: async (url: RequestInfo | URL, init?: RequestInit) => {
+        const headers = new Headers(init?.headers as HeadersInit | undefined)
+        for (const h of BLOCKED_HEADERS) headers.delete(h)
+
+        // Debug: log exact request so we can replicate with curl
+        const headersObj: Record<string, string> = {}
+        headers.forEach((v, k) => { headersObj[k] = k.toLowerCase() === "authorization" ? `Bearer ••••${v.slice(-6)}` : v })
+        log.info(`[hiveagents] → POST ${url}`)
+        log.info(`[hiveagents] → Headers: ${JSON.stringify(headersObj)}`)
+        if (init?.body) {
+          try {
+            const parsed = JSON.parse(init.body as string)
+            const summary = { model: parsed.model, messages: parsed.messages?.length, tools: parsed.tools?.length, max_tokens: parsed.max_tokens, temperature: parsed.temperature, tool_choice: parsed.tool_choice, extra_body: parsed.extra_body }
+            log.info(`[hiveagents] → Body summary: ${JSON.stringify(summary)}`)
+          } catch { /* ignore */ }
+        }
+
+        const res = await fetch(url, { ...init, headers })
+        log.info(`[hiveagents] ← Response: ${res.status} ${res.statusText}`)
+        return res
+      },
+    })
+  }
+
+  async call(options: LLMCallOptions): Promise<LLMResponse> {
+    const realModelId = options.model.replace(/^hiveagents\//i, "")
+    if (realModelId && realModelId !== "local") {
+      await this._ensureModelLoaded(realModelId, options)
+    }
+    this._currentModelId = realModelId
+
+    let callOptions = { ...options, model: "hiveagents/local" }
+
+    // Qwen3: inject /no_think when thinking is explicitly disabled
+    if (this._isQwen3(realModelId) && options.thinking?.enabled === false) {
+      const msgs = callOptions.messages.map(m => ({ ...m }))
+      const sysMsg = msgs.find(m => m.role === "system")
+      if (sysMsg && typeof sysMsg.content === "string") {
+        if (!sysMsg.content.startsWith("/no_think"))
+          sysMsg.content = "/no_think\n" + sysMsg.content
+      } else {
+        msgs.unshift({ role: "system", content: "/no_think" })
+      }
+      callOptions = { ...callOptions, messages: msgs }
+    }
+
+    return super.call(callOptions)
+  }
+
+  // Gemma 4: inject chat_template_kwargs.enable_thinking via extra_body.
+  // Default is true (thinking ON) when options.thinking is not set.
+  protected modifyRequestBody(body: any, options: LLMCallOptions): any {
+    if (this._isGemma4(this._currentModelId)) {
+      const enableThinking = options.thinking?.enabled !== false
+      body.extra_body = {
+        ...(body.extra_body ?? {}),
+        chat_template_kwargs: { enable_thinking: enableThinking },
+      }
+    }
+    return body
+  }
+
+  /**
+   * Fallback defensivo: si la UI no cargó el modelo previamente,
+   * lo intenta cargar justo antes de inferir.
+   */
+  private async _ensureModelLoaded(modelId: string, options: LLMCallOptions): Promise<void> {
+    const status = await getHiveAgentsModelStatus(options.apiKey, options.baseUrl)
+    if (status.loaded && status.model?.name === modelId) {
+      log.info(`[hiveagents] Model ${modelId} already loaded`)
+      return
+    }
+    log.warn(`[hiveagents] Model ${modelId} not loaded. Triggering load with ctx=${HIVEAGENTS_DEFAULT_LOAD_CTX}`)
+    const result = await loadHiveAgentsModel(modelId, options.apiKey, options.baseUrl)
+    if (!result.success) {
+      log.warn(`[hiveagents] Auto-load failed for ${modelId}: ${result.error}`)
+    }
+  }
+
+  protected injectToolsIntoPrompt(body: any, preparedTools: any[]): void {
+    // When the backend already receives native OpenAI-style tools, do not confuse
+    // the model with an alternate <tool_call> text format. HiveAgents supports
+    // native tool_calls when the model/chat-template supports them.
+    if (body.tools && body.tools.length > 0) {
+      return
+    }
+
+    // Fallback for models/backends that do not expose native tool calling:
+    // inject the tool descriptions as text and instruct the model to emit
+    // a single JSON block wrapped in <tool_call> tags.
+    const toolDescriptions = preparedTools.map(t => JSON.stringify(t.function)).join("\n")
+    const instruction = [
+      "You have access to the following tools.",
+      "When you need to use a tool, output EXACTLY one JSON block wrapped in <tool_call> tags and NOTHING ELSE in that turn:",
+      "",
+      "<tool_call>",
+      '{"name": "browser_navigate", "arguments": {"url": "https://example.com"}}',
+      "</tool_call>",
+      "",
+      "Use the exact tool name and argument names from the list below. Do not add extra text, markdown, or explanations inside the tool_call block.",
+      "",
+      "Tools:",
+      toolDescriptions,
+    ].join("\n")
+    const sysMsg = body.messages.find((m: any) => m.role === "system")
+    if (sysMsg) {
+      sysMsg.content += "\n\n" + instruction
+    } else {
+      body.messages.unshift({ role: "system", content: instruction })
+    }
+  }
+}

package/packages/core/src/agent/llm-providers/interface.ts

@@ -27,7 +27,10 @@ export const OPENAI_COMPAT_BASE_URLS: Record<string, string> = {
   kimi: "https://api.moonshot.ai/v1",
   "local-llama": "http://localhost:8081/v1",
   nvidia: "https://integrate.api.nvidia.com/v1",
-  qwen: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+  qwen: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+  minimax: "https://api.minimaxi.com/v1",
+  "opencode-go": "https://opencode.ai/zen/go/v1",
+  hiveagents: "https://llm.hiveagents.io/v1",
 }
 
 // ─── Provider profiles ────────────────────────────────────────────────────────
@@ -66,6 +69,9 @@ export const PROVIDER_PROFILES: Record<string, ProviderProfile> = {
   nvidia: { ...DEFAULT_PROFILE, normalizeToolNames: true },
   qwen: { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
   "local-llama": { ...DEFAULT_PROFILE },
+  minimax: { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
+  "opencode-go": { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
+  hiveagents: { ...DEFAULT_PROFILE, retryWithoutToolsOnCodes: [400, 422] },
 }
 
 export function getProviderProfile(provider: string): ProviderProfile {

package/packages/core/src/agent/llm-providers/minimax.ts

@@ -0,0 +1,13 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class MiniMaxProvider extends OpenAICompatBase {
+  static readonly secretKey = "MINIMAX_API_KEY"
+
+  constructor() {
+    super("minimax")
+  }
+
+  protected needsReasoningRoundtrip(): boolean {
+    return true
+  }
+}