@johpaz/hive-sdk 0.0.17 → 0.1.3

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

@@ -2,20 +2,33 @@
  * Meeting Tools - 4 tools para transcripción de reuniones
  *
  * @category meeting
- *
- * - meeting_start       — Inicia una sesión de transcripción
- * - meeting_add_segment — Transcribe un chunk de audio y lo agrega a la sesión
- * - meeting_stop        — Detiene la sesión de transcripción
- * - meeting_report      — Obtiene el transcript completo para que el agente genere el reporte
  */
 
 import type { Tool } from "../types.ts";
-import { getDb } from "../../storage/SQLiteStorage.ts";
+import { getHiveDB } from "../../storage/HiveDBStorage.ts";
 import { voiceService, type AudioInput } from "../../voice/index.ts";
 import { logger } from "../../utils/logger.ts";
 
 const log = logger.child("meeting");
 
+interface MeetingSession {
+  id: string;
+  title: string;
+  status: string;
+  sttModel: string;
+  startedAt: number;
+  stoppedAt?: number;
+}
+
+interface MeetingSegment {
+  sessionId: string;
+  seq: number;
+  speaker?: string;
+  text: string;
+  durationMs?: number;
+  createdAt: number;
+}
+
 // ─── meeting_start ───────────────────────────────────────────────────────────
 
 export const meetingStartTool: Tool = {
@@ -43,30 +56,27 @@ export const meetingStartTool: Tool = {
       (params.stt_model as string) || "whisper-large-v3-turbo";
 
     try {
-      const db = getDb();
-      const result = db
-        .query(
-          `INSERT INTO meeting_sessions (title, stt_model)
-           VALUES (?, ?)
-           RETURNING id, title, status, stt_model, started_at`
-        )
-        .get(title, sttModel) as {
-        id: string;
-        title: string;
-        status: string;
-        stt_model: string;
-        started_at: number;
+      const db = await getHiveDB();
+      const sessionsCol = db.collection<MeetingSession>("meeting_sessions");
+      const id = crypto.randomUUID();
+      const session: MeetingSession = {
+        id,
+        title,
+        status: "active",
+        sttModel,
+        startedAt: Math.floor(Date.now() / 1000),
       };
+      await sessionsCol.put(id, session);
 
-      log.info(`Meeting session started: ${result.id} — "${title}"`);
+      log.info(`Meeting session started: ${id} — "${title}"`);
 
       return {
         ok: true,
-        session_id: result.id,
-        title: result.title,
-        status: result.status,
-        stt_model: result.stt_model,
-        message: `✅ Sesión de reunión iniciada. ID: ${result.id}\nTítulo: "${title}"\nModelo STT: ${sttModel}`,
+        session_id: id,
+        title,
+        status: session.status,
+        stt_model: sttModel,
+        message: `✅ Sesión de reunión iniciada. ID: ${id}\nTítulo: "${title}"\nModelo STT: ${sttModel}`,
       };
     } catch (error) {
       log.error(`meeting_start error: ${(error as Error).message}`);
@@ -106,21 +116,19 @@ export const meetingAddSegmentTool: Tool = {
   execute: async (params) => {
     const sessionId = params.session_id as string;
     const audioBase64 = params.audio_base64 as string;
-    const speaker = (params.speaker as string) || null;
+    const speaker = (params.speaker as string) || undefined;
     const mimeType = (params.mime_type as string) || "audio/webm";
 
     try {
-      const db = getDb();
+      const db = await getHiveDB();
+      const sessionsCol = db.collection<MeetingSession>("meeting_sessions");
+      const segmentsCol = db.collection<MeetingSegment>("meeting_segments");
 
-      const session = db
-        .query(
-          `SELECT id, stt_model, status FROM meeting_sessions WHERE id = ?`
-        )
-        .get(sessionId) as { id: string; stt_model: string; status: string } | undefined;
-
-      if (!session) {
+      const sessionEntry = await sessionsCol.get(sessionId);
+      if (!sessionEntry) {
         return { ok: false, error: `Sesión ${sessionId} no encontrada.` };
       }
+      const session = sessionEntry.doc;
       if (session.status !== "active") {
         return {
           ok: false,
@@ -136,7 +144,7 @@ export const meetingAddSegmentTool: Tool = {
 
       let transcription: string;
       try {
-        transcription = await voiceService.transcribe(audioInput, session.stt_model);
+        transcription = await voiceService.transcribe(audioInput, session.sttModel);
       } catch (transcribeError) {
         return {
           ok: false,
@@ -144,18 +152,19 @@ export const meetingAddSegmentTool: Tool = {
         };
       }
 
-      const seqResult = db
-        .query(
-          `SELECT COALESCE(MAX(seq) + 1, 0) as next_seq FROM meeting_segments WHERE session_id = ?`
-        )
-        .get(sessionId) as { next_seq: number };
-
-      const seq = seqResult.next_seq;
+      const entries = await segmentsCol.scan();
+      const seq = entries
+        .filter(e => e.doc.sessionId === sessionId)
+        .reduce((max, e) => Math.max(max, e.doc.seq), -1) + 1;
 
-      db.query(
-        `INSERT INTO meeting_segments (session_id, seq, speaker, text, duration_ms)
-         VALUES (?, ?, ?, ?, NULL)`
-      ).run(sessionId, seq, speaker, transcription);
+      const segmentId = `${sessionId}:${seq}`;
+      await segmentsCol.put(segmentId, {
+        sessionId,
+        seq,
+        speaker,
+        text: transcription,
+        createdAt: Math.floor(Date.now() / 1000),
+      });
 
       log.info(`Segment ${seq} added to session ${sessionId}: "${transcription.substring(0, 60)}..."`);
 
@@ -196,15 +205,15 @@ export const meetingStopTool: Tool = {
     const sessionId = params.session_id as string;
 
     try {
-      const db = getDb();
-
-      const session = db
-        .query(`SELECT id, title, status FROM meeting_sessions WHERE id = ?`)
-        .get(sessionId) as { id: string; title: string; status: string } | undefined;
+      const db = await getHiveDB();
+      const sessionsCol = db.collection<MeetingSession>("meeting_sessions");
+      const segmentsCol = db.collection<MeetingSegment>("meeting_segments");
 
-      if (!session) {
+      const sessionEntry = await sessionsCol.get(sessionId);
+      if (!sessionEntry) {
         return { ok: false, error: `Sesión ${sessionId} no encontrada.` };
       }
+      const session = sessionEntry.doc;
       if (session.status === "stopped" || session.status === "report_ready") {
         return {
           ok: true,
@@ -213,22 +222,20 @@ export const meetingStopTool: Tool = {
         };
       }
 
-      db.query(
-        `UPDATE meeting_sessions SET status = 'stopped', stopped_at = unixepoch() WHERE id = ?`
-      ).run(sessionId);
+      const stoppedAt = Math.floor(Date.now() / 1000);
+      await sessionsCol.put(sessionId, { ...session, status: "stopped", stoppedAt });
 
-      const countResult = db
-        .query(`SELECT COUNT(*) as count FROM meeting_segments WHERE session_id = ?`)
-        .get(sessionId) as { count: number };
+      const entries = await segmentsCol.scan();
+      const count = entries.filter(e => e.doc.sessionId === sessionId).length;
 
-      log.info(`Meeting session stopped: ${sessionId} — ${countResult.count} segments`);
+      log.info(`Meeting session stopped: ${sessionId} — ${count} segments`);
 
       return {
         ok: true,
         session_id: sessionId,
         title: session.title,
-        segment_count: countResult.count,
-        message: `⏹️ Sesión "${session.title}" detenida.\n${countResult.count} segmentos transcritos.\n\nPuedes pedir el reporte con: "Genera el reporte de la reunión ${sessionId}"`,
+        segment_count: count,
+        message: `⏹️ Sesión "${session.title}" detenida.\n${count} segmentos transcritos.\n\nPuedes pedir el reporte con: "Genera el reporte de la reunión ${sessionId}"`,
       };
     } catch (error) {
       log.error(`meeting_stop error: ${(error as Error).message}`);
@@ -257,38 +264,21 @@ export const meetingReportTool: Tool = {
     const sessionId = params.session_id as string;
 
     try {
-      const db = getDb();
-
-      const session = db
-        .query(
-          `SELECT id, title, status, stt_model, started_at, stopped_at
-           FROM meeting_sessions WHERE id = ?`
-        )
-        .get(sessionId) as {
-        id: string;
-        title: string;
-        status: string;
-        stt_model: string;
-        started_at: number;
-        stopped_at: number | null;
-      } | undefined;
-
-      if (!session) {
+      const db = await getHiveDB();
+      const sessionsCol = db.collection<MeetingSession>("meeting_sessions");
+      const segmentsCol = db.collection<MeetingSegment>("meeting_segments");
+
+      const sessionEntry = await sessionsCol.get(sessionId);
+      if (!sessionEntry) {
         return { ok: false, error: `Sesión ${sessionId} no encontrada.` };
       }
+      const session = sessionEntry.doc;
 
-      const segments = db
-        .query(
-          `SELECT seq, speaker, text, created_at
-           FROM meeting_segments WHERE session_id = ?
-           ORDER BY seq ASC`
-        )
-        .all(sessionId) as {
-        seq: number;
-        speaker: string | null;
-        text: string;
-        created_at: number;
-      }[];
+      const entries = await segmentsCol.scan();
+      const segments = entries
+        .filter(e => e.doc.sessionId === sessionId)
+        .map(e => e.doc)
+        .sort((a, b) => a.seq - b.seq);
 
       if (segments.length === 0) {
         return {
@@ -301,9 +291,9 @@ export const meetingReportTool: Tool = {
         .map((s) => (s.speaker ? `[${s.speaker}]: ${s.text}` : s.text))
         .join("\n");
 
-      const durationSec = session.stopped_at
-        ? session.stopped_at - session.started_at
-        : Math.floor(Date.now() / 1000) - session.started_at;
+      const durationSec = session.stoppedAt
+        ? session.stoppedAt - session.startedAt
+        : Math.floor(Date.now() / 1000) - session.startedAt;
       const durationMin = Math.floor(durationSec / 60);
       const durationSecRem = durationSec % 60;
 

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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,239 @@
+/**
+ * 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}` };
+    }
+  },
+};