@johpaz/hive-sdk 0.1.5 → 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/toon.test.ts

@@ -1,429 +0,0 @@
-/**
- * TOON Format Utility Tests
- *
- * Tests for TOON (Token-Oriented Object Notation) implementation
- * using toon-format-parser library with native compression analysis
- */
-
-import { describe, test, expect } from 'bun:test'
-import {
-  stringify,
-  formatToolResult,
-  formatMCPResponse,
-  formatSkillOutput,
-  formatContext,
-  estimateTokens,
-  getCompressionAnalysis,
-  withToonFormat,
-  type ToonStringifyResult,
-} from '../packages/core/src/utils/toon.ts'
-
-describe('TOON Utility', () => {
-  describe('stringify()', () => {
-    test('convierte objeto simple a TOON', () => {
-      const data = { name: 'John', age: 30, city: 'New York' }
-      const result = stringify(data)
-
-      expect(result.content).toBeDefined()
-      expect(result.format).toBe('toon')
-      expect(result.originalSize).toBeGreaterThan(0)
-      expect(result.toonSize).toBeGreaterThan(0)
-      expect(typeof result.tokensSaved).toBe('number')
-      expect(typeof result.savingsPercent).toBe('number')
-      expect(typeof result.costSaved).toBe('number')
-      // New complete metrics
-      expect(typeof result.jsonBytes).toBe('number')
-      expect(typeof result.toonBytes).toBe('number')
-      expect(typeof result.savedBytes).toBe('number')
-      expect(typeof result.savedPercent).toBe('number')
-      expect(typeof result.jsonTokens).toBe('number')
-      expect(typeof result.toonTokens).toBe('number')
-      expect(typeof result.savedTokensPercent).toBe('number')
-    })
-
-    test('convierte objeto anidado a TOON', () => {
-      const data = {
-        user: {
-          name: 'Alice',
-          email: 'alice@example.com',
-          preferences: {
-            theme: 'dark',
-            notifications: true,
-          },
-        },
-        projects: [
-          { id: 1, name: 'Project A', status: 'active' },
-          { id: 2, name: 'Project B', status: 'completed' },
-        ],
-      }
-      const result = stringify(data)
-
-      expect(result.content).toBeDefined()
-      expect(result.format).toBe('toon')
-      expect(result.toonSize).toBeGreaterThan(0)
-    })
-
-    test('calcula tokens ahorrados correctamente', () => {
-      const data = {
-        success: true,
-        data: {
-          emails: [
-            { id: '1', from: 'alice@example.com', subject: 'Hello' },
-            { id: '2', from: 'bob@example.com', subject: 'World' },
-          ],
-        },
-      }
-      const result = stringify(data)
-
-      // savingsPercent debería ser >= 0 (usamos Math.max)
-      expect(result.savingsPercent).toBeGreaterThanOrEqual(0)
-      expect(result.tokensSaved).toBeGreaterThanOrEqual(0)
-    })
-
-    test('calcula costo USD con modelo', () => {
-      const data = { message: 'Hello World', count: 42 }
-      const result = stringify(data, 'gemini-2.0-flash-exp')
-
-      expect(result.costSaved).toBeGreaterThanOrEqual(0)
-
-      // Si hay ahorro de tokens, debería haber ahorro de costo
-      if (result.tokensSaved > 0) {
-        expect(result.costSaved).toBeGreaterThan(0)
-      }
-    })
-
-    test('maneja arrays grandes', () => {
-      const data = Array.from({ length: 100 }, (_, i) => ({
-        id: i,
-        name: `Item ${i}`,
-        value: Math.random(),
-      }))
-      const result = stringify(data)
-
-      expect(result.content).toBeDefined()
-      expect(result.format).toBe('toon')
-    })
-
-    test('maneja objetos vacíos', () => {
-      const result = stringify({})
-
-      expect(result.content).toBeDefined()
-      expect(result.format).toBe('toon')
-    })
-
-    test('maneja valores null y undefined', () => {
-      const data = {
-        nullValue: null,
-        undefinedValue: undefined,
-        stringValue: 'test',
-      }
-      const result = stringify(data)
-
-      expect(result.content).toBeDefined()
-      expect(result.format).toBe('toon')
-    })
-
-    test('maneja primitivos', () => {
-      expect(stringify('hello').content).toBeDefined()
-      expect(stringify(42).content).toBeDefined()
-      expect(stringify(true).content).toBeDefined()
-      expect(stringify(null).content).toBeDefined()
-    })
-  })
-
-  describe('formatToolResult()', () => {
-    test('formatea resultado de herramienta', () => {
-      const toolResult = {
-        success: true,
-        data: { items: [1, 2, 3] },
-        timestamp: new Date().toISOString(),
-      }
-      const result = formatToolResult(toolResult, 'gpt-4o-mini')
-
-      expect(typeof result).toBe('string')
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    test('formatea error de herramienta', () => {
-      const errorResult = {
-        error: true,
-        tool: 'test_tool',
-        message: 'Something went wrong',
-        timestamp: new Date().toISOString(),
-      }
-      const result = formatToolResult(errorResult)
-
-      expect(typeof result).toBe('string')
-      expect(result).toContain('error')
-    })
-
-    test('maneja resultado sin modelo', () => {
-      const result = formatToolResult({ data: 'test' })
-
-      expect(typeof result).toBe('string')
-    })
-  })
-
-  describe('formatMCPResponse()', () => {
-    test('formatea respuesta MCP', () => {
-      const mcpResponse = {
-        content: [
-          { type: 'text', text: 'Hello from MCP' },
-        ],
-        isError: false,
-      }
-      const result = formatMCPResponse(mcpResponse, 'gemini-2.0-flash-exp')
-
-      expect(typeof result).toBe('string')
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    test('formatea lista de herramientas MCP', () => {
-      const toolsResponse = {
-        tools: [
-          {
-            name: 'search_web',
-            description: 'Search the web',
-            inputSchema: { type: 'object', properties: { query: { type: 'string' } } },
-          },
-          {
-            name: 'send_email',
-            description: 'Send an email',
-            inputSchema: { type: 'object', properties: { to: { type: 'string' } } },
-          },
-        ],
-      }
-      const result = formatMCPResponse(toolsResponse)
-
-      expect(typeof result).toBe('string')
-    })
-  })
-
-  describe('formatSkillOutput()', () => {
-    test('formatea output de skill', () => {
-      const skillOutput = {
-        skill: 'pdf',
-        result: { pages: 10, text: 'Extracted text...' },
-      }
-      const result = formatSkillOutput(skillOutput, 'claude-3-5-sonnet')
-
-      expect(typeof result).toBe('string')
-    })
-  })
-
-  describe('formatContext()', () => {
-    test('formatea contexto del agente', () => {
-      const contextData = {
-        ethics: ['Be helpful', 'Be honest'],
-        notes: { key1: 'value1', key2: 'value2' },
-        projects: { active: 3, completed: 10 },
-      }
-      const result = formatContext(contextData)
-
-      expect(typeof result).toBe('string')
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    test('formatea scratchpad data', () => {
-      const scratchpadData = {
-        currentTask: 'Research hotels',
-        lastStep: 'Searched Google',
-        nextStep: 'Compare prices',
-      }
-      const result = formatContext(scratchpadData)
-
-      expect(typeof result).toBe('string')
-    })
-  })
-
-  describe('estimateTokens()', () => {
-    test('estima tokens para texto vacío', () => {
-      expect(estimateTokens('')).toBe(0)
-    })
-
-    test('estima tokens para texto corto', () => {
-      expect(estimateTokens('Hello World')).toBe(3) // ceil(11/4) = 3
-    })
-
-    test('estima tokens para texto largo', () => {
-      const text = 'A'.repeat(1000)
-      expect(estimateTokens(text)).toBe(250) // 1000/4 = 250
-    })
-
-    test('estima tokens para JSON', () => {
-      const json = JSON.stringify({ name: 'test', value: 42 })
-      expect(estimateTokens(json)).toBeGreaterThan(0)
-    })
-  })
-
-  describe('getCompressionAnalysis()', () => {
-    test('retorna análisis de compresión completo', () => {
-      const data = {
-        users: [
-          { id: 1, name: 'Alice', email: 'alice@example.com' },
-          { id: 2, name: 'Bob', email: 'bob@example.com' },
-        ],
-        metadata: {
-          total: 2,
-          page: 1,
-        },
-      }
-      const analysis = getCompressionAnalysis(data)
-
-      expect(analysis).toBeDefined()
-      expect(analysis.jsonBytes).toBeGreaterThan(0)
-      expect(analysis.toonBytes).toBeGreaterThan(0)
-      expect(analysis.jsonTokens).toBeGreaterThan(0)
-      expect(analysis.toonTokens).toBeGreaterThan(0)
-      expect(typeof analysis.savedTokens).toBe('number')
-      expect(typeof analysis.savedPercent).toBe('number')
-      expect(typeof analysis.savedTokensPercent).toBe('number')
-      expect(typeof analysis.savedBytes).toBe('number')
-    })
-
-    test('muestra ahorro significativo en datos estructurados', () => {
-      const data = Array.from({ length: 50 }, (_, i) => ({
-        id: i,
-        name: `Item ${i}`,
-        description: `Description for item ${i}`,
-      }))
-      const analysis = getCompressionAnalysis(data)
-
-      // En datos estructurados grandes, TOON debería ahorrar
-      expect(analysis.savedTokens).toBeGreaterThan(0)
-      expect(analysis.savedPercent).toBeGreaterThan(0)
-    })
-  })
-
-  describe('withToonFormat()', () => {
-    test('formatea resultado de función asíncrona', async () => {
-      const mockFn = async () => ({ result: 'success', data: [1, 2, 3] })
-      const result = await withToonFormat('test_tool', mockFn, 'gpt-4o')
-
-      expect(typeof result).toBe('string')
-      expect(result.length).toBeGreaterThan(0)
-    })
-
-    test('maneja error de función asíncrona', async () => {
-      const mockFn = async () => {
-        throw new Error('Test error')
-      }
-      const result = await withToonFormat('failing_tool', mockFn)
-
-      expect(typeof result).toBe('string')
-      expect(result).toContain('error')
-      expect(result).toContain('Test error')
-    })
-
-    test('registra duración de ejecución', async () => {
-      const mockFn = async () => {
-        await new Promise(resolve => setTimeout(resolve, 10))
-        return { done: true }
-      }
-      const result = await withToonFormat('slow_tool', mockFn)
-
-      expect(typeof result).toBe('string')
-    })
-  })
-
-  describe('Integration: Real-world scenarios', () => {
-    test('simula flujo real: tool result → LLM message', () => {
-      // 1. Tool ejecuta y retorna dato
-      const toolResult = {
-        success: true,
-        url: 'https://example.com',
-        content: 'Page content here',
-        statusCode: 200,
-      }
-
-      // 2. Formatear para LLM
-      const formattedForLLM = formatToolResult(toolResult, 'gpt-4o-mini')
-
-      // 3. Verificar formato
-      expect(typeof formattedForLLM).toBe('string')
-      expect(formattedForLLM.length).toBeGreaterThan(0)
-    })
-
-    test('simula respuesta MCP compleja', () => {
-      const mcpResponse = {
-        content: [
-          {
-            type: 'text',
-            text: 'Found 5 emails',
-          },
-          {
-            type: 'json',
-            data: {
-              emails: [
-                { id: '1', from: 'a@b.com', subject: 'Test 1' },
-                { id: '2', from: 'c@d.com', subject: 'Test 2' },
-              ],
-            },
-          },
-        ],
-        metadata: {
-          server: 'gmail',
-          timestamp: new Date().toISOString(),
-        },
-      }
-
-      const formatted = formatMCPResponse(mcpResponse)
-
-      expect(typeof formatted).toBe('string')
-      expect(formatted.length).toBeGreaterThan(0)
-    })
-
-    test('comparación JSON vs TOON en datos típicos', () => {
-      const typicalData = {
-        agent: {
-          id: 'coordinator',
-          name: 'Main Agent',
-          status: 'thinking',
-        },
-        conversation: {
-          threadId: 'thread-123',
-          messages: [
-            { role: 'user', content: 'Hello' },
-            { role: 'assistant', content: 'Hi there!' },
-          ],
-        },
-        tools: [
-          { name: 'search', status: 'available' },
-          { name: 'browser', status: 'busy' },
-        ],
-      }
-
-      const jsonSize = JSON.stringify(typicalData).length
-      const toonResult = stringify(typicalData)
-
-      expect(toonResult.originalSize).toBe(jsonSize)
-      expect(toonResult.toonSize).toBeGreaterThan(0)
-      expect(toonResult.savingsPercent).toBeGreaterThanOrEqual(0)
-    })
-  })
-
-  describe('Performance', () => {
-    test('stringify es rápido para objetos pequeños', () => {
-      const data = { key: 'value', num: 42 }
-      const start = performance.now()
-      stringify(data)
-      const duration = performance.now() - start
-
-      expect(duration).toBeLessThan(10) // < 10ms
-    })
-
-    test('stringify es razonable para objetos grandes', () => {
-      const data = Array.from({ length: 500 }, (_, i) => ({
-        id: i,
-        name: `Item ${i}`,
-        description: `Description for item ${i}`,
-      }))
-
-      const start = performance.now()
-      stringify(data)
-      const duration = performance.now() - start
-
-      expect(duration).toBeLessThan(100) // < 100ms
-    })
-  })
-})