@johpaz/hive-sdk 0.1.4 → 0.1.5

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

@@ -1,293 +0,0 @@
-import { getDb } from "../storage/SQLiteStorage.ts"
-import { decryptApiKey } from "../storage/crypto.ts"
-import { logger } from "../utils/logger.ts"
-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 provider = db.query(`
-      SELECT api_key_encrypted, api_key_iv FROM providers WHERE id = ?
-    `).get(providerId) as { api_key_encrypted: string; api_key_iv: string } | undefined
-
-    if (!provider?.api_key_encrypted) return null
-
-    try {
-      return await decryptApiKey(provider.api_key_encrypted, provider.api_key_iv)
-    } catch (error) {
-      log.error(`Failed to decrypt API key for provider ${providerId}: ${(error as Error).message}`)
-      return 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/scheduler/dag/AgentExecutor.ts

@@ -1,53 +0,0 @@
-/**
- * DAGScheduler — AgentExecutor
- *
- * Bridges the DAGScheduler to the existing runAgentIsolated() call.
- * Adds timeout enforcement via Promise.race().
- *
- * NOTE: There are no Bun Worker threads in Hive OSS. "Workers" are logical
- * agents stored in the DB and executed as async calls in the same process.
- * Parallelism is achieved by launching multiple runAgentIsolated() calls
- * concurrently without awaiting each one serially.
- */
-
-import { runAgentIsolated } from "../../agent/AgentRunner"
-import { TaskNode } from "./TaskNode"
-import { TaskTimeoutError } from "./errors"
-
-export class AgentExecutor {
-  /**
-   * Execute a TaskNode.
-   * Injects dependency results into the task description as context.
-   * Returns the final text output from the agent.
-   */
-  async execute(
-    node: TaskNode,
-    depResults: Record<string, string>,
-    threadId: string
-  ): Promise<string> {
-    const hasDeps = Object.keys(depResults).length > 0
-    const contextBlock = hasDeps
-      ? `\n\n---\nContext from completed dependencies:\n${JSON.stringify(depResults, null, 2)}\n---`
-      : ""
-
-    const taskDescription = node.taskDescription + contextBlock
-
-    const agentPromise = runAgentIsolated({
-      agentId: node.agentId,
-      taskDescription,
-      threadId,
-    })
-
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      const t = setTimeout(() => {
-        reject(new TaskTimeoutError(node.id, node.timeout))
-      }, node.timeout)
-      // Ensure the timeout timer doesn't prevent process exit
-      if (typeof t === "object" && t !== null && "unref" in t) {
-        (t as any).unref()
-      }
-    })
-
-    return Promise.race([agentPromise, timeoutPromise])
-  }
-}

package/packages/core/src/scheduler/dag/DAGScheduler.ts

