@johpaz/hive-agents 0.0.35 → 0.0.37

package/packages/core/src/gateway/routes/meeting.ts

@@ -0,0 +1,232 @@
+import { getDb } from "../../storage/sqlite";
+import { voiceService, type AudioInput } from "../../voice/index";
+import { logger } from "../../utils/logger";
+
+const log = logger.child("meeting-routes");
+
+type CorsHelper = (r: Response, req: Request) => Response;
+
+// POST /api/meetings — Crear sesión
+export async function handleCreateMeeting(
+  req: Request,
+  addCorsHeaders: CorsHelper
+): Promise<Response> {
+  try {
+    const body = await req.json().catch(() => ({})) as Record<string, unknown>;
+    const title = (body.title as string) || "Reunión sin título";
+    const sttModel = (body.stt_model as string) || "whisper-large-v3-turbo";
+
+    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;
+    };
+
+    log.info(`Meeting session created: ${result.id}`);
+    return addCorsHeaders(Response.json({ ok: true, session: result }), req);
+  } catch (error) {
+    log.error(`handleCreateMeeting: ${(error as Error).message}`);
+    return addCorsHeaders(
+      Response.json({ ok: false, error: (error as Error).message }, { status: 500 }),
+      req
+    );
+  }
+}
+
+// GET /api/meetings — Listar sesiones
+export async function handleListMeetings(
+  req: Request,
+  addCorsHeaders: CorsHelper
+): Promise<Response> {
+  try {
+    const db = getDb();
+    const sessions = db
+      .query(
+        `SELECT ms.*, COUNT(seg.id) as segment_count
+         FROM meeting_sessions ms
+         LEFT JOIN meeting_segments seg ON seg.session_id = ms.id
+         GROUP BY ms.id
+         ORDER BY ms.started_at DESC
+         LIMIT 50`
+      )
+      .all() as Record<string, unknown>[];
+
+    return addCorsHeaders(Response.json({ ok: true, sessions }), req);
+  } catch (error) {
+    log.error(`handleListMeetings: ${(error as Error).message}`);
+    return addCorsHeaders(
+      Response.json({ ok: false, error: (error as Error).message }, { status: 500 }),
+      req
+    );
+  }
+}
+
+// GET /api/meetings/:id — Detalle + segmentos
+export async function handleGetMeeting(
+  req: Request,
+  addCorsHeaders: CorsHelper,
+  sessionId: string
+): Promise<Response> {
+  try {
+    const db = getDb();
+    const session = db
+      .query(`SELECT * FROM meeting_sessions WHERE id = ?`)
+      .get(sessionId) as Record<string, unknown> | undefined;
+
+    if (!session) {
+      return addCorsHeaders(
+        Response.json({ ok: false, error: "Sesión no encontrada" }, { status: 404 }),
+        req
+      );
+    }
+
+    const segments = db
+      .query(
+        `SELECT seq, speaker, text, created_at FROM meeting_segments
+         WHERE session_id = ? ORDER BY seq ASC`
+      )
+      .all(sessionId) as Record<string, unknown>[];
+
+    return addCorsHeaders(Response.json({ ok: true, session, segments }), req);
+  } catch (error) {
+    log.error(`handleGetMeeting: ${(error as Error).message}`);
+    return addCorsHeaders(
+      Response.json({ ok: false, error: (error as Error).message }, { status: 500 }),
+      req
+    );
+  }
+}
+
+// POST /api/meetings/:id/segments — Agregar segmento con audio base64
+export async function handleAddMeetingSegment(
+  req: Request,
+  addCorsHeaders: CorsHelper,
+  sessionId: string
+): Promise<Response> {
+  try {
+    const body = await req.json().catch(() => ({})) as Record<string, unknown>;
+    const audioBase64 = body.audio_base64 as string;
+    const speaker = (body.speaker as string) || null;
+    const mimeType = (body.mime_type as string) || "audio/webm";
+
+    if (!audioBase64) {
+      return addCorsHeaders(
+        Response.json({ ok: false, error: "audio_base64 es requerido" }, { status: 400 }),
+        req
+      );
+    }
+
+    const db = getDb();
+    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) {
+      return addCorsHeaders(
+        Response.json({ ok: false, error: "Sesión no encontrada" }, { status: 404 }),
+        req
+      );
+    }
+    if (session.status !== "active") {
+      return addCorsHeaders(
+        Response.json(
+          { ok: false, error: `La sesión está ${session.status}` },
+          { status: 409 }
+        ),
+        req
+      );
+    }
+
+    const audioInput: AudioInput = { type: "base64", data: audioBase64, mimeType };
+    const transcription = await voiceService.transcribe(audioInput, session.stt_model);
+
+    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;
+    db.query(
+      `INSERT INTO meeting_segments (session_id, seq, speaker, text) VALUES (?, ?, ?, ?)`
+    ).run(sessionId, seq, speaker, transcription);
+
+    return addCorsHeaders(
+      Response.json({ ok: true, seq, speaker, text: transcription }),
+      req
+    );
+  } catch (error) {
+    log.error(`handleAddMeetingSegment: ${(error as Error).message}`);
+    return addCorsHeaders(
+      Response.json({ ok: false, error: (error as Error).message }, { status: 500 }),
+      req
+    );
+  }
+}
+
+// POST /api/meetings/:id/stop — Detener sesión
+export async function handleStopMeeting(
+  req: Request,
+  addCorsHeaders: CorsHelper,
+  sessionId: string
+): Promise<Response> {
+  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;
+
+    if (!session) {
+      return addCorsHeaders(
+        Response.json({ ok: false, error: "Sesión no encontrada" }, { status: 404 }),
+        req
+      );
+    }
+
+    if (session.status !== "active") {
+      const count = (
+        db
+          .query(`SELECT COUNT(*) as c FROM meeting_segments WHERE session_id = ?`)
+          .get(sessionId) as { c: number }
+      ).c;
+      return addCorsHeaders(
+        Response.json({ ok: true, session_id: sessionId, segment_count: count }),
+        req
+      );
+    }
+
+    db.query(
+      `UPDATE meeting_sessions SET status = 'stopped', stopped_at = unixepoch() WHERE id = ?`
+    ).run(sessionId);
+
+    const countResult = db
+      .query(`SELECT COUNT(*) as count FROM meeting_segments WHERE session_id = ?`)
+      .get(sessionId) as { count: number };
+
+    log.info(`Meeting stopped: ${sessionId} — ${countResult.count} segments`);
+    return addCorsHeaders(
+      Response.json({
+        ok: true,
+        session_id: sessionId,
+        title: session.title,
+        segment_count: countResult.count,
+      }),
+      req
+    );
+  } catch (error) {
+    log.error(`handleStopMeeting: ${(error as Error).message}`);
+    return addCorsHeaders(
+      Response.json({ ok: false, error: (error as Error).message }, { status: 500 }),
+      req
+    );
+  }
+}

