@johpaz/hive-sdk 0.1.4 → 0.1.5

package/packages/core/src/agent/{providers → llm-providers}/gemini.ts

@@ -1,10 +1,73 @@
-import { logger } from "../../utils/logger.ts"
-import { sanitizeMessages } from "./interface"
+import { logger } from "../../utils/logger"
+import { sanitizeMessages, resolveMaxTokens, ensureArrayItems } from "./interface"
 import type { LLMCallOptions, LLMProvider, LLMResponse, LLMToolCall } from "./interface"
-import type { ContentPart, LLMMessage } from "./LLMClient.ts"
+import type { ContentPart, LLMMessage } from "../llm-client"
 
 const log = logger.child("llm-client")
 
+/** Re-applies Gemini's structural invariants (INV-1/2/3) in place — needed both on the initial build and after compacting `contents` for a context-overflow retry. */
+function enforceGeminiConstraints(contents: any[]): void {
+  while (contents.length > 0 && contents[0].role === "model") {
+    log.warn(`[llm-client] Gemini: removed leading model turn (no preceding user turn)`)
+    contents.shift()
+  }
+
+  let changed = true
+  let safetyLimit = 10
+  while (changed && safetyLimit-- > 0) {
+    changed = false
+
+    for (let i = 0; i < contents.length; i++) {
+      const turn = contents[i]
+      const prev = i > 0 ? contents[i - 1] : null
+
+      // INV-3: merge consecutive model turns
+      if (turn.role === "model" && prev?.role === "model") {
+        prev.parts.push(...(turn.parts ?? []))
+        contents.splice(i, 1)
+        i--
+        changed = true
+        continue
+      }
+
+      // INV-1: model(fc) must come after user
+      if (turn.role === "model") {
+        const hasFc = turn.parts?.some((p: any) => p.functionCall)
+        if (hasFc && prev?.role !== "user") {
+          turn.parts = (turn.parts ?? []).filter((p: any) => !p.functionCall)
+          log.warn(`[llm-client] Gemini: stripped functionCall not after user turn (i=${i})`)
+          if (turn.parts.length === 0) { contents.splice(i, 1); i-- }
+          changed = true
+          continue
+        }
+      }
+
+      // INV-2: user(fr) must come after model(fc)
+      if (turn.role === "user") {
+        const hasFr = turn.parts?.some((p: any) => p.functionResponse)
+        const prevHasFc = prev?.role === "model" && prev?.parts?.some((p: any) => p.functionCall)
+        if (hasFr && !prevHasFc) {
+          turn.parts = (turn.parts ?? []).filter((p: any) => !p.functionResponse)
+          log.warn(`[llm-client] Gemini: stripped orphaned functionResponse (i=${i})`)
+          if (turn.parts.length === 0) { contents.splice(i, 1); i-- }
+          changed = true
+          continue
+        }
+      }
+    }
+  }
+
+  if (safetyLimit <= 0) {
+    log.error(`[llm-client] Gemini: constraint enforcement loop exhausted — message history may still violate Gemini constraints`)
+  }
+}
+
+/** Best-effort heuristic — Gemini has no structured error code for context overflow like llama.cpp's n_ctx. */
+function isGeminiContextOverflowError(err: any): boolean {
+  const msg = (err?.message ?? String(err) ?? "").toLowerCase()
+  return msg.includes("token") && (msg.includes("exceed") || msg.includes("too long") || msg.includes("maximum"))
+}
+
 export class GeminiProvider implements LLMProvider {
   private _convertContentPart(part: ContentPart): any {
     switch (part.type) {
@@ -90,78 +153,43 @@ export class GeminiProvider implements LLMProvider {
 
     // Gemini constraint enforcement
     const contents: any[] = rawContents
-
-    while (contents.length > 0 && contents[0].role === "model") {
-      log.warn(`[llm-client] Gemini: removed leading model turn (no preceding user turn)`)
-      contents.shift()
-    }
-
-    let changed = true
-    let safetyLimit = 10
-    while (changed && safetyLimit-- > 0) {
-      changed = false
-
-      for (let i = 0; i < contents.length; i++) {
-        const turn = contents[i]
-        const prev = i > 0 ? contents[i - 1] : null
-
-        // INV-3: merge consecutive model turns
-        if (turn.role === "model" && prev?.role === "model") {
-          prev.parts.push(...(turn.parts ?? []))
-          contents.splice(i, 1)
-          i--
-          changed = true
-          continue
-        }
-
-        // INV-1: model(fc) must come after user
-        if (turn.role === "model") {
-          const hasFc = turn.parts?.some((p: any) => p.functionCall)
-          if (hasFc && prev?.role !== "user") {
-            turn.parts = (turn.parts ?? []).filter((p: any) => !p.functionCall)
-            log.warn(`[llm-client] Gemini: stripped functionCall not after user turn (i=${i})`)
-            if (turn.parts.length === 0) { contents.splice(i, 1); i-- }
-            changed = true
-            continue
-          }
-        }
-
-        // INV-2: user(fr) must come after model(fc)
-        if (turn.role === "user") {
-          const hasFr = turn.parts?.some((p: any) => p.functionResponse)
-          const prevHasFc = prev?.role === "model" && prev?.parts?.some((p: any) => p.functionCall)
-          if (hasFr && !prevHasFc) {
-            turn.parts = (turn.parts ?? []).filter((p: any) => !p.functionResponse)
-            log.warn(`[llm-client] Gemini: stripped orphaned functionResponse (i=${i})`)
-            if (turn.parts.length === 0) { contents.splice(i, 1); i-- }
-            changed = true
-            continue
-          }
-        }
-      }
-    }
-
-    if (safetyLimit <= 0) {
-      log.error(`[llm-client] Gemini: constraint enforcement loop exhausted — message history may still violate Gemini constraints`)
-    }
+    enforceGeminiConstraints(contents)
 
     const config: any = {}
     if (systemText) config.systemInstruction = systemText
-    if (options.maxTokens) config.maxOutputTokens = options.maxTokens
+    const maxTokens = resolveMaxTokens(options.maxTokens, options.contextWindow)
+    if (maxTokens) config.maxOutputTokens = maxTokens
     if (options.temperature !== undefined) config.temperature = options.temperature
+    if (options.thinking?.enabled) config.thinkingConfig = { includeThoughts: true }
+    if (options.signal) config.abortSignal = options.signal
     if (options.tools?.length) {
       config.tools = [{
         functionDeclarations: options.tools.map((t) => ({
           name: t.function.name,
           description: t.function.description,
-          parameters: t.function.parameters,
+          parameters: ensureArrayItems(t.function.parameters),
         })),
       }]
     }
 
     log.info(`[llm-client] gemini/${options.model} — ${contents.length} turns, ${options.tools?.length ?? 0} tools`)
 
-    const response = await ai.models.generateContent({ model: options.model, contents, config })
+    let response
+    try {
+      response = await ai.models.generateContent({ model: options.model, contents, config })
+    } catch (err: any) {
+      if (!isGeminiContextOverflowError(err)) throw err
+      log.warn(`[llm-client] gemini: context overflow — compacting turns and retrying`)
+      const originalCount = contents.length
+      // Keep only the last ~33% of turns, then re-apply the structural invariants
+      // (compacting can orphan a functionCall/functionResponse pairing).
+      const keepRatio = Math.max(1, Math.floor(contents.length / 3))
+      contents.splice(0, contents.length - keepRatio)
+      enforceGeminiConstraints(contents)
+      if (config.maxOutputTokens) config.maxOutputTokens = Math.min(config.maxOutputTokens, 4096)
+      log.info(`[llm-client] gemini: compacted ${originalCount} turns → ${contents.length} turns, maxOutputTokens=${config.maxOutputTokens}`)
+      response = await ai.models.generateContent({ model: options.model, contents, config })
+    }
 
     const candidate = response.candidates?.[0]
 
@@ -181,9 +209,14 @@ export class GeminiProvider implements LLMProvider {
     const parts: any[] = candidate?.content?.parts ?? []
 
     let content = ""
+    let reasoning_content = ""
     const tool_calls: LLMToolCall[] = []
 
     for (const part of parts) {
+      if (part.thought && part.text) {
+        reasoning_content += part.text
+        continue
+      }
       if (part.text) content += part.text
       if (part.functionCall) {
         tool_calls.push({
@@ -200,9 +233,14 @@ export class GeminiProvider implements LLMProvider {
         : candidate?.finishReason === "MAX_TOKENS" ? "max_tokens"
           : "stop"
 
+    // Gemini has no streaming path (generateContent, not generateContentStream),
+    // so any thought content only arrives here — emit it as a single chunk.
+    if (reasoning_content) options.onReasoningToken?.(reasoning_content)
+
     const usageMeta = response.usageMetadata
     return {
       content,
+      reasoning_content: reasoning_content || undefined,
       tool_calls: tool_calls.length ? tool_calls : undefined,
       stop_reason,
       usage: usageMeta ? {

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

@@ -0,0 +1,5 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class GroqProvider extends OpenAICompatBase {
+  constructor() { super("groq") }
+}

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

@@ -0,0 +1,253 @@
+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. */
+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) }
+  private _isAgentWorld(modelId: string): boolean { return /agentworld/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 and Qwen-AgentWorld: 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) || this._isAgentWorld(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
+    }
+    // The model's own context_window (BD, via resolveProviderConfig) is the source
+    // of truth for how much context to request when mounting it — only fall back
+    // to the generic default when it's genuinely unavailable.
+    const ctx = options.contextWindow || HIVEAGENTS_DEFAULT_LOAD_CTX
+    log.warn(`[hiveagents] Model ${modelId} not loaded. Triggering load with ctx=${ctx}`)
+    const result = await loadHiveAgentsModel(modelId, options.apiKey, options.baseUrl, ctx)
+    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/{providers → llm-providers}/interface.ts

@@ -2,10 +2,10 @@
  * Shared types and utilities for LLM providers.
  */
 
-import type { LLMCallOptions, LLMMessage, LLMResponse, LLMToolCall, ContentPart } from "./LLMClient.ts"
-export type { LLMCallOptions, LLMMessage, LLMResponse, LLMToolCall, ContentPart }
+import type { LLMCallOptions, LLMMessage, LLMResponse, LLMToolCall, ContentPart, ThinkingBlock } from "../llm-client"
+export type { LLMCallOptions, LLMMessage, LLMResponse, LLMToolCall, ContentPart, ThinkingBlock }
 
-import { logger } from "../../utils/logger.ts"
+import { logger } from "../../utils/logger"
 const log = logger.child("llm-client")
 
 // ─── Provider interface ────────────────────────────────────────────────────────
@@ -17,7 +17,7 @@ export interface LLMProvider {
 // ─── Shared constants ─────────────────────────────────────────────────────────
 
 // Models that only accept temperature=1 (reasoning/thinking models).
-export const FIXED_TEMPERATURE_1_MODELS = new Set(["kimi-k2.5", "kimi-k2", "kimi-k2-5"])
+const FIXED_TEMPERATURE_1_MODELS = new Set(["kimi-k2.5", "kimi-k2", "kimi-k2-5"])
 
 export const OPENAI_COMPAT_BASE_URLS: Record<string, string> = {
   groq: "https://api.groq.com/openai/v1",
@@ -25,9 +25,16 @@ export const OPENAI_COMPAT_BASE_URLS: Record<string, string> = {
   openrouter: "https://openrouter.ai/api/v1",
   deepseek: "https://api.deepseek.com/v1",
   kimi: "https://api.moonshot.ai/v1",
-  "local-llama": "http://localhost:8080/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",
+  "z-ai": "https://api.z.ai/api/paas/v4",
+  // OJO: `.ai`, no `.cn`. Son dos plataformas con cuentas y tokens distintos, y
+  // un token de la internacional da 401 contra el endpoint chino aunque el
+  // listado de modelos responda 200 en ambos (ese listado es público).
+  modelscope: "https://api-inference.modelscope.ai/v1",
 }
 
 // ─── Provider profiles ────────────────────────────────────────────────────────
@@ -56,16 +63,24 @@ const DEFAULT_PROFILE: ProviderProfile = {
   retryWithoutToolsOnCodes: [],
 }
 
-export const PROVIDER_PROFILES: Record<string, ProviderProfile> = {
+const PROVIDER_PROFILES: Record<string, ProviderProfile> = {
   openai: { ...DEFAULT_PROFILE, normalizeToolNames: true },
   kimi: { ...DEFAULT_PROFILE, normalizeToolNames: true, disableParallelToolCalls: true, retryWithoutToolsOnCodes: [422] },
   deepseek: { ...DEFAULT_PROFILE, normalizeToolNames: true },
   groq: { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
-  mistral: { ...DEFAULT_PROFILE, normalizeToolNames: true, toolChoiceAuto: "any", stripAdditionalProperties: true },
+  // tool_choice "any" *forces* a tool call on every request per docs.mistral.ai —
+  // it is not Mistral's spelling of "auto", which Mistral supports and defaults to.
+  // With "any" the agent could never answer in plain text: every turn had to end
+  // in a tool call, so the loop only stopped when it hit max iterations.
+  mistral: { ...DEFAULT_PROFILE, normalizeToolNames: true, stripAdditionalProperties: true },
   openrouter: { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
-  nvidia: { ...DEFAULT_PROFILE, normalizeToolNames: true },
+  nvidia: { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
+  "z-ai": { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
+  modelscope: { ...DEFAULT_PROFILE, normalizeToolNames: true, retryWithoutToolsOnCodes: [400, 422] },
   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 {
@@ -74,7 +89,7 @@ export function getProviderProfile(provider: string): ProviderProfile {
 
 // ─── Models that don't support tool calling ───────────────────────────────────
 
-export const NO_TOOL_MODELS = new Set([
+const NO_TOOL_MODELS = new Set([
   "deepseek-reasoner",
   "deepseek/deepseek-r1:free",
 ])
@@ -106,8 +121,34 @@ export function normalizeToolSchema(
   schema: Record<string, unknown>,
   profile: ProviderProfile
 ): Record<string, unknown> {
-  if (!profile.stripAdditionalProperties) return schema
-  return deepStripSchema(schema)
+  const withItems = ensureArrayItems(schema)
+  if (!profile.stripAdditionalProperties) return withItems
+  return deepStripSchema(withItems)
+}
+
+/**
+ * Recursively ensures every `{ type: "array" }` node in a JSON Schema has an
+ * `items` sub-schema. `items` is optional per the JSON Schema spec, but some
+ * providers' function-calling validators (Gemini in particular) reject arrays
+ * without one — found via a real Gemini call rejecting a tool with a bare
+ * `datos: { type: "array" }` field. An empty `{}` items schema (accept
+ * anything) is always a safe, permissive default, so this runs unconditionally
+ * for every provider, not just ones with a matching profile flag — the same
+ * schema bug in an MCP-provided tool (outside hive's control) would break the
+ * exact same way, so this has to protect the wire path, not just hive's own
+ * tool definitions.
+ */
+export function ensureArrayItems(obj: unknown): any {
+  if (typeof obj !== "object" || obj === null) return obj
+  if (Array.isArray(obj)) return obj.map(ensureArrayItems)
+  const result: any = {}
+  for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+    result[k] = ensureArrayItems(v)
+  }
+  if (result.type === "array" && !result.items) {
+    result.items = {}
+  }
+  return result
 }
 
 function deepStripSchema(obj: unknown): any {
@@ -121,6 +162,25 @@ function deepStripSchema(obj: unknown): any {
   return result
 }
 
+// ─── Output token budget ───────────────────────────────────────────────────────
+
+const OUTPUT_RESERVE_RATIO = 0.15
+const MAX_OUTPUT_TOKENS_CEILING = 32768
+
+/**
+ * Derives the output token budget from the model's context_window (BD), reserving
+ * a fraction of it for generation. An explicit maxTokens always wins. The ceiling
+ * only guards against a misconfigured/absurd context_window — it must stay well
+ * above what any real seeded model's 15% reserve would produce (200k window → 30k),
+ * or every large-context model silently gets clamped to the same fixed number
+ * regardless of what's actually configured.
+ */
+export function resolveMaxTokens(explicitMaxTokens?: number, contextWindow?: number): number | undefined {
+  if (explicitMaxTokens) return explicitMaxTokens
+  if (!contextWindow) return undefined
+  return Math.min(MAX_OUTPUT_TOKENS_CEILING, Math.floor(contextWindow * OUTPUT_RESERVE_RATIO))
+}
+
 // ─── Temperature constraints ──────────────────────────────────────────────────
 
 /**

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

@@ -0,0 +1,8 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class KimiProvider extends OpenAICompatBase {
+  constructor() { super("kimi") }
+
+  /** Kimi K2 thinking mode returns reasoning_content that must be round-tripped. */
+  protected needsReasoningRoundtrip(): boolean { return true }
+}

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
+  }
+}

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

@@ -0,0 +1,5 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class MistralProvider extends OpenAICompatBase {
+  constructor() { super("mistral") }
+}

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

@@ -0,0 +1,5 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class ModelScopeProvider extends OpenAICompatBase {
+  constructor() { super("modelscope") }
+}

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

@@ -0,0 +1,5 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class NvidiaProvider extends OpenAICompatBase {
+  constructor() { super("nvidia") }
+}