@johpaz/hive-sdk 0.1.3 → 0.1.5

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

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs"
 import { fileURLToPath } from "node:url"
+import { dirname, join } from "node:path"
 import { availableParallelism } from "node:os"
 import type { Config } from "../config/loader.ts"
 import { loadConfig } from "../config/loader.ts"
@@ -15,6 +16,8 @@ export type ToolCallLike = {
 export type RuntimeTool = {
   name: string
   execute?: (params: Record<string, unknown>, config?: any) => Promise<unknown>
+  /** Per-tool timeout (ms) override from the Tool definition. */
+  timeoutMs?: number
 }
 
 export type ToolRuntimeConfig = {
@@ -32,6 +35,12 @@ export type ExecuteToolBatchOptions = {
     thread_id?: string
     channel?: string
     workspace?: string | null
+    /** The currently-running agent's own id (agent-loop.ts's opts.agentId) — read by tools that need to know who's calling them (task_delegate's parent lookup, agent_create's parent_id, bus_publish's sender). */
+    agent_id?: string
+    run_id?: string
+    turn_id?: string
+    task_id?: string
+    session_id?: string
   }
   hiveConfig?: Config
   workerPool?: ToolRuntimeConfig
@@ -110,8 +119,28 @@ function resolveWorkerEntry(): string {
     }
   }
 
+  const fallbacks: string[] = []
+  const envPath = process.env.HIVE_TOOL_WORKER_PATH
+  if (envPath) fallbacks.push(envPath)
+
+  try {
+    const execDir = dirname(process.execPath)
+    fallbacks.push(join(execDir, "tool-worker.js"))
+    fallbacks.push(join(execDir, "packages", "core", "src", "tool-runtime", "tool-worker.js"))
+  } catch {
+    // process.execPath is not available — skip execDir-based fallbacks
+  }
+
+  fallbacks.push("/app/tool-worker.js")
+
+  for (const filePath of fallbacks) {
+    if (existsSync(filePath)) {
+      return filePath
+    }
+  }
+
   throw new Error(
-    `Tool worker entry not found. Tried: ${candidates.map((candidate) => fileURLToPath(candidate)).join(", ")}`
+    `Tool worker entry not found. Tried: ${[...candidates.map((candidate) => fileURLToPath(candidate)), ...fallbacks].join(", ")}`
   )
 }
 
