@johpaz/hive-sdk 0.1.6 → 0.2.0

package/packages/core/src/api/createAgent.test.ts

@@ -1,160 +0,0 @@
-/**
- * `createAgent` persiste su configuración en la fila del agente.
- *
- * Hasta 0.1.5 aceptaba `provider`, `model`, `maxIterations`, `workspace` y
- * `systemPrompt` y los descartaba: construía el loop global y corría con lo que
- * hubiera en la base. Estos tests fijan que ahora sí lleguen.
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { z } from "zod";
-import { closeHiveDb } from "../storage/hivedb.ts";
-import { ensureHiveDb } from "../storage/bootstrap.ts";
-import { col, fromIndexable } from "../storage/hive.ts";
-import { clearAppTools, createAllTools } from "../tools/index.ts";
-import { selectTools } from "../agent/tool-selector.ts";
-import { loadConfig } from "../config/loader.ts";
-import type { AgentDoc, ModelDoc } from "../storage/collections.ts";
-import { createAgent } from "./createAgent.ts";
-import { defineTool } from "../tools/ToolRegistry.ts";
-import { defineSkill } from "../skills/defineSkill.ts";
-
-beforeEach(async () => {
-	closeHiveDb();
-	clearAppTools();
-	await ensureHiveDb();
-});
-
-afterEach(() => {
-	clearAppTools();
-	closeHiveDb();
-});
-
-describe("createAgent", () => {
-	it("persiste provider, modelo, prompt e iteraciones en la fila del agente", async () => {
-		const agent = await createAgent({
-			name: "Test Agent",
-			provider: "anthropic",
-			model: "claude-opus-5",
-			systemPrompt: "Sos un asistente de prueba.",
-			maxIterations: 7,
-			workspace: "/tmp/ws",
-		});
-
-		expect(agent.name).toBe("Test Agent");
-		expect(agent.id).toBe("test_agent");
-
-		const agentsCol = await col<AgentDoc>("agents");
-		const row = (await agentsCol.get("test_agent"))!.doc;
-
-		expect(fromIndexable(row.provider_id)).toBe("anthropic");
-		expect(fromIndexable(row.model_id)).toBe("claude-opus-5");
-		expect(row.system_prompt).toBe("Sos un asistente de prueba.");
-		expect(row.max_iterations).toBe(7);
-		expect(row.workspace).toBe("/tmp/ws");
-	});
-
-	it("prefija el id del modelo cuando el provider es revendedor", async () => {
-		await createAgent({
-			name: "reseller",
-			provider: "modelscope",
-			model: "Qwen-Ambassador/Qwen3.8-Max",
-		});
-
-		const agentsCol = await col<AgentDoc>("agents");
-		const row = (await agentsCol.get("reseller"))!.doc;
-
-		expect(fromIndexable(row.model_id)).toBe("modelscope/Qwen-Ambassador/Qwen3.8-Max");
-	});
-
-	it("activa el modelo elegido, o resolveProviderConfig no encuentra su base_url", async () => {
-		await createAgent({ name: "activador", provider: "anthropic", model: "claude-opus-5" });
-
-		const modelsCol = await col<ModelDoc>("models");
-		const model = (await modelsCol.get("claude-opus-5"))!.doc;
-
-		expect(model.active).toBe(true);
-		expect(model.enabled).toBe(true);
-	});
-
-	it("rechaza un modelo que no está en el catálogo", async () => {
-		await expect(
-			createAgent({ name: "fantasma", provider: "anthropic", model: "claude-que-no-existe" })
-		).rejects.toThrow(/no está en el catálogo/);
-	});
-
-	it("pide provider cuando se especifica un modelo", async () => {
-		// El mismo modelo lo sirven varios providers y la clave del catálogo
-		// depende de cuál, así que adivinarlo sería elegir por el usuario.
-		await expect(createAgent({ name: "sin-provider", model: "claude-opus-5" })).rejects.toThrow(
-			/necesita también `provider`/
-		);
-	});
-
-	it("registra las tools de la app con su ejecutor, no sólo la declaración", async () => {
-		const greet = defineTool({
-			name: "greet_person",
-			description: "Saluda a alguien",
-			schema: z.object({ name: z.string().describe("a quién saludar") }),
-			execute: async (args: { name: string }) => `Hola ${args.name}`,
-		});
-
-		await createAgent({ name: "con-tools", tools: [greet] });
-
-		const registered = createAllTools(await loadConfig()).find((t) => t.name === "greet_person");
-		expect(registered, "la tool no llegó al registry que lee el context compiler").toBeDefined();
-		expect(registered!.parameters.properties).toHaveProperty("name");
-		expect(registered!.parameters.required).toEqual(["name"]);
-		expect(await registered!.execute({ name: "Ana" })).toBe("Hola Ana");
-	});
-
-	it("deja la tool de la app descubrible por búsqueda de capacidad", async () => {
-		// El loadout inicial es mínimo a propósito; el resto se encuentra vía
-		// `search_knowledge`, que corre sobre el índice BM25. Si createAgent no
-		// siembra la fila en `tools` y no reindexa, la tool tiene ejecutor pero el
-		// modelo no se entera de que existe.
-		const weather = defineTool({
-			name: "get_weather",
-			description: "Consulta el clima actual de una ciudad. Sinónimos: tiempo, temperatura, pronóstico",
-			schema: z.object({ city: z.string() }),
-			execute: async (a: { city: string }) => `Soleado en ${a.city}`,
-		});
-
-		await createAgent({ name: "descubrible", tools: [weather] });
-
-		const found = await selectTools("clima de una ciudad", undefined, 5);
-		expect(found.map((t) => t.name)).toContain("get_weather");
-	});
-
-	it("reusa la fila al recrear un agente con el mismo nombre", async () => {
-		const first = await createAgent({ name: "estable", provider: "anthropic", model: "claude-opus-5" });
-		const second = await createAgent({ name: "estable", provider: "anthropic", model: "claude-sonnet-5" });
-
-		expect(second.id).toBe(first.id);
-
-		const agentsCol = await col<AgentDoc>("agents");
-		const all = (await agentsCol.scan({})).filter((e) => e.id === "estable");
-		expect(all).toHaveLength(1);
-		expect(fromIndexable(all[0].doc.model_id)).toBe("claude-sonnet-5");
-	});
-});
-
-describe("defineTool / defineSkill", () => {
-	it("siguen siendo funciones de declaración puras", () => {
-		const tool = defineTool({
-			name: "greet",
-			description: "Says hello",
-			execute: async (args: { name: string }) => `Hello ${args.name}`,
-		});
-		expect(tool.name).toBe("greet");
-
-		const skill = defineSkill({
-			name: "greeting-skill",
-			description: "Greeting skill",
-			steps: [{ action: "greet", instruction: "Say hello" }],
-		});
-		expect(skill.name).toBe("greeting-skill");
-	});
-});

package/packages/core/src/canvas/canvas.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { emitCanvas, subscribeCanvas, unsubscribeCanvas } from "./emitter.ts";
-
-// `canvas:render` desapareció en 0.1.5: el canvas dejó de emitir componentes
-// sueltos y pasó a un modelo de grafo (`node_add` / `node_update` / `edge_*`),
-// que es el que consume la vista de oficina 3D.
-
-describe("canvas emitter", () => {
-  it("subscribes and unsubscribes websocket-like objects", () => {
-    let received: any = null;
-    const ws = {
-      send: (data: string) => { received = JSON.parse(data); },
-    };
-
-    subscribeCanvas(ws);
-    emitCanvas("canvas:node_update", { nodeId: "test", changes: { status: "thinking" } });
-    unsubscribeCanvas(ws);
-
-    expect(received).toBeDefined();
-    expect(received.type).toBe("canvas:node_update");
-  });
-
-  it("stops receiving after unsubscribe", () => {
-    let count = 0;
-    const ws = {
-      send: () => { count++; },
-    };
-
-    subscribeCanvas(ws);
-    emitCanvas("canvas:node_update", { nodeId: "a", changes: { status: "thinking" } });
-    unsubscribeCanvas(ws);
-    emitCanvas("canvas:node_update", { nodeId: "b", changes: { status: "idle" } });
-
-    expect(count).toBe(1);
-  });
-});

package/packages/core/src/channels/channels.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { ChannelManager } from "./manager.ts";
-import { loadConfig } from "../config/loader.ts";
-
-describe("ChannelManager", () => {
-  it("creates a channel manager", () => {
-    const config = loadConfig();
-    const manager = new ChannelManager(config);
-    expect(manager).toBeDefined();
-  });
-
-  it("has onMessage handler", () => {
-    const config = loadConfig();
-    const manager = new ChannelManager(config);
-    manager.onMessage(async () => {});
-    expect(manager).toBeDefined();
-  });
-});

package/packages/core/src/ethics/EthicsGuard.test.ts

@@ -1,108 +0,0 @@
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { EthicsGuard } from "./EthicsGuard.ts";
-import { closeHiveDb } from "../storage/hivedb.ts";
-import { ensureHiveDb } from "../storage/bootstrap.ts";
-import { col } from "../storage/hive.ts";
-import { toIndexable } from "../storage/hive.ts";
-import type { PlaybookDoc } from "../storage/collections.ts";
-
-async function addRule(id: string, rule: string, category: string, opts?: {
-	applicableTo?: string;
-	helpfulCount?: number;
-	active?: boolean;
-}) {
-	const playbookCol = await col<PlaybookDoc>("playbook");
-	const now = Date.now();
-	await playbookCol.put(id, {
-		id,
-		rule,
-		category,
-		applicable_to: opts?.applicableTo ?? null,
-		helpful_count: opts?.helpfulCount ?? 0,
-		harmful_count: 0,
-		active: opts?.active ?? true,
-		source_reflection_id: toIndexable(null),
-		created_at: now,
-		updated_at: now,
-	});
-}
-
-beforeEach(async () => {
-	closeHiveDb();
-	await ensureHiveDb();
-});
-
-afterEach(() => {
-	closeHiveDb();
-});
-
-describe("EthicsGuard", () => {
-	it("sólo devuelve reglas de response_quality activas", async () => {
-		await addRule("rq-1", "Verificá las fuentes antes de responder", "response_quality");
-		await addRule("rq-2", "Regla apagada", "response_quality", { active: false });
-		await addRule("otra", "Usá web_search para noticias", "tool_selection");
-
-		const rules = await new EthicsGuard().getRules();
-
-		expect(rules.map((r) => r.id)).toEqual(["rq-1"]);
-	});
-
-	it("ordena por helpful_count descendente", async () => {
-		await addRule("poco", "poco útil", "response_quality", { helpfulCount: 1 });
-		await addRule("mucho", "muy útil", "response_quality", { helpfulCount: 9 });
-
-		const rules = await new EthicsGuard().getRules();
-
-		expect(rules.map((r) => r.id)).toEqual(["mucho", "poco"]);
-	});
-
-	it("filtra por agentRole cuando alguna regla lo declara", async () => {
-		await addRule("para-coord", "regla del coordinador", "response_quality", {
-			applicableTo: JSON.stringify(["coordinator"]),
-		});
-		await addRule("para-worker", "regla del worker", "response_quality", {
-			applicableTo: JSON.stringify(["worker"]),
-		});
-
-		const rules = await new EthicsGuard().getRules("coordinator");
-
-		expect(rules.map((r) => r.id)).toEqual(["para-coord"]);
-	});
-
-	it("cae a todas las reglas si ninguna declara ese rol", async () => {
-		// Sin esto, un `applicable_to` mal cargado dejaría al agente sin capa
-		// de calidad en vez de con una de más.
-		await addRule("generica", "regla general", "response_quality", {
-			applicableTo: JSON.stringify(["worker"]),
-		});
-
-		const rules = await new EthicsGuard().getRules("coordinator");
-
-		expect(rules.map((r) => r.id)).toEqual(["generica"]);
-	});
-
-	it("injectIntoPrompt agrega las reglas y conserva el prompt original", async () => {
-		await addRule("rq-1", "Verificá las fuentes", "response_quality");
-
-		const guard = new EthicsGuard();
-		const result = guard.injectIntoPrompt("Eres un asistente.", await guard.getRules());
-
-		expect(result).toContain("Eres un asistente.");
-		expect(result).toContain("## Reglas de Calidad de Respuesta");
-		expect(result).toContain("- Verificá las fuentes");
-	});
-
-	it("injectIntoPrompt devuelve el prompt intacto sin reglas", () => {
-		expect(new EthicsGuard().injectIntoPrompt("Eres un asistente.", [])).toBe("Eres un asistente.");
-	});
-
-	it("hasEthicsLayer refleja si hay reglas cargadas", async () => {
-		const guard = new EthicsGuard();
-		expect(await guard.hasEthicsLayer()).toBe(false);
-
-		await addRule("rq-1", "Verificá las fuentes", "response_quality");
-		expect(await guard.hasEthicsLayer()).toBe(true);
-	});
-});

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

@@ -1,38 +0,0 @@
-import { describe, expect, it, beforeAll, afterAll } from "bun:test";
-import { startGateway } from "./index.ts";
-
-describe("gateway", () => {
-  let server: ReturnType<typeof startGateway> extends Promise<infer T> ? T : never;
-
-  beforeAll(async () => {
-    server = await startGateway({ host: "127.0.0.1", port: 18791, agentId: "test" });
-  });
-
-  afterAll(() => {
-    server?.stop(true);
-  });
-
-  it("returns health status", async () => {
-    const res = await fetch("http://127.0.0.1:18791/status");
-    expect(res.status).toBe(200);
-    const body = await res.json();
-    expect(body.status).toBe("ok");
-    expect(body.gateway).toBe(true);
-    expect(body.agentId).toBe("test");
-  });
-
-  it("returns 404 for unknown routes", async () => {
-    const res = await fetch("http://127.0.0.1:18791/unknown");
-    expect(res.status).toBe(404);
-  });
-
-  it("chat endpoint requires database setup", async () => {
-    const res = await fetch("http://127.0.0.1:18791/chat", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ message: "hello" }),
-    });
-    // Will fail because no DB/agent configured, but endpoint exists
-    expect(res.status).toBe(500);
-  });
-});

package/packages/core/src/memory/Scratchpad.test.ts

@@ -1,68 +0,0 @@
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { Scratchpad } from "./Scratchpad.ts";
-import { closeHiveDb } from "../storage/hivedb.ts";
-import { ensureHiveDb } from "../storage/bootstrap.ts";
-import { getScratchpad } from "../agent/conversation-store.ts";
-
-const THREAD = "test-thread";
-
-let pad: Scratchpad;
-
-beforeEach(async () => {
-	closeHiveDb();
-	await ensureHiveDb();
-	pad = new Scratchpad();
-});
-
-afterEach(() => {
-	closeHiveDb();
-});
-
-describe("Scratchpad", () => {
-	it("writes and reads a note", async () => {
-		await pad.write(THREAD, "test-1", "hello world");
-		expect(await pad.read(THREAD, "test-1")).toBe("hello world");
-	});
-
-	it("lists notes as key-value map", async () => {
-		await pad.write(THREAD, "list-a", "aaa");
-		await pad.write(THREAD, "list-b", "bbb");
-
-		const notes = await pad.list(THREAD);
-		expect(notes["list-a"]).toBe("aaa");
-		expect(notes["list-b"]).toBe("bbb");
-	});
-
-	it("deletes a note", async () => {
-		await pad.write(THREAD, "to-delete", "delete me");
-		await pad.delete(THREAD, "to-delete");
-		expect(await pad.read(THREAD, "to-delete")).toBeUndefined();
-	});
-
-	it("clear removes all notes for a thread", async () => {
-		await pad.write(THREAD, "clear-a", "a");
-		await pad.write(THREAD, "clear-b", "b");
-		await pad.clear(THREAD);
-		expect(Object.keys(await pad.list(THREAD))).toHaveLength(0);
-	});
-
-	it("no toca las notas de otros threads", async () => {
-		await pad.write("thread-uno", "k", "uno");
-		await pad.write("thread-dos", "k", "dos");
-		await pad.clear("thread-uno");
-
-		expect(await pad.read("thread-dos", "k")).toBe("dos");
-	});
-
-	it("escribe el mismo documento que lee el context compiler", async () => {
-		// La clase y `conversation-store` comparten colección e id. Antes la clase
-		// guardaba un doc incompleto (sin `source`, `createdAt` ni `seq`), así que
-		// una nota escrita por acá se ordenaba mal dentro del prompt.
-		await pad.write(THREAD, "compartida", "valor", "test");
-
-		const notes = await getScratchpad(THREAD);
-		expect(notes).toEqual([{ key: "compartida", value: "valor" }]);
-	});
-});

package/packages/core/src/scheduler/scheduler.test.ts

@@ -1,15 +0,0 @@
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, expect, it } from "bun:test";
-import { CronScheduler } from "./CronScheduler.ts";
-
-// `new CronScheduler(db, handler)` pasó a `new CronScheduler(handler)`: los jobs
-// viven en la colección `cronJobs` de HiveDB y el scheduler la abre solo, así
-// que ya no recibe un handle de base.
-
-describe("CronScheduler", () => {
-  it("creates a scheduler instance with a handler", () => {
-    const scheduler = new CronScheduler(async () => ({ success: true }));
-    expect(scheduler).toBeDefined();
-  });
-});

package/packages/core/src/skills/skills.test.ts

@@ -1,62 +0,0 @@
-/**
- * El catálogo de skills bundled se genera desde los SKILL.md de `skills/bundled/`
- * con `bun run skills:bundle`. Hasta 0.1.5 el SDK traía 44 skills copiadas a
- * mano, 21 de las cuales invocaban tools que ya no existen (`voice_*`,
- * `meeting_transcription`, `canvas_*`, `code_*`, `project_*`): el selector se
- * las podía ofrecer al modelo y la ejecución moría sin ejecutor.
- */
-
-import { describe, it, expect } from "bun:test";
-import { BUNDLED_SKILLS_DATA } from "./bundled-data.generated.ts";
-import { createAllTools } from "../tools/index.ts";
-import { loadConfig } from "../config/loader.ts";
-
-describe("Bundled skills", () => {
-  it("incluye las skills web y de browser", () => {
-    const names = BUNDLED_SKILLS_DATA.map((s) => s.name);
-    expect(names).toContain("web_research");
-    expect(names).toContain("browser_scrape");
-    expect(names).toContain("browser_automate");
-  });
-
-  it("no arrastra las skills retiradas", () => {
-    const names = BUNDLED_SKILLS_DATA.map((s) => s.name);
-    for (const retired of [
-      "web_browser_research",
-      "voice_input",
-      "voice_output",
-      "voice_assistant",
-      "meeting_transcription",
-      "canvas_report",
-      "canvas_dashboard",
-      "code_review",
-      "code_generate",
-      "project_planner",
-      "busqueda_fts5",
-      "ai_coder",
-      "data_analyst",
-    ]) {
-      expect(names, `la skill retirada "${retired}" volvió al bundle`).not.toContain(retired);
-    }
-  });
-
-  it("cada skill declara sólo tools que existen en el registry", async () => {
-    const available = new Set(createAllTools(await loadConfig()).map((t) => t.name));
-
-    const dangling = BUNDLED_SKILLS_DATA.flatMap((skill) =>
-      (skill.tools ?? [])
-        .filter((tool) => !available.has(tool))
-        .map((tool) => `${skill.name} → ${tool}`)
-    );
-
-    expect(dangling, `skills apuntando a tools inexistentes:\n${dangling.join("\n")}`).toEqual([]);
-  });
-
-  it("toda skill tiene nombre, descripción y categoría", () => {
-    for (const skill of BUNDLED_SKILLS_DATA) {
-      expect(skill.name, "skill sin nombre").toBeTruthy();
-      expect(skill.description, `${skill.name} sin descripción`).toBeTruthy();
-      expect(skill.category, `${skill.name} sin categoría`).toBeTruthy();
-    }
-  });
-});

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

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { TaskGraph } from "./TaskGraph.ts";
-
-describe("TaskGraph", () => {
-  it("creates a graph with nodes", () => {
-    const graph = new TaskGraph([
-      { id: "a", agentId: "agent-a", name: "Task A", taskDescription: "Task A", deps: [] },
-      { id: "b", agentId: "agent-b", name: "Task B", taskDescription: "Task B", deps: ["a"] },
-    ]);
-
-    expect(graph.nodes.size).toBe(2);
-    expect(graph.nodes.get("a")?.deps).toEqual([]);
-    expect(graph.nodes.get("b")?.deps).toEqual(["a"]);
-  });
-
-  it("validates node existence", () => {
-    const graph = new TaskGraph([
-      { id: "a", agentId: "agent-a", name: "Task A", taskDescription: "Task A", deps: [] },
-    ]);
-
-    expect(graph.nodes.has("a")).toBe(true);
-    expect(graph.nodes.has("missing")).toBe(false);
-  });
-});

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

