@johpaz/hive-agents 0.0.34 → 0.0.36

package/packages/core/src/mcp/tool-sync.ts

@@ -0,0 +1,176 @@
+/**
+ * MCP Tool Sync — Persist MCP tool definitions to DB and FTS5
+ *
+ * When an MCP server connects, its tool definitions are persisted to
+ * the mcp_tools table and indexed in mcp_tools_fts for search_knowledge.
+ * When the server disconnects, all its tools are deleted from both.
+ *
+ * This enables:
+ * 1. search_knowledge to find MCP tools via FTS5
+ * 2. Tool definitions to survive across context compiler invocations
+ * 3. Offline visibility of what MCP tools were available
+ */
+
+import { getDb } from "../storage/sqlite"
+import { logger } from "../utils/logger"
+
+const log = logger.child("mcp:tool-sync")
+
+export interface MCPToolDefinition {
+    name: string
+    description: string
+    inputSchema?: Record<string, unknown>
+}
+
+/**
+ * Generate a stable ID for an MCP tool based on server + tool name.
+ * Uses the same sanitization as mcpToolFullName for consistency.
+ */
+export function mcpToolId(serverName: string, toolName: string): string {
+    const safe = (s: string) => s.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_\-]/g, '_')
+    const full = `${safe(serverName)}__${safe(toolName)}`
+    const trimmed = full.length > 64 ? full.substring(0, 64) : full
+    return /^[a-zA-Z_]/.test(trimmed) ? trimmed : `_${trimmed}`.substring(0, 64)
+}
+
+/**
+ * Persist MCP tool definitions to the mcp_tools table.
+ * Called when a server connects or reconnects.
+ * Deletes existing tools for the server first, then inserts fresh data.
+ */
+export function syncMCPToolsToDB(
+    serverId: string,
+    serverName: string,
+    tools: MCPToolDefinition[]
+): void {
+    const db = getDb()
+
+    try {
+        const deleteExisting = db.prepare("DELETE FROM mcp_tools WHERE server_id = ?")
+        deleteExisting.run(serverId)
+
+        if (tools.length === 0) {
+            log.debug(`[mcp:tool-sync] No tools to persist for server ${serverName}`)
+            return
+        }
+
+        const insertTool = db.prepare(`
+            INSERT INTO mcp_tools(id, server_id, server_name, tool_name, description, category, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, 'mcp', 1, (unixepoch()), (unixepoch()))
+        `)
+
+        let count = 0
+        for (const tool of tools) {
+            const id = mcpToolId(serverName, tool.name)
+            insertTool.run(id, serverId, serverName, tool.name, tool.description || "")
+            count++
+        }
+
+        log.info(`[mcp:tool-sync] Persisted ${count} MCP tools for server ${serverName} to mcp_tools`)
+    } catch (err) {
+        log.error(`[mcp:tool-sync] Failed to persist MCP tools for server ${serverName}:`, err)
+    }
+}
+
+/**
+ * Sync all active MCP tools from mcp_tools table to mcp_tools_fts.
+ * Called after syncMCPToolsToDB or after startup to ensure FTS5 is in sync.
+ *
+ * This does a full clear + re-insert to avoid schema drift.
+ */
+export async function syncMCPToolsToFTS(): Promise<void> {
+    const db = getDb()
+
+    try {
+        const syncTransaction = db.transaction(() => {
+            // Verify table exists
+            const tableCheck = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='mcp_tools_fts'").get()
+            if (!tableCheck) {
+                throw new Error("mcp_tools_fts table does not exist!")
+            }
+
+            // Clear existing FTS data
+            db.run("DELETE FROM mcp_tools_fts")
+
+            // Re-populate from mcp_tools where active
+            const mcpTools = db.query(`
+                SELECT id, server_name, tool_name, description, category
+                FROM mcp_tools
+                WHERE active = 1
+            `).all() as Array<{ id: string; server_name: string; tool_name: string; description: string; category: string }>
+
+            if (mcpTools.length === 0) {
+                log.debug(`[mcp:tool-sync] No MCP tools to sync to FTS5`)
+                return
+            }
+
+            const insert = db.prepare(`
+                INSERT INTO mcp_tools_fts(id, server_name, tool_name, description, category)
+                VALUES (?, ?, ?, ?, ?)
+            `)
+
+            for (const tool of mcpTools) {
+                insert.run(tool.id, tool.server_name, tool.tool_name, tool.description, tool.category)
+            }
+
+            log.info(`[mcp:tool-sync] Synced ${mcpTools.length} MCP tools to mcp_tools_fts`)
+        })
+
+        syncTransaction()
+    } catch (err) {
+        log.error(`[mcp:tool-sync] Failed to sync MCP tools to FTS5:`, err)
+    }
+}
+
+/**
+ * Delete all MCP tool definitions for a server from both mcp_tools and mcp_tools_fts.
+ * Called when a server disconnects or is removed.
+ */
+export function clearMCPToolsFromDB(serverId: string): void {
+    const db = getDb()
+
+    try {
+        // Delete from mcp_tools (CASCADE will handle FTS5 via trigger or manual sync)
+        const result = db.query("DELETE FROM mcp_tools WHERE server_id = ?").run(serverId)
+
+        log.info(`[mcp:tool-sync] Cleared MCP tools for server_id=${serverId}`)
+
+        // Re-sync FTS5 to remove stale entries
+        syncMCPToolsToFTSSync()
+    } catch (err) {
+        log.error(`[mcp:tool-sync] Failed to clear MCP tools for server_id=${serverId}:`, err)
+    }
+}
+
+/**
+ * Synchronous version of syncMCPToolsToFTS for use in clearMCPToolsFromDB.
+ * Avoids async/await in transaction that was already started.
+ */
+function syncMCPToolsToFTSSync(): void {
+    const db = getDb()
+
+    try {
+        db.run("DELETE FROM mcp_tools_fts")
+
+        const mcpTools = db.query(`
+            SELECT id, server_name, tool_name, description, category
+            FROM mcp_tools
+            WHERE active = 1
+        `).all() as Array<{ id: string; server_name: string; tool_name: string; description: string; category: string }>
+
+        if (mcpTools.length === 0) return
+
+        const insert = db.prepare(`
+            INSERT INTO mcp_tools_fts(id, server_name, tool_name, description, category)
+            VALUES (?, ?, ?, ?, ?)
+        `)
+
+        for (const tool of mcpTools) {
+            insert.run(tool.id, tool.server_name, tool.tool_name, tool.description, tool.category)
+        }
+
+        log.debug(`[mcp:tool-sync] Re-synced ${mcpTools.length} MCP tools to FTS5 after deletion`)
+    } catch (err) {
+        log.error(`[mcp:tool-sync] Failed to re-sync MCP tools to FTS5:`, err)
+    }
+}

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

