@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/tool-runtime/index.ts

@@ -0,0 +1,476 @@
+import { availableParallelism } from "node:os"
+import type { Config } from "../config/loader.ts"
+import { loadConfig } from "../config/loader.ts"
+
+export type ToolCallLike = {
+  id: string
+  function: {
+    name: string
+    arguments: unknown
+  }
+}
+
+export type RuntimeTool = {
+  name: string
+  execute?: (params: Record<string, unknown>, config?: any) => Promise<unknown>
+}
+
+export type ToolRuntimeConfig = {
+  enabled?: boolean
+  maxWorkers?: number
+  toolTimeoutMs?: number
+  parallelToolCalls?: boolean
+}
+
+export type ExecuteToolBatchOptions = {
+  toolCalls: ToolCallLike[]
+  allTools: RuntimeTool[]
+  toolConfig: {
+    user_id?: string
+    thread_id?: string
+    channel?: string
+    workspace?: string | null
+  }
+  hiveConfig?: Config
+  workerPool?: ToolRuntimeConfig
+  mainThreadToolNames?: string[]
+  signal?: AbortSignal
+}
+
+export type ToolBatchResult = {
+  toolCall: ToolCallLike
+  toolName: string
+  result: unknown
+  ok: boolean
+  durationMs: number
+  error?: SerializedError
+  timedOut?: boolean
+  aborted?: boolean
+}
+
+type SerializedError = {
+  name: string
+  message: string
+  stack?: string
+}
+
+type WorkerMessage =
+  | {
+    type: "result"
+    jobId: string
+    ok: boolean
+    result?: unknown
+    error?: SerializedError
+    durationMs: number
+  }
+  | {
+    type: "rpc_call"
+    rpcId: string
+    jobId: string
+    toolName: string
+    args: unknown
+    toolConfig: Record<string, unknown>
+  }
+
+type QueuedJob = {
+  id: string
+  batchId: string
+  index: number
+  toolCall: ToolCallLike
+  allTools: RuntimeTool[]
+  toolConfig: ExecuteToolBatchOptions["toolConfig"]
+  hiveConfig: Config
+  mainThreadToolNames: string[]
+  timeoutMs: number
+  resolve: (result: ToolBatchResult) => void
+  settled: boolean
+  startedAt: number
+  timer?: ReturnType<typeof setTimeout>
+}
+
+type WorkerSlot = {
+  worker: Worker
+  busy: boolean
+  job?: QueuedJob
+}
+
+function serializeError(error: unknown): SerializedError {
+  const err = error instanceof Error ? error : new Error(String(error))
+  return {
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+  }
+}
+
+function toolErrorResult(
+  toolName: string,
+  message: string,
+  extra: Partial<ToolBatchResult> = {}
+): unknown {
+  return {
+    error: true,
+    tool: toolName,
+    message,
+    timestamp: new Date().toISOString(),
+    ...extra,
+  }
+}
+
+const DEFAULT_MAIN_THREAD_TOOL_NAMES = new Set([
+  "browser_navigate",
+  "browser_screenshot",
+  "browser_click",
+  "browser_type",
+  "browser_extract",
+  "browser_script",
+  "browser_wait",
+  "canvas_render",
+  "canvas_ask",
+  "canvas_confirm",
+  "canvas_show_card",
+  "canvas_show_progress",
+  "canvas_show_list",
+  "canvas_clear",
+  "a2ui_create_surface",
+  "a2ui_update_components",
+  "a2ui_update_data_model",
+  "a2ui_delete_surface",
+  "cron.create",
+  "cron.list",
+  "cron.update",
+  "cron.pause",
+  "cron.resume",
+  "cron.delete",
+  "cron.trigger",
+  "cron.history",
+  "notify",
+  "report_progress",
+  "task_delegate",
+  "task_delegate_code",
+  "voice_transcribe",
+  "voice_speak",
+])
+
+async function executeInMainThread(job: {
+  toolCall: ToolCallLike
+  allTools: RuntimeTool[]
+  toolConfig: ExecuteToolBatchOptions["toolConfig"]
+}): Promise<unknown> {
+  const toolName = job.toolCall.function.name
+  const tool = job.allTools.find((candidate) => candidate.name === toolName)
+  if (!tool?.execute) {
+    return toolErrorResult(toolName, `Tool '${toolName}' not found or not executable`)
+  }
+
+  try {
+    const args = typeof job.toolCall.function.arguments === "string"
+      ? JSON.parse(job.toolCall.function.arguments)
+      : job.toolCall.function.arguments
+    return await tool.execute((args ?? {}) as Record<string, unknown>, { configurable: job.toolConfig })
+  } catch (error) {
+    return toolErrorResult(toolName, (error as Error).message)
+  }
+}
+
+class ToolWorkerPool {
+  private workers: WorkerSlot[] = []
+  private queue: QueuedJob[] = []
+  private readonly maxWorkers: number
+
+  constructor(maxWorkers: number) {
+    this.maxWorkers = Math.max(1, maxWorkers)
+  }
+
+  execute(job: Omit<QueuedJob, "resolve" | "settled" | "startedAt">): Promise<ToolBatchResult> {
+    return new Promise((resolve) => {
+      this.queue.push({
+        ...job,
+        resolve,
+        settled: false,
+        startedAt: 0,
+      })
+      this.drain()
+    })
+  }
+
+  abortBatch(batchId: string, reason = "Tool execution aborted"): void {
+    const remaining: QueuedJob[] = []
+    const aborted: QueuedJob[] = []
+    for (const job of this.queue) {
+      if (job.batchId === batchId) aborted.push(job)
+      else remaining.push(job)
+    }
+    this.queue = remaining
+
+    for (const job of aborted) {
+      job.resolve({
+        toolCall: job.toolCall,
+        toolName: job.toolCall.function.name,
+        result: toolErrorResult(job.toolCall.function.name, reason),
+        ok: false,
+        durationMs: 0,
+        error: { name: "AbortError", message: reason },
+        aborted: true,
+      })
+    }
+
+    for (const slot of this.workers) {
+      if (slot.busy && slot.job?.batchId === batchId) {
+        this.finishJob(slot, {
+          toolCall: slot.job.toolCall,
+          toolName: slot.job.toolCall.function.name,
+          result: toolErrorResult(slot.job.toolCall.function.name, reason),
+          ok: false,
+          durationMs: Math.round(performance.now() - slot.job.startedAt),
+          error: { name: "AbortError", message: reason },
+          aborted: true,
+        }, true)
+      }
+    }
+  }
+
+  dispose(): void {
+    for (const slot of this.workers) {
+      slot.worker.terminate()
+    }
+    this.workers = []
+    this.queue = []
+  }
+
+  private drain(): void {
+    while (this.queue.length > 0) {
+      const slot = this.getIdleSlot()
+      if (!slot) return
+
+      const job = this.queue.shift()!
+      this.startJob(slot, job)
+    }
+  }
+
+  private getIdleSlot(): WorkerSlot | null {
+    const idle = this.workers.find((slot) => !slot.busy)
+    if (idle) return idle
+
+    if (this.workers.length >= this.maxWorkers) return null
+
+    const slot = this.createSlot()
+    this.workers.push(slot)
+    return slot
+  }
+
+  private createSlot(): WorkerSlot {
+    const worker = new Worker(new URL("./tool-worker.ts", import.meta.url).href, { type: "module" })
+    const slot: WorkerSlot = { worker, busy: false }
+
+    worker.onmessage = (event: MessageEvent<WorkerMessage>) => {
+      const message = event.data
+      if (message.type === "rpc_call") {
+        void this.handleRpc(slot, message)
+        return
+      }
+
+      const job = slot.job
+      if (!job || job.id !== message.jobId) return
+
+      this.finishJob(slot, {
+        toolCall: job.toolCall,
+        toolName: job.toolCall.function.name,
+        result: message.ok ? message.result : toolErrorResult(job.toolCall.function.name, message.error?.message || "Tool failed"),
+        ok: message.ok && !(message.result && typeof message.result === "object" && (message.result as any).error === true),
+        durationMs: message.durationMs,
+        error: message.error,
+      })
+    }
+
+    worker.onerror = (event) => {
+      const job = slot.job
+      if (!job) return
+
+      this.finishJob(slot, {
+        toolCall: job.toolCall,
+        toolName: job.toolCall.function.name,
+        result: toolErrorResult(job.toolCall.function.name, event.message || "Tool worker failed"),
+        ok: false,
+        durationMs: Math.round(performance.now() - job.startedAt),
+        error: { name: "WorkerError", message: event.message || "Tool worker failed" },
+      }, true)
+    }
+
+    return slot
+  }
+
+  private startJob(slot: WorkerSlot, job: QueuedJob): void {
+    slot.busy = true
+    slot.job = job
+    job.startedAt = performance.now()
+    job.timer = setTimeout(() => {
+      if (job.settled) return
+
+      this.finishJob(slot, {
+        toolCall: job.toolCall,
+        toolName: job.toolCall.function.name,
+        result: toolErrorResult(job.toolCall.function.name, `Tool timed out after ${job.timeoutMs}ms`),
+        ok: false,
+        durationMs: Math.round(performance.now() - job.startedAt),
+        error: { name: "TimeoutError", message: `Tool timed out after ${job.timeoutMs}ms` },
+        timedOut: true,
+      }, true)
+    }, job.timeoutMs)
+
+    slot.worker.postMessage({
+      type: "run",
+      jobId: job.id,
+      toolName: job.toolCall.function.name,
+      args: job.toolCall.function.arguments,
+      toolConfig: job.toolConfig,
+      hiveConfig: job.hiveConfig,
+      mainThreadToolNames: job.mainThreadToolNames,
+    })
+  }
+
+  private async handleRpc(
+    slot: WorkerSlot,
+    message: Extract<WorkerMessage, { type: "rpc_call" }>
+  ): Promise<void> {
+    const job = slot.job
+    if (!job || job.id !== message.jobId || job.settled) return
+
+    try {
+      const result = await executeInMainThread({
+        toolCall: {
+          id: job.toolCall.id,
+          function: {
+            name: message.toolName,
+            arguments: message.args,
+          },
+        },
+        allTools: job.allTools,
+        toolConfig: job.toolConfig,
+      })
+      slot.worker.postMessage({ type: "rpc_result", rpcId: message.rpcId, ok: true, result })
+    } catch (error) {
+      slot.worker.postMessage({ type: "rpc_result", rpcId: message.rpcId, ok: false, error: serializeError(error) })
+    }
+  }
+
+  private finishJob(slot: WorkerSlot, result: ToolBatchResult, restart = false): void {
+    const job = slot.job
+    if (!job || job.settled) return
+
+    job.settled = true
+    if (job.timer) clearTimeout(job.timer)
+    job.resolve(result)
+
+    if (restart) {
+      slot.worker.terminate()
+      const index = this.workers.indexOf(slot)
+      if (index >= 0) {
+        this.workers[index] = this.createSlot()
+      }
+    } else {
+      slot.busy = false
+      slot.job = undefined
+    }
+
+    this.drain()
+  }
+}
+
+let sharedPool: ToolWorkerPool | null = null
+let sharedPoolSize = 0
+
+function getDefaultMaxWorkers(): number {
+  return Math.min(4, Math.max(1, availableParallelism()))
+}
+
+function resolveRuntimeConfig(config?: ToolRuntimeConfig): Required<ToolRuntimeConfig> {
+  return {
+    enabled: config?.enabled ?? true,
+    maxWorkers: config?.maxWorkers ?? getDefaultMaxWorkers(),
+    toolTimeoutMs: config?.toolTimeoutMs ?? 300000,
+    parallelToolCalls: config?.parallelToolCalls ?? true,
+  }
+}
+
+function getPool(maxWorkers: number): ToolWorkerPool {
+  if (!sharedPool || sharedPoolSize !== maxWorkers) {
+    sharedPool = new ToolWorkerPool(maxWorkers)
+    sharedPoolSize = maxWorkers
+  }
+  return sharedPool
+}
+
+export async function executeToolBatch(options: ExecuteToolBatchOptions): Promise<ToolBatchResult[]> {
+  const runtimeConfig = resolveRuntimeConfig(options.workerPool)
+  const hiveConfig = options.hiveConfig ?? loadConfig()
+  const mainThreadToolNames = [
+    ...DEFAULT_MAIN_THREAD_TOOL_NAMES,
+    ...(options.mainThreadToolNames ?? []),
+  ]
+
+  if (options.signal?.aborted) {
+    return options.toolCalls.map((toolCall) => ({
+      toolCall,
+      toolName: toolCall.function.name,
+      result: toolErrorResult(toolCall.function.name, "Tool execution aborted"),
+      ok: false,
+      durationMs: 0,
+      error: { name: "AbortError", message: "Tool execution aborted" },
+      aborted: true,
+    }))
+  }
+
+  if (!runtimeConfig.enabled || !runtimeConfig.parallelToolCalls || options.toolCalls.length <= 1) {
+    const results: ToolBatchResult[] = []
+    for (const toolCall of options.toolCalls) {
+      const startedAt = performance.now()
+      const result = await executeInMainThread({
+        toolCall,
+        allTools: options.allTools,
+        toolConfig: options.toolConfig,
+      })
+      results.push({
+        toolCall,
+        toolName: toolCall.function.name,
+        result,
+        ok: !(result && typeof result === "object" && (result as any).error === true),
+        durationMs: Math.round(performance.now() - startedAt),
+      })
+    }
+    return results
+  }
+
+  const pool = getPool(runtimeConfig.maxWorkers)
+  const batchId = crypto.randomUUID()
+  const abortHandler = () => pool.abortBatch(batchId, "Tool execution aborted")
+  options.signal?.addEventListener("abort", abortHandler, { once: true })
+
+  try {
+    const results = await Promise.all(options.toolCalls.map((toolCall, index) => pool.execute({
+      id: `${Date.now()}:${index}:${crypto.randomUUID()}`,
+      batchId,
+      index,
+      toolCall,
+      allTools: options.allTools,
+      toolConfig: options.toolConfig,
+      hiveConfig,
+      mainThreadToolNames,
+      timeoutMs: runtimeConfig.toolTimeoutMs,
+    })))
+
+    return results.sort((a, b) => {
+      const aIndex = options.toolCalls.indexOf(a.toolCall)
+      const bIndex = options.toolCalls.indexOf(b.toolCall)
+      return aIndex - bIndex
+    })
+  } finally {
+    options.signal?.removeEventListener("abort", abortHandler)
+  }
+}
+
+export function shutdownToolRuntime(): void {
+  sharedPool?.dispose()
+  sharedPool = null
+  sharedPoolSize = 0
+}

