@johpaz/hive-sdk 0.1.6 → 0.2.0

package/test/tool-runtime.test.ts

@@ -1,258 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test"
-import { executeToolBatch, shutdownToolRuntime, type RuntimeTool, type ToolCallLike } from "../packages/core/src/tool-runtime/index.ts"
-import { loadConfig } from "../packages/core/src/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 () => {
-    const tools: RuntimeTool[] = ["slow_a", "slow_b", "slow_c"].map((name) => ({
-      name,
-      execute: async () => {
-        await delay(120)
-        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: 1000, 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(260)
-  })
-
-  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((result) => result.toolName)).toEqual(["first", "second", "third"])
-    expect(results.map((result) => (result.result as any).value)).toEqual([1, 2, 3])
-  })
-
-  it("isolates tool errors without cancelling sibling tools", async () => {
-    const tools: RuntimeTool[] = [
-      { name: "ok", execute: async () => ({ ok: true }) },
-      { name: "fail", execute: async () => { throw new Error("boom") } },
-      { name: "also_ok", execute: async () => ({ ok: "also" }) },
-    ]
-
-    const results = await executeToolBatch({
-      toolCalls: [toolCall("1", "ok"), toolCall("2", "fail"), toolCall("3", "also_ok")],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 3, toolTimeoutMs: 1000, parallelToolCalls: true },
-    })
-
-    expect(results[0].ok).toBe(true)
-    expect(results[1].ok).toBe(false)
-    expect((results[1].result as any).error).toBe(true)
-    expect((results[1].result as any).message).toContain("boom")
-    expect(results[2].ok).toBe(true)
-  })
-
-  it("routes non-reconstructible tools through main-thread RPC", async () => {
-    let executedInMainThread = false
-    const tools: RuntimeTool[] = [
-      {
-        name: "ExampleServer__live_tool",
-        execute: async (params) => {
-          executedInMainThread = true
-          return { echoed: params.value }
-        },
-      },
-      {
-        name: "other_rpc_tool",
-        execute: async () => ({ ok: true }),
-      },
-    ]
-
-    const results = await executeToolBatch({
-      toolCalls: [
-        toolCall("1", "ExampleServer__live_tool", { value: "ok" }),
-        toolCall("2", "other_rpc_tool"),
-      ],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 1, toolTimeoutMs: 1000, parallelToolCalls: true },
-    })
-
-    expect(executedInMainThread).toBe(true)
-    expect(results[0].ok).toBe(true)
-    expect(results[0].result).toEqual({ echoed: "ok" })
-  })
-
-  it("settles in-flight RPC work when the runtime shuts down", async () => {
-    const tools: RuntimeTool[] = [
-      {
-        name: "ExampleServer__slow_live_tool",
-        execute: async () => {
-          await delay(100)
-          return { late: true }
-        },
-      },
-      { name: "other_rpc_tool", execute: async () => ({ ok: true }) },
-    ]
-
-    const pending = executeToolBatch({
-      toolCalls: [
-        toolCall("1", "ExampleServer__slow_live_tool"),
-        toolCall("2", "other_rpc_tool"),
-      ],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 1, toolTimeoutMs: 1000, parallelToolCalls: true },
-    })
-
-    await delay(20)
-    shutdownToolRuntime()
-
-    const results = await pending
-    expect(results.every((result) => result.aborted)).toBe(true)
-  })
-
-  it("routes singleton-backed native tools through main-thread RPC", async () => {
-    const executed = new Set<string>()
-    const tools: RuntimeTool[] = [
-      "search_knowledge",
-      "save_note",
-      "memory_write",
-      "task_status",
-      "project_create",
-    ].map((name) => ({
-      name,
-      execute: async () => {
-        executed.add(name)
-        return { name, mainThread: true }
-      },
-    }))
-
-    const results = await executeToolBatch({
-      toolCalls: [
-        toolCall("1", "search_knowledge", { query: "A2UI" }),
-        toolCall("2", "save_note", { key: "k", value: "v" }),
-        toolCall("3", "memory_write", { key: "m", value: "v" }),
-        toolCall("4", "task_status", { task_id: "t1" }),
-        toolCall("5", "project_create", { name: "release" }),
-      ],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 2, toolTimeoutMs: 1000, parallelToolCalls: true },
-    })
-
-    expect(results.every((result) => result.ok)).toBe(true)
-    expect(executed).toEqual(new Set(["search_knowledge", "save_note", "memory_write", "task_status", "project_create"]))
-    expect(results.map((result) => (result.result as any).mainThread)).toEqual([true, true, true, true, true])
-  })
-
-  it("marks timed out tools and keeps completed tools", async () => {
-    const tools: RuntimeTool[] = [
-      { name: "fast", execute: async () => ({ done: true }) },
-      { name: "timeout", execute: async () => { await delay(400); return { late: true } } },
-    ]
-
-    const results = await executeToolBatch({
-      toolCalls: [toolCall("1", "fast"), toolCall("2", "timeout")],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 2, toolTimeoutMs: 150, parallelToolCalls: true },
-    })
-
-    expect(results[0].ok).toBe(true)
-    expect(results[1].ok).toBe(false)
-    expect(results[1].timedOut).toBe(true)
-    expect((results[1].result as any).error).toBe(true)
-  })
-
-  it("marks queued and running work as aborted", async () => {
-    const controller = new AbortController()
-    const tools: RuntimeTool[] = [
-      { name: "slow_one", execute: async () => { await delay(200); return { done: 1 } } },
-      { name: "slow_two", execute: async () => { await delay(200); return { done: 2 } } },
-    ]
-
-    setTimeout(() => controller.abort(), 30)
-
-    const results = await executeToolBatch({
-      toolCalls: [toolCall("1", "slow_one"), toolCall("2", "slow_two")],
-      allTools: tools,
-      toolConfig: {},
-      hiveConfig: loadConfig(),
-      workerPool: { enabled: true, maxWorkers: 1, toolTimeoutMs: 1000, parallelToolCalls: true },
-      signal: controller.signal,
-    })
-
-    expect(results.every((result) => result.aborted)).toBe(true)
-    expect(results.map((result) => result.toolName)).toEqual(["slow_one", "slow_two"])
-  })
-
-  it("passes toolConfig (including agent_id) through to a single tool call's config.configurable", async () => {
-    // Single tool call → always the serial/main-thread path (executeToolBatch's
-    // `toolCalls.length <= 1` branch) — exactly what task_delegate/agent_create/
-    // bus_publish go through. Regression test for a real bug: toolConfig never
-    // included agent_id, so config.configurable.agent_id was always undefined
-    // inside every tool's execute() (task_delegate's parent-agent lookup always
-    // failed as a result — see agent-loop.ts's toolConfig construction).
-    let seenConfigurable: Record<string, unknown> | undefined;
-    const tools: RuntimeTool[] = [
-      {
-        name: "whoami",
-        execute: async (_params, config) => {
-          seenConfigurable = config?.configurable;
-          return { ok: true };
-        },
-      },
-    ];
-
-    await executeToolBatch({
-      toolCalls: [toolCall("1", "whoami")],
-      allTools: tools,
-      toolConfig: { agent_id: "bee-coordinator", user_id: "u1", thread_id: "t1", channel: "webchat", workspace: "/tmp/ws" },
-      hiveConfig: loadConfig(),
-    });
-
-    expect(seenConfigurable?.agent_id).toBe("bee-coordinator");
-    expect(seenConfigurable?.user_id).toBe("u1");
-    expect(seenConfigurable?.workspace).toBe("/tmp/ws");
-  })
-})

