@johpaz/hive-sdk 0.0.15 → 0.0.16

package/packages/core/src/gateway/server.ts

@@ -0,0 +1,139 @@
+/**
+ * Hive Gateway — simplified HTTP/WebSocket server for the SDK harness.
+ *
+ * Provides:
+ * - POST /chat — chat with an agent
+ * - GET /status — health check
+ * - WebSocket /ws — real-time streaming
+ */
+
+import { logger } from "../utils/logger";
+import { runAgent } from "../agent/AgentRunner";
+import type { MCPClientManager } from "../mcp/index";
+
+const log = logger.child("gateway");
+
+export interface GatewayConfig {
+  host?: string;
+  port?: number;
+  agentId?: string;
+  mcpManager?: MCPClientManager | null;
+}
+
+export async function startGateway(config: GatewayConfig = {}) {
+  const host = config.host ?? "127.0.0.1";
+  const port = config.port ?? 18790;
+  const agentId = config.agentId ?? "main";
+
+  log.info(`Starting gateway on ${host}:${port}`);
+
+  const server = Bun.serve({
+    hostname: host,
+    port,
+    fetch(req, server) {
+      const url = new URL(req.url);
+
+      // WebSocket upgrade
+      if (url.pathname === "/ws") {
+        const success = server.upgrade(req);
+        if (success) return undefined as any;
+      }
+
+      // Health check
+      if (url.pathname === "/status" && req.method === "GET") {
+        return Response.json({
+          status: "ok",
+          gateway: true,
+          agentId,
+          uptime: process.uptime(),
+        });
+      }
+
+      // Chat endpoint
+      if (url.pathname === "/chat" && req.method === "POST") {
+        return handleChat(req, agentId, config.mcpManager);
+      }
+
+      return new Response("Not Found", { status: 404 });
+    },
+    websocket: {
+      async message(ws, message) {
+        try {
+          const data = JSON.parse(String(message));
+          const threadId = data.threadId ?? crypto.randomUUID();
+
+          const stream = runAgent({
+            agentId,
+            userMessage: data.message ?? "",
+            threadId,
+            channel: "webchat",
+            mcpManager: config.mcpManager,
+          });
+
+          for await (const chunk of stream) {
+            ws.send(JSON.stringify(chunk));
+          }
+          ws.send(JSON.stringify({ done: true }));
+        } catch (err) {
+          log.error("WebSocket error:", err);
+          ws.send(JSON.stringify({ error: (err as Error).message }));
+        }
+      },
+      open(ws) {
+        log.info("WebSocket client connected");
+      },
+      close(ws, code, reason) {
+        log.info("WebSocket client disconnected");
+      },
+    },
+  });
+
+  log.info(`Gateway ready at http://${host}:${port}`);
+  return server;
+}
+
+async function handleChat(
+  req: Request,
+  agentId: string,
+  mcpManager?: MCPClientManager | null
+): Promise<Response> {
+  try {
+    const body = await req.json();
+    const message = body.message ?? "";
+    const threadId = body.threadId ?? crypto.randomUUID();
+
+    const stream = runAgent({
+      agentId,
+      userMessage: message,
+      threadId,
+      channel: "webchat",
+      mcpManager,
+    });
+
+    const chunks: any[] = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+
+    // Extract text from the last agent message
+    let responseText = "";
+    for (const chunk of chunks) {
+      if (chunk.agent?.messages) {
+        for (const msg of chunk.agent.messages) {
+          if (msg.content && typeof msg.content === "string") {
+            responseText = msg.content;
+          }
+        }
+      }
+    }
+
+    return Response.json({
+      response: responseText,
+      threadId,
+      chunks,
+    });
+  } catch (err) {
+    log.error("Chat error:", err);
+    return Response.json({ error: (err as Error).message }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,157 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface HealthStatus {
+  status: "healthy" | "degraded" | "unhealthy";
+  checks: Record<string, {
+    status: "ok" | "warning" | "error";
+    message?: string;
+    latency?: number;
+  }>;
+  uptime: number;
+  lastCheck: Date;
+}
+
+export interface HeartbeatOptions {
+  intervalMs?: number;
+  onHealthChange?: (status: HealthStatus) => void;
+}
+
+type HealthCheck = () => Promise<{
+  status: "ok" | "warning" | "error";
+  message?: string;
+  latency?: number;
+}>;
+
+export class Heartbeat {
+  private intervalMs: number;
+  private checks: Map<string, HealthCheck> = new Map();
+  private intervalId: Timer | null = null;
+  private startTime: Date;
+  private lastStatus: HealthStatus | null = null;
+  private onHealthChange?: (status: HealthStatus) => void;
+  private log = logger.child("heartbeat");
+
+  constructor(_config: Config, options: HeartbeatOptions = {}) {
+    this.intervalMs = options.intervalMs ?? 30000;
+    this.onHealthChange = options.onHealthChange;
+    this.startTime = new Date();
+  }
+
+  registerCheck(name: string, check: HealthCheck): void {
+    this.checks.set(name, check);
+    this.log.debug(`Registered health check: ${name}`);
+  }
+
+  removeCheck(name: string): boolean {
+    return this.checks.delete(name);
+  }
+
+  async runChecks(): Promise<HealthStatus> {
+    const checks: HealthStatus["checks"] = {};
+    let overallStatus: "healthy" | "degraded" | "unhealthy" = "healthy";
+
+    for (const [name, check] of this.checks) {
+      try {
+        const start = Date.now();
+        const result = await check();
+        const latency = Date.now() - start;
+
+        checks[name] = {
+          status: result.status,
+          message: result.message,
+          latency: result.latency ?? latency,
+        };
+
+        if (result.status === "warning" && overallStatus === "healthy") {
+          overallStatus = "degraded";
+        } else if (result.status === "error") {
+          overallStatus = "unhealthy";
+        }
+      } catch (error) {
+        checks[name] = {
+          status: "error",
+          message: (error as Error).message,
+        };
+        overallStatus = "unhealthy";
+      }
+    }
+
+    const status: HealthStatus = {
+      status: overallStatus,
+      checks,
+      uptime: Date.now() - this.startTime.getTime(),
+      lastCheck: new Date(),
+    };
+
+    const prevStatus = this.lastStatus?.status;
+    if (prevStatus && prevStatus !== overallStatus) {
+      this.log.info(`Health status changed: ${prevStatus} -> ${overallStatus}`);
+      this.onHealthChange?.(status);
+    }
+
+    this.lastStatus = status;
+    return status;
+  }
+
+  start(): void {
+    if (this.intervalId) {
+      this.log.warn("Heartbeat already running");
+      return;
+    }
+
+    this.runChecks();
+
+    this.intervalId = setInterval(async () => {
+      await this.runChecks();
+    }, this.intervalMs);
+
+    this.log.info(`Heartbeat started (interval: ${this.intervalMs}ms)`);
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      this.log.info("Heartbeat stopped");
+    }
+  }
+
+  getStatus(): HealthStatus | null {
+    return this.lastStatus;
+  }
+
+  isRunning(): boolean {
+    return this.intervalId !== null;
+  }
+}
+
+export function createHeartbeat(config: Config, options?: HeartbeatOptions): Heartbeat {
+  const heartbeat = new Heartbeat(config, options);
+
+  heartbeat.registerCheck("memory", async () => {
+    const memUsage = process.memoryUsage();
+    const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+    const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
+    const ratio = memUsage.heapUsed / memUsage.heapTotal;
+
+    if (ratio > 0.9) {
+      return {
+        status: "error",
+        message: `Memory critically high: ${heapUsedMB}/${heapTotalMB}MB`,
+      };
+    } else if (ratio > 0.75) {
+      return {
+        status: "warning",
+        message: `Memory usage high: ${heapUsedMB}/${heapTotalMB}MB`,
+      };
+    }
+
+    return {
+      status: "ok",
+      message: `${heapUsedMB}/${heapTotalMB}MB used`,
+    };
+  });
+
+  return heartbeat;
+}

package/packages/core/src/index.ts

@@ -1,37 +1,81 @@
+// ─── API ─────────────────────────────────────────────────────────────────────
 export { createAgent } from "./api/index.ts";
 export type { AgentConfig, Agent, AgentEvent } from "./api/index.ts";
 
+// ─── Tools ───────────────────────────────────────────────────────────────────
 export { defineTool } from "./tools/ToolRegistry.ts";
 export type { ToolDefinition } from "./tools/ToolRegistry.ts";
 export { ToolRegistry } from "./tools/ToolRegistry.ts";
 export { ToolExecutor } from "./tools/ToolExecutor.ts";
 export type { ToolExecutionResult } from "./tools/ToolExecutor.ts";
 
+// ─── Skills ──────────────────────────────────────────────────────────────────
 export { defineSkill } from "./skills/defineSkill.ts";
 export type { SkillDefinition } from "./skills/defineSkill.ts";
 export { SkillLoader } from "./skills/index.ts";
 export type { Skill, SkillStep, OutputFormat, SkillsConfig } from "./skills/index.ts";
 
+// ─── Agent ───────────────────────────────────────────────────────────────────
 export { AgentLoop, runAgent, runAgentIsolated, buildAgentLoop, getAgentLoop, rebuildAgentLoop } from "./agent/index.ts";
 export type { AgentLoopOptions, StepEvent, StreamChunk } from "./agent/index.ts";
 export type { Tool, ToolParameter, ToolResult } from "./agent/index.ts";
+
+// ─── Swarm / Scheduler ───────────────────────────────────────────────────────
 export { DAGScheduler } from "./swarm/index.ts";
 export type { DAGSchedulerOptions, IAgentExecutor } from "./swarm/index.ts";
 export { TaskGraph, TaskNode } from "./swarm/index.ts";
 export type { TaskNodeConfig, NodeStatus, DAGResult, NodeSummary } from "./swarm/index.ts";
+export { CronScheduler } from "./scheduler/index.ts";
+export type { CronJob } from "./scheduler/index.ts";
 
+// ─── MCP ─────────────────────────────────────────────────────────────────────
 export { MCPClientManager } from "./mcp/index.ts";
 export type { MCPTool, MCPResource, MCPPrompt, MCPConfig, MCPServerConfig } from "./mcp/index.ts";
 
+// ─── Ethics ──────────────────────────────────────────────────────────────────
 export { EthicsGuard } from "./ethics/index.ts";
 export type { EthicsRule } from "./ethics/index.ts";
 
+// ─── Memory ──────────────────────────────────────────────────────────────────
 export { Scratchpad } from "./memory/index.ts";
 export type { IStorage } from "./memory/index.ts";
 
+// ─── Storage ─────────────────────────────────────────────────────────────────
 export { initializeDatabase, dbService } from "./storage/index.ts";
 
+// ─── Config ──────────────────────────────────────────────────────────────────
 export { loadConfig, loadEnv, getHiveDir } from "./config/index.ts";
 export type { Config } from "./config/index.ts";
 
+// ─── Gateway ─────────────────────────────────────────────────────────────────
+export { startGateway } from "./gateway/index.ts";
+export type { GatewayConfig } from "./gateway/index.ts";
+
+// ─── Channels ────────────────────────────────────────────────────────────────
+export { ChannelManager } from "./channels/manager.ts";
+export { BaseChannel } from "./channels/base.ts";
+export { TelegramChannel } from "./channels/telegram.ts";
+export { DiscordChannel } from "./channels/discord.ts";
+export { WhatsAppChannel } from "./channels/whatsapp.ts";
+export { SlackChannel } from "./channels/slack.ts";
+export { WebChatChannel } from "./channels/webchat.ts";
+
+// ─── Canvas ──────────────────────────────────────────────────────────────────
+export { CanvasManager } from "./canvas/CanvasManager.ts";
+export { emitCanvas, subscribeCanvas, unsubscribeCanvas } from "./canvas/emitter.ts";
+
+// ─── Tool Runtime ────────────────────────────────────────────────────────────
+export { executeToolBatch } from "./tool-runtime/index.ts";
+export type { ToolBatchResult, ExecuteToolBatchOptions } from "./tool-runtime/index.ts";
+
+// ─── Events ──────────────────────────────────────────────────────────────────
+export { eventBus } from "./events/event-bus.ts";
+export { agentBus } from "./events/agent-bus.ts";
+
+// ─── Workers ─────────────────────────────────────────────────────────────────
+export { createWorker, WorkerPool } from "./workers/index.ts";
+export type { WorkerConfig, WorkerInstance, WorkerChunk, WorkerPoolConfig, PoolTask, PoolTaskResult } from "./workers/index.ts";
+
+// ─── Utils ───────────────────────────────────────────────────────────────────
 export { logger } from "./utils/index.ts";
+export { retry } from "./utils/retry.ts";

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

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

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

@@ -0,0 +1,283 @@
+import { getDb } from "../storage/SQLiteStorage"
+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()