@johpaz/hive-agents 0.0.34 → 0.0.36

package/packages/mcp/src/transports/sse.ts

@@ -0,0 +1,238 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { logger } from "../logger";
+
+export interface SSETransportConfig {
+  url: string;                        // URL base
+  headers?: Record<string, string>;
+}
+
+export class SSETransport implements Transport {
+  private baseUrl: string;
+  private messagesUrl: string | null = null; // Endpoint recibido del servidor
+
+  private headers: Record<string, string>;
+  private abortController: AbortController | null = null;
+  private cookies: string[] = [];
+  private startResolve: (() => void) | null = null;
+  private startReject: ((err: Error) => void) | null = null;
+  sessionId?: string;
+
+  onmessage: ((message: unknown) => void) | undefined;
+  onerror: ((error: Error) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  constructor(config: SSETransportConfig) {
+    this.baseUrl = config.url;
+    this.headers = config.headers ?? {};
+  }
+
+  async start(): Promise<void> {
+    this.abortController = new AbortController();
+
+    return new Promise(async (resolve, reject) => {
+      // Timeout fallback: if no endpoint received in 5s, continue anyway
+      const timeout = setTimeout(() => {
+        this.startResolve = null;
+        this.startReject = null;
+        resolve();
+      }, 5000);
+
+      this.startResolve = () => {
+        clearTimeout(timeout);
+        this.startResolve = null;
+        this.startReject = null;
+        resolve();
+      };
+
+      this.startReject = (err) => {
+        clearTimeout(timeout);
+        this.startResolve = null;
+        this.startReject = null;
+        reject(err);
+      };
+
+      try {
+        logger.debug(`[SSE] Connecting to: ${this.baseUrl}`);
+        const response = await fetch(this.baseUrl, {
+          method: "GET",
+          headers: {
+            "Accept": "application/json, text/event-stream",
+            "Cache-Control": "no-cache",
+            ...this.headers,
+          },
+          signal: this.abortController!.signal,
+        });
+
+        if (response.status === 405 || response.status === 400) {
+          logger.debug(`[SSE] GET not allowed (${response.status}), falling back to Streamable HTTP pattern for ${this.baseUrl}`);
+          this.startResolve();
+          return;
+        }
+
+        if (!response.ok) {
+          this.startReject(new Error(`MCP SSE connection failed: ${response.status} ${response.statusText}`));
+          return;
+        }
+
+        this.readSessionId(response);
+
+        if (response.body) {
+          this.startReading(response.body);
+        } else {
+          this.startResolve();
+        }
+      } catch (error: any) {
+        if (error.name !== "AbortError") {
+          this.startReject(error);
+        }
+      }
+    });
+  }
+
+  private readSessionId(response: Response) {
+    const sessionId = response.headers.get("x-session-id") ??
+      response.headers.get("mcp-session-id");
+    if (sessionId) {
+      this.sessionId = sessionId;
+    }
+
+    // Track cookies for session affinity (important for n8n/proxies)
+    const setCookie = response.headers.get("set-cookie");
+    if (setCookie) {
+      // Simple cookie extraction: just keep the keys and values
+      const newCookies = setCookie.split(',').map(c => c.split(';')[0].trim());
+      this.cookies = [...new Set([...this.cookies, ...newCookies])];
+    }
+  }
+
+  private startReading(stream: ReadableStream<Uint8Array>) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    this.processStream(reader, decoder, buffer).catch((error) => {
+      if (this.onerror && error.name !== "AbortError") {
+        this.onerror(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+
+  private async processStream(
+    reader: ReadableStreamDefaultReader<Uint8Array>,
+    decoder: TextDecoder,
+    buffer: string
+  ): Promise<void> {
+    try {
+      let eventType = "message";
+      let eventData = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          return;
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            eventType = line.slice(7).trim();
+          } else if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data.trim() === "[DONE]") {
+              this.onclose?.();
+              return;
+            }
+            eventData += data + "\n";
+          } else if (line === "") {
+            if (eventData) {
+              eventData = eventData.trim();
+              if (eventType === "endpoint") {
+                try {
+                  this.messagesUrl = new URL(eventData, this.baseUrl).href;
+                  logger.debug(`[SSE] Messages endpoint received: ${this.messagesUrl}`);
+                  this.startResolve?.();
+                } catch (e) {
+                  logger.warn(`[SSE] Failed to parse endpoint: ${eventData}`);
+                }
+              } else if (eventType === "message" || eventType === "") {
+                try {
+                  const parsed = JSON.parse(eventData);
+                  this.onmessage?.(parsed);
+                } catch {
+                  // Ignorar heartbeats o no-JSON
+                }
+              }
+              eventData = "";
+            }
+            eventType = "message";
+          }
+        }
+      }
+    } catch (error: any) {
+      if (error.name !== "AbortError") {
+        this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.sessionId = undefined;
+    this.onclose?.();
+  }
+
+  async send(message: unknown): Promise<void> {
+    if (!this.abortController) {
+      throw new Error("SSE transport not started — llama start() primero");
+    }
+
+    const targetUrl = this.messagesUrl || this.baseUrl;
+
+    const response = await fetch(targetUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        ...this.headers,
+        // Streamable HTTP spec requires session ID as header, not query param
+        ...(this.sessionId ? { "mcp-session-id": this.sessionId } : {}),
+        ...(this.cookies.length > 0 ? { "Cookie": this.cookies.join('; ') } : {}),
+      },
+      body: JSON.stringify(message),
+      signal: this.abortController.signal,
+    });
+
+    this.readSessionId(response);
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`MCP message failed (${response.status}): ${body || response.statusText}`);
+    }
+
+    const contentType = response.headers.get("content-type") ?? "";
+
+    if (contentType.includes("text/event-stream") && response.body) {
+      this.startReading(response.body);
+    }
+    else if (contentType.includes("application/json")) {
+      const text = await response.text();
+      if (text.trim()) {
+        try {
+          this.onmessage?.(JSON.parse(text));
+        } catch {
+          // ignored
+        }
+      }
+    }
+  }
+}
+
+export function createSSETransport(config: SSETransportConfig): Transport {
+  return new SSETransport(config) as unknown as Transport;
+}

