@johpaz/hive-sdk 0.0.14 → 0.0.16

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

@@ -0,0 +1,125 @@
+import { createAllTools } from "../tools/index.ts"
+import type { Config } from "../config/loader.ts"
+
+type WorkerRunMessage = {
+  type: "run"
+  jobId: string
+  toolName: string
+  args: unknown
+  toolConfig: Record<string, unknown>
+  hiveConfig: Config
+  mainThreadToolNames: string[]
+}
+
+type WorkerRpcResponse = {
+  type: "rpc_result"
+  rpcId: string
+  ok: boolean
+  result?: unknown
+  error?: SerializedError
+}
+
+type SerializedError = {
+  name: string
+  message: string
+  stack?: string
+}
+
+const pendingRpc = new Map<string, {
+  resolve: (value: unknown) => void
+  reject: (error: Error) => void
+}>()
+
+function serializeError(error: unknown): SerializedError {
+  const err = error instanceof Error ? error : new Error(String(error))
+  return {
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+  }
+}
+
+function parseArgs(args: unknown): Record<string, unknown> {
+  if (typeof args === "string") {
+    return JSON.parse(args) as Record<string, unknown>
+  }
+  if (args && typeof args === "object") {
+    return args as Record<string, unknown>
+  }
+  return {}
+}
+
+function requestMainThreadTool(
+  jobId: string,
+  toolName: string,
+  args: unknown,
+  toolConfig: Record<string, unknown>
+): Promise<unknown> {
+  const rpcId = `${jobId}:${crypto.randomUUID()}`
+  return new Promise((resolve, reject) => {
+    pendingRpc.set(rpcId, { resolve, reject })
+    postMessage({
+      type: "rpc_call",
+      rpcId,
+      jobId,
+      toolName,
+      args,
+      toolConfig,
+    })
+  })
+}
+
+async function runTool(message: WorkerRunMessage): Promise<void> {
+  const startedAt = performance.now()
+
+  try {
+    const parsedArgs = parseArgs(message.args)
+    const forceMainThread = message.mainThreadToolNames.includes(message.toolName)
+    const allTools = forceMainThread ? [] : createAllTools(message.hiveConfig)
+    const tool = allTools.find((candidate) => candidate.name === message.toolName)
+
+    const result = tool?.execute
+      ? await tool.execute(parsedArgs, { configurable: message.toolConfig })
+      : await requestMainThreadTool(message.jobId, message.toolName, parsedArgs, message.toolConfig)
+
+    postMessage({
+      type: "result",
+      jobId: message.jobId,
+      ok: true,
+      result,
+      durationMs: Math.round(performance.now() - startedAt),
+    })
+  } catch (error) {
+    postMessage({
+      type: "result",
+      jobId: message.jobId,
+      ok: false,
+      error: serializeError(error),
+      durationMs: Math.round(performance.now() - startedAt),
+    })
+  }
+}
+
+onmessage = (event: MessageEvent<WorkerRunMessage | WorkerRpcResponse>) => {
+  const message = event.data
+
+  if (message.type === "rpc_result") {
+    const pending = pendingRpc.get(message.rpcId)
+    if (!pending) return
+
+    pendingRpc.delete(message.rpcId)
+    if (message.ok) {
+      pending.resolve(message.result)
+    } else {
+      const error = new Error(message.error?.message || "Tool RPC failed")
+      error.name = message.error?.name || "ToolRpcError"
+      error.stack = message.error?.stack
+      pending.reject(error)
+    }
+    return
+  }
+
+  if (message.type === "run") {
+    void runTool(message)
+  }
+}

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

@@ -0,0 +1,58 @@
+import type { ToolDefinition } from "./ToolRegistry";
+import type { ToolRegistry } from "./ToolRegistry";
+
+export interface ToolExecutionResult {
+  toolName: string;
+  args: any;
+  result: any;
+  durationMs: number;
+  error?: string;
+}
+
+export class ToolExecutor {
+  constructor(private registry: ToolRegistry) {}
+
+  async execute(
+    name: string,
+    args: any,
+    config?: any
+  ): Promise<ToolExecutionResult> {
+    const tool = this.registry.get(name);
+    if (!tool) {
+      return {
+        toolName: name,
+        args,
+        result: null,
+        durationMs: 0,
+        error: `Tool '${name}' not found`,
+      };
+    }
+
+    const start = Date.now();
+    try {
+      const validatedArgs = tool.schema ? tool.schema.parse(args) : args;
+      const result = await tool.execute(validatedArgs, config);
+      return {
+        toolName: name,
+        args: validatedArgs,
+        result,
+        durationMs: Date.now() - start,
+      };
+    } catch (error: any) {
+      return {
+        toolName: name,
+        args,
+        result: null,
+        durationMs: Date.now() - start,
+        error: error.message || String(error),
+      };
+    }
+  }
+
+  async executeBatch(
+    calls: Array<{ name: string; args: any }>,
+    config?: any
+  ): Promise<ToolExecutionResult[]> {
+    return Promise.all(calls.map(c => this.execute(c.name, c.args, config)));
+  }
+}