package/test/tool-selector-runtime-tools.test.ts

@@ -1,117 +0,0 @@
-/**
- * tool-selector — las tools que sólo viven en la colección `tools`.
- *
- * `syncToolCatalogToIndex` construye el índice BM25 con CORE_TOOL_CATALOG **más**
- * las filas de la colección. `selectTools`, en cambio, resolvía los hits contra
- * `fullToolList`, que por defecto es sólo CORE_TOOL_CATALOG. Una tool registrada
- * en runtime podía salir primera en la búsqueda y aun así no llegar nunca al
- * modelo: el hit se descartaba en silencio, sin log ni error.
- *
- * Acá no se notaba porque todas las tools de hive están en el catálogo estático.
- * Se detectó en el SDK, donde las apps declaran tools con `defineTool`.
- *
- * Usa HIVE_DB_PATH=":memory:".
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { col } from "../packages/core/src/storage/hive";
-import type { ToolDoc } from "../packages/core/src/storage/collections";
-import { selectTools, syncToolCatalogToIndex } from "../packages/core/src/agent/tool-selector";
-
-/** Nombre y vocabulario deliberadamente ajenos al catálogo estático. */
-const RUNTIME_TOOL = "consultar_inventario_ferreteria";
-const QUERY = "necesito consultar el inventario de la ferretería";
-
-async function registerRuntimeTool(overrides: Partial<ToolDoc> = {}): Promise<void> {
-  const tools = await col<ToolDoc>("tools");
-  await tools.put(RUNTIME_TOOL, {
-    id: RUNTIME_TOOL,
-    name: RUNTIME_TOOL,
-    description: "Consulta el inventario de la ferretería: stock, existencias y precios de artículos",
-    category: "core",
-    enabled: true,
-    active: true,
-    created_at: Date.now(),
-    updated_at: Date.now(),
-    ...overrides,
-  });
-}
-
-beforeEach(async () => {
-  closeHiveDb();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-describe("selectTools con tools registradas en runtime", () => {
-  test("una tool que sólo está en la colección llega al modelo", async () => {
-    await registerRuntimeTool();
-    await syncToolCatalogToIndex();
-
-    const selected = await selectTools(QUERY);
-
-    expect(selected.map((t) => t.name)).toContain(RUNTIME_TOOL);
-  });
-
-  test("conserva la descripción de la fila — es lo que el modelo lee para decidir", async () => {
-    await registerRuntimeTool();
-    await syncToolCatalogToIndex();
-
-    const tool = (await selectTools(QUERY)).find((t) => t.name === RUNTIME_TOOL);
-
-    expect(tool?.description).toContain("inventario de la ferretería");
-  });
-
-  test("una tool deshabilitada no se ofrece aunque esté indexada", async () => {
-    // El índice se construye desde la colección sin mirar `enabled`, así que la
-    // única defensa es el filtro al resolver el hit.
-    await registerRuntimeTool({ enabled: false });
-    await syncToolCatalogToIndex();
-
-    const selected = await selectTools(QUERY);
-
-    expect(selected.map((t) => t.name)).not.toContain(RUNTIME_TOOL);
-  });
-
-  test("una tool inactiva tampoco se ofrece", async () => {
-    await registerRuntimeTool({ active: false });
-    await syncToolCatalogToIndex();
-
-    const selected = await selectTools(QUERY);
-
-    expect(selected.map((t) => t.name)).not.toContain(RUNTIME_TOOL);
-  });
-
-  test("un hit sin fila en la colección se descarta sin romper la selección", async () => {
-    // El índice puede quedar con basura de una tool borrada; el resto del
-    // loadout tiene que seguir funcionando.
-    await registerRuntimeTool();
-    await syncToolCatalogToIndex();
-    await (await col<ToolDoc>("tools")).delete(RUNTIME_TOOL);
-
-    const selected = await selectTools(QUERY);
-
-    expect(selected.map((t) => t.name)).not.toContain(RUNTIME_TOOL);
-    expect(Array.isArray(selected)).toBe(true);
-  });
-
-  test("no rompe la resolución de las tools del catálogo estático", async () => {
-    await registerRuntimeTool();
-    await syncToolCatalogToIndex();
-
-    const selected = await selectTools("buscá en la web información sobre tarifas de envío");
-
-    expect(selected.length).toBeGreaterThan(0);
-    for (const tool of selected) {
-      expect(tool.name).toBeString();
-      expect(tool.description).toBeString();
-    }
-  });
-});