package/packages/core/src/tool-runtime/tool-worker.ts

@@ -0,0 +1,125 @@
+import { createAllTools } from "../tools/index.ts"
+import type { Config } from "../config/loader.ts"
+
+type WorkerRunMessage = {
+  type: "run"
+  jobId: string
+  toolName: string
+  args: unknown
+  toolConfig: Record<string, unknown>
+  hiveConfig: Config
+  mainThreadToolNames: string[]
+}
+
+type WorkerRpcResponse = {
+  type: "rpc_result"
+  rpcId: string
+  ok: boolean
+  result?: unknown
+  error?: SerializedError
+}
+
+type SerializedError = {
+  name: string
+  message: string
+  stack?: string
+}
+
+const pendingRpc = new Map<string, {
+  resolve: (value: unknown) => void
+  reject: (error: Error) => void
+}>()
+
+function serializeError(error: unknown): SerializedError {
+  const err = error instanceof Error ? error : new Error(String(error))
+  return {
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+  }
+}
+
+function parseArgs(args: unknown): Record<string, unknown> {
+  if (typeof args === "string") {
+    return JSON.parse(args) as Record<string, unknown>
+  }
+  if (args && typeof args === "object") {
+    return args as Record<string, unknown>
+  }
+  return {}
+}
+
+function requestMainThreadTool(
+  jobId: string,
+  toolName: string,
+  args: unknown,
+  toolConfig: Record<string, unknown>
+): Promise<unknown> {
+  const rpcId = `${jobId}:${crypto.randomUUID()}`
+  return new Promise((resolve, reject) => {
+    pendingRpc.set(rpcId, { resolve, reject })
+    postMessage({
+      type: "rpc_call",
+      rpcId,
+      jobId,
+      toolName,
+      args,
+      toolConfig,
+    })
+  })
+}
+
+async function runTool(message: WorkerRunMessage): Promise<void> {
+  const startedAt = performance.now()
+
+  try {
+    const parsedArgs = parseArgs(message.args)
+    const forceMainThread = message.mainThreadToolNames.includes(message.toolName)
+    const allTools = forceMainThread ? [] : createAllTools(message.hiveConfig)
+    const tool = allTools.find((candidate) => candidate.name === message.toolName)
+
+    const result = tool?.execute
+      ? await tool.execute(parsedArgs, { configurable: message.toolConfig })
+      : await requestMainThreadTool(message.jobId, message.toolName, parsedArgs, message.toolConfig)
+
+    postMessage({
+      type: "result",
+      jobId: message.jobId,
+      ok: true,
+      result,
+      durationMs: Math.round(performance.now() - startedAt),
+    })
+  } catch (error) {
+    postMessage({
+      type: "result",
+      jobId: message.jobId,
+      ok: false,
+      error: serializeError(error),
+      durationMs: Math.round(performance.now() - startedAt),
+    })
+  }
+}
+
+onmessage = (event: MessageEvent<WorkerRunMessage | WorkerRpcResponse>) => {
+  const message = event.data
+
+  if (message.type === "rpc_result") {
+    const pending = pendingRpc.get(message.rpcId)
+    if (!pending) return
+
+    pendingRpc.delete(message.rpcId)
+    if (message.ok) {
+      pending.resolve(message.result)
+    } else {
+      const error = new Error(message.error?.message || "Tool RPC failed")
+      error.name = message.error?.name || "ToolRpcError"
+      error.stack = message.error?.stack
+      pending.reject(error)
+    }
+    return
+  }
+
+  if (message.type === "run") {
+    void runTool(message)
+  }
+}