package/packages/core/src/tools/ToolRegistry.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "bun:test";
+import { ToolRegistry, defineTool } from "./ToolRegistry.ts";
+import { ToolExecutor } from "./ToolExecutor.ts";
+
+describe("defineTool", () => {
+	it("creates a tool definition", () => {
+		const tool = defineTool({
+			name: "hello",
+			description: "Say hello",
+			execute: async (args: { name?: string }) => ({ greeting: `Hello, ${args.name ?? "world"}!` }),
+		});
+		expect(tool.name).toBe("hello");
+		expect(tool.description).toBe("Say hello");
+	});
+});
+
+describe("ToolRegistry", () => {
+	it("register, get, has", () => {
+		const reg = new ToolRegistry();
+		const tool = defineTool({
+			name: "test",
+			description: "a test tool",
+			execute: async () => ({ ok: true }),
+		});
+		reg.register(tool);
+		expect(reg.has("test")).toBe(true);
+		expect(reg.get("test")).toBe(tool);
+		expect(reg.get("nope")).toBeUndefined();
+	});
+
+	it("throws on duplicate registration", () => {
+		const reg = new ToolRegistry();
+		reg.register(defineTool({ name: "dup", description: "", execute: async () => ({}) }));
+		expect(() =>
+			reg.register(defineTool({ name: "dup", description: "", execute: async () => ({}) }))
+		).toThrow("already registered");
+	});
+
+	it("lists and categorizes", () => {
+		const reg = new ToolRegistry();
+		reg.register(defineTool({ name: "a", description: "", category: "web", execute: async () => ({}) }));
+		reg.register(defineTool({ name: "b", description: "", category: "fs", execute: async () => ({}) }));
+		reg.register(defineTool({ name: "c", description: "", category: "web", execute: async () => ({}) }));
+		expect(reg.size()).toBe(3);
+		expect(reg.list()).toHaveLength(3);
+		expect(reg.getByCategory("web")).toHaveLength(2);
+		expect(reg.getNames()).toEqual(["a", "b", "c"]);
+	});
+
+	it("merge and clear", () => {
+		const a = new ToolRegistry();
+		const b = new ToolRegistry();
+		a.register(defineTool({ name: "x", description: "", execute: async () => ({}) }));
+		b.register(defineTool({ name: "y", description: "", execute: async () => ({}) }));
+		a.merge(b);
+		expect(a.size()).toBe(2);
+		a.clear();
+		expect(a.size()).toBe(0);
+	});
+});
+
+describe("ToolExecutor", () => {
+	it("executes a registered tool", async () => {
+		const reg = new ToolRegistry();
+		reg.register(
+			defineTool({
+				name: "echo",
+				description: "echo args",
+				execute: async (args) => args,
+			})
+		);
+		const exec = new ToolExecutor(reg);
+		const result = await exec.execute("echo", { msg: "hi" });
+		expect(result.toolName).toBe("echo");
+		expect(result.result).toEqual({ msg: "hi" });
+		expect(result.error).toBeUndefined();
+		expect(result.durationMs).toBeGreaterThanOrEqual(0);
+	});
+
+	it("returns error for unknown tool", async () => {
+		const exec = new ToolExecutor(new ToolRegistry());
+		const result = await exec.execute("ghost", {});
+		expect(result.error).toBeString();
+		expect(result.error).toContain("not found");
+	});
+
+	it("executes batch", async () => {
+		const reg = new ToolRegistry();
+		reg.register(defineTool({ name: "t1", description: "", execute: async () => 1 }));
+		reg.register(defineTool({ name: "t2", description: "", execute: async () => 2 }));
+		const exec = new ToolExecutor(reg);
+		const results = await exec.executeBatch([{ name: "t1", args: {} }, { name: "t2", args: {} }, { name: "nope", args: {} }]);
+		expect(results).toHaveLength(3);
+		expect(results[0].result).toBe(1);
+		expect(results[1].result).toBe(2);
+		expect(results[2].error).toBeString();
+	});
+});

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