@@ -1,250 +0,0 @@
-/**
- * DAGScheduler — Main orchestrator
- *
- * Executes a TaskGraph by:
- *   1. Identifying all nodes with no dependencies → mark READY
- *   2. Launching them concurrently via AgentExecutor (respecting maxConcurrentWorkers)
- *   3. When a node completes, finding newly unblocked nodes and launching them
- *   4. Propagating failures to dependent nodes
- *   5. Emitting progress via EventBridge → agentBus + canvas
- *
- * Parallelism model: Promise.race() over a Set of active promises + a FIFO/priority
- * queue of READY nodes waiting for a slot. No Bun Worker threads — workers are async
- * agent calls (runAgentIsolated) running concurrently in the same process.
- */
-
-import { writeFileSync, mkdirSync, existsSync } from "node:fs"
-import * as path from "node:path"
-import { logger } from "../../utils/logger"
-import { TaskGraph } from "./TaskGraph"
-import { TaskNode } from "./TaskNode"
-import { AgentExecutor } from "./AgentExecutor"
-import { EventBridge } from "./EventBridge"
-import { TaskFailureError } from "./errors"
-import type { DAGResult, NodeSummary } from "./TaskResult"
-import type { ExecutionStrategy } from "./strategies/ParallelStrategy"
-import { ParallelStrategy } from "./strategies/ParallelStrategy"
-
-const log = logger.child("dag-scheduler")
-
-export interface IAgentExecutor {
-  execute(node: TaskNode, depResults: Record<string, string>, threadId: string): Promise<string>
-}
-
-export interface DAGSchedulerOptions {
-  strategy?: ExecutionStrategy
-  maxConcurrentWorkers?: number
-  /** Project ID for agentBus/canvas events */
-  projectId?: string
-  /** Coordinator agent ID for agentBus events */
-  coordinatorId?: string
-  /** Disables ASCII log and file logging. Default: false in development */
-  silent?: boolean
-  /** Custom executor — defaults to AgentExecutor (runAgentIsolated). Override to bypass context-compiler. */
-  executor?: IAgentExecutor
-}
-
-export class DAGScheduler {
-  private strategy: ExecutionStrategy
-  private maxConcurrentWorkers: number
-  private executor: IAgentExecutor
-  private aborted = false
-
-  constructor(options: DAGSchedulerOptions = {}) {
-    this.strategy = options.strategy ?? new ParallelStrategy()
-    this.maxConcurrentWorkers = options.maxConcurrentWorkers ?? 2
-    this.executor = options.executor ?? new AgentExecutor()
-  }
-
-  abort(): void {
-    this.aborted = true
-  }
-
-  async execute(graph: TaskGraph, options: DAGSchedulerOptions = {}): Promise<DAGResult> {
-    this.aborted = false
-    const swarmId = crypto.randomUUID()
-    const startedAt = Date.now()
-
-    const projectId = options.projectId ?? `swarm:${swarmId}`
-    const coordinatorId = options.coordinatorId ?? "dag-scheduler"
-    const silent = options.silent ?? (process.env.NODE_ENV === "production")
-
-    const bridge = new EventBridge(swarmId, projectId, coordinatorId)
-
-    // Allow strategy to precompute (e.g. critical path)
-    if (this.strategy.initialize) {
-      this.strategy.initialize(graph.nodes)
-    }
-
-    bridge.onSwarmStarted(graph.nodes.size)
-    this.logState(swarmId, graph, startedAt, silent, swarmId)
-
-    // Seed the READY queue with nodes that have no dependencies
-    const readyQueue: TaskNode[] = []
-    const completedIds = graph.getCompletedIds()
-
-    for (const node of graph.nodes.values()) {
-      if (node.deps.length === 0) {
-        node.markReady()
-        readyQueue.push(node)
-      }
-    }
-
-    // Active promise set — we track them with a wrapper so we can drain
-    const running = new Set<Promise<void>>()
-
-    const launchNode = (node: TaskNode): void => {
-      if (this.aborted) return
-
-      node.markRunning()
-      bridge.onTaskStarted(node)
-      this.logState(swarmId, graph, startedAt, silent, swarmId)
-
-      const depResults = graph.getDepResults(node.id)
-      const threadId = `dag-${swarmId}-${node.id}`
-
-      const p: Promise<void> = this.executor
-        .execute(node, depResults, threadId)
-        .then(result => {
-          node.markCompleted(result)
-          log.info(`[DAG] ${node.name} COMPLETED in ${node.elapsedSeconds()}s`)
-          bridge.onTaskCompleted(node, graph.getProgress())
-          this.logState(swarmId, graph, startedAt, silent, swarmId)
-
-          // Unlock dependent nodes
-          const newlyReady = graph.getNewlyReadyNodes(graph.getCompletedIds())
-          for (const n of newlyReady) {
-            n.markReady()
-            readyQueue.push(n)
-          }
-        })
-        .catch(err => {
-          const error = err instanceof Error ? err.message : String(err)
-
-          if (node.canRetry()) {
-            node.retryCount++
-            log.warn(`[DAG] ${node.name} failed (retry ${node.retryCount}/${node.maxRetries}): ${error}`)
-            node.status = "PENDING"
-            node.markReady()
-            readyQueue.push(node)
-          } else {
-            node.markFailed(error)
-            log.error(`[DAG] ${node.name} FAILED permanently: ${error}`)
-            bridge.onTaskFailed(node, graph.getProgress())
-            graph.propagateFailure(node.id, error)
-            this.logState(swarmId, graph, startedAt, silent, swarmId)
-          }
-        })
-        .finally(() => {
-          running.delete(p)
-          drain()
-        })
-
-      running.add(p)
-    }
-
-    // Drain the ready queue into available worker slots
-    const drain = (): void => {
-      while (readyQueue.length > 0 && running.size < this.maxConcurrentWorkers && !this.aborted) {
-        const node = this.strategy.pick(readyQueue)
-        if (!node) break
-        launchNode(node)
-      }
-    }
-
-    // Start initial drain
-    drain()
-
-    // Wait until the graph is complete
-    while (!graph.isComplete() && !this.aborted) {
-      if (running.size === 0 && readyQueue.length === 0) {
-        // Deadlock guard: no running, nothing ready, but graph not done
-        // This can happen if all remaining nodes are FAILED
-        break
-      }
-      // Wait for any active promise to settle
-      if (running.size > 0) {
-        await Promise.race([...running])
-        drain()
-      } else {
-        // Brief yield to let microtasks settle
-        await new Promise(resolve => setTimeout(resolve, 10))
-      }
-    }
-
-    // Collect results
-    const completed: NodeSummary[] = []
-    const failed: NodeSummary[] = []
-
-    for (const node of graph.nodes.values()) {
-      const summary: NodeSummary = {
-        id: node.id,
-        name: node.name,
-        status: node.status === "COMPLETED" ? "COMPLETED" : "FAILED",
-        durationMs: node.startedAt ? (node.completedAt ?? Date.now()) - node.startedAt : 0,
-        result: node.result,
-        error: node.error,
-        retries: node.retryCount,
-      }
-      if (node.status === "COMPLETED") completed.push(summary)
-      else failed.push(summary)
-    }
-
-    const result: DAGResult = {
-      swarmId,
-      totalDurationMs: Date.now() - startedAt,
-      completed,
-      failed,
-      success: failed.length === 0,
-    }
-
-    bridge.onSwarmCompleted(result)
-    this.logState(swarmId, graph, startedAt, silent, swarmId)
-
-    log.info(`[DAG] swarm ${swarmId} finished. ${completed.length} completed, ${failed.length} failed. Total: ${Math.round(result.totalDurationMs / 1000)}s`)
-
-    return result
-  }
-
-  // ─── ASCII log ───────────────────────────────────────────────────────────────
-
-  private logState(
-    swarmId: string,
-    graph: TaskGraph,
-    startedAt: number,
-    silent: boolean,
-    sessionId: string
-  ): void {
-    const elapsed = Math.round((Date.now() - startedAt) / 1000)
-    const lines: string[] = [`[DAG] swarm:${swarmId.slice(0, 8)} T+${elapsed}s`]
-
-    for (const node of graph.nodes.values()) {
-      const icon =
-        node.status === "COMPLETED" ? "✓" :
-        node.status === "FAILED"    ? "✗" :
-        node.status === "RUNNING"   ? "●" : "○"
-
-      const depStr = node.deps.length > 0 ? `  (deps: ${node.deps.join(", ")})` : ""
-      const timeStr = node.startedAt ? `  (${node.elapsedSeconds()}s)` : ""
-      const statusLabel = node.status.padEnd(10)
-
-      lines.push(`  ${icon} ${node.name.padEnd(24)} ${statusLabel}${timeStr}${depStr}`)
-    }
-
-    const output = lines.join("\n")
-
-    if (!silent) {
-      // Write to log file (never committed — in .gitignore)
-      try {
-        const logDir = path.join(process.cwd(), "packages", "core", "logs")
-        if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true })
-        const logFile = path.join(logDir, `dag-${sessionId.slice(0, 8)}.log`)
-        writeFileSync(logFile, output + "\n\n", { flag: "a" })
-      } catch {
-        // Non-critical — never throw for logging
-      }
-    }
-
-    log.debug(output)
-  }
-}