package/packages/core/src/gateway/routes/models.ts

@@ -0,0 +1,163 @@
+import { getDb } from "../../storage/sqlite.ts"
+import type { Config } from "../../config/loader.ts"
+
+export async function handleGetModels(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  const providerId = url.searchParams.get("provider_id")
+
+  let models
+  if (providerId) {
+    models = getDb().query("SELECT * FROM models WHERE provider_id = ? ORDER BY name").all(providerId)
+  } else {
+    models = getDb().query("SELECT * FROM models ORDER BY name").all()
+  }
+
+  return addCorsHeaders(Response.json({ models }), req)
+}
+
+export async function handleCreateModel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const body = await req.json().catch(() => ({}))
+
+  const providerId = body.provider_id || body.providerId
+  const name = body.name
+  const modelType = body.model_type || body.modelType || "llm"
+  const contextWindow = body.context_window || body.contextWindow || 50000
+
+  if (!name || !providerId) {
+    return addCorsHeaders(Response.json({ ok: false, error: "name and provider_id are required" }, { status: 400 }), req)
+  }
+
+  const id = body.id || name
+
+  const existing = getDb().query("SELECT * FROM models WHERE id = ?").get(id) as any
+  if (existing) {
+    return addCorsHeaders(Response.json({ ok: false, error: "Model already exists", id, model: existing }, { status: 409 }), req)
+  }
+
+  getDb().query(`
+    INSERT INTO models(id, name, provider_id, model_type, context_window, enabled, active)
+    VALUES(?, ?, ?, ?, ?, 1, 1)
+  `).run(id, name, providerId, modelType, contextWindow)
+
+  const model = getDb().query("SELECT * FROM models WHERE id = ?").get(id)
+  return addCorsHeaders(Response.json({ ok: true, id, model }, { status: 201 }), req)
+}
+
+export async function handleToggleModel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  // URL pattern: /api/models/:id/toggle — extract model id from path
+  const pathMatch = url.pathname.match(/^\/api\/models\/([^/]+)\/toggle$/)
+  const modelId = pathMatch ? decodeURIComponent(pathMatch[1]) : null
+  const body = await req.json().catch(() => ({}))
+  const { active } = body
+
+  if (!modelId || active === undefined) {
+    return addCorsHeaders(Response.json({ success: false, error: "model id and active required" }), req)
+  }
+
+  getDb().query(`UPDATE models SET active = ?, enabled = ? WHERE id = ?`).run(active ? 1 : 0, active ? 1 : 0, modelId)
+
+  return addCorsHeaders(Response.json({ success: true, active }), req)
+}
+
+export async function handleGetModelsConfig(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  config: Config
+): Promise<Response> {
+  return addCorsHeaders(Response.json({
+    config: config.models || {},
+    availableProviders: ["openai", "anthropic", "gemini", "kimi", "ollama", "openrouter", "deepseek"],
+  }), req);
+}
+
+export async function handleDeleteModel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  const pathMatch = url.pathname.match(/^\/api\/models\/([^/]+)$/)
+  const modelId = pathMatch ? decodeURIComponent(pathMatch[1]) : null
+
+  if (!modelId) {
+    return addCorsHeaders(Response.json({ ok: false, error: "model id required" }, { status: 400 }), req)
+  }
+
+  const existing = getDb().query("SELECT * FROM models WHERE id = ?").get(modelId) as any
+  if (!existing) {
+    return addCorsHeaders(Response.json({ ok: false, error: "Model not found" }, { status: 404 }), req)
+  }
+
+  const agents = getDb().query("SELECT id, name FROM agents WHERE model_id = ?").all(modelId) as any[]
+  if (agents.length > 0) {
+    const names = agents.map(a => a.name).join(", ")
+    return addCorsHeaders(Response.json({ ok: false, error: `En uso por agentes: ${names}` }, { status: 409 }), req)
+  }
+
+  getDb().query("DELETE FROM models WHERE id = ?").run(modelId)
+  return addCorsHeaders(Response.json({ ok: true }), req)
+}
+
+export async function handleUpdateModel(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const url = new URL(req.url)
+  const pathMatch = url.pathname.match(/^\/api\/models\/([^/]+)$/)
+  const oldId = pathMatch ? decodeURIComponent(pathMatch[1]) : null
+
+  if (!oldId) {
+    return addCorsHeaders(Response.json({ ok: false, error: "model id required" }, { status: 400 }), req)
+  }
+
+  const existing = getDb().query("SELECT * FROM models WHERE id = ?").get(oldId) as any
+  if (!existing) {
+    return addCorsHeaders(Response.json({ ok: false, error: "Model not found" }, { status: 404 }), req)
+  }
+
+  const body = await req.json().catch(() => ({}))
+  const newId: string | undefined = body.id
+  const newName: string | undefined = body.name
+
+  if (!newId || newId === oldId) {
+    // Only name change
+    const name = newName || existing.name
+    getDb().query("UPDATE models SET name = ? WHERE id = ?").run(name, oldId)
+    const model = getDb().query("SELECT * FROM models WHERE id = ?").get(oldId)
+    return addCorsHeaders(Response.json({ ok: true, model }), req)
+  }
+
+  // ID is changing — use a transaction to migrate agents references
+  const checkConflict = getDb().query("SELECT id FROM models WHERE id = ?").get(newId) as any
+  if (checkConflict) {
+    return addCorsHeaders(Response.json({ ok: false, error: "Ya existe un modelo con ese ID" }, { status: 409 }), req)
+  }
+
+  const name = newName || existing.name
+  getDb().transaction(() => {
+    getDb().query(`
+      INSERT INTO models(id, name, provider_id, model_type, context_window, capabilities, enabled, active)
+      SELECT ?, ?, provider_id, model_type, context_window, capabilities, enabled, active FROM models WHERE id = ?
+    `).run(newId, name, oldId)
+    getDb().query("UPDATE agents SET model_id = ? WHERE model_id = ?").run(newId, oldId)
+    getDb().query("DELETE FROM models WHERE id = ?").run(oldId)
+  })()
+
+  const model = getDb().query("SELECT * FROM models WHERE id = ?").get(newId)
+  return addCorsHeaders(Response.json({ ok: true, model }), req)
+}
+
+export async function handleUpdateModelsConfig(
+  req: Request,
+  addCorsHeaders: (r: Response, req: Request) => Response,
+  config: Config,
+  agent?: any
+): Promise<Response> {
+  const body = await req.json().catch(() => ({}));
+  const { defaultProvider, defaults, providers } = body;
+
+  config.models = config.models || {};
+  if (defaultProvider) config.models.defaultProvider = defaultProvider;
+  if (defaults) config.models.defaults = { ...(config.models.defaults || {}), ...defaults };
+  if (providers) config.models.providers = { ...(config.models.providers || {}), ...providers };
+
+  if (agent) {
+    await agent.updateConfig(config);
+  }
+
+  return addCorsHeaders(Response.json({ success: true }), req);
+}