@@ -139,7 +168,7 @@ function toolErrorResult(
 }
 
 const DEFAULT_MAIN_THREAD_TOOL_NAMES = new Set([
-  // These tools depend on process-local singleton state (SQLite DB, live
+  // These tools depend on process-local singleton state (HiveDB handle, live
   // channel senders, schedulers, browser sessions, or in-memory services).
   "search_knowledge",
   "save_note",
@@ -155,24 +184,14 @@ const DEFAULT_MAIN_THREAD_TOOL_NAMES = new Set([
   "bus_publish",
   "bus_read",
   "get_available_models",
-  "meeting_start",
-  "meeting_add_segment",
-  "meeting_stop",
-  "meeting_report",
   "browser_navigate",
   "browser_screenshot",
+  "artifact_inspect",
   "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",
@@ -188,15 +207,14 @@ const DEFAULT_MAIN_THREAD_TOOL_NAMES = new Set([
   "notify",
   "report_progress",
   "task_delegate",
-  "task_delegate_code",
-  "voice_transcribe",
-  "voice_speak",
+  "task_list",
 ])
 
 async function executeInMainThread(job: {
   toolCall: ToolCallLike
   allTools: RuntimeTool[]
   toolConfig: ExecuteToolBatchOptions["toolConfig"]
+  signal?: AbortSignal
 }): Promise<unknown> {
   const toolName = job.toolCall.function.name
   const tool = job.allTools.find((candidate) => candidate.name === toolName)
@@ -208,16 +226,36 @@ async function executeInMainThread(job: {
     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 })
+    return await tool.execute((args ?? {}) as Record<string, unknown>, { configurable: job.toolConfig, signal: job.signal })
   } catch (error) {
     return toolErrorResult(toolName, (error as Error).message)
   }
 }
 
+/**
+ * Bounds a single tool execution to its own timeout window (per-operation, not
+ * an aggregate turn deadline). A slow tool loses its race and yields a normal
+ * error result — the underlying promise is left to settle on its own (main-thread
+ * tools have no cross-realm handle to kill), but the caller is freed to move on.
+ */
+export function executeInMainThreadWithTimeout(
+  job: { toolCall: ToolCallLike; allTools: RuntimeTool[]; toolConfig: ExecuteToolBatchOptions["toolConfig"]; signal?: AbortSignal },
+  timeoutMs: number,
+): Promise<unknown> {
+  const toolName = job.toolCall.function.name
+  return Promise.race([
+    executeInMainThread(job),
+    new Promise<unknown>((resolve) => {
+      setTimeout(() => resolve(toolErrorResult(toolName, `Tool execution timed out after ${timeoutMs}ms`)), timeoutMs)
+    }),
+  ])
+}
+
 class ToolWorkerPool {
   private workers: WorkerSlot[] = []
   private queue: QueuedJob[] = []
   private readonly maxWorkers: number
+  private disposed = false
 
   constructor(maxWorkers: number) {
     this.maxWorkers = Math.max(1, maxWorkers)
@@ -225,6 +263,18 @@ class ToolWorkerPool {
 
   execute(job: Omit<QueuedJob, "resolve" | "settled" | "startedAt">): Promise<ToolBatchResult> {
     return new Promise((resolve) => {
+      if (this.disposed) {
+        resolve({
+          toolCall: job.toolCall,
+          toolName: job.toolCall.function.name,
+          result: toolErrorResult(job.toolCall.function.name, "Tool runtime shut down"),
+          ok: false,
+          durationMs: 0,
+          error: { name: "AbortError", message: "Tool runtime shut down" },
+          aborted: true,
+        })
+        return
+      }
       this.queue.push({
         ...job,
         resolve,
@@ -272,14 +322,48 @@ class ToolWorkerPool {
   }
 
   dispose(): void {
+    this.disposed = true
+    const reason = "Tool runtime shut down"
+
+    for (const job of this.queue) {
+      if (job.settled) continue
+      job.settled = true
+      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,
+      })
+    }
+    this.queue = []
+
     for (const slot of this.workers) {
+      const job = slot.job
+      if (job && !job.settled) {
+        job.settled = true
+        if (job.timer) clearTimeout(job.timer)
+        job.resolve({
+          toolCall: job.toolCall,
+          toolName: job.toolCall.function.name,
+          result: toolErrorResult(job.toolCall.function.name, reason),
+          ok: false,
+          durationMs: Math.round(performance.now() - job.startedAt),
+          error: { name: "AbortError", message: reason },
+          aborted: true,
+        })
+      }
+      slot.job = undefined
+      slot.busy = false
       slot.worker.terminate()
     }
     this.workers = []
-    this.queue = []
   }
 
   private drain(): void {
+    if (this.disposed) return
     while (this.queue.length > 0) {
       const slot = this.getIdleSlot()
       if (!slot) return
@@ -381,6 +465,7 @@ class ToolWorkerPool {
   ): Promise<void> {
     const job = slot.job
     if (!job || job.id !== message.jobId || job.settled) return
+    const worker = slot.worker
 
     try {
       const result = await executeInMainThread({
@@ -394,9 +479,15 @@ class ToolWorkerPool {
         allTools: job.allTools,
         toolConfig: job.toolConfig,
       })
-      slot.worker.postMessage({ type: "rpc_result", rpcId: message.rpcId, ok: true, result })
+      if (this.disposed || slot.job !== job || job.settled || slot.worker !== worker) return
+      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) })
+      if (this.disposed || slot.job !== job || job.settled || slot.worker !== worker) return
+      try {
+        worker.postMessage({ type: "rpc_result", rpcId: message.rpcId, ok: false, error: serializeError(error) })
+      } catch {
+        // El worker pudo terminar entre la comprobación y el envío.
+      }
     }
   }
 
@@ -439,6 +530,26 @@ function resolveRuntimeConfig(config?: ToolRuntimeConfig): Required<ToolRuntimeC
   }
 }
 
+/**
+ * Resolve the effective timeout (ms) for a single tool call.
+ * Priority: Tool.timeoutMs → config.tools.timeouts[name] → workerPool.toolTimeoutMs.
+ */
+function resolveToolTimeout(
+  toolName: string,
+  allTools: RuntimeTool[],
+  hiveConfig: Config,
+  baseTimeoutMs: number,
+): number {
+  // 1. Tool definition timeoutMs (carried on the RuntimeTool via ContextTool cast)
+  const def = allTools.find((t) => t.name === toolName)
+  if (def?.timeoutMs && def.timeoutMs > 0) return def.timeoutMs
+  // 2. config.tools.timeouts[name]
+  const cfgOverride = hiveConfig?.tools?.timeouts?.[toolName]
+  if (typeof cfgOverride === "number" && cfgOverride > 0) return cfgOverride
+  // 3. base (workerPool.toolTimeoutMs)
+  return baseTimeoutMs
+}
+
 function getPool(maxWorkers: number): ToolWorkerPool {
   if (!sharedPool || sharedPoolSize !== maxWorkers) {
     sharedPool = new ToolWorkerPool(maxWorkers)
@@ -471,11 +582,18 @@ export async function executeToolBatch(options: ExecuteToolBatchOptions): Promis
     const results: ToolBatchResult[] = []
     for (const toolCall of options.toolCalls) {
       const startedAt = performance.now()
-      const result = await executeInMainThread({
+      const effectiveTimeout = resolveToolTimeout(
+        toolCall.function.name,
+        options.allTools,
+        hiveConfig,
+        runtimeConfig.toolTimeoutMs,
+      )
+      const result = await executeInMainThreadWithTimeout({
         toolCall,
         allTools: options.allTools,
         toolConfig: options.toolConfig,
-      })
+        signal: options.signal,
+      }, effectiveTimeout)
       results.push({
         toolCall,
         toolName: toolCall.function.name,
@@ -502,7 +620,12 @@ export async function executeToolBatch(options: ExecuteToolBatchOptions): Promis
       toolConfig: options.toolConfig,
       hiveConfig,
       mainThreadToolNames,
-      timeoutMs: runtimeConfig.toolTimeoutMs,
+      timeoutMs: resolveToolTimeout(
+        toolCall.function.name,
+        options.allTools,
+        hiveConfig,
+        runtimeConfig.toolTimeoutMs,
+      ),
     })))
 
     return results.sort((a, b) => {

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

@@ -1,4 +1,4 @@
-import { createAllTools } from "../tools/index.ts"
+import { createWorkerTools } from "./worker-tools.ts"
 import type { Config } from "../config/loader.ts"
 
 type WorkerRunMessage = {
@@ -75,7 +75,7 @@ async function runTool(message: WorkerRunMessage): Promise<void> {
   try {
     const parsedArgs = parseArgs(message.args)
     const forceMainThread = message.mainThreadToolNames.includes(message.toolName)
-    const allTools = forceMainThread ? [] : createAllTools(message.hiveConfig)
+    const allTools = forceMainThread ? [] : createWorkerTools(message.hiveConfig)
     const tool = allTools.find((candidate) => candidate.name === message.toolName)
 
     const result = tool?.execute

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

@@ -0,0 +1,27 @@
+import type { Config } from "../config/loader.ts"
+import type { Tool } from "../tools/types.ts"
+import * as filesystem from "../tools/filesystem/index.ts"
+import { webSearchTool } from "../tools/web/web-search.ts"
+import { webFetchTool } from "../tools/web/web-fetch.ts"
+import * as cli from "../tools/cli/index.ts"
+import * as office from "../tools/office/index.ts"
+import * as api from "../tools/api/index.ts"
+
+/**
+ * Reconstruct only stateless tools inside worker realms.
+ *
+ * Importing the complete tool registry pulls process-local services (including
+ * HiveDB) into tool-worker.js even though those tools are always executed by
+ * RPC on the main thread. Keeping this registry explicit makes the worker
+ * bundle platform-neutral and prevents native bindings from leaking into it.
+ */
+export function createWorkerTools(_config: Config): Tool[] {
+  return [
+    ...filesystem.createTools(),
+    webSearchTool,
+    webFetchTool,
+    ...cli.createTools(),
+    ...office.createTools(),
+    ...api.createTools(),
+  ]
+}

package/packages/core/src/{canvas/a2ui-tools.ts → tools/a2ui/index.ts}

@@ -1,14 +1,14 @@
-import type { Tool } from "../agent/NativeTools.ts";
-import type { Config } from "../config/loader.ts";
-import { canvasManager } from "./CanvasManager.ts";
-import { logger } from "../utils/logger.ts";
+import type { Tool } from "../types.ts";
+import type { Config } from "../../config/loader.ts";
+import { canvasManager } from "../../canvas/canvas-manager.ts";
+import { logger } from "../../utils/logger.ts";
 
 export function createA2UISurfaceTool(_config: Config): Tool {
   const log = logger.child("a2ui-surface");
 
   return {
     name: "a2ui_create_surface",
-    description: "Create an A2UI v0.9 surface on the user's canvas for rendering rich interactive UIs",
+    description: "Create an A2UI v0.9 surface in the user's interactive panel",
     parameters: {
       type: "object",
       properties: {
@@ -58,7 +58,7 @@ export function createA2UISurfaceTool(_config: Config): Tool {
 
       if (!canvasManager.isSessionConnected(sessionId)) {
         const connected = canvasManager.getConnectedSessions();
-        log.warn(`No canvas sessions connected. Rendering to ${sessionId} anyway. Available: ${connected.join(", ")}`);
+        log.warn(`No visual sessions connected. Rendering to ${sessionId} anyway. Available: ${connected.join(", ")}`);
       }
 
       await canvasManager.sendA2UIMessage(sessionId, "a2ui:createSurface", {
@@ -219,7 +219,7 @@ export function createA2UIDeleteSurfaceTool(_config: Config): Tool {
 
   return {
     name: "a2ui_delete_surface",
-    description: "Delete an A2UI v0.9 surface and remove it from the user's canvas",
+    description: "Delete an A2UI v0.9 surface from the user's interactive panel",
     parameters: {
       type: "object",
       properties: {
@@ -252,4 +252,13 @@ export function createA2UIDeleteSurfaceTool(_config: Config): Tool {
       });
     },
   };
-}
+}
+
+export function createTools(config: Config): Tool[] {
+  return [
+    createA2UISurfaceTool(config),
+    createA2UIUpdateComponentsTool(config),
+    createA2UIUpdateDataModelTool(config),
+    createA2UIDeleteSurfaceTool(config),
+  ];
+}

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

@@ -8,12 +8,12 @@
  */
 
 import type { Tool } from "../types.ts";
-import { getHiveDB } from "../../storage/HiveDBStorage.ts";
-import type { HiveProviderDoc, HiveModelDoc } from "../../storage/hiveSeed.ts";
+import { col } from "../../storage/hive.ts";
+import type { ProviderDoc, ModelDoc } from "../../storage/collections.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",
+  description: "Obtener el catálogo completo de modelos de los providers configurados (con credenciales activas) para elegir el más adecuado según capacidad, contexto o costo — no solo el modelo por defecto del usuario. 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: {
@@ -39,70 +39,52 @@ export const getAvailableModelsTool: Tool = {
     };
 
     try {
-      const db = await getHiveDB();
-      const providersCol = db.collection<HiveProviderDoc>("providers");
-      const modelsCol = db.collection<HiveModelDoc>("models");
+      const providersCol = await col<ProviderDoc>("providers");
+      const providersById = new Map(
+        (await providersCol.scan({}))
+          .map(e => e.doc)
+          .filter(p => p.enabled && p.active)
+          .map(p => [p.id, p])
+      );
 
-      const [providers, models] = await Promise.all([
-        providersCol.scan(),
-        modelsCol.scan(),
-      ]);
+      // Gate on the *provider* being configured (enabled + active, i.e. it has valid
+      // credentials) — not on the individual model's own `active` flag. `active` on a
+      // ModelDoc only marks the single model onboarding/voice-setup picked as the
+      // user's current default; it is not "this model is unusable". Once a provider is
+      // configured, every model under it should be visible so the caller can pick the
+      // one that actually fits the task (capability, context window, cost), instead of
+      // being stuck with whichever model happened to be flagged as the default.
+      const modelsCol = await col<ModelDoc>("models");
+      let models = (await modelsCol.scan({}))
+        .map(e => e.doc)
+        .filter(m => m.enabled && providersById.has(m.provider_id));
 
-      const activeProviders = new Map(
-        providers
-          .filter(p => p.doc.enabled && p.doc.active)
-          .map(p => [p.id, p.doc])
-      );
+      if (providerId) models = models.filter(m => m.provider_id === providerId);
+      if (modelType) models = models.filter(m => m.model_type === modelType);
+      if (capabilities) models = models.filter(m => (m.capabilities ?? "").includes(capabilities));
 
-      let rows = models
-        .filter(m => m.doc.enabled && m.doc.active)
+      // Transformar a formato amigable
+      const result = models
         .map(m => {
-          const provider = activeProviders.get(m.doc.providerId);
-          if (!provider) return null;
+          const provider = providersById.get(m.provider_id)!;
           return {
             providerId: provider.id,
             providerName: provider.name,
             providerCategory: provider.category,
-            modelId: m.doc.id,
-            modelName: m.doc.name,
-            modelType: m.doc.modelType,
-            contextWindow: m.doc.contextWindow ?? null,
-            capabilities: m.doc.capabilities ?? null,
+            modelId: m.id,
+            modelName: m.name,
+            modelType: m.model_type,
+            contextWindow: m.context_window,
+            capabilities: m.capabilities ? JSON.parse(m.capabilities) : null,
+            isDefault: m.active,
           };
         })
-        .filter(Boolean) as Array<{
-          providerId: string;
-          providerName: string;
-          providerCategory: string;
-          modelId: string;
-          modelName: string;
-          modelType: string;
-          contextWindow: number | null;
-          capabilities: string[] | null;
-        }>;
-
-      if (providerId) {
-        rows = rows.filter(r => r.providerId === providerId);
-      }
-
-      if (modelType) {
-        rows = rows.filter(r => r.modelType === modelType);
-      }
-
-      if (capabilities) {
-        const cap = capabilities.toLowerCase();
-        rows = rows.filter(r => r.capabilities?.some(c => c.toLowerCase().includes(cap)));
-      }
-
-      rows.sort((a, b) => {
-        if (a.providerName !== b.providerName) return a.providerName.localeCompare(b.providerName);
-        return a.modelName.localeCompare(b.modelName);
-      });
+        .sort((a, b) => (Number(b.isDefault) - Number(a.isDefault)) || a.providerName.localeCompare(b.providerName) || a.modelName.localeCompare(b.modelName));
 
       return {
         ok: true,
-        count: rows.length,
-        models: rows,
+        count: result.length,
+        models: result,
       };
     } catch (error) {
       return {