@johpaz/hive-sdk 0.0.14 → 0.0.15

package/packages/core/src/agent/Service.ts

@@ -0,0 +1,267 @@
+/**
+ * AgentService — Wrapper del nuevo agent-loop nativo.
+ * 
+ * Reemplaza la clase Agent legacy.
+ * Mantiene compatibilidad con server.ts pero usa el agent-loop nativo por debajo.
+ * 
+ * Responsabilidades:
+ * - Cargar agente desde DB
+ * - Cargar ética desde DB
+ * - Obtener MCP Manager
+ * - Hot reload (MCP, skills, ethics)
+ * - Eventos (cron, etc.)
+ */
+
+import { getDb } from "../storage/SQLiteStorage.ts"
+import { logger } from "../utils/logger.ts"
+import { buildSystemPromptWithProjects } from "./PromptBuilder"
+import { getAgentLoop, rebuildAgentLoop } from "./AgentRunner"
+import type { MCPClientManager } from "../mcp/index.ts"
+import { resolveAgentId, resolveUserId } from "../storage/onboarding.ts"
+import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton.ts"
+import type { ContentPart } from "./providers/LLMClient"
+
+const log = logger.child("agent-service")
+
+// Event handler types
+type CronHandler = (sessionId: string, task: string, jobId?: string, context?: any) => Promise<void>
+
+export interface AgentServiceConfig {
+  agentId?: string
+  workspacePath?: string
+}
+
+export interface AgentDBRecord {
+  id: string
+  user_id: string
+  name: string
+  description: string | null
+  system_prompt: string | null
+  tone: string | null
+  role: string
+  status: string
+  enabled: number
+  provider_id: string
+  model_id: string
+  tools_json: string | null
+  skills_json: string | null
+  parent_id: string | null
+  max_iterations: number
+  headers_encrypted: string | null
+  headers_iv: string | null
+  created_at: number
+  updated_at: number
+}
+
+export class AgentService {
+  private agentId: string
+  private workspacePath: string
+  private mcpManager: MCPClientManager | null = null
+  private cronHandlers: CronHandler[] = []
+  private initialized: boolean = false
+
+  constructor(config?: AgentServiceConfig) {
+    // Resolve agentId from database if not provided
+    this.agentId = config?.agentId || resolveAgentId(null) || "main"
+    this.workspacePath = config?.workspacePath || ""
+  }
+
+  /**
+   * Inicializa el servicio del agente
+   * - Carga el MCP Manager
+   * - Configura el supervisor graph
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      log.debug("AgentService already initialized")
+      return
+    }
+
+    try {
+      // Obtener MCP Manager del agent loop
+      const agentLoop = getAgentLoop()
+      if (agentLoop) {
+        // MCP Manager se inicializa en el agent-loop
+        log.info("AgentService: MCP Manager available from agent-loop")
+      }
+
+      this.initialized = true
+      log.info(`AgentService initialized for agent=${this.agentId}`)
+    } catch (error) {
+      log.error(`Failed to initialize AgentService: ${(error as Error).message}`)
+      throw error
+    }
+  }
+
+  /**
+   * Obtiene el registro del agente desde la DB
+   */
+  async getAgent(agentId?: string): Promise<AgentDBRecord | null> {
+    const db = getDb()
+    const id = agentId || this.agentId
+    
+    const agent = db.query<any, [string]>(
+      "SELECT * FROM agents WHERE id = ? LIMIT 1"
+    ).get(id) as AgentDBRecord | undefined
+
+    return agent || null
+  }
+
+  /**
+   * Obtiene la ética desde la DB
+   */
+  async getEthics(): Promise<string> {
+    const db = getDb()
+    const ethics = db.query<any, []>(
+      "SELECT content FROM ethics WHERE active = 1 LIMIT 1"
+    ).get() as { content: string } | undefined
+
+    return ethics?.content || ""
+  }
+
+  /**
+   * Obtiene el MCP Manager
+   */
+  getMCPManager(): MCPClientManager | null {
+    const agentLoop = getAgentLoop()
+    if (agentLoop && (agentLoop as any).mcpManager) {
+      return (agentLoop as any).mcpManager as MCPClientManager
+    }
+    // Fallback to singleton
+    return getSingletonMCPManager()
+  }
+
+  /**
+   * Recarga la configuración del MCP
+   */
+  async reloadMCP(): Promise<void> {
+    log.info("Reloading MCP configuration...")
+    const mcp = this.getMCPManager()
+    if (mcp) {
+      await mcp.reconnectAll().catch(err => {
+        log.warn(`Failed to reconnect MCP: ${(err as Error).message}`)
+      })
+    }
+    log.info("MCP reloaded")
+  }
+
+  /**
+   * Recarga los skills desde la DB
+   */
+  async reloadSkills(): Promise<void> {
+    log.info("Reloading skills...")
+    const { syncSkillsToFTS } = await import("./selectors/index.ts")
+    await syncSkillsToFTS()
+    log.info("Skills reloaded")
+  }
+
+  /**
+   * Recarga la ética desde la DB
+   */
+  async reloadEthics(): Promise<void> {
+    log.info("Reloading ethics...")
+    // La ética se carga automáticamente en buildSystemPrompt()
+    // No hay acción necesaria aquí
+    log.info("Ethics reloaded (will be picked up on next agent call)")
+  }
+
+  /**
+   * Recarga el soul (system prompt del agente)
+   */
+  async reloadSoul(): Promise<void> {
+    log.info("Reloading soul...")
+    // El soul se carga automáticamente desde DB en buildSystemPrompt()
+    log.info("Soul reloaded (will be picked up on next agent call)")
+  }
+
+  /**
+   * Recarga la configuración del usuario
+   */
+  async reloadUser(): Promise<void> {
+    log.info("Reloading user configuration...")
+    // La configuración del usuario se carga desde DB en buildSystemPrompt()
+    log.info("User configuration reloaded (will be picked up on next agent call)")
+  }
+
+  /**
+   * Actualiza la configuración del agente
+   */
+  async updateConfig(config: any): Promise<void> {
+    log.info("Updating agent configuration...")
+    // La configuración ahora se carga desde DB dinámicamente
+    // No hay acción necesaria aquí
+    log.info("Configuration updated (will be picked up from DB)")
+  }
+
+  /**
+   * Recarga el agente (hot reload)
+   */
+  async reload(): Promise<void> {
+    log.info("Reloading agent...")
+    await this.reloadMCP()
+    await this.reloadSkills()
+    await this.reloadEthics()
+    log.info("Agent reloaded")
+  }
+
+  /**
+   * Registra un handler para eventos cron
+   */
+  on(event: 'cron', handler: CronHandler): void {
+    if (event === 'cron') {
+      this.cronHandlers.push(handler)
+      log.debug(`Registered cron handler, total=${this.cronHandlers.length}`)
+    }
+  }
+
+  /**
+   * Emite un evento cron
+   */
+  emit(event: 'cron', sessionId: string, task: string, jobId?: string, context?: any): void {
+    if (event === 'cron') {
+      log.debug(`Emitting cron event: task=${task}, sessionId=${sessionId}, jobId=${jobId}`)
+      for (const handler of this.cronHandlers) {
+        handler(sessionId, task, jobId, context).catch(err => {
+          log.error(`Cron handler error: ${(err as Error).message}`)
+        })
+      }
+    }
+  }
+
+  /**
+   * Obtiene el system prompt para un agente
+   */
+  async getSystemPrompt(agentId?: string, userId?: string): Promise<string> {
+    const id = agentId || this.agentId
+    const uid = userId || resolveUserId({}) || "default"
+    return buildSystemPromptWithProjects({ agentId: id, userId: uid })
+  }
+
+  /**
+   * Ejecuta un agente con un mensaje
+   */
+  async runAgent(message: string | ContentPart[], threadId: string, userId?: string): Promise<string> {
+    const { runAgentIsolated } = await import("./AgentRunner.ts")
+    const result = await runAgentIsolated({
+      agentId: this.agentId,
+      taskDescription: message,
+      threadId,
+    })
+    return result
+  }
+}
+
+// Singleton para compatibilidad
+let _agentService: AgentService | null = null
+
+export function getAgentService(): AgentService {
+  if (!_agentService) {
+    _agentService = new AgentService()
+  }
+  return _agentService
+}
+
+export function createAgentService(config?: AgentServiceConfig): AgentService {
+  _agentService = new AgentService(config)
+  return _agentService
+}