package/packages/mcp/src/transports/websocket.ts

@@ -0,0 +1,159 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+export interface WebSocketTransportConfig {
+  url: string;
+  headers?: Record<string, string>;
+  reconnect?: boolean;        // reconectar automáticamente si se cae (default: true)
+  reconnectDelay?: number;    // ms entre intentos de reconexión (default: 3000)
+  reconnectMaxAttempts?: number; // máximo de intentos (default: 10)
+}
+
+export class WebSocketTransport implements Transport {
+  private url: string;
+  private ws: WebSocket | null = null;
+  private headers?: Record<string, string>;
+  private intentionallyClosed = false;  // distingue close() manual de caída
+  private reconnectAttempts = 0;
+  private reconnectDelay: number;
+  private reconnectMaxAttempts: number;
+  private shouldReconnect: boolean;
+
+  onmessage: ((message: unknown) => void) | undefined;
+  onerror: ((error: Error) => void) | undefined;
+  onclose: (() => void) | undefined;
+
+  constructor(config: WebSocketTransportConfig) {
+    this.url = config.url;
+    this.headers = config.headers;
+    this.shouldReconnect = config.reconnect ?? true;
+    this.reconnectDelay = config.reconnectDelay ?? 3000;
+    this.reconnectMaxAttempts = config.reconnectMaxAttempts ?? 10;
+  }
+
+  async start(): Promise<void> {
+    this.intentionallyClosed = false;
+    this.reconnectAttempts = 0;
+    return this.connect();
+  }
+
+  private connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+
+      // CORRECCIÓN 1 — headers en Bun WebSocket
+      // Bun acepta las opciones como segundo argumento cuando no hay subprotocols,
+      // o como objeto con `headers` dentro de un array de subprotocols vacío.
+      // La forma más segura y compatible:
+      const ws = this.headers && Object.keys(this.headers).length > 0
+        ? new WebSocket(this.url, {
+          // @ts-expect-error — Bun extiende la API estándar de WebSocket
+          headers: this.headers,
+        })
+        : new WebSocket(this.url);
+
+      this.ws = ws;
+      let resolved = false;
+
+      ws.onopen = () => {
+        resolved = true;
+        this.reconnectAttempts = 0; // reset contador al conectar exitosamente
+        resolve();
+      };
+
+      ws.onmessage = (event: MessageEvent) => {
+        try {
+          const data = JSON.parse(event.data as string);
+          this.onmessage?.(data);
+        } catch {
+          // Ignorar mensajes no-JSON (ping/pong, heartbeats)
+        }
+      };
+
+      // CORRECCIÓN 2 — separar el error de conexión del error post-conexión
+      ws.onerror = (event: Event) => {
+        const error =
+          (event as ErrorEvent).error ??
+          new Error(`WebSocket error en ${this.url}`);
+
+        if (!resolved) {
+          // Error durante la conexión inicial → rechazar la promesa
+          reject(error);
+        } else {
+          // Error después de conectar → notificar sin rechazar
+          this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+        }
+      };
+
+      // CORRECCIÓN 3 — reconexión automática en cierre inesperado
+      ws.onclose = (event: CloseEvent) => {
+        this.ws = null;
+
+        if (this.intentionallyClosed) {
+          // Cierre manual con close() — notificar y no reconectar
+          this.onclose?.();
+          return;
+        }
+
+        if (!resolved) {
+          // Cierre antes de que se abriera → rechazar la promesa
+          reject(new Error(
+            `WebSocket cerrado antes de conectar — code: ${event.code}, reason: ${event.reason}`
+          ));
+          return;
+        }
+
+        // Cierre inesperado después de conectar
+        if (
+          this.shouldReconnect &&
+          this.reconnectAttempts < this.reconnectMaxAttempts
+        ) {
+          this.reconnectAttempts++;
+          const delay = this.reconnectDelay * this.reconnectAttempts; // backoff lineal
+
+          setTimeout(async () => {
+            try {
+              await this.connect();
+            } catch (err) {
+              this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+              this.onclose?.();
+            }
+          }, delay);
+        } else {
+          // Sin más intentos → notificar cierre definitivo
+          this.onerror?.(new Error(
+            `WebSocket desconectado después de ${this.reconnectAttempts} intentos — ${this.url}`
+          ));
+          this.onclose?.();
+        }
+      };
+    });
+  }
+
+  async close(): Promise<void> {
+    this.intentionallyClosed = true; // marcar como cierre intencional
+    if (this.ws) {
+      // Código 1000 = cierre normal
+      this.ws.close(1000, "Client closed connection");
+      this.ws = null;
+    }
+  }
+
+  async send(message: unknown): Promise<void> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error(
+        `WebSocket no está conectado — readyState: ${this.ws?.readyState ?? "null"}`
+      );
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+
+  // Útil para health checks desde el MCP client
+  get isConnected(): boolean {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+}
+
+export function createWebSocketTransport(
+  config: WebSocketTransportConfig
+): Transport {
+  return new WebSocketTransport(config) as unknown as Transport;
+}