@@ -1,99 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { executeToolBatch, shutdownToolRuntime, type RuntimeTool, type ToolCallLike } from "./index.ts";
-import { loadConfig } from "../config/loader.ts";
-
-const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
-function toolCall(id: string, name: string, args: unknown = {}): ToolCallLike {
-  return {
-    id,
-    function: {
-      name,
-      arguments: JSON.stringify(args),
-    },
-  };
-}
-
-describe("tool runtime worker pool", () => {
-  afterEach(() => {
-    shutdownToolRuntime();
-  });
-
-  it("runs multiple tools in parallel through worker scheduling", async () => {
-    // Per-tool delay + threshold sized for CI headroom: worker spawn/scheduling
-    // overhead is roughly fixed, so a larger delay keeps that overhead a small
-    // fraction of the budget instead of dominating it on a loaded runner.
-    // Serial execution would take ~3x the delay; the threshold stays well
-    // under that so the assertion still proves parallelism, not just patience.
-    const TOOL_DELAY_MS = 200;
-    const PARALLEL_THRESHOLD_MS = 450;
-
-    const tools: RuntimeTool[] = ["slow_a", "slow_b", "slow_c"].map((name) => ({
-      name,
-      execute: async () => {
-        await delay(TOOL_DELAY_MS);
-        return { name };
-      },
-    }));
-
-    const startedAt = performance.now();
-    const results = await executeToolBatch({
-      toolCalls: [
-        toolCall("1", "slow_a"),
-        toolCall("2", "slow_b"),
-        toolCall("3", "slow_c"),
-      ],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 3, toolTimeoutMs: 5000, parallelToolCalls: true },
-    });
-    const elapsed = performance.now() - startedAt;
-
-    expect(results.map((result) => (result.result as any).name)).toEqual(["slow_a", "slow_b", "slow_c"]);
-    expect(elapsed).toBeLessThan(PARALLEL_THRESHOLD_MS);
-  });
-
-  it("preserves input order when tools complete out of order", async () => {
-    const tools: RuntimeTool[] = [
-      { name: "first", execute: async () => { await delay(120); return { value: 1 } } },
-      { name: "second", execute: async () => { await delay(20); return { value: 2 } } },
-      { name: "third", execute: async () => { await delay(60); return { value: 3 } } },
-    ];
-
-    const results = await executeToolBatch({
-      toolCalls: [toolCall("1", "first"), toolCall("2", "second"), toolCall("3", "third")],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 3, toolTimeoutMs: 1000, parallelToolCalls: true },
-    });
-
-    expect(results.map((r) => (r.result as any).value)).toEqual([1, 2, 3]);
-  });
-
-  it("handles tool errors gracefully", async () => {
-    const tools: RuntimeTool[] = [
-      {
-        name: "fail",
-        execute: async () => {
-          throw new Error("intentional failure");
-        },
-      },
-    ];
-
-    const results = await executeToolBatch({
-      toolCalls: [toolCall("1", "fail")],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 1, toolTimeoutMs: 1000, parallelToolCalls: false },
-    });
-
-    expect(results[0].ok).toBe(false);
-    expect(results[0].result).toBeDefined();
-    const result = results[0].result as any;
-    expect(result.error).toBe(true);
-    expect(result.message).toContain("intentional failure");
-  });
-});