@@ -0,0 +1,2 @@
+export type { ContentPart, ImageInput, DocumentInput, VisionConfig, MultimodalMessageType } from "./types"
+export { multimodalService } from "./vision-service"

package/packages/core/src/multimodal/types.ts

@@ -0,0 +1,28 @@
+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 ImageInput {
+  type: "url" | "base64" | "buffer"
+  data: string | Buffer
+  mimeType?: string
+  caption?: string
+}
+
+export interface DocumentInput {
+  type: "url" | "base64" | "buffer"
+  data: string | Buffer
+  mimeType: string
+  fileName?: string
+}
+
+export interface VisionConfig {
+  visionEnabled: boolean
+  ocrProvider: string | null
+  visionProvider: string | null
+  visionModelId: string | null
+}
+
+export type MultimodalMessageType = "text" | "image" | "document" | "audio"

package/packages/core/src/multimodal/vision-service.ts

@@ -0,0 +1,283 @@
+import { getDb } from "../storage/sqlite"
+import { loadProviderApiKey } from "../storage/crypto"
+import { logger } from "../utils/logger"
+import type { ImageInput, DocumentInput, VisionConfig } from "./types"
+import type { ContentPart } from "./types"
+
+const log = logger.child("multimodal")
+
+class MultimodalService {
+  private static instance: MultimodalService
+
+  private constructor() {}
+
+  static getInstance(): MultimodalService {
+    if (!MultimodalService.instance) {
+      MultimodalService.instance = new MultimodalService()
+    }
+    return MultimodalService.instance
+  }
+
+  getChannelVisionConfig(channelId: string): VisionConfig {
+    const db = getDb()
+    const result = db.query(`
+      SELECT vision_enabled, ocr_provider, vision_provider, vision_model_id
+      FROM channels WHERE id = ?
+    `).get(channelId) as {
+      vision_enabled: number
+      ocr_provider: string | null
+      vision_provider: string | null
+      vision_model_id: string | null
+    } | undefined
+
+    if (!result) {
+      return { visionEnabled: false, ocrProvider: null, visionProvider: null, visionModelId: null }
+    }
+
+    return {
+      visionEnabled: result.vision_enabled === 1,
+      ocrProvider: result.ocr_provider,
+      visionProvider: result.vision_provider,
+      visionModelId: result.vision_model_id,
+    }
+  }
+
+  async processImage(image: ImageInput, visionModelId?: string): Promise<ContentPart[]> {
+    const parts: ContentPart[] = []
+
+    if (image.caption) {
+      parts.push({ type: "text", text: image.caption })
+    }
+
+    if (image.type === "url") {
+      parts.push({ type: "image_url", image_url: { url: image.data as string } })
+    } else if (image.type === "base64") {
+      parts.push({
+        type: "image_base64",
+        base64: image.data as string,
+        mimeType: image.mimeType || "image/jpeg",
+      })
+    } else if (image.type === "buffer") {
+      const base64 = Buffer.from(image.data as Buffer).toString("base64")
+      parts.push({
+        type: "image_base64",
+        base64,
+        mimeType: image.mimeType || "image/jpeg",
+      })
+    }
+
+    return parts
+  }
+
+  async ocrImage(image: ImageInput, providerId?: string): Promise<string> {
+    const resolved = providerId || "openai"
+
+    if (resolved === "openai") {
+      return this.ocrWithOpenAI(image)
+    } else if (resolved === "gemini") {
+      return this.ocrWithGemini(image)
+    } else if (resolved === "anthropic") {
+      return this.ocrWithAnthropic(image)
+    }
+
+    log.warn(`Unknown OCR provider ${resolved}, defaulting to OpenAI`)
+    return this.ocrWithOpenAI(image)
+  }
+
+  normalizeImageFromChannel(channelType: string, imageData: unknown): ImageInput {
+    const data = imageData as { url?: string; base64?: string; buffer?: Buffer; mimeType?: string; caption?: string }
+
+    if (data.url) {
+      return { type: "url", data: data.url, mimeType: data.mimeType, caption: data.caption }
+    }
+    if (data.base64) {
+      return { type: "base64", data: data.base64, mimeType: data.mimeType || "image/jpeg", caption: data.caption }
+    }
+    if (data.buffer) {
+      return { type: "buffer", data: data.buffer, mimeType: data.mimeType || "image/jpeg", caption: data.caption }
+    }
+
+    throw new Error(`${channelType} image missing url, base64, or buffer`)
+  }
+
+  normalizeDocumentFromChannel(channelType: string, docData: unknown): DocumentInput {
+    const data = docData as { url?: string; base64?: string; buffer?: Buffer; mimeType?: string; fileName?: string }
+
+    if (data.url) {
+      return { type: "url", data: data.url, mimeType: data.mimeType || "application/pdf", fileName: data.fileName }
+    }
+    if (data.base64) {
+      return { type: "base64", data: data.base64, mimeType: data.mimeType || "application/pdf", fileName: data.fileName }
+    }
+    if (data.buffer) {
+      return { type: "buffer", data: data.buffer, mimeType: data.mimeType || "application/pdf", fileName: data.fileName }
+    }
+
+    throw new Error(`${channelType} document missing url, base64, or buffer`)
+  }
+
+  async resolveImageUrl(image: ImageInput): Promise<string> {
+    if (image.type === "url") return image.data as string
+    if (image.type === "base64") {
+      const mime = image.mimeType || "image/jpeg"
+      return `data:${mime};base64,${image.data as string}`
+    }
+    if (image.type === "buffer") {
+      const base64 = Buffer.from(image.data as Buffer).toString("base64")
+      const mime = image.mimeType || "image/jpeg"
+      return `data:${mime};base64,${base64}`
+    }
+    throw new Error("Cannot resolve image URL")
+  }
+
+  private async getProviderApiKey(providerId: string): Promise<string | null> {
+    const db = getDb()
+    const apiKey = await loadProviderApiKey(providerId)
+    return apiKey || null
+  }
+
+  private async ocrWithOpenAI(image: ImageInput): Promise<string> {
+    const key = await this.getProviderApiKey("openai") || process.env.OPENAI_API_KEY
+    if (!key) throw new Error("OPENAI_API_KEY not configured for OCR")
+
+    const imageUrl = await this.resolveImageUrl(image)
+
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+      body: JSON.stringify({
+        model: "gpt-4o-mini",
+        messages: [{
+          role: "user",
+          content: [
+            { type: "text", text: "Describe el contenido de esta imagen en detalle. Si hay texto, transcríbelo exactamente." },
+            { type: "image_url", image_url: { url: imageUrl } },
+          ],
+        }],
+        max_tokens: 1000,
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`OpenAI OCR failed: ${error}`)
+    }
+
+    const data = await response.json() as { choices: Array<{ message: { content: string } }> }
+    return data.choices[0]?.message?.content || ""
+  }
+
+  private async ocrWithGemini(image: ImageInput): Promise<string> {
+    const key = await this.getProviderApiKey("gemini") || process.env.GEMINI_API_KEY
+    if (!key) throw new Error("GEMINI_API_KEY not configured for OCR")
+
+    let imagePart: any
+    if (image.type === "url") {
+      const imgResponse = await fetch(image.data as string)
+      const buffer = Buffer.from(await imgResponse.arrayBuffer())
+      imagePart = { inlineData: { data: buffer.toString("base64"), mimeType: image.mimeType || "image/jpeg" } }
+    } else if (image.type === "base64") {
+      imagePart = { inlineData: { data: image.data as string, mimeType: image.mimeType || "image/jpeg" } }
+    } else {
+      imagePart = { inlineData: { data: Buffer.from(image.data as Buffer).toString("base64"), mimeType: image.mimeType || "image/jpeg" } }
+    }
+
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${key}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: "Describe el contenido de esta imagen en detalle. Si hay texto, transcríbelo exactamente." }, imagePart] }],
+        }),
+      },
+    )
+
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Gemini OCR failed: ${error}`)
+    }
+
+    const data = await response.json() as { candidates: Array<{ content: { parts: Array<{ text?: string }> } }> }
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || ""
+  }
+
+  private async ocrWithAnthropic(image: ImageInput): Promise<string> {
+    const key = await this.getProviderApiKey("anthropic") || process.env.ANTHROPIC_API_KEY
+    if (!key) throw new Error("ANTHROPIC_API_KEY not configured for OCR")
+
+    const imageUrl = await this.resolveImageUrl(image)
+
+    let source: any
+    if (imageUrl.startsWith("data:")) {
+      const match = imageUrl.match(/^data:([^;]+);base64,(.+)$/)
+      if (match) {
+        source = { type: "base64", media_type: match[1], data: match[2] }
+      } else {
+        throw new Error("Invalid base64 data URL")
+      }
+    } else {
+      source = { type: "url", url: imageUrl }
+    }
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": key,
+        "anthropic-version": "2023-06-01",
+        "anthropic-dangerous-direct-browser-access": "true",
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 1000,
+        messages: [{
+          role: "user",
+          content: [
+            { type: "image", source },
+            { type: "text", text: "Describe el contenido de esta imagen en detalle. Si hay texto, transcríbelo exactamente." },
+          ],
+        }],
+      }),
+    })
+
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Anthropic OCR failed: ${error}`)
+    }
+
+    const data = await response.json() as { content: Array<{ type: string; text?: string }> }
+    const textBlock = data.content?.find(b => b.type === "text" && b.text)
+    return textBlock?.text || ""
+  }
+
+  getConfiguredVisionProviders(): Record<string, boolean> {
+    const db = getDb()
+    const hasDbKey = (providerId: string): boolean => {
+      const row = db.query(
+        `SELECT api_key_encrypted FROM providers WHERE id = ? AND api_key_encrypted IS NOT NULL AND api_key_encrypted != ''`
+      ).get(providerId) as { api_key_encrypted: string } | undefined
+      return !!row
+    }
+
+    return {
+      openai: hasDbKey("openai") || !!(process.env.OPENAI_API_KEY),
+      gemini: hasDbKey("gemini") || !!(process.env.GEMINI_API_KEY),
+      anthropic: hasDbKey("anthropic") || !!(process.env.ANTHROPIC_API_KEY),
+    }
+  }
+
+  modelSupportsVision(providerId: string, modelId: string): boolean {
+    const db = getDb()
+    const model = db.query(`SELECT capabilities FROM models WHERE id = ? AND provider_id = ?`).get(modelId, providerId) as { capabilities: string } | undefined
+    if (!model?.capabilities) return false
+    try {
+      const caps = JSON.parse(model.capabilities) as string[]
+      return caps.includes("vision")
+    } catch {
+      return false
+    }
+  }
+}
+
+export const multimodalService = MultimodalService.getInstance()