package/packages/skills/src/bundled/agents/agent_spawner/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: agent_spawner
+description: "Create and manage specialized worker agents with optimal tool assignments and lifecycle control"
+version: 1.1.0
+author: Hive Team
+icon: "🤖"
+category: agents
+permissions:
+  - agent_manage
+dependencies: []
+tools: [get_available_models, find_agent, create_agent, archive_agent]
+
+# Structured skill fields
+triggers:
+  - "creá un agente"
+  - "create agent"
+  - "creá un worker"
+  - "create worker"
+  - "nuevo agente"
+  - "new agent"
+  - "agente especializado"
+  - "specialized agent"
+  - "buscá un agente"
+  - "find agent"
+  - "archivá agente"
+  - "archive agent"
+  - "worker inactivo"
+  - "inactive worker"
+
+preferred_agents: []
+
+steps:
+  - step: 1
+    action: find_agent
+    instruction: "Search for existing agents before creating new one"
+    params:
+      search: "agent name or specialty"
+      status: "idle"
+    output: existing_agents
+
+  - step: 2
+    action: decision_reuse_or_create
+    instruction: "If suitable agent exists, reuse it. Otherwise, proceed to create"
+    output: decision
+
+  - step: 3
+    action: get_available_models
+    instruction: "Query available providers and models from database to select optimal model for the agent"
+    params:
+      capabilities: "required capability (coding, chat, analysis, vision)"
+      modelType: "llm (default)"
+    output: available_models
+
+  - step: 4
+    action: create_agent
+    instruction: "Create new worker with focused system_prompt, minimal tools, and optimal provider/model"
+    params:
+      name: "specialty_name"
+      description: "Clear specialty description"
+      system_prompt: "Focused instructions for role"
+      tools_json: ["minimal", "required", "tools"]
+      providerId: "selected from get_available_models"
+      modelId: "selected from get_available_models"
+    output: new_agent_id
+
+  - step: 5
+    action: archive_agent (if needed)
+    instruction: "Archive workers that are no longer needed or inactive >14 days"
+    params:
+      agent_id: "agent to archive"
+      reason: "no longer needed"
+    output: archived
+
+rules:
+  - "ALWAYS use find_agent BEFORE create_agent — never duplicate workers"
+  - "ALWAYS use get_available_models BEFORE create_agent — providerId y modelId son OBLIGATORIOS"
+  - "Workers have role='worker', coordinator has role='coordinator'"
+  - "Assign MINIMUM required tools (principle of least privilege)"
+  - "system_prompt must be specific and focused on specialty"
+  - "Use descriptive names that indicate agent's purpose"
+  - "Archive agents inactive >14 days (Curator does this automatically)"
+
+output_format:
+  structure: markdown
+  sections:
+    - "action_taken"
+    - "agent_name"
+    - "specialty"
+    - "tools_assigned"
+    - "status"
+  max_length: "Agent creation/management summary"
+
+examples:
+  - user_input: "creá un agente para investigación web"
+    expected_behavior: "find_agent('researcher') → if not exists, create_agent({ name: 'ai_researcher', tools: ['web_search', 'web_fetch'] })"
+
+  - user_input: "hay un worker para escribir contenido"
+    expected_behavior: "find_agent({ search: 'writer' }) → return existing writer agents"
+
+  - user_input: "archivá los agentes inactivos"
+    expected_behavior: "find_agent({ status: 'idle' }) → archive_agent for those inactive >14 days"
+---
+
+# Agent Spawner Skill
+
+## Cuándo se Activa
+
+Para crear nuevos workers especializados o gestionar el ciclo de vida de agents existentes.
+
+## Herramientas Disponibles
+
+| Tool | Qué hace | Cuándo usarla |
+|------|----------|---------------|
+| `get_available_models` | Consulta providers y modelos activos de la BD | **ANTES de crear** — seleccionar modelo óptimo |
+| `find_agent` | Busca agents existentes | **PRIMERO** — antes de crear |
+| `create_agent` | Crea nuevo worker | Si no existe apto |
+| `archive_agent` | Archiva worker | Limpieza, inactivos |
+
+## Workflow
+
+### Crear Agent
+1. **Buscar** → `find_agent({ search })` — ¿existe?
+2. **Si existe** → Reutilizar
+3. **Si no existe** → `get_available_models({ capabilities })` — seleccionar modelo óptimo
+4. **Crear** → `create_agent({...})` con providerId y modelId seleccionados
+
+### Create Agent Config
+```javascript
+// 1. Consultar modelos disponibles para coding
+get_available_models({ capabilities: "coding" })
+// → [{ providerId: "openai", modelId: "gpt-4o", contextWindow: 128000 }, ...]
+
+// 2. Crear agente con modelo óptimo (providerId y modelId son OBLIGATORIOS)
+create_agent({
+  name: "ai_coder",
+  description: "Especialista en código y refactorización",
+  system_prompt: `
+    Sos desarrollador experto. Tu rol:
+    1. Escribir código limpio y testeable
+    2. Refactorizar código existente
+    3. Revisar PRs y sugerir mejoras
+  `,
+  tools_json: ["fs_read", "fs_write", "fs_edit", "cli_exec"],
+  providerId: "openai",  // OBLIGATORIO - seleccionado de get_available_models
+  modelId: "gpt-4o",     // OBLIGATORIO - seleccionado de get_available_models
+  tone: "professional",
+  max_iterations: 15
+})
+```
+
+## Mejores Prácticas
+
+- **Buscar primero**: Nunca duplicar workers
+- **Consultar modelos**: Usar `get_available_models` ANTES de crear para seleccionar provider/model óptimo
+- **System prompt específico**: Enfocado en especialidad
+- **Mínimo privilegio**: Solo tools necesarias
+- **Nombres descriptivos**: Que indiquen propósito
+- **Modelo adecuado**: Seleccionar según capacidad requerida (coding, chat, analysis, vision)
+
+## Errores a Evitar
+
+- ❌ Crear sin buscar primero
+- ❌ Crear sin consultar modelos disponibles (`get_available_models`)
+- ❌ Usar modelo inadecuado para la tarea (ej: modelo pequeño para coding complejo)
+- ❌ Tools en exceso ("por las dudas")
+- ❌ System prompt genérico
+- ❌ Nombres vagos ("worker1", "agent1")