@@ -0,0 +1,61 @@
+import { z } from "zod";
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  schema?: z.ZodType;
+  execute: (args: any, config?: any) => Promise<any>;
+  category?: string;
+  abstractionLevel?: "atomic" | "orchestration";
+}
+
+export class ToolRegistry {
+  private tools: Map<string, ToolDefinition> = new Map();
+
+  register(tool: ToolDefinition): void {
+    if (this.tools.has(tool.name)) {
+      throw new Error(`Tool '${tool.name}' already registered`);
+    }
+    this.tools.set(tool.name, tool);
+  }
+
+  get(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  list(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  getByCategory(category: string): ToolDefinition[] {
+    return this.list().filter(t => t.category === category);
+  }
+
+  getNames(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  size(): number {
+    return this.tools.size;
+  }
+
+  merge(other: ToolRegistry): void {
+    for (const tool of other.list()) {
+      if (!this.tools.has(tool.name)) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+  }
+
+  clear(): void {
+    this.tools.clear();
+  }
+}
+
+export function defineTool(config: ToolDefinition): ToolDefinition {
+  return config;
+}

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

@@ -0,0 +1,118 @@
+/**
+ * Get Available Models Tool
+ *
+ * Permite a los agentes consultar providers y modelos activos en la BD
+ * para seleccionar el modelo óptimo al crear nuevos agentes.
+ *
+ * @category agents
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.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",
+  parameters: {
+    type: "object",
+    properties: {
+      providerId: {
+        type: "string",
+        description: "Opcional: filtrar por provider (openai, ollama, anthropic, gemini, etc.)"
+      },
+      modelType: {
+        type: "string",
+        description: "Opcional: filtrar por tipo (llm, stt, tts, vision, embedding)"
+      },
+      capabilities: {
+        type: "string",
+        description: "Opcional: filtrar por capacidad (coding, chat, analysis, vision, reasoning)"
+      }
+    },
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const db = getDb();
+    const { providerId, modelType, capabilities } = params as {
+      providerId?: string;
+      modelType?: string;
+      capabilities?: string;
+    };
+
+    try {
+      // Construir query con filtros opcionales
+      let query = `
+        SELECT 
+          p.id as provider_id,
+          p.name as provider_name,
+          p.category as provider_category,
+          m.id as model_id,
+          m.name as model_name,
+          m.model_type,
+          m.context_window,
+          m.capabilities
+        FROM models m
+        INNER JOIN providers p ON m.provider_id = p.id
+        WHERE m.enabled = 1 AND m.active = 1 AND p.enabled = 1 AND p.active = 1
+      `;
+
+      const whereClauses: string[] = [];
+      const queryParams: string[] = [];
+
+      if (providerId) {
+        whereClauses.push("p.id = ?");
+        queryParams.push(providerId as string);
+      }
+
+      if (modelType) {
+        whereClauses.push("m.model_type = ?");
+        queryParams.push(modelType as string);
+      }
+
+      if (capabilities) {
+        whereClauses.push("m.capabilities LIKE ?");
+        queryParams.push(`%${capabilities as string}%`);
+      }
+
+      if (whereClauses.length > 0) {
+        query += " AND " + whereClauses.join(" AND ");
+      }
+
+      query += " ORDER BY p.name, m.name";
+
+      // Ejecutar query
+      const rows = db.query<any, string[]>(query).all(...queryParams) as Array<{
+        provider_id: string;
+        provider_name: string;
+        provider_category: string;
+        model_id: string;
+        model_name: string;
+        model_type: string;
+        context_window: number | null;
+        capabilities: string | null;
+      }>;
+
+      // Transformar a formato amigable
+      const result = rows.map(row => ({
+        providerId: row.provider_id,
+        providerName: row.provider_name,
+        providerCategory: row.provider_category,
+        modelId: row.model_id,
+        modelName: row.model_name,
+        modelType: row.model_type,
+        contextWindow: row.context_window,
+        capabilities: row.capabilities ? JSON.parse(row.capabilities) : null,
+      }));
+
+      return {
+        ok: true,
+        count: result.length,
+        models: result,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to get available models: ${(error as Error).message}`,
+      };
+    }
+  },
+};