package/packages/core/src/agent/StuckLoop.ts

@@ -0,0 +1,133 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import { hashObject } from "../utils/crypto.ts";
+
+interface ToolCallRecord {
+  toolName: string;
+  argsHash: string;
+  errorMessage?: string;
+  timestamp: number;
+}
+
+interface StuckLoopState {
+  detected: boolean;
+  toolName: string;
+  count: number;
+  lastError?: string;
+}
+
+export class StuckLoopDetector {
+  private log = logger.child("stuck-loop");
+  private history: Map<string, ToolCallRecord[]> = new Map();
+  private readonly maxHistoryPerSession = 50;
+  private readonly triggerThreshold = 3;
+
+  constructor(_config: Config) {}
+
+  recordToolCall(
+    sessionId: string,
+    toolName: string,
+    args: Record<string, unknown>,
+    error?: string
+  ): void {
+    let sessionHistory = this.history.get(sessionId);
+    if (!sessionHistory) {
+      sessionHistory = [];
+      this.history.set(sessionId, sessionHistory);
+    }
+
+    const record: ToolCallRecord = {
+      toolName,
+      argsHash: hashObject(args),
+      errorMessage: error,
+      timestamp: Date.now(),
+    };
+
+    sessionHistory.push(record);
+
+    if (sessionHistory.length > this.maxHistoryPerSession) {
+      sessionHistory.shift();
+    }
+
+    this.log.debug(`Recorded tool call: ${toolName} for session ${sessionId}`);
+  }
+
+  check(sessionId: string): StuckLoopState {
+    const sessionHistory = this.history.get(sessionId) ?? [];
+    
+    if (sessionHistory.length < this.triggerThreshold) {
+      return { detected: false, toolName: "", count: 0 };
+    }
+
+    const recent = sessionHistory.slice(-10);
+    const counts = new Map<string, { count: number; error?: string }>();
+
+    for (const record of recent) {
+      const key = `${record.toolName}:${record.argsHash}`;
+      const existing = counts.get(key);
+      
+      if (existing) {
+        existing.count++;
+        if (record.errorMessage) {
+          existing.error = record.errorMessage;
+        }
+      } else {
+        counts.set(key, { count: 1, error: record.errorMessage });
+      }
+    }
+
+    for (const [key, data] of counts) {
+      if (data.count >= this.triggerThreshold && data.error) {
+        const toolName = key.split(":")[0] ?? "unknown";
+        
+        this.log.warn(`Stuck loop detected: ${toolName} called ${data.count} times with same args and error`);
+        
+        return {
+          detected: true,
+          toolName,
+          count: data.count,
+          lastError: data.error,
+        };
+      }
+    }
+
+    return { detected: false, toolName: "", count: 0 };
+  }
+
+  getInterventionMessage(state: StuckLoopState): string | null {
+    if (!state.detected) return null;
+
+    if (state.count >= this.triggerThreshold + 1) {
+      return `CRITICAL: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing with: "${state.lastError}". The user has been notified. You MUST try a completely different approach or ask the user for guidance.`;
+    }
+
+    return `WARNING: You have called ${state.toolName} ${state.count} times with the same arguments and it keeps failing. You MUST try a completely different approach instead of repeating the same action.`;
+  }
+
+  clear(sessionId: string): void {
+    this.history.delete(sessionId);
+    this.log.debug(`Cleared stuck loop history for session ${sessionId}`);
+  }
+
+  prune(maxAgeMs: number = 30 * 60 * 1000): number {
+    const now = Date.now();
+    let pruned = 0;
+
+    for (const [sessionId, history] of this.history) {
+      const filtered = history.filter(r => now - r.timestamp < maxAgeMs);
+      
+      if (filtered.length === 0) {
+        this.history.delete(sessionId);
+        pruned++;
+      } else if (filtered.length !== history.length) {
+        this.history.set(sessionId, filtered);
+      }
+    }
+
+    return pruned;
+  }
+}
+
+export function createStuckLoopDetector(config: Config): StuckLoopDetector {
+  return new StuckLoopDetector(config);
+}

