@johpaz/hive-sdk 0.1.6 → 0.3.0

package/packages/core/src/swarm/RoleSwarm.ts

@@ -0,0 +1,234 @@
+/**
+ * Enjambre por roles — orquestador y trabajadores, con estrategia declarada.
+ *
+ * Es la tercera forma de armar un enjambre en Hive, y convive con las otras dos
+ * a propósito:
+ *
+ *  - **Delegación por catálogo** (`agent/delegation-runtime.ts`, `task_delegate`):
+ *    el coordinador decide a quién delegar en tiempo real, con criterios de
+ *    aceptación y proof packets. El modelo elige la forma del trabajo.
+ *  - **DAG de tareas** (`Coordinator.ts`): el grafo se conoce de antemano y el
+ *    scheduler resuelve dependencias y concurrencia.
+ *  - **Roles (esto)**: el enjambre es *configuración persistida* — una lista de
+ *    agentes con rol y orden, y una estrategia. Quien lo define es un usuario en
+ *    una UI, no el modelo ni el programador.
+ *
+ * La tercera no se puede expresar con las otras dos: un DAG exige conocer las
+ * aristas, y acá la topología es la estrategia. Por eso existe.
+ *
+ * Este módulo no persiste nada: `onMessage` es el punto donde el consumidor
+ * guarda cada paso donde quiera (Postgres, HiveDB, un log).
+ */
+
+import { runAgentIsolated } from "../agent/agent-loop.ts"
+import type { ProviderCredentials } from "../agent/llm-client.ts"
+import { logger } from "../utils/logger.ts"
+
+const log = logger.child("role-swarm")
+
+export type SwarmStrategy = "sequential" | "parallel" | "hierarchical"
+
+export interface RoleAgent {
+  agentId: string
+  role: "orchestrator" | "worker"
+  /** Orden de ejecución en la estrategia secuencial. */
+  orderIndex?: number
+}
+
+/** Un paso del enjambre, tal como se lo entrega a `onMessage`. */
+export interface SwarmMessage {
+  agentId: string
+  role: "user" | "assistant"
+  content: string
+  stepIndex: number
+}
+
+/** Cómo se invoca a un agente. Se puede reemplazar para tests o para envolverlo. */
+export type AgentInvoker = (input: {
+  agentId: string
+  message: string
+  threadId: string
+  channel?: string
+  credentials?: ProviderCredentials
+  signal?: AbortSignal
+}) => Promise<string>
+
+export const defaultInvoker: AgentInvoker = async (input) =>
+  runAgentIsolated({
+    agentId: input.agentId,
+    taskDescription: input.message,
+    threadId: input.threadId,
+    channel: input.channel,
+    credentials: input.credentials,
+    signal: input.signal,
+  })
+
+export interface RoleSwarmOptions {
+  /** Los agentes del enjambre, con su rol. */
+  agents: RoleAgent[]
+  strategy: SwarmStrategy
+  input: string
+  /** Identifica la corrida; también es el threadId del orquestador. */
+  runId: string
+  channel?: string
+  /** Requerido por la estrategia jerárquica si ningún agente tiene rol orchestrator. */
+  orchestratorAgentId?: string
+  /**
+   * Tope de delegaciones en la estrategia jerárquica.
+   *
+   * Sin esto, un orquestador que siga emitiendo `DELEGATE:` no termina nunca:
+   * cada vuelta es una llamada al modelo, así que un bucle no es sólo lento, es
+   * caro. Al agotarse se devuelve lo último que dijo el orquestador.
+   */
+  maxDelegations?: number
+  /** Credenciales del inquilino, propagadas a cada agente. */
+  credentials?: ProviderCredentials
+  signal?: AbortSignal
+  /** Se llama en cada paso; acá persiste el consumidor si quiere. */
+  onMessage?: (message: SwarmMessage) => void | Promise<void>
+  /** Reemplaza la invocación real (tests, instrumentación). */
+  invoke?: AgentInvoker
+}
+
+export interface RoleSwarmResult {
+  output: string
+  /** Llamadas al modelo, para contabilidad de uso. */
+  agentCalls: number
+  /** Delegaciones efectuadas (sólo jerárquica). */
+  delegations: number
+  /** true si la jerárquica se cortó por `maxDelegations`. */
+  truncated: boolean
+}
+
+const DEFAULT_MAX_DELEGATIONS = 10
+
+/**
+ * `DELEGATE:<agente>:<subtarea>` y `FINAL:<respuesta>`.
+ *
+ * El `[\s\S]` en lugar de `.` es deliberado: una subtarea de varias líneas es lo
+ * normal, y con `.` se cortaba en el primer salto de línea y el worker recibía
+ * una instrucción truncada.
+ */
+const DELEGATE_RE = /DELEGATE:\s*([^\s:]+)\s*:\s*([\s\S]+?)(?=\nDELEGATE:|\nFINAL:|$)/
+const FINAL_RE = /FINAL:\s*([\s\S]+)/
+
+function orderedWorkers(agents: RoleAgent[]): RoleAgent[] {
+  return [...agents].sort((a, b) => (a.orderIndex ?? 0) - (b.orderIndex ?? 0))
+}
+
+export async function runRoleSwarm(opts: RoleSwarmOptions): Promise<RoleSwarmResult> {
+  const invoke = opts.invoke ?? defaultInvoker
+  const emit = async (m: SwarmMessage) => { await opts.onMessage?.(m) }
+  let agentCalls = 0
+
+  const call = async (agentId: string, message: string, threadId: string) => {
+    agentCalls++
+    return invoke({
+      agentId,
+      message,
+      threadId,
+      channel: opts.channel,
+      credentials: opts.credentials,
+      signal: opts.signal,
+    })
+  }
+
+  if (opts.agents.length === 0) {
+    throw new Error("Un enjambre necesita al menos un agente")
+  }
+
+  // ── Secuencial: la salida de cada uno es la entrada del siguiente ──────────
+  if (opts.strategy === "sequential") {
+    const agents = orderedWorkers(opts.agents)
+    let context = opts.input
+    for (const [i, agent] of agents.entries()) {
+      await emit({ agentId: agent.agentId, role: "user", content: context, stepIndex: i })
+      context = await call(agent.agentId, context, opts.runId)
+      await emit({ agentId: agent.agentId, role: "assistant", content: context, stepIndex: i })
+    }
+    return { output: context, agentCalls, delegations: 0, truncated: false }
+  }
+
+  // ── Paralelo: todos ven la misma entrada; se concatenan las salidas ────────
+  if (opts.strategy === "parallel") {
+    const agents = orderedWorkers(opts.agents)
+    const outputs = await Promise.all(
+      agents.map(async (agent, i) => {
+        await emit({ agentId: agent.agentId, role: "user", content: opts.input, stepIndex: i })
+        // Hilo propio por agente: comparten la entrada, no la conversación.
+        const out = await call(agent.agentId, opts.input, `${opts.runId}-${agent.agentId}`)
+        await emit({ agentId: agent.agentId, role: "assistant", content: out, stepIndex: i })
+        return out
+      }),
+    )
+    return { output: outputs.join("\n\n---\n\n"), agentCalls, delegations: 0, truncated: false }
+  }
+
+  // ── Jerárquica: el orquestador delega hasta dar una respuesta final ────────
+  const orchestratorId =
+    opts.orchestratorAgentId ?? opts.agents.find((a) => a.role === "orchestrator")?.agentId
+  if (!orchestratorId) {
+    throw new Error("La estrategia jerárquica necesita un agente con rol orchestrator")
+  }
+
+  const workers = opts.agents.filter((a) => a.role === "worker")
+  const workerIds = new Set(workers.map((w) => w.agentId))
+  if (workerIds.size === 0) {
+    throw new Error("La estrategia jerárquica necesita al menos un agente con rol worker")
+  }
+
+  const protocol = [
+    `Eres el orquestador de un enjambre de agentes.`,
+    `Agentes disponibles: ${[...workerIds].join(", ")}.`,
+    `Para delegar usa el formato: DELEGATE:<agent_id>:<subtarea>`,
+    `Cuando hayas terminado responde con: FINAL:<respuesta>`,
+  ].join("\n")
+
+  const firstInput = `${protocol}\n\nTarea: ${opts.input}`
+  await emit({ agentId: orchestratorId, role: "user", content: firstInput, stepIndex: 0 })
+  let output = await call(orchestratorId, firstInput, opts.runId)
+  await emit({ agentId: orchestratorId, role: "assistant", content: output, stepIndex: 0 })
+
+  const maxDelegations = opts.maxDelegations ?? DEFAULT_MAX_DELEGATIONS
+  let delegations = 0
+  let step = 1
+  let truncated = false
+
+  while (true) {
+    const match = output.match(DELEGATE_RE)
+    if (!match) break
+
+    const delegateId = match[1]!.trim()
+    const subtask = match[2]!.trim()
+
+    if (!workerIds.has(delegateId)) {
+      log.warn(`el orquestador delegó a "${delegateId}", que no está en el enjambre — se corta`)
+      break
+    }
+    if (delegations >= maxDelegations) {
+      log.warn(`tope de ${maxDelegations} delegaciones alcanzado — se corta con lo último del orquestador`)
+      truncated = true
+      break
+    }
+
+    await emit({ agentId: delegateId, role: "user", content: subtask, stepIndex: step })
+    const workerOutput = await call(delegateId, subtask, `${opts.runId}-${delegateId}`)
+    await emit({ agentId: delegateId, role: "assistant", content: workerOutput, stepIndex: step })
+    delegations++
+    step++
+
+    const followUp = `Resultado de ${delegateId}: ${workerOutput}\n\nContinúa o responde con FINAL:<respuesta>`
+    await emit({ agentId: orchestratorId, role: "user", content: followUp, stepIndex: step })
+    output = await call(orchestratorId, followUp, opts.runId)
+    await emit({ agentId: orchestratorId, role: "assistant", content: output, stepIndex: step })
+    step++
+  }
+
+  const final = output.match(FINAL_RE)
+  return {
+    output: final ? final[1]!.trim() : output,
+    agentCalls,
+    delegations,
+    truncated,
+  }
+}