package/packages/core/src/plugins/api.ts

@@ -0,0 +1,128 @@
+import type { Logger, ChildLogger } from "../utils/logger.ts";
+import type { eventBus, EventMap, EventKey } from "../events/event-bus.ts";
+import type { StateStore } from "../state/store.ts";
+
+export interface PluginManifest {
+  name: string;
+  version: string;
+  description?: string;
+  author?: string;
+  dependencies?: string[];
+  hiveVersion?: string;
+  main?: string;
+  enabled?: boolean;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: Record<string, ParameterDefinition>;
+  execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+
+export interface ParameterDefinition {
+  type: "string" | "number" | "boolean" | "object" | "array";
+  description?: string;
+  required?: boolean;
+  default?: unknown;
+  enum?: string[];
+  items?: ParameterDefinition;
+  properties?: Record<string, ParameterDefinition>;
+}
+
+export interface ChannelDefinition {
+  name: string;
+  type: string;
+  config: Record<string, unknown>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  send: (sessionId: string, message: unknown) => Promise<void>;
+}
+
+export interface CLICommand {
+  name: string;
+  description: string;
+  handler: (args: string[], options: Record<string, unknown>) => Promise<void>;
+  options?: Record<string, CommandOption>;
+}
+
+export interface CommandOption {
+  alias?: string;
+  description?: string;
+  type?: "string" | "boolean" | "number";
+  default?: unknown;
+}
+
+export interface PluginContext {
+  pluginName: string;
+  logger: ChildLogger;
+  config: Record<string, unknown>;
+  registerTool: (tool: ToolDefinition) => void;
+  unregisterTool: (name: string) => void;
+  registerChannel: (channel: ChannelDefinition) => void;
+  unregisterChannel: (name: string) => void;
+  registerCommand: (command: CLICommand) => void;
+  unregisterCommand: (name: string) => void;
+  events: {
+    emit: <K extends EventKey>(event: K, data: EventMap[K]) => void;
+    on: <K extends EventKey>(event: K, handler: (data: EventMap[K]) => void | Promise<void>) => () => void;
+    once: <K extends EventKey>(event: K, handler: (data: EventMap[K]) => void | Promise<void>) => void;
+  };
+  state: {
+    get: () => ReturnType<StateStore["getState"]>;
+    subscribe: (listener: (state: ReturnType<StateStore["getState"]>) => void) => () => void;
+  };
+  getTool: (name: string) => ToolDefinition | undefined;
+  getTools: () => ToolDefinition[];
+}
+
+export interface InboundMessage {
+  sessionId: string;
+  channel: string;
+  userId: string;
+  content: string;
+  timestamp: number;
+}
+
+export interface AgentResponse {
+  sessionId: string;
+  content: string;
+  toolsUsed: string[];
+  duration: number;
+}
+
+export interface PluginToolCall {
+  name: string;
+  args: Record<string, unknown>;
+  sessionId: string;
+}
+
+export type MiddlewareNext = () => Promise<void>;
+export type MiddlewareResult = Promise<void>;
+
+export interface HivePlugin {
+  name: string;
+  version: string;
+  dependencies?: string[];
+  manifest?: PluginManifest;
+
+  activate(context: PluginContext): Promise<void>;
+  deactivate(): Promise<void>;
+
+  onMessage?: (message: InboundMessage, next: MiddlewareNext) => MiddlewareResult;
+  onAgentResponse?: (response: AgentResponse, next: MiddlewareNext) => MiddlewareResult;
+  onToolCall?: (call: PluginToolCall, next: () => Promise<unknown>) => Promise<unknown>;
+  onError?: (error: Error, context: Record<string, unknown>) => Promise<void>;
+}
+
+export interface PluginState {
+  name: string;
+  status: "inactive" | "activating" | "active" | "deactivating" | "error";
+  version: string;
+  enabled: boolean;
+  error?: string;
+  loadedAt?: number;
+  activatedAt?: number;
+}
+
+export type PluginConstructor = new () => HivePlugin;

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

@@ -0,0 +1,2 @@
+export * from "./api.ts";
+export * from "./loader.ts";