package/packages/core/src/agent/index.ts

@@ -0,0 +1,12 @@
+export * from "./AgentRunner.ts";
+export * from "./Compaction.ts";
+export * from "./ContextCompiler.ts";
+export * from "./ContextGuard.ts";
+export * from "./ConversationStore.ts";
+export * from "./Hooks.ts";
+export * from "./NativeTools.ts";
+export * from "./PromptBuilder.ts";
+export * from "./Service.ts";
+export * from "./StuckLoop.ts";
+export * from "./providers/index.ts";
+export * from "./selectors/index.ts";

package/packages/core/src/agent/providers/LLMClient.ts

@@ -0,0 +1,149 @@
+/**
+ * LLM client — direct official SDKs, no abstraction layers.
+ *
+ *   gemini / google  → native Gemini REST API (v1beta, ?key=)
+ *   anthropic        → @anthropic-ai/sdk
+ *   ollama           → ollama npm package
+ *   everything else  → openai  npm package  (OpenAI-compatible endpoint)
+ *
+ * Public interface (LLMMessage, callLLM, resolveProviderConfig) is stable.
+ */
+
+import { logger } from "../../utils/logger.ts"
+import { GeminiProvider } from "./gemini.ts"
+import { AnthropicProvider } from "./anthropic.ts"
+import { OllamaProvider } from "./ollama.ts"
+import { OpenAICompatProvider } from "./openai-compat.ts"
+import type { LLMProvider } from "./interface.ts"
+
+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
+  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 ─────────────────────────────────────────────────────────
+
+const GEMINI_PROVIDERS = new Set(["gemini", "google"])
+
+const KNOWN_PROVIDERS = new Set(["anthropic", "gemini", "google", "ollama", "openai", "groq", "mistral", "openrouter", "deepseek", "kimi", "local-llama", "nvidia"])
+
+function getProvider(provider: string): LLMProvider {
+  if (GEMINI_PROVIDERS.has(provider)) return new GeminiProvider()
+  if (provider === "anthropic") return new AnthropicProvider()
+  if (provider === "ollama") return new OllamaProvider()
+  if (!KNOWN_PROVIDERS.has(provider)) {
+    log.warn(`[llm-client] Unknown provider "${provider}" — falling back to OpenAI-compatible endpoint`)
+  }
+  return new OpenAICompatProvider()
+}
+
+// ─── 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">> {
+  const { getDb } = await import("../../storage/SQLiteStorage.ts")
+  const { decryptApiKey } = await import("../../storage/crypto.ts")
+
+  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,
+  }
+}