@johpaz/hive-sdk 0.1.3 → 0.1.5

package/packages/core/src/tools/voice/index.ts

@@ -1,104 +0,0 @@
-/**
- * Voice Tools - 2 tools
- * 
- * @category voice
- */
-import type { Tool } from "../types.ts";
-import { logger } from "../../utils/logger.ts";
-
-const log = logger.child("voice");
-
-// ─── voice_transcribe ────────────────────────────────────────────────────────
-
-export const voiceTranscribeTool: Tool = {
-  name: "voice_transcribe",
-  description: "Transcribe audio input to text. Spanish: transcribir audio, voz a texto, reconocimiento de voz",
-  parameters: {
-    type: "object",
-    properties: {
-      audio: {
-        type: "string",
-        description: "Audio file path or base64 encoded audio",
-      },
-      language: {
-        type: "string",
-        description: "Language code (e.g., 'es', 'en'). Auto-detect if not specified.",
-      },
-    },
-    required: ["audio"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const audio = params.audio as string;
-    const language = (params.language as string) ?? "auto";
-
-    log.info(`Transcribing audio: ${audio.substring(0, 50)}...`);
-
-    try {
-      // Placeholder implementation - real transcription would call STT API
-      return {
-        ok: true,
-        transcription: "[Transcription requires STT provider configuration]",
-        language: language,
-        duration: 0,
-        confidence: 0,
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        error: `Failed to transcribe: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-// ─── voice_speak ─────────────────────────────────────────────────────────────
-
-export const voiceSpeakTool: Tool = {
-  name: "voice_speak",
-  description: "Convert text to synthesized speech output. Spanish: texto a voz, sintetizar, hablar, leer en voz alta",
-  parameters: {
-    type: "object",
-    properties: {
-      text: {
-        type: "string",
-        description: "Text to convert to speech",
-      },
-      voice_id: {
-        type: "string",
-        description: "Voice ID to use (provider-specific)",
-      },
-      language: {
-        type: "string",
-        description: "Language code (e.g., 'es', 'en')",
-      },
-    },
-    required: ["text"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const text = params.text as string;
-    const voiceId = (params.voice_id as string) ?? "default";
-    const language = (params.language as string) ?? "es";
-
-    log.info(`Synthesizing speech: ${text.substring(0, 50)}...`);
-
-    try {
-      // Placeholder implementation - real TTS would call TTS API
-      return {
-        ok: true,
-        audio_url: "[TTS requires provider configuration]",
-        voice_id: voiceId,
-        language: language,
-        duration: 0,
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        error: `Failed to synthesize speech: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-export function createTools(): Tool[] {
-  return [voiceTranscribeTool, voiceSpeakTool];
-}

package/packages/core/src/tools/web/api-request.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { apiRequestTool } from "./api-request.ts";
-
-describe("apiRequestTool", () => {
-  let originalFetch: typeof fetch;
-
-  beforeEach(() => {
-    originalFetch = globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  function mockFetch(response: Response) {
-    globalThis.fetch = Object.assign(async () => response, { preconnect: async () => undefined }) as typeof fetch;
-  }
-
-  function mockResponse(
-    body: BodyInit,
-    init: ResponseInit & { headers?: Record<string, string> } = {}
-  ): Response {
-    return new Response(body, {
-      status: init.status ?? 200,
-      statusText: init.statusText ?? "OK",
-      headers: init.headers ?? {},
-    });
-  }
-
-  it("executes a simple GET request", async () => {
-    let capturedUrl = "";
-    let capturedInit: RequestInit = {};
-    globalThis.fetch = Object.assign(async (url, init) => {
-      capturedUrl = url.toString();
-      capturedInit = init ?? {};
-      return mockResponse(JSON.stringify({ ok: true }), { headers: { "content-type": "application/json" } });
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    const result = await apiRequestTool.execute({ url: "https://api.example.com/data" });
-
-    expect(capturedUrl).toBe("https://api.example.com/data");
-    expect(capturedInit.method).toBe("GET");
-    expect(result).toMatchObject({
-      ok: true,
-      status: 200,
-      data: { ok: true },
-    });
-  });
-
-  it("sends POST with JSON body", async () => {
-    let capturedInit: RequestInit = {};
-    globalThis.fetch = Object.assign(async (_url, init) => {
-      capturedInit = init ?? {};
-      return mockResponse(JSON.stringify({ id: 1 }), { headers: { "content-type": "application/json" } });
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    const result = await apiRequestTool.execute({
-      url: "https://api.example.com/items",
-      method: "POST",
-      body: { name: "test" },
-    });
-
-    expect(capturedInit.method).toBe("POST");
-    expect(capturedInit.headers).toMatchObject({ "content-type": "application/json" });
-    expect(capturedInit.body).toBe(JSON.stringify({ name: "test" }));
-    expect(result).toMatchObject({ ok: true, data: { id: 1 } });
-  });
-
-  it("applies bearer auth", async () => {
-    let capturedInit: RequestInit = {};
-    globalThis.fetch = Object.assign(async (_url, init) => {
-      capturedInit = init ?? {};
-      return mockResponse("{}");
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    await apiRequestTool.execute({
-      url: "https://api.example.com/private",
-      auth: { type: "bearer", token: "secret-token" },
-    });
-
-    expect(new Headers(capturedInit.headers).get("Authorization")).toBe("Bearer secret-token");
-  });
-
-  it("applies basic auth", async () => {
-    let capturedInit: RequestInit = {};
-    globalThis.fetch = Object.assign(async (_url, init) => {
-      capturedInit = init ?? {};
-      return mockResponse("{}");
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    await apiRequestTool.execute({
-      url: "https://api.example.com/private",
-      auth: { type: "basic", username: "alice", password: "secret" },
-    });
-
-    expect(new Headers(capturedInit.headers).get("Authorization")).toBe(`Basic ${btoa("alice:secret")}`);
-  });
-
-  it("applies api_key in header", async () => {
-    let capturedInit: RequestInit = {};
-    globalThis.fetch = Object.assign(async (_url, init) => {
-      capturedInit = init ?? {};
-      return mockResponse("{}");
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    await apiRequestTool.execute({
-      url: "https://api.example.com/private",
-      auth: { type: "api_key", in: "header", name: "X-API-Key", value: "abc123" },
-    });
-
-    expect(new Headers(capturedInit.headers).get("X-API-Key")).toBe("abc123");
-  });
-
-  it("applies api_key in query", async () => {
-    let capturedUrl = "";
-    globalThis.fetch = Object.assign(async (url, _init) => {
-      capturedUrl = url.toString();
-      return mockResponse("{}");
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    await apiRequestTool.execute({
-      url: "https://api.example.com/private",
-      auth: { type: "api_key", in: "query", name: "api_key", value: "abc123" },
-    });
-
-    expect(capturedUrl).toBe("https://api.example.com/private?api_key=abc123");
-  });
-
-  it("returns error for non-ok HTTP response", async () => {
-    globalThis.fetch = Object.assign(async () => mockResponse("Not found", { status: 404, statusText: "Not Found" }), { preconnect: async () => undefined }) as typeof fetch;
-
-    const result = await apiRequestTool.execute({ url: "https://api.example.com/missing" });
-
-    expect(result).toMatchObject({
-      ok: false,
-      status: 404,
-      error: "HTTP 404: Not Found",
-    });
-  });
-
-  it("rejects non-http URLs", async () => {
-    const result = await apiRequestTool.execute({ url: "file:///etc/passwd" });
-
-    expect(result).toMatchObject({
-      ok: false,
-      error: "Invalid URL. Only http:// and https:// are allowed.",
-    });
-  });
-
-  it("respects timeout", async () => {
-    globalThis.fetch = Object.assign(async (_url, init) => {
-      expect(init?.signal).toBeDefined();
-      return mockResponse("{}");
-    }, { preconnect: async () => undefined }) as typeof fetch;
-
-    const result = await apiRequestTool.execute({ url: "https://api.example.com/data", timeoutMs: 5000 });
-    expect(result).toMatchObject({ ok: true });
-  });
-
-  it("returns text for non-json responses", async () => {
-    globalThis.fetch = Object.assign(async () => mockResponse("hello world", { headers: { "content-type": "text/plain" } }), { preconnect: async () => undefined }) as typeof fetch;
-
-    const result = await apiRequestTool.execute({ url: "https://api.example.com/text" });
-
-    expect(result).toMatchObject({
-      ok: true,
-      data: "hello world",
-    });
-  });
-});

package/packages/core/src/tools/web/api-request.ts

@@ -1,239 +0,0 @@
-/**
- * api_request - Make generic HTTP requests to connect REST APIs
- *
- * @category web
- * @seedId api_request
- * @spanish conectar api, peticion http, llamada api, rest api, endpoint
- */
-
-import type { Tool } from "../types.ts";
-import { logger } from "../../utils/logger.ts";
-
-const log = logger.child("api-request");
-
-const DEFAULT_TIMEOUT_MS = 30_000;
-const MAX_RESPONSE_CHARS = 100_000;
-
-export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-export type ResponseFormat = "auto" | "json" | "text" | "binary";
-
-export interface ApiAuthBearer {
-  type: "bearer";
-  token: string;
-}
-
-export interface ApiAuthBasic {
-  type: "basic";
-  username: string;
-  password: string;
-}
-
-export interface ApiAuthApiKey {
-  type: "api_key";
-  in: "header" | "query";
-  name: string;
-  value: string;
-}
-
-export type ApiAuth = ApiAuthBearer | ApiAuthBasic | ApiAuthApiKey;
-
-function applyAuth(
-  url: string,
-  init: RequestInit,
-  auth?: ApiAuth
-): { url: string; init: RequestInit } {
-  if (!auth) return { url, init };
-
-  const headers = new Headers(init.headers);
-
-  switch (auth.type) {
-    case "bearer":
-      headers.set("Authorization", `Bearer ${auth.token}`);
-      break;
-    case "basic": {
-      const credentials = btoa(`${auth.username}:${auth.password}`);
-      headers.set("Authorization", `Basic ${credentials}`);
-      break;
-    }
-    case "api_key":
-      if (auth.in === "query") {
-        const parsed = new URL(url);
-        parsed.searchParams.set(auth.name, auth.value);
-        url = parsed.toString();
-      } else {
-        headers.set(auth.name, auth.value);
-      }
-      break;
-  }
-
-  return { url, init: { ...init, headers } };
-}
-
-function isValidHttpUrl(url: string): boolean {
-  try {
-    const parsed = new URL(url);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-async function parseResponse(
-  response: Response,
-  format: ResponseFormat
-): Promise<{ data: unknown; contentType: string }> {
-  const contentType = response.headers.get("content-type") || "";
-
-  if (format === "json" || (format === "auto" && contentType.includes("application/json"))) {
-    const json = await response.json();
-    return { data: json, contentType };
-  }
-
-  if (format === "text" || (format === "auto" && contentType.includes("text/"))) {
-    const text = await response.text();
-    return { data: text.slice(0, MAX_RESPONSE_CHARS), contentType };
-  }
-
-  if (format === "binary") {
-    const arrayBuffer = await response.arrayBuffer();
-    const base64 = Buffer.from(arrayBuffer).toString("base64");
-    return { data: base64, contentType };
-  }
-
-  // Fallback: try text, then JSON
-  const text = await response.text();
-  if (text.trim().startsWith("{") || text.trim().startsWith("[")) {
-    try {
-      return { data: JSON.parse(text), contentType };
-    } catch {
-      /* fallthrough */
-    }
-  }
-  return { data: text.slice(0, MAX_RESPONSE_CHARS), contentType };
-}
-
-export const apiRequestTool: Tool = {
-  name: "api_request",
-  description:
-    "Connect to REST APIs: make HTTP requests with methods, headers, body and authentication. Spanish: conectar api, peticion http, llamada api, rest api, endpoint, bearer, api key",
-  parameters: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description: "The API endpoint URL (http:// or https://)",
-      },
-      method: {
-        type: "string",
-        enum: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-        description: "HTTP method (default: GET)",
-      },
-      headers: {
-        type: "object",
-        additionalProperties: { type: "string" },
-        description: "Optional HTTP headers as key-value pairs",
-      },
-      body: {
-        type: "string",
-        description: "Request body. Objects should be passed as JSON strings; strings are sent as-is",
-      },
-      auth: {
-        type: "object",
-        description: "Optional authentication configuration",
-        properties: {
-          type: {
-            type: "string",
-            enum: ["bearer", "basic", "api_key"],
-          },
-          token: { type: "string" },
-          username: { type: "string" },
-          password: { type: "string" },
-          in: { type: "string", enum: ["header", "query"] },
-          name: { type: "string" },
-          value: { type: "string" },
-        },
-        required: ["type"],
-      },
-      timeoutMs: {
-        type: "number",
-        description: "Request timeout in milliseconds (default: 30000)",
-      },
-      responseFormat: {
-        type: "string",
-        enum: ["auto", "json", "text", "binary"],
-        description: "How to parse the response (default: auto)",
-      },
-    },
-    required: ["url"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const url = params.url as string;
-    const method = (params.method as HttpMethod) ?? "GET";
-    const headers = (params.headers as Record<string, string>) ?? {};
-    const bodyParam = params.body;
-    const auth = params.auth as ApiAuth | undefined;
-    const timeoutMs = (params.timeoutMs as number) ?? DEFAULT_TIMEOUT_MS;
-    const responseFormat = (params.responseFormat as ResponseFormat) ?? "auto";
-
-    if (!isValidHttpUrl(url)) {
-      return { ok: false, error: "Invalid URL. Only http:// and https:// are allowed." };
-    }
-
-    log.info(`API request: ${method} ${url}`);
-
-    let body: BodyInit | undefined;
-    const finalHeaders: Record<string, string> = { ...headers };
-
-    if (bodyParam !== undefined) {
-      if (typeof bodyParam === "string") {
-        body = bodyParam;
-      } else {
-        body = JSON.stringify(bodyParam);
-        if (!finalHeaders["content-type"] && !finalHeaders["Content-Type"]) {
-          finalHeaders["content-type"] = "application/json";
-        }
-      }
-    }
-
-    let init: RequestInit = {
-      method,
-      headers: finalHeaders,
-      body,
-      signal: AbortSignal.timeout(timeoutMs),
-    };
-
-    const final = applyAuth(url, init, auth);
-
-    try {
-      const response = await fetch(final.url, final.init);
-      const { data, contentType } = await parseResponse(response, responseFormat);
-
-      const responseHeaders: Record<string, string> = {};
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-      });
-
-      const result = {
-        ok: response.ok,
-        status: response.status,
-        statusText: response.statusText,
-        url: final.url,
-        contentType,
-        headers: responseHeaders,
-        data,
-      };
-
-      if (!response.ok) {
-        log.warn(`API request returned ${response.status} for ${final.url}`);
-        return { ok: false, error: `HTTP ${response.status}: ${response.statusText}`, ...result };
-      }
-
-      log.info(`API request successful: ${response.status} ${final.url}`);
-      return result;
-    } catch (error) {
-      const message = (error as Error).message;
-      log.error(`API request failed: ${message}`);
-      return { ok: false, error: `API request failed: ${message}` };
-    }
-  },
-};