package/packages/core/src/gateway/routes/multimodal.ts

@@ -0,0 +1,93 @@
+import { multimodalService } from "../../multimodal/index"
+import { getDb } from "../../storage/sqlite"
+
+export async function handleGetVisionProviders(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const configured = multimodalService.getConfiguredVisionProviders()
+  const db = getDb()
+  const visionModels = db.query(`
+    SELECT m.id, m.name, m.provider_id, m.capabilities
+    FROM models m
+    JOIN providers p ON m.provider_id = p.id
+    WHERE m.enabled = 1 AND p.enabled = 1 AND p.api_key_encrypted IS NOT NULL AND p.api_key_encrypted != ''
+  `).all() as Array<{ id: string; name: string; provider_id: string; capabilities: string }>
+
+  const modelsWithVision = visionModels.filter(m => {
+    try {
+      const caps = JSON.parse(m.capabilities || "[]") as string[]
+      return caps.includes("vision")
+    } catch { return false }
+  })
+
+  return addCorsHeaders(Response.json({
+    configuredProviders: configured,
+    visionModels: modelsWithVision.map(m => ({
+      id: m.id,
+      name: m.name,
+      providerId: m.provider_id,
+    })),
+  }), req)
+}
+
+export async function handleGetChannelVision(req: Request, addCorsHeaders: (r: Response, req: Request) => Response, channelId: string): Promise<Response> {
+  const config = multimodalService.getChannelVisionConfig(channelId)
+  return addCorsHeaders(Response.json(config), req)
+}
+
+export async function handleUpdateChannelVision(req: Request, addCorsHeaders: (r: Response, req: Request) => Response, channelId: string): Promise<Response> {
+  const body = await req.json().catch(() => ({})) as {
+    visionEnabled?: boolean
+    ocrProvider?: string
+    visionProvider?: string
+    visionModelId?: string
+  }
+
+  const db = getDb()
+  const updates: string[] = []
+  const values: any[] = []
+
+  if (body.visionEnabled !== undefined) {
+    updates.push("vision_enabled = ?")
+    values.push(body.visionEnabled ? 1 : 0)
+  }
+  if (body.ocrProvider !== undefined) {
+    updates.push("ocr_provider = ?")
+    values.push(body.ocrProvider)
+  }
+  if (body.visionProvider !== undefined) {
+    updates.push("vision_provider = ?")
+    values.push(body.visionProvider)
+  }
+  if (body.visionModelId !== undefined) {
+    updates.push("vision_model_id = ?")
+    values.push(body.visionModelId)
+  }
+
+  if (updates.length === 0) {
+    return addCorsHeaders(Response.json({ success: false, error: "No fields to update" }, { status: 400 }), req)
+  }
+
+  values.push(channelId)
+  db.query(`UPDATE channels SET ${updates.join(", ")} WHERE id = ?`).run(...values)
+
+  const updated = multimodalService.getChannelVisionConfig(channelId)
+  return addCorsHeaders(Response.json({ success: true, config: updated }), req)
+}
+
+export async function handleOcrImage(req: Request, addCorsHeaders: (r: Response, req: Request) => Response): Promise<Response> {
+  const body = await req.json().catch(() => ({})) as {
+    image?: { url?: string; base64?: string; buffer?: string; mimeType?: string; caption?: string }
+    provider?: string
+  }
+
+  if (!body.image) {
+    return addCorsHeaders(Response.json({ success: false, error: "image required" }, { status: 400 }), req)
+  }
+
+  try {
+    const imageInput = multimodalService.normalizeImageFromChannel("api", body.image)
+    const text = await multimodalService.ocrImage(imageInput, body.provider)
+    return addCorsHeaders(Response.json({ success: true, text }), req)
+  } catch (error) {
+    return addCorsHeaders(Response.json({ success: false, error: (error as Error).message }, { status: 500 }), req)
+  }
+}