package/packages/core/src/tools/agents/get-available-models.ts

@@ -0,0 +1,118 @@
+/**
+ * Get Available Models Tool
+ *
+ * Permite a los agentes consultar providers y modelos activos en la BD
+ * para seleccionar el modelo óptimo al crear nuevos agentes.
+ *
+ * @category agents
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/sqlite.ts";
+
+export const getAvailableModelsTool: Tool = {
+  name: "get_available_models",
+  description: "Obtener lista de providers y modelos activos de la base de datos. Sinónimos: ver modelos, listar providers, modelos disponibles, consultar modelos, provider activo, qué modelos tengo, modelos para código, modelos para chat",
+  parameters: {
+    type: "object",
+    properties: {
+      providerId: {
+        type: "string",
+        description: "Opcional: filtrar por provider (openai, ollama, anthropic, gemini, etc.)"
+      },
+      modelType: {
+        type: "string",
+        description: "Opcional: filtrar por tipo (llm, stt, tts, vision, embedding)"
+      },
+      capabilities: {
+        type: "string",
+        description: "Opcional: filtrar por capacidad (coding, chat, analysis, vision, reasoning)"
+      }
+    },
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const db = getDb();
+    const { providerId, modelType, capabilities } = params as {
+      providerId?: string;
+      modelType?: string;
+      capabilities?: string;
+    };
+
+    try {
+      // Construir query con filtros opcionales
+      let query = `
+        SELECT 
+          p.id as provider_id,
+          p.name as provider_name,
+          p.category as provider_category,
+          m.id as model_id,
+          m.name as model_name,
+          m.model_type,
+          m.context_window,
+          m.capabilities
+        FROM models m
+        INNER JOIN providers p ON m.provider_id = p.id
+        WHERE m.enabled = 1 AND m.active = 1 AND p.enabled = 1 AND p.active = 1
+      `;
+
+      const whereClauses: string[] = [];
+      const queryParams: string[] = [];
+
+      if (providerId) {
+        whereClauses.push("p.id = ?");
+        queryParams.push(providerId as string);
+      }
+
+      if (modelType) {
+        whereClauses.push("m.model_type = ?");
+        queryParams.push(modelType as string);
+      }
+
+      if (capabilities) {
+        whereClauses.push("m.capabilities LIKE ?");
+        queryParams.push(`%${capabilities as string}%`);
+      }
+
+      if (whereClauses.length > 0) {
+        query += " AND " + whereClauses.join(" AND ");
+      }
+
+      query += " ORDER BY p.name, m.name";
+
+      // Ejecutar query
+      const rows = db.query<any, string[]>(query).all(...queryParams) as Array<{
+        provider_id: string;
+        provider_name: string;
+        provider_category: string;
+        model_id: string;
+        model_name: string;
+        model_type: string;
+        context_window: number | null;
+        capabilities: string | null;
+      }>;
+
+      // Transformar a formato amigable
+      const result = rows.map(row => ({
+        providerId: row.provider_id,
+        providerName: row.provider_name,
+        providerCategory: row.provider_category,
+        modelId: row.model_id,
+        modelName: row.model_name,
+        modelType: row.model_type,
+        contextWindow: row.context_window,
+        capabilities: row.capabilities ? JSON.parse(row.capabilities) : null,
+      }));
+
+      return {
+        ok: true,
+        count: result.length,
+        models: result,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to get available models: ${(error as Error).message}`,
+      };
+    }
+  },
+};