@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,503 +0,0 @@
-/**
- * LLM client — direct official SDKs, no abstraction layers.
- *
- *   gemini / google  → native Gemini REST API (v1beta, ?key=)
- *   anthropic        → @anthropic-ai/sdk
- *   everything else  → openai  npm package  (OpenAI-compatible endpoint)
- *
- * Public interface (LLMMessage, callLLM, resolveProviderConfig) is stable.
- */
-
-import { logger } from "../utils/logger"
-
-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 interface LLMMessage {
-  role: "system" | "user" | "assistant" | "tool"
-  content: string
-  tool_calls?: LLMToolCall[]
-  tool_call_id?: string
-  name?: 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
-  messages: LLMMessage[]
-  tools?: LLMToolDef[]
-  temperature?: number
-  maxTokens?: number
-  numGpu?: number
-  onToken?: (token: string) => void
-}
-
-export interface LLMResponse {
-  content: string
-  tool_calls?: LLMToolCall[]
-  stop_reason: "stop" | "tool_calls" | "max_tokens" | "error"
-  usage?: { input_tokens: number; output_tokens: number }
-}
-
-// ─── Provider routing ──────────────────────────────────────────────────────────
-
-const GEMINI_PROVIDERS = new Set(["gemini", "google"])
-
-const OPENAI_COMPAT_BASE_URLS: Record<string, string> = {
-  groq: "https://api.groq.com/openai/v1",
-  mistral: "https://api.mistral.ai/v1",
-  openrouter: "https://openrouter.ai/api/v1",
-  deepseek: "https://api.deepseek.com/v1",
-  kimi: "https://api.moonshot.ai/v1",
-}
-
-// ─── Gemini  (@google/genai) ───────────────────────────────────────────────────
-
-async function callGemini(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)
-
-  // Build toolCallId → name map for converting tool results
-  const toolNameMap = new Map<string, string>()
-  for (const msg of options.messages) {
-    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 contents: any[] = []
-
-  for (const msg of options.messages) {
-    if (msg.role === "system") {
-      systemText += (systemText ? "\n\n" : "") + msg.content
-      continue
-    }
-    if (msg.role === "user") {
-      contents.push({ role: "user", parts: [{ text: msg.content }] })
-      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) contents.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 = contents[contents.length - 1]
-      if (last?.role === "user" && Array.isArray(last.parts)) {
-        last.parts.push(frPart)
-      } else {
-        contents.push({ role: "user", parts: [frPart] })
-      }
-    }
-  }
-
-  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]
-  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"
-
-  return {
-    content,
-    tool_calls: tool_calls.length ? tool_calls : undefined,
-    stop_reason,
-    usage: response.usageMetadata ? {
-      input_tokens: response.usageMetadata.promptTokenCount ?? 0,
-      output_tokens: response.usageMetadata.candidatesTokenCount ?? 0,
-    } : undefined,
-  }
-}
-
-// ─── Anthropic (@anthropic-ai/sdk) ────────────────────────────────────────────
-
-async function callAnthropic(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) {
-        content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: JSON.parse(tc.function.arguments || "{}") })
-      }
-      anthropicMessages.push({ role: "assistant", content })
-      continue
-    }
-
-    anthropicMessages.push({ role: msg.role, content: 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 ?? 8192,
-    messages: anthropicMessages,
-  }
-  if (systemText) body.system = systemText
-  if (tools.length) body.tools = tools
-
-  log.info(`[llm-client] anthropic/${options.model} — ${anthropicMessages.length} msgs, ${tools.length} tools`)
-
-  const response = await client.messages.create(body)
-
-  let content = ""
-  const tool_calls: LLMToolCall[] = []
-
-  for (const block of response.content) {
-    if (block.type === "text") content = block.text
-    if (block.type === "tool_use") {
-      tool_calls.push({
-        id: block.id,
-        type: "function",
-        function: { name: block.name, arguments: JSON.stringify(block.input) },
-      })
-    }
-  }
-
-  return {
-    content,
-    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,
-    },
-  }
-}
-
-// ─── Ollama (sdk nativo) ──────────────────────────────────────────────────────
-
-async function callOllama(options: LLMCallOptions): Promise<LLMResponse> {
-  const { Ollama } = await import("ollama")
-
-  // Limpiar el prefijo "ollama/" del modelo si viene del DB
-  const modelName = options.model.replace(/^ollama\//, "")
-  const host = options.baseUrl?.trim() || "http://localhost:11434"
-
-  try {
-    // Detectar Cloud API de Ollama (ollama.com) → usar Authorization header
-    const isCloud = host.includes("ollama.com")
-    const headers: Record<string, string> = {}
-    if (isCloud && options.apiKey) {
-      headers["Authorization"] = `Bearer ${options.apiKey}`
-    }
-
-    const client = new Ollama({
-      host,
-      ...(Object.keys(headers).length ? { headers } : {}),
-    })
-
-    // Convertir mensajes al formato que espera Ollama:
-    // - assistant con tool_calls → incluir tool_calls con arguments como objeto (no string)
-    // - tool result → role:"tool", content (sin tool_call_id, Ollama no lo usa)
-    const messages = options.messages.map((m): any => {
-      if (m.role === "assistant" && m.tool_calls?.length) {
-        return {
-          role: "assistant",
-          content: m.content || "",
-          tool_calls: m.tool_calls.map((tc) => ({
-            function: {
-              name: tc.function.name,
-              arguments: (() => {
-                try { return JSON.parse(tc.function.arguments) } catch { return {} }
-              })(),
-            },
-          })),
-        }
-      }
-      if (m.role === "tool") {
-        return { role: "tool", content: m.content }
-      }
-      return { role: m.role, content: m.content }
-    })
-
-    // Convertir tools al formato Ollama (igual que OpenAI function-calling)
-    const tools = options.tools?.map((t) => ({
-      type: "function" as const,
-      function: {
-        name: t.function.name,
-        description: t.function.description,
-        parameters: t.function.parameters,
-      },
-    }))
-
-    // Opciones de runtime (num_ctx para contextos grandes)
-    const runtimeOptions: Record<string, unknown> = {}
-    if (options.numCtx) runtimeOptions.num_ctx = options.numCtx
-    if (options.numGpu !== undefined) runtimeOptions.num_gpu = options.numGpu
-    if (options.temperature !== undefined) runtimeOptions.temperature = options.temperature
-
-    log.info(
-      `[llm-client] ollama/${modelName} @ ${isCloud ? "ollama.com" : host} stream=true` +
-      ` — ${messages.length} msgs, ${tools?.length ?? 0} tools` +
-      (options.numCtx ? ` num_ctx=${options.numCtx}` : "")
-    )
-
-    // ── Streaming ───────────────────────────────────────────────────────────────
-    const stream = await client.chat({
-      model: modelName,
-      messages,
-      tools: tools?.length ? tools : undefined,
-      options: Object.keys(runtimeOptions).length ? runtimeOptions : undefined,
-      stream: true,
-    })
-
-    let content = ""
-    let promptEvalCount = 0
-    let evalCount = 0
-    const tool_calls: LLMToolCall[] = []
-
-    for await (const part of stream) {
-      // Acumular texto parcial
-      const delta = part.message?.content ?? ""
-      if (delta) {
-        content += delta
-        if (options.onToken) options.onToken(delta)
-      }
-
-      // tool_calls solo llegan en el último chunk
-      if (part.message?.tool_calls?.length) {
-        for (const tc of part.message.tool_calls) {
-          tool_calls.push({
-            id: crypto.randomUUID(),
-            type: "function" as const,
-            function: {
-              name: (tc as any).function.name,
-              arguments: JSON.stringify((tc as any).function.arguments ?? {}),
-            },
-          })
-        }
-      }
-
-      // Tokens de uso en el chunk final
-      if (part.prompt_eval_count !== undefined) promptEvalCount = part.prompt_eval_count
-      if (part.eval_count !== undefined) evalCount = part.eval_count
-    }
-
-    return {
-      content,
-      tool_calls: tool_calls.length ? tool_calls : undefined,
-      stop_reason: tool_calls.length > 0 ? "tool_calls" : "stop",
-      usage:
-        evalCount > 0
-          ? { input_tokens: promptEvalCount, output_tokens: evalCount }
-          : undefined,
-    }
-  } catch (error: any) {
-    // Logger mucho más explícito para errores críticos (especialmente resource issues)
-    log.error(`[llm-client] FAILED call to ollama/${modelName} at ${host}`)
-    log.error(`[llm-client] Error details: ${error.message || error}`)
-    if (options.numCtx) log.error(`[llm-client] Context requested: num_ctx=${options.numCtx}`)
-    if (options.tools?.length) log.error(`[llm-client] Tools defined: ${options.tools.length}`)
-
-    // Sugerencia proactiva si es el error típico de Ollama server crash
-    if (error.message?.includes("model runner has unexpectedly stopped")) {
-      log.warn(`[llm-client] TIP: This usually means Ollama ran out of VRAM/RAM. Try reducing 'num_ctx' or the number of tools.`)
-    }
-
-    throw error // Re-throw to be caught by the main callLLM for consistent response
-  }
-}
-
-
-// ─── OpenAI-compatible (openai npm package) ────────────────────────────────────
-
-async function callOpenAICompat(options: LLMCallOptions): Promise<LLMResponse> {
-  const { default: OpenAI } = await import("openai")
-
-  const baseURL = options.baseUrl?.trim() || OPENAI_COMPAT_BASE_URLS[options.provider] || undefined
-  const isLocal = baseURL?.includes("localhost") || baseURL?.includes("127.0.0.1")
-  const apiKey = options.apiKey || (isLocal ? "ollama" : "missing-api-key")
-
-  const client = new OpenAI({ apiKey, baseURL })
-
-  const body: any = {
-    model: options.provider === "ollama" ? options.model.replace(/^ollama\//, "") : options.model,
-    messages: options.messages,
-    temperature: options.temperature ?? 0.7,
-  }
-  if (options.maxTokens) body.max_tokens = options.maxTokens
-  if (options.numCtx && isLocal) body.num_ctx = options.numCtx
-  if (options.tools?.length) {
-    body.tools = options.tools
-    body.tool_choice = "auto"
-  }
-
-  log.info(`[llm-client] ${options.provider}/${body.model} — ${options.messages.length} msgs, ${options.tools?.length ?? 0} tools`)
-
-  const response = await client.chat.completions.create(body)
-  const choice = response.choices[0]
-  const msg = choice.message
-
-  const tool_calls: LLMToolCall[] | undefined = (msg.tool_calls as any[])?.map((tc: any) => ({
-    id: tc.id,
-    type: "function" as const,
-    function: { name: tc.function.name, arguments: tc.function.arguments },
-  }))
-
-  return {
-    content: msg.content ?? "",
-    tool_calls: tool_calls?.length ? tool_calls : undefined,
-    stop_reason:
-      choice.finish_reason === "tool_calls" ? "tool_calls"
-        : choice.finish_reason === "length" ? "max_tokens"
-          : "stop",
-    usage: response.usage ? {
-      input_tokens: response.usage.prompt_tokens,
-      output_tokens: response.usage.completion_tokens,
-    } : undefined,
-  }
-}
-
-// ─── Public API ────────────────────────────────────────────────────────────────
-
-/**
- * Call any LLM provider. Returns a canonical LLMResponse regardless of provider.
- */
-export async function callLLM(options: LLMCallOptions): Promise<LLMResponse> {
-  try {
-    if (GEMINI_PROVIDERS.has(options.provider)) return await callGemini(options)
-    if (options.provider === "anthropic") return await callAnthropic(options)
-    if (options.provider === "ollama") return await callOllama(options)
-    return await callOpenAICompat(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}`)
-    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">> {
-  const { getDb } = await import("../storage/sqlite")
-  const { decryptApiKey } = await import("../storage/crypto")
-
-  const db = getDb()
-  const providerRow = db
-    .query<any, [string]>("SELECT * FROM providers WHERE id = ? AND enabled = 1")
-    .get(providerId)
-
-  let apiKey = ""
-  if (providerRow?.api_key_encrypted && providerRow?.api_key_iv) {
-    try {
-      apiKey = await decryptApiKey(providerRow.api_key_encrypted, providerRow.api_key_iv)
-    } catch { /* fall through to env var */ }
-  }
-  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,
-  }
-}

package/packages/core/src/agent/native-tools.ts

@@ -1,31 +0,0 @@
-/**
- * Native Tools Type Definitions
- * 
- * Tool interface for native Hive tools (no LangChain)
- */
-
-export interface Tool {
-  name: string
-  description: string
-  parameters: {
-    type: "object"
-    properties: Record<string, ToolParameter>
-    required?: string[]
-  }
-  execute: (params: Record<string, unknown>, config?: any) => Promise<string | object>
-}
-
-export interface ToolParameter {
-  type: string
-  description?: string
-  enum?: string[]
-  items?: ToolParameter
-  properties?: Record<string, ToolParameter>
-  required?: string[]
-}
-
-export interface ToolResult {
-  success: boolean
-  result?: any
-  error?: string
-}

package/packages/core/src/agent/playbook-selector.ts

@@ -1,143 +0,0 @@
-/**
- * FTS5-based Playbook Rules Selector (ACE Curator)
- * 
- * This module allows the Context Compiler to inject relevant evolved rules
- * into the agent prompt based on semantic relevance to the current message.
- */
-
-import { getDb } from "../storage/sqlite"
-import { logger } from "../utils/logger"
-
-const log = logger.child("playbook-selector")
-
-// ─── Types ───────────────────────────────────────────────────────────────────────
-
-export interface PlaybookRule {
-    id: number
-    rule: string
-    category: string
-    applicable_to?: string
-}
-
-// ─── Configuration ─────────────────────────────────────────────────────────────
-
-/** Maximum rules to inject per context window */
-const MAX_RULES_PER_TURN = 5
-
-/** Minimum bm25 score threshold for rules */
-const MIN_RELEVANCE_THRESHOLD = -10 // Relaxed for better matching
-
-// ─── Selection Logic ───────────────────────────────────────────────────────────
-
-/**
- * Select relevant rules from the Playbook based on semantic matching
- */
-export function selectPlaybookRules(message: string): PlaybookRule[] {
-    const db = getDb()
-    const startTime = performance.now()
-
-    // Clean query
-    const keywords = message
-        .toLowerCase()
-        // Keep only letters, numbers, spaces (strips ALL FTS5 special syntax)
-        .replace(/[^\p{L}\p{N}\s]/gu, " ")
-        .split(/\s+/)
-        .filter(w => w.length > 3)
-        .slice(0, 5)
-
-    if (keywords.length === 0) return []
-
-    const ftsQuery = keywords.join(" OR ")
-
-    try {
-        // Query FTS table
-        const ftsResults = db.query(`
-            SELECT rowid, bm25(playbook_fts) as score
-            FROM playbook_fts
-            WHERE playbook_fts MATCH ?
-            ORDER BY score ASC
-            LIMIT ?
-        `).all(ftsQuery, MAX_RULES_PER_TURN) as Array<{ rowid: number; score: number }>
-
-        const relevantIds = ftsResults
-            .filter(r => r.score >= MIN_RELEVANCE_THRESHOLD)
-            .map(r => r.rowid)
-
-        if (relevantIds.length === 0) return []
-
-        // Fetch full rules
-        const rules = db.query(`
-            SELECT id, rule, category, applicable_to
-            FROM playbook
-            WHERE id IN (${relevantIds.map(() => '?').join(',')})
-            AND active = 1
-        `).all(...relevantIds) as PlaybookRule[]
-
-        const timing = performance.now() - startTime
-        log.info(`[playbook-selector] Selected ${rules.length} rules in ${timing.toFixed(2)}ms`)
-
-        return rules
-    } catch (err) {
-        log.error(`[playbook-selector] Failed to select rules:`, err)
-        return []
-    }
-}
-
-// ─── Sync Logic ───────────────────────────────────────────────────────────────
-
-/**
- * Sync active playbook rules to FTS5 virtual table
- */
-export async function syncPlaybookToFTS(): Promise<void> {
-    const db = getDb()
-
-    try {
-        // Step 1: Get active rules
-        const rules = db.query(`
-            SELECT id, rule, category, applicable_to
-            FROM playbook
-            WHERE active = 1
-        `).all() as Array<{
-            id: number
-            rule: string
-            category: string
-            applicable_to: string
-        }>
-
-        if (rules.length === 0) {
-            log.debug(`[playbook-selector] No rules in playbook to sync`)
-        }
-
-        // Step 2: Atomic transaction for FTS5 sync
-        const syncTransaction = db.transaction(() => {
-            // Verify table exists
-            const tableCheck = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='playbook_fts'").get()
-            if (!tableCheck) {
-                throw new Error("playbook_fts table does not exist!")
-            }
-
-            // A: Clear existing data
-            db.run("DELETE FROM playbook_fts")
-
-            // B: Prepare insertion
-            const insert = db.prepare(`
-                INSERT INTO playbook_fts(rowid, rule, category, applicable_to)
-                VALUES (?, ?, ?, ?)
-            `)
-
-            // C: Re-populate
-            for (const item of rules) {
-                insert.run(item.id, item.rule, item.category, item.applicable_to)
-            }
-        })
-
-        // Execute transaction
-        syncTransaction()
-
-        log.info(`[playbook-selector] Atomic sync complete: ${rules.length} rules indexed in FTS5`)
-
-    } catch (err) {
-        log.error(`[playbook-selector] Transactional sync failed:`, err)
-        throw err
-    }
-}