@johpaz/hive-agents 0.0.35 → 0.0.36

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

@@ -0,0 +1,167 @@
+/**
+ * LLM client — direct official SDKs, no abstraction layers.
+ *
+ *   gemini / google  → native Gemini REST API (v1beta, ?key=)
+ *   anthropic        → @anthropic-ai/sdk
+ *   ollama           → ollama npm package
+ *   openai           → openai npm package
+ *   groq / mistral / openrouter / deepseek / kimi / local-llama / nvidia / qwen
+ *                    → openai npm package (OpenAI-compatible endpoint, per-provider adapter)
+ *
+ * Public interface (LLMMessage, callLLM, resolveProviderConfig) is stable.
+ */
+
+import { logger } from "../utils/logger"
+import { GeminiProvider } from "./llm-providers/gemini"
+import { AnthropicProvider } from "./llm-providers/anthropic"
+import { OllamaProvider } from "./llm-providers/ollama"
+import { OpenAIProvider } from "./llm-providers/openai"
+import { GroqProvider } from "./llm-providers/groq"
+import { MistralProvider } from "./llm-providers/mistral"
+import { OpenRouterProvider } from "./llm-providers/openrouter"
+import { DeepSeekProvider } from "./llm-providers/deepseek"
+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 type { LLMProvider } from "./llm-providers/interface"
+
+const log = logger.child("llm-client")
+
+// ─── Canonical types ───────────────────────────────────────────────────────────
+
+export interface LLMToolCall {
+  id: string
+  type: "function"
+  function: { name: string; arguments: string }
+  /** Gemini 3.x thought signature — must be round-tripped for tool-calling. */
+  thought_signature?: string
+}
+
+export type ContentPart =
+  | { type: "text"; text: string }
+  | { type: "image_url"; image_url: { url: string } }
+  | { type: "image_base64"; base64: string; mimeType: string }
+  | { type: "document"; base64: string; mimeType: string; fileName?: string }
+
+export interface LLMMessage {
+  role: "system" | "user" | "assistant" | "tool"
+  content: string | ContentPart[]
+  tool_calls?: LLMToolCall[]
+  tool_call_id?: string
+  name?: string
+  /** Kimi K2 thinking mode — must be round-tripped when tool calls are present. */
+  reasoning_content?: string
+}
+
+export interface LLMToolDef {
+  type: "function"
+  function: {
+    name: string
+    description: string
+    parameters: Record<string, unknown>
+  }
+}
+
+export interface LLMCallOptions {
+  provider: string
+  model: string
+  apiKey: string
+  baseUrl?: string
+  numCtx?: number
+  contextWindow?: number
+  messages: LLMMessage[]
+  tools?: LLMToolDef[]
+  temperature?: number
+  maxTokens?: number
+  numGpu?: number
+  onToken?: (token: string) => void
+  signal?: AbortSignal
+  /** Enable extended thinking for supported models (Anthropic Claude 3.7+). */
+  thinking?: { enabled: boolean; budget_tokens?: number }
+}
+
+export interface LLMResponse {
+  content: string
+  tool_calls?: LLMToolCall[]
+  stop_reason: "stop" | "tool_calls" | "max_tokens" | "error"
+  usage?: { input_tokens: number; output_tokens: number; thinking_tokens?: number }
+  /** Kimi K2 / DeepSeek thinking mode — must be round-tripped in assistant messages. */
+  reasoning_content?: string
+  /** Anthropic extended thinking content (not sent to LLM, for display only). */
+  thinking_content?: string
+}
+
+// ─── Provider factory ─────────────────────────────────────────────────────────
+
+function getProvider(provider: string): LLMProvider {
+  switch (provider) {
+    case "gemini":
+    case "google":      return new GeminiProvider()
+    case "anthropic":   return new AnthropicProvider()
+    case "ollama":      return new OllamaProvider()
+    case "openai":      return new OpenAIProvider()
+    case "groq":        return new GroqProvider()
+    case "mistral":     return new MistralProvider()
+    case "openrouter":  return new OpenRouterProvider()
+    case "deepseek":    return new DeepSeekProvider()
+    case "kimi":        return new KimiProvider()
+    case "local-llama": return new LocalLlamaProvider()
+    case "nvidia":      return new NvidiaProvider()
+    case "qwen":        return new QwenProvider()
+    default:
+      log.warn(`[llm-client] Unknown provider "${provider}" — falling back to OpenAI-compatible endpoint`)
+      return new OpenAIProvider()
+  }
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Call any LLM provider. Returns a canonical LLMResponse regardless of provider.
+ */
+export async function callLLM(options: LLMCallOptions): Promise<LLMResponse> {
+  try {
+    return await getProvider(options.provider).call(options)
+  } catch (err) {
+    const msg = (err as Error).message
+    const cleanModel = options.model.replace(new RegExp(`^${options.provider}\\/`), "")
+    log.error(`[llm-client] Error calling ${options.provider}/${cleanModel}: ${msg}`, err)
+    return { content: `[LLM Error] ${msg}`, stop_reason: "error" }
+  }
+}
+
+/**
+ * Resolve provider config from DB (decrypts API key).
+ */
+export async function resolveProviderConfig(
+  providerId: string,
+  modelId: string
+): Promise<Pick<LLMCallOptions, "provider" | "model" | "apiKey" | "baseUrl" | "numCtx" | "numGpu" | "contextWindow">> {
+  const { getDb } = await import("../storage/sqlite")
+  const { loadProviderApiKey } = await import("../storage/crypto")
+  const db = getDb()
+  const providerRow = db
+    .query<any, [string]>("SELECT * FROM providers WHERE id = ? AND enabled = 1")
+    .get(providerId)
+
+  // Load model's context window for token budget management
+  const modelRow = db
+    .query<any, [string]>("SELECT context_window FROM models WHERE id = ?")
+    .get(modelId)
+
+  let apiKey = await loadProviderApiKey(providerId)
+  if (!apiKey) {
+    apiKey = process.env[`${providerId.toUpperCase()}_API_KEY`] || ""
+  }
+
+  return {
+    provider: providerId,
+    model: modelId,
+    apiKey,
+    baseUrl: providerRow?.base_url || undefined,
+    numCtx: providerRow?.num_ctx ?? undefined,
+    numGpu: providerRow?.num_gpu ?? undefined,
+    contextWindow: modelRow?.context_window ?? undefined,
+  }
+}

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

@@ -0,0 +1,212 @@
+import { logger } from "../../utils/logger"
+import type { LLMCallOptions, LLMProvider, LLMResponse, LLMToolCall } from "./interface"
+import type { ContentPart, LLMMessage } from "../llm-client"
+
+const log = logger.child("llm-client")
+
+// Models that support extended thinking (claude-3-7+ and claude-4.x).
+const THINKING_CAPABLE_MODELS = new Set([
+  "claude-3-7-sonnet-20250219",
+  "claude-sonnet-4-5",
+  "claude-sonnet-4-6",
+  "claude-opus-4-5",
+  "claude-opus-4-6",
+  "claude-opus-4-7",
+  "claude-haiku-4-5",
+  "claude-haiku-4-5-20251001",
+])
+
+function supportsThinking(model: string): boolean {
+  if (THINKING_CAPABLE_MODELS.has(model)) return true
+  // Also match any claude-4.x or claude-3-7+ by prefix
+  return /^claude-(4|3-7)/.test(model)
+}
+
+export class AnthropicProvider implements LLMProvider {
+  private _convertContentPart(part: ContentPart): any {
+    switch (part.type) {
+      case "text":
+        return { type: "text", text: part.text }
+      case "image_url": {
+        const url = part.image_url.url
+        if (url.startsWith("data:")) {
+          const match = url.match(/^data:([^;]+);base64,(.+)$/)
+          if (match) return { type: "image", source: { type: "base64", media_type: match[1], data: match[2] } }
+        }
+        return { type: "image", source: { type: "url", url } }
+      }
+      case "image_base64":
+        return { type: "image", source: { type: "base64", media_type: part.mimeType, data: part.base64 } }
+      case "document":
+        return { type: "document", source: { type: "base64", media_type: part.mimeType, data: part.base64 } }
+      default:
+        return { type: "text", text: JSON.stringify(part) }
+    }
+  }
+
+  private _convertUserContent(msg: LLMMessage): any[] {
+    if (Array.isArray(msg.content)) {
+      return msg.content.map(p => this._convertContentPart(p))
+    }
+    return [{ type: "text", text: msg.content }]
+  }
+
+  async call(options: LLMCallOptions): Promise<LLMResponse> {
+    const Anthropic = await import("@anthropic-ai/sdk")
+    const client = new Anthropic.default({ apiKey: options.apiKey })
+
+    const systemText = options.messages
+      .filter((m) => m.role === "system")
+      .map((m) => m.content)
+      .join("\n\n")
+
+    const anthropicMessages: any[] = []
+
+    for (const msg of options.messages) {
+      if (msg.role === "system") continue
+
+      if (msg.role === "tool") {
+        const block = { type: "tool_result", tool_use_id: msg.tool_call_id, content: msg.content }
+        const last = anthropicMessages[anthropicMessages.length - 1]
+        if (last?.role === "user" && Array.isArray(last.content)) {
+          last.content.push(block)
+        } else {
+          anthropicMessages.push({ role: "user", content: [block] })
+        }
+        continue
+      }
+
+      if (msg.role === "assistant" && msg.tool_calls?.length) {
+        const content: any[] = []
+        if (msg.content) content.push({ type: "text", text: msg.content })
+        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 })
+        }
+        anthropicMessages.push({ role: "assistant", content })
+        continue
+      }
+
+      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 body: any = {
+      model: options.model,
+      max_tokens: options.maxTokens ?? 16384,
+      messages: anthropicMessages,
+    }
+    if (systemText) body.system = systemText
+    if (tools.length) body.tools = tools
+
+    // Extended thinking — only for supported models
+    const thinkingEnabled = options.thinking?.enabled && supportsThinking(options.model)
+    if (thinkingEnabled) {
+      body.thinking = { type: "enabled", budget_tokens: options.thinking?.budget_tokens ?? 10000 }
+    }
+
+    log.info(
+      `[llm-client] anthropic/${options.model} — ${anthropicMessages.length} msgs, ${tools.length} tools` +
+      (thinkingEnabled ? ` thinking=${body.thinking.budget_tokens}tok` : "")
+    )
+
+    let content = ""
+    let thinking_content = ""
+    const tool_calls: LLMToolCall[] = []
+
+    // Streaming via messages.stream()
+    const useStream = true  // Always stream for better UX
+    if (useStream) {
+      const stream = client.messages.stream({ ...body, ...(options.signal ? {} : {}) })
+
+      // Track partial tool inputs by index
+      const partialInputs: Record<number, string> = {}
+      const toolMeta: Record<number, { id: string; name: string }> = {}
+
+      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 }
+            partialInputs[event.index] = ""
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            content += event.delta.text
+            if (options.onToken) options.onToken(event.delta.text)
+          } else if (event.delta.type === "thinking_delta") {
+            thinking_content += event.delta.thinking
+          } else if (event.delta.type === "input_json_delta") {
+            if (partialInputs[event.index] !== undefined) {
+              partialInputs[event.index] += event.delta.partial_json
+            }
+          }
+        }
+      }
+
+      const finalMsg = await stream.finalMessage()
+
+      // Build tool_calls from accumulated partial inputs
+      for (const [idx, meta] of Object.entries(toolMeta)) {
+        const args = partialInputs[Number(idx)] ?? "{}"
+        tool_calls.push({
+          id: meta.id,
+          type: "function",
+          function: { name: meta.name, arguments: args },
+        })
+      }
+
+      const usage = finalMsg.usage
+      return {
+        content,
+        thinking_content: thinking_content || undefined,
+        tool_calls: tool_calls.length ? tool_calls : undefined,
+        stop_reason:
+          finalMsg.stop_reason === "tool_use" ? "tool_calls"
+            : finalMsg.stop_reason === "max_tokens" ? "max_tokens"
+              : "stop",
+        usage: {
+          input_tokens: usage.input_tokens,
+          output_tokens: usage.output_tokens,
+          thinking_tokens: (usage as any).thinking_tokens ?? 0,
+        },
+      }
+    }
+
+    // Non-streaming fallback (kept for reference, unreachable with useStream=true)
+    const response = await client.messages.create(body)
+
+    for (const block of response.content) {
+      if (block.type === "text") content = block.text
+      if (block.type === "thinking") thinking_content = (block as any).thinking ?? ""
+      if (block.type === "tool_use") {
+        let args: string
+        try { args = JSON.stringify(block.input) } catch { args = "{}" }
+        tool_calls.push({
+          id: block.id,
+          type: "function",
+          function: { name: block.name, arguments: args },
+        })
+      }
+    }
+
+    return {
+      content,
+      thinking_content: thinking_content || undefined,
+      tool_calls: tool_calls.length ? tool_calls : undefined,
+      stop_reason:
+        response.stop_reason === "tool_use" ? "tool_calls"
+          : response.stop_reason === "max_tokens" ? "max_tokens"
+            : "stop",
+      usage: {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+      },
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+import { OpenAICompatBase } from "./openai-compat-base"
+
+export class DeepSeekProvider extends OpenAICompatBase {
+  constructor() { super("deepseek") }
+
+  /** DeepSeek reasoner models return reasoning_content that must be round-tripped. */
+  protected needsReasoningRoundtrip(): boolean { return true }
+}

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

@@ -0,0 +1,215 @@
+import { logger } from "../../utils/logger"
+import { sanitizeMessages } from "./interface"
+import type { LLMCallOptions, LLMProvider, LLMResponse, LLMToolCall } from "./interface"
+import type { ContentPart, LLMMessage } from "../llm-client"
+
+const log = logger.child("llm-client")
+
+export class GeminiProvider implements LLMProvider {
+  private _convertContentPart(part: ContentPart): any {
+    switch (part.type) {
+      case "text":
+        return { text: part.text }
+      case "image_url": {
+        const url = part.image_url.url
+        if (url.startsWith("data:")) {
+          const match = url.match(/^data:([^;]+);base64,(.+)$/)
+          if (match) return { inlineData: { mimeType: match[1], data: match[2] } }
+        }
+        return { text: `[Image URL: ${url}]` }
+      }
+      case "image_base64":
+        return { inlineData: { mimeType: part.mimeType, data: part.base64 } }
+      case "document":
+        return { inlineData: { mimeType: part.mimeType, data: part.base64 } }
+      default:
+        return { text: JSON.stringify(part) }
+    }
+  }
+
+  private _convertUserParts(msg: LLMMessage): any[] {
+    if (Array.isArray(msg.content)) {
+      return msg.content.map(p => this._convertContentPart(p))
+    }
+    return [{ text: msg.content }]
+  }
+
+  async call(options: LLMCallOptions): Promise<LLMResponse> {
+    const { GoogleGenAI } = await import("@google/genai")
+
+    const clientOpts: any = { apiKey: options.apiKey }
+    if (options.baseUrl?.trim()) clientOpts.httpOptions = { baseUrl: options.baseUrl.trim() }
+
+    const ai = new GoogleGenAI(clientOpts)
+
+    const cleanMessages = sanitizeMessages(options.messages)
+
+    // Build toolCallId → name map for converting tool results
+    const toolNameMap = new Map<string, string>()
+    for (const msg of cleanMessages) {
+      if (msg.role === "assistant" && msg.tool_calls) {
+        for (const tc of msg.tool_calls) toolNameMap.set(tc.id, tc.function.name)
+      }
+    }
+
+    // Convert canonical messages → Gemini Content[]
+    let systemText = ""
+    const rawContents: any[] = []
+
+    for (const msg of cleanMessages) {
+      if (msg.role === "system") {
+        systemText += (systemText ? "\n\n" : "") + msg.content
+        continue
+      }
+    if (msg.role === "user") {
+      rawContents.push({ role: "user", parts: this._convertUserParts(msg) })
+      continue
+    }
+      if (msg.role === "assistant") {
+        const parts: any[] = []
+        if (msg.content) parts.push({ text: msg.content })
+        for (const tc of msg.tool_calls ?? []) {
+          const fcPart: any = { functionCall: { name: tc.function.name, args: JSON.parse(tc.function.arguments || "{}") } }
+          if (tc.thought_signature) fcPart.thoughtSignature = tc.thought_signature
+          parts.push(fcPart)
+        }
+        if (parts.length) rawContents.push({ role: "model", parts })
+        continue
+      }
+      if (msg.role === "tool") {
+        const fnName = toolNameMap.get(msg.tool_call_id || "") || msg.name || "tool"
+        const frPart = { functionResponse: { name: fnName, response: { output: msg.content } } }
+        const last = rawContents[rawContents.length - 1]
+        if (last?.role === "user" && Array.isArray(last.parts)) {
+          last.parts.push(frPart)
+        } else {
+          rawContents.push({ role: "user", parts: [frPart] })
+        }
+      }
+    }
+
+    // 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`)
+    }
+
+    const config: any = {}
+    if (systemText) config.systemInstruction = systemText
+    if (options.maxTokens) config.maxOutputTokens = options.maxTokens
+    if (options.temperature !== undefined) config.temperature = options.temperature
+    if (options.tools?.length) {
+      config.tools = [{
+        functionDeclarations: options.tools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description,
+          parameters: 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 })
+
+    const candidate = response.candidates?.[0]
+
+    // Handle safety blocks explicitly
+    if (candidate?.finishReason === "SAFETY") {
+      log.warn(`[llm-client] Gemini: response blocked by safety filters (model=${options.model})`)
+      return {
+        content: "[Response blocked by Gemini safety filters]",
+        stop_reason: "stop",
+        usage: response.usageMetadata ? {
+          input_tokens: response.usageMetadata.promptTokenCount ?? 0,
+          output_tokens: 0,
+        } : undefined,
+      }
+    }
+
+    const parts: any[] = candidate?.content?.parts ?? []
+
+    let content = ""
+    const tool_calls: LLMToolCall[] = []
+
+    for (const part of parts) {
+      if (part.text) content += part.text
+      if (part.functionCall) {
+        tool_calls.push({
+          id: crypto.randomUUID(),
+          type: "function",
+          function: { name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args ?? {}) },
+          thought_signature: part.thoughtSignature ?? undefined,
+        })
+      }
+    }
+
+    const stop_reason: LLMResponse["stop_reason"] =
+      tool_calls.length > 0 ? "tool_calls"
+        : candidate?.finishReason === "MAX_TOKENS" ? "max_tokens"
+          : "stop"
+
+    const usageMeta = response.usageMetadata
+    return {
+      content,
+      tool_calls: tool_calls.length ? tool_calls : undefined,
+      stop_reason,
+      usage: usageMeta ? {
+        input_tokens: usageMeta.promptTokenCount ?? 0,
+        output_tokens: usageMeta.candidatesTokenCount ?? 0,
+        thinking_tokens: (usageMeta as any).thoughtsTokenCount ?? 0,
+      } : undefined,
+    }
+  }
+}

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