package/packages/core/src/swarm/TaskGraph.ts

@@ -8,8 +8,8 @@
  *   3. Provide runtime queries: ready nodes, overall progress
  */
 
-import { TaskNode, type TaskNodeConfig } from "./TaskNode"
-import { CyclicDependencyError } from "./errors"
+import { TaskNode, type TaskNodeConfig } from "./TaskNode.ts"
+import { CyclicDependencyError } from "./errors.ts"
 
 export class TaskGraph {
   readonly nodes: Map<string, TaskNode>

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

@@ -31,3 +31,10 @@ export { createHiveLearnGraph } from "./presets/index.ts";
 export type { HiveLearnAgentIds, HiveLearnInput } from "./presets/index.ts";
 export { createResearchGraph } from "./presets/index.ts";
 export type { ResearchAgentIds } from "./presets/index.ts";
+
+// ─── Enjambre por roles (orquestador/trabajadores) ───────────────────────────
+export { runRoleSwarm, defaultInvoker } from "./RoleSwarm.ts";
+export type {
+  SwarmStrategy, RoleAgent, SwarmMessage, AgentInvoker,
+  RoleSwarmOptions, RoleSwarmResult,
+} from "./RoleSwarm.ts";

package/packages/core/src/swarm/presets/HiveLearnPreset.ts

@@ -16,8 +16,8 @@
  *   Savings vs sequential: ~38% (~75s)
  */
 
-import { TaskGraph } from "../TaskGraph"
-import type { TaskNodeConfig } from "../TaskNode"
+import { TaskGraph } from "../TaskGraph.ts"
+import type { TaskNodeConfig } from "../TaskNode.ts"
 
 export interface HiveLearnAgentIds {
   curriculum: string

package/packages/core/src/swarm/presets/ResearchPreset.ts

@@ -18,8 +18,8 @@
  *   await scheduler.execute(graph, { projectId, coordinatorId })
  */
 
-import { TaskGraph } from "../TaskGraph"
-import type { TaskNodeConfig } from "../TaskNode"
+import { TaskGraph } from "../TaskGraph.ts"
+import type { TaskNodeConfig } from "../TaskNode.ts"
 
 export interface ResearchAgentIds {
   research: string

package/packages/core/src/swarm/strategies/ParallelStrategy.ts

@@ -6,7 +6,7 @@
  * otherwise they wait in the queue.
  */
 
-import { TaskNode } from "../TaskNode"
+import { TaskNode } from "../TaskNode.ts"
 
 export interface ExecutionStrategy {
   pick(queue: TaskNode[]): TaskNode | undefined

package/packages/core/src/swarm/strategies/PriorityStrategy.ts

@@ -5,9 +5,9 @@
  * when slots are limited. Within same effective priority, FIFO order applies.
  */
 
-import { TaskNode } from "../TaskNode"
-import { TaskGraph } from "../TaskGraph"
-import type { ExecutionStrategy } from "./ParallelStrategy"
+import { TaskNode } from "../TaskNode.ts"
+import { TaskGraph } from "../TaskGraph.ts"
+import type { ExecutionStrategy } from "./ParallelStrategy.ts"
 
 export class PriorityStrategy implements ExecutionStrategy {
   private criticalPathSet = new Set<string>()

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

@@ -1,12 +1,12 @@
 /**
  * Hive Scheduler - Type Definitions
  * 
- * Type interfaces for the Croner-based scheduling system.
+ * Type interfaces for the scheduling system.
  * All names use "CronJob" terminology (formerly ScheduledTask).
  */
 
 import type { Database } from "bun:sqlite";
-import type { Cron } from "croner";
+import type { Cron } from "../scheduler/cron/index.ts";
 
 /**
  * Task type: recurring uses cron expression, one_shot uses fire_at
@@ -141,24 +141,9 @@ export interface CronJobExecutionResult {
 }
 
 /**
- * Internal job wrapper holding Croner instance and metadata
+ * Internal job wrapper holding the scheduled job and its metadata
  */
 export interface CronJobEntry {
   job: CronJob;
   cron: Cron;
 }
-
-/**
- * Options for Croner job creation
- */
-export interface CronerOptions {
-  timezone: string;
-  protect: boolean;
-  catch: boolean | ((error: Error) => void);
-  name: string;
-  maxRuns?: number;
-  interval?: number;
-  startAt?: string;
-  stopAt?: string;
-  domAndDow?: boolean;
-}

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

@@ -0,0 +1,21 @@
+// Auto-generado — NO EDITAR.
+//
+// En este paquete el valor es SIEMPRE null, y así debe quedarse: el SDK se
+// publica como fuente, no como ejecutable standalone, así que el worker se
+// resuelve desde disco (tool-worker.ts al lado de este archivo, o
+// dist/tool-worker.js junto al bundle).
+//
+// El archivo existe porque el gateway de hive sí compila un binario, y ahí su
+// `scripts/build-gateway.ts` reescribe este stub antes de compilar con:
+//
+//   import workerFile from "./tool-worker.generated.js" with { type: "file" }
+//   export const embeddedToolWorkerPath: string | null = workerFile
+//
+// Ese `with { type: "file" }` es lo que mete el bundle del worker dentro del
+// ejecutable, porque `new Worker(new URL("./tool-worker.ts", import.meta.url))`
+// NO se embebe solo: el path se resuelve en runtime y el bundler no lo ve.
+// Sin eso la app de escritorio se instalaba sin worker y cualquier turno con
+// más de una tool call moría con "Tool worker entry not found" (v1.0.3 y
+// anteriores). Mantener el símbolo acá deja que `tool-runtime/index.ts` sea el
+// mismo archivo en los dos repos.
+export const embeddedToolWorkerPath: string | null = null

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

@@ -4,6 +4,9 @@ import { dirname, join } from "node:path"
 import { availableParallelism } from "node:os"
 import type { Config } from "../config/loader.ts"
 import { loadConfig } from "../config/loader.ts"
+import { logger } from "../utils/logger.ts"
+import { embeddedToolWorkerPath } from "./embedded-worker.generated.ts"
+import { hasHooks, runBeforeToolCall, runAfterToolCall } from "../hooks/index.ts"
 
 export type ToolCallLike = {
   id: string
@@ -105,7 +108,19 @@ type WorkerSlot = {
   job?: QueuedJob
 }
 
-function resolveWorkerEntry(): string {
+let cachedWorkerEntry: string | null | undefined
+
+/**
+ * Locate the tool worker entry, or null when this build ships without one.
+ *
+ * Returning null instead of throwing is deliberate: workers are an
+ * optimization, and a packaging gap must never take a whole turn down with it
+ * (it did until v1.0.3 — every desktop install failed each multi-tool turn
+ * with "Tool worker entry not found"). The caller degrades to the main thread.
+ */
+function resolveWorkerEntry(): string | null {
+  if (cachedWorkerEntry !== undefined) return cachedWorkerEntry
+
   const candidates = [
     new URL("./tool-worker.js", import.meta.url),
     new URL("./tool-worker.ts", import.meta.url),
@@ -115,7 +130,8 @@ function resolveWorkerEntry(): string {
 
   for (const candidate of candidates) {
     if (existsSync(fileURLToPath(candidate))) {
-      return candidate.href
+      cachedWorkerEntry = candidate.href
+      return cachedWorkerEntry
     }
   }
 
@@ -135,13 +151,25 @@ function resolveWorkerEntry(): string {
 
   for (const filePath of fallbacks) {
     if (existsSync(filePath)) {
-      return filePath
+      cachedWorkerEntry = filePath
+      return cachedWorkerEntry
     }
   }
 
-  throw new Error(
-    `Tool worker entry not found. Tried: ${[...candidates.map((candidate) => fileURLToPath(candidate)), ...fallbacks].join(", ")}`
+  // Standalone executable: the worker was embedded at compile time and lives in
+  // the virtual bunfs, where existsSync() reports false — so it is taken on
+  // trust. It is only ever set by scripts/build-gateway.ts.
+  if (embeddedToolWorkerPath) {
+    cachedWorkerEntry = embeddedToolWorkerPath
+    return cachedWorkerEntry
+  }
+
+  logger.warn(
+    "[tool-runtime] No tool worker entry found — running tool batches on the main thread (sequentially)",
+    { tried: [...candidates.map((candidate) => fileURLToPath(candidate)), ...fallbacks] }
   )
+  cachedWorkerEntry = null
+  return null
 }
 
 function serializeError(error: unknown): SerializedError {
@@ -187,6 +215,7 @@ const DEFAULT_MAIN_THREAD_TOOL_NAMES = new Set([
   "browser_navigate",
   "browser_screenshot",
   "artifact_inspect",
+  "artifact_read",
   "browser_click",
   "browser_type",
   "browser_extract",
@@ -255,10 +284,12 @@ class ToolWorkerPool {
   private workers: WorkerSlot[] = []
   private queue: QueuedJob[] = []
   private readonly maxWorkers: number
+  private readonly workerEntry: string
   private disposed = false
 
-  constructor(maxWorkers: number) {
+  constructor(maxWorkers: number, workerEntry: string) {
     this.maxWorkers = Math.max(1, maxWorkers)
+    this.workerEntry = workerEntry
   }
 
   execute(job: Omit<QueuedJob, "resolve" | "settled" | "startedAt">): Promise<ToolBatchResult> {
@@ -385,7 +416,7 @@ class ToolWorkerPool {
   }
 
   private createSlot(): WorkerSlot {
-    const worker = new Worker(resolveWorkerEntry(), { type: "module" })
+    const worker = new Worker(this.workerEntry, { type: "module" })
     const slot: WorkerSlot = { worker, busy: false }
 
     worker.onmessage = (event: MessageEvent<WorkerMessage>) => {
@@ -500,11 +531,15 @@ class ToolWorkerPool {
     job.resolve(result)
 
     if (restart) {
+      // Un worker que abortó o murió se descarta, y el reemplazo lo crea
+      // `drain()` solo si queda trabajo. Antes se levantaba uno nuevo en el
+      // acto: sobre un aborto —el caso típico al terminar un turno o una
+      // suite— eso deja un worker recién arrancado que nadie va a usar y que
+      // hay que terminar a mitad del arranque. Bun se cae con SIGSEGV al
+      // cerrar el proceso en ese estado (CI: workers_spawned 13, terminated 11).
       slot.worker.terminate()
       const index = this.workers.indexOf(slot)
-      if (index >= 0) {
-        this.workers[index] = this.createSlot()
-      }
+      if (index >= 0) this.workers.splice(index, 1)
     } else {
       slot.busy = false
       slot.job = undefined
@@ -550,15 +585,90 @@ function resolveToolTimeout(
   return baseTimeoutMs
 }
 
-function getPool(maxWorkers: number): ToolWorkerPool {
+function getPool(maxWorkers: number): ToolWorkerPool | null {
+  const workerEntry = resolveWorkerEntry()
+  if (!workerEntry) return null
+
   if (!sharedPool || sharedPoolSize !== maxWorkers) {
-    sharedPool = new ToolWorkerPool(maxWorkers)
+    sharedPool = new ToolWorkerPool(maxWorkers, workerEntry)
     sharedPoolSize = maxWorkers
   }
   return sharedPool
 }
 
+/**
+ * Ejecuta un lote de tool calls, aplicando los hooks alrededor.
+ *
+ * Los hooks se resuelven acá y no dentro del despacho porque hay dos caminos
+ * —hilo principal y pool de workers— con puntos de retorno distintos.
+ * Engancharlos abajo dejaría la mitad de las llamadas sin revisar, que en un
+ * hook de política es peor que no tenerlo.
+ *
+ * Una tool bloqueada **no se ejecuta**: se saca del lote y su lugar se rellena
+ * con el motivo, para que el modelo sepa por qué no se hizo en vez de
+ * reintentar a ciegas.
+ */
 export async function executeToolBatch(options: ExecuteToolBatchOptions): Promise<ToolBatchResult[]> {
+  const bloqueadas = new Map<string, string>()
+
+  if (hasHooks("beforeToolCall")) {
+    for (const toolCall of options.toolCalls) {
+      const args = typeof toolCall.function.arguments === "string"
+        ? (() => { try { return JSON.parse(toolCall.function.arguments) } catch { return {} } })()
+        : (toolCall.function.arguments ?? {})
+
+      const motivo = await runBeforeToolCall({
+        toolName: toolCall.function.name,
+        args: args as Record<string, unknown>,
+        agentId: options.toolConfig?.agent_id as string | undefined,
+        userId: options.toolConfig?.user_id as string | undefined,
+        threadId: options.toolConfig?.thread_id as string | undefined,
+      })
+      if (motivo) bloqueadas.set(toolCall.id, motivo)
+    }
+  }
+
+  const permitidas = options.toolCalls.filter((tc) => !bloqueadas.has(tc.id))
+  const ejecutadas = permitidas.length > 0
+    ? await executeToolBatchInner({ ...options, toolCalls: permitidas })
+    : []
+
+  // Se reconstruye el orden original: el modelo espera una respuesta por cada
+  // llamada que hizo, en el orden en que las hizo.
+  const porId = new Map(ejecutadas.map((r) => [r.toolCall.id, r]))
+  const resultados = options.toolCalls.map((toolCall) => {
+    const bloqueo = bloqueadas.get(toolCall.id)
+    if (bloqueo) {
+      return {
+        toolCall,
+        toolName: toolCall.function.name,
+        result: toolErrorResult(toolCall.function.name, bloqueo),
+        ok: false,
+        durationMs: 0,
+      } as ToolBatchResult
+    }
+    return porId.get(toolCall.id)!
+  })
+
+  if (hasHooks("afterToolCall")) {
+    for (const r of resultados) {
+      await runAfterToolCall({
+        toolName: r.toolName,
+        args: {},
+        result: r.result,
+        ok: r.ok,
+        durationMs: r.durationMs,
+        agentId: options.toolConfig?.agent_id as string | undefined,
+        userId: options.toolConfig?.user_id as string | undefined,
+        threadId: options.toolConfig?.thread_id as string | undefined,
+      })
+    }
+  }
+
+  return resultados
+}
+
+async function executeToolBatchInner(options: ExecuteToolBatchOptions): Promise<ToolBatchResult[]> {
   const runtimeConfig = resolveRuntimeConfig(options.workerPool)
   const hiveConfig = options.hiveConfig ?? loadConfig()
   const mainThreadToolNames = [
@@ -578,7 +688,13 @@ export async function executeToolBatch(options: ExecuteToolBatchOptions): Promis
     }))
   }
 
-  if (!runtimeConfig.enabled || !runtimeConfig.parallelToolCalls || options.toolCalls.length <= 1) {
+  // A null pool means workers are disabled, unnecessary (single call), or
+  // unavailable in this build — all three degrade to the main thread.
+  const pool = runtimeConfig.enabled && runtimeConfig.parallelToolCalls && options.toolCalls.length > 1
+    ? getPool(runtimeConfig.maxWorkers)
+    : null
+
+  if (!pool) {
     const results: ToolBatchResult[] = []
     for (const toolCall of options.toolCalls) {
       const startedAt = performance.now()
@@ -605,7 +721,6 @@ export async function executeToolBatch(options: ExecuteToolBatchOptions): Promis
     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 })

package/packages/core/src/tools/ToolExecutor.ts

@@ -1,5 +1,5 @@
-import type { ToolDefinition } from "./ToolRegistry";
-import type { ToolRegistry } from "./ToolRegistry";
+import type { ToolDefinition } from "./ToolRegistry.ts";
+import type { ToolRegistry } from "./ToolRegistry.ts";
 
 export interface ToolExecutionResult {
   toolName: string;
@@ -10,7 +10,11 @@ export interface ToolExecutionResult {
 }
 
 export class ToolExecutor {
-  constructor(private registry: ToolRegistry) {}
+  private registry: ToolRegistry;
+
+  constructor(registry: ToolRegistry) {
+    this.registry = registry;
+  }
 
   async execute(
     name: string,