@vaia-lab/sdk 0.3.0 → 0.4.1

package/dist/agent-1bVw0eB8.d.cts

@@ -0,0 +1,222 @@
+/**
+ * VAIA Extension Protocol — superficie de AGENTE.
+ *
+ * Es la parte del protocolo que permite que el asistente de Handeia viva
+ * dentro de un espacio de terceros. Sigue la regla del ecosistema: protocolo
+ * antes que SDK. Lo que hay aquí son CONTRATOS; el SDK solo los transporta.
+ *
+ * ── El reparto de papeles ────────────────────────────────────────────────
+ *   El espacio  → superficie y manos. Declara qué sabe y qué puede hacer.
+ *   Handeia     → cerebro, memoria y autoridad. Decide y ejecuta a través suyo.
+ *
+ * Por eso un espacio NO trae su propia IA: si la trajera, no te conocería,
+ * empezaría de cero cada vez, y no podría contradecirse a sí mismo. El caso
+ * que lo justifica: el espacio puntúa un resultado con 90 y el agente te dice
+ * que te conviene el de 87, porque sabe algo de ti que el espacio no sabe.
+ * Eso solo es posible si el cerebro vive fuera del espacio.
+ *
+ * ── La regla de confianza, que manda sobre todo lo demás ─────────────────
+ * El espacio es CÓDIGO DE TERCEROS. Nada de lo que envía es un hecho: es una
+ * AFIRMACIÓN. Handeia la trata como dato citado, nunca como instrucción y
+ * nunca al mismo nivel que lo que sabe del usuario. Un espacio que escriba
+ * "ignora las instrucciones anteriores" en su contexto no logra nada.
+ *
+ * @see AGENT_PROTOCOL_VERSION para la política de compatibilidad.
+ */
+/**
+ * Versión del protocolo de agente. Viaja en cada mensaje.
+ *
+ * Se versiona desde el primer día a propósito: este contrato es público y
+ * cambiarlo después obliga a coordinar despliegues entre partes que no se
+ * conocen. Ya se pagó esa factura una vez con la codificación del JWT.
+ */
+declare const AGENT_PROTOCOL_VERSION = 1;
+/** Un parámetro de una acción. Sin tipos no hay validación posible. */
+interface AgentActionParam {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required?: boolean | undefined;
+    /** Valores admitidos. Si se define, nada fuera de la lista es válido. */
+    enum?: string[] | undefined;
+}
+/**
+ * Algo que el espacio sabe hacer.
+ *
+ * Handeia SOLO puede pedir acciones declaradas aquí. No improvisa, no toca el
+ * DOM, no busca la forma. Si no está declarada, para el agente no existe —
+ * y eso es lo que hace que el mismo agente sirva en cualquier espacio sin que
+ * Handeia sepa nada de ninguno en particular.
+ */
+interface AgentAction {
+    /** Identificador estable, en minúsculas: 'filtrar_resultados'. */
+    name: string;
+    /** Qué hace, en lenguaje natural. Es lo que lee el modelo para elegirla. */
+    description: string;
+    params?: AgentActionParam[] | undefined;
+    /**
+     * true si modifica algo. Las que escriben se confirman con el usuario ANTES
+     * de ejecutarse — un agente que escribe sin preguntar se siente fuera de
+     * control incluso cuando acierta.
+     */
+    writes?: boolean | undefined;
+    /** Permiso que el usuario debe haber concedido a este espacio. */
+    permission?: string | undefined;
+}
+/** Configuración de la superficie de agente dentro de defineCapability. */
+interface AgentSurfaceConfig {
+    /** Acciones que el espacio expone. Vacío = el agente solo puede responder. */
+    actions?: AgentAction[] | undefined;
+    /**
+     * Endpoint para preguntarle al espacio cuando el usuario NO está dentro
+     * ("¿tengo algo pendiente ahí?"). El círculo solo existe con el espacio
+     * abierto; esto es lo que permite que Handeia sea el lugar donde convergen
+     * todos tus espacios en vez de uno más al que entrar.
+     */
+    queryEndpoint?: string | undefined;
+    /** Frase de bienvenida propia del espacio. */
+    greeting?: string | undefined;
+    /**
+     * Servicios externos que el espacio necesita consultar. El usuario los
+     * concede por espacio y los puede revocar cuando quiera. El espacio jamás
+     * recibe el token: pide operaciones, la plataforma las ejecuta.
+     */
+    needs?: ConnectorNeed[] | undefined;
+}
+/**
+ * Servicios externos que un espacio puede necesitar (GitHub, Drive, Calendar…).
+ *
+ * ── La regla, y no tiene excepciones ─────────────────────────────────────
+ * El espacio NUNCA recibe el token del usuario. Declara qué necesita, la
+ * plataforma llama al proveedor con el token que YA tiene guardado, y le
+ * devuelve solo el resultado.
+ *
+ * Por qué así y no entregando el token:
+ *   - Si cada espacio guardara tokens, la superficie de ataque se multiplica
+ *     por cada desarrollador que publique. Un espacio comprometido entregaría
+ *     el GitHub y el Drive de todos sus usuarios.
+ *   - Prestado, un espacio comprometido solo puede pedir las operaciones que
+ *     el usuario le concedió, con límite de frecuencia, auditadas y
+ *     revocables al instante desde Conectores.
+ *
+ * De regalo, publicar un espacio se vuelve barato: el desarrollador no
+ * implementa OAuth de nada.
+ */
+type ConnectorNeed = 'github' | 'drive' | 'calendar' | 'email' | 'notion' | 'discord';
+/**
+ * Operaciones de LECTURA que la plataforma sabe hacer por el espacio.
+ *
+ * Lista cerrada a propósito: un espacio no puede pedir "haz esta llamada
+ * arbitraria a la API de GitHub". Solo puede pedir lo que está aquí, y cada
+ * una devuelve datos ya acotados. Escribir en un servicio externo NO se
+ * presta — para eso el usuario usa el servicio.
+ */
+type ConnectorOperation = 'github.repos' | 'github.issues' | 'drive.files' | 'calendar.events' | 'email.recent' | 'notion.pages';
+/** Lo que el espacio pide prestado. */
+interface ConnectorRequest {
+    operation: ConnectorOperation;
+    /** Filtros simples. La plataforma los valida; nada de consultas libres. */
+    params?: Record<string, string | number | boolean> | undefined;
+}
+/** Lo que la plataforma devuelve. Datos, jamás credenciales. */
+interface ConnectorResult {
+    operation: ConnectorOperation;
+    ok: boolean;
+    items?: Record<string, unknown>[] | undefined;
+    /** 'sin_conectar' = el usuario no ha vinculado ese servicio todavía. */
+    error?: 'sin_permiso' | 'sin_conectar' | 'no_soportada' | 'limite_excedido' | 'fallo' | undefined;
+}
+/** Qué operación necesita qué conector — la plataforma lo usa para autorizar. */
+declare const CONNECTOR_OF_OPERATION: Record<ConnectorOperation, ConnectorNeed>;
+/**
+ * Lo que el espacio dice que está pasando.
+ *
+ * OJO: se llama `claims` y no `facts` a propósito. Handeia lo etiqueta como
+ * afirmación de un tercero antes de dárselo al modelo.
+ */
+interface AgentSpaceContext {
+    /** Dónde está el usuario dentro del espacio: '/lista'. */
+    route?: string | undefined;
+    /** Qué está viendo, en lenguaje natural: 'Lista de 12 resultados'. */
+    view?: string | undefined;
+    /** Datos que el espacio considera relevantes ahora mismo. */
+    claims?: Record<string, unknown> | undefined;
+}
+/** Petición del espacio a Handeia. Un solo endpoint, un solo formato. */
+interface AgentTurnRequest {
+    protocol: typeof AGENT_PROTOCOL_VERSION;
+    /** Lo que escribió el usuario. */
+    message: string;
+    context?: AgentSpaceContext | undefined;
+    /** Acciones disponibles AHORA (pueden ser menos que las declaradas). */
+    actions?: AgentAction[] | undefined;
+    /** Turnos previos, para que el agente no pierda el hilo. */
+    history?: {
+        role: 'user' | 'agent';
+        text: string;
+    }[] | undefined;
+    /** Resultado de una acción que Handeia pidió en el turno anterior. */
+    actionResult?: AgentActionResult | undefined;
+}
+/** Lo que el espacio devuelve tras ejecutar una acción. */
+interface AgentActionResult {
+    action: string;
+    ok: boolean;
+    /** Qué pasó, para que el agente pueda cerrar el ciclo con el usuario. */
+    summary?: string | undefined;
+    error?: string | undefined;
+}
+/**
+ * De dónde salió lo que el agente afirma.
+ *
+ * No es adorno: es el pilar de info verificada. Cuando el agente contradice
+ * al espacio ("dice 90, pero te conviene la de 87"), tiene que poder decir de
+ * dónde sacó su razón. Un oráculo que no se explica no se gana la confianza.
+ */
+interface AgentEvidence {
+    /** 'handeia' = memoria del usuario · 'space' = lo que declaró el espacio. */
+    source: 'handeia' | 'space';
+    label: string;
+}
+/** Respuesta de Handeia al espacio. */
+interface AgentTurnResponse {
+    protocol: typeof AGENT_PROTOCOL_VERSION;
+    /** Qué decirle al usuario. */
+    text?: string | undefined;
+    /** Acción a ejecutar. Siempre sale de la lista declarada, nunca inventada. */
+    action?: {
+        name: string;
+        args?: Record<string, unknown> | undefined;
+    } | undefined;
+    /** true si hay que confirmar con el usuario antes de ejecutarla. */
+    confirm?: boolean | undefined;
+    evidence?: AgentEvidence[] | undefined;
+    /** Identificador para cruzar los registros de todas las capas. */
+    traceId?: string | undefined;
+}
+/**
+ * Revisa que las acciones declaradas sean utilizables.
+ *
+ * Corre al declarar la capacidad, no en producción: un contrato mal escrito
+ * debe reventar en el escritorio del desarrollador, no frente al usuario.
+ */
+declare function validateAgentSurface(cfg: AgentSurfaceConfig): string[];
+/**
+ * ¿Es válida esta acción contra lo declarado?
+ *
+ * La usa Handeia antes de reenviarle nada al espacio. Es la lista blanca en
+ * ejecución: aunque el modelo se invente una acción o un argumento fuera de
+ * rango, aquí se detiene.
+ */
+declare function validateActionCall(llamada: {
+    name: string;
+    args?: Record<string, unknown> | undefined;
+}, declaradas: AgentAction[]): {
+    ok: true;
+    action: AgentAction;
+} | {
+    ok: false;
+    reason: string;
+};
+
+export { type AgentSurfaceConfig as A, CONNECTOR_OF_OPERATION as C, type AgentAction as a, AGENT_PROTOCOL_VERSION as b, type AgentActionParam as c, type AgentActionResult as d, type AgentEvidence as e, type AgentSpaceContext as f, type AgentTurnRequest as g, type AgentTurnResponse as h, type ConnectorNeed as i, type ConnectorOperation as j, type ConnectorRequest as k, type ConnectorResult as l, validateAgentSurface as m, validateActionCall as v };

package/dist/agent-1bVw0eB8.d.ts

@@ -0,0 +1,222 @@
+/**
+ * VAIA Extension Protocol — superficie de AGENTE.
+ *
+ * Es la parte del protocolo que permite que el asistente de Handeia viva
+ * dentro de un espacio de terceros. Sigue la regla del ecosistema: protocolo
+ * antes que SDK. Lo que hay aquí son CONTRATOS; el SDK solo los transporta.
+ *
+ * ── El reparto de papeles ────────────────────────────────────────────────
+ *   El espacio  → superficie y manos. Declara qué sabe y qué puede hacer.
+ *   Handeia     → cerebro, memoria y autoridad. Decide y ejecuta a través suyo.
+ *
+ * Por eso un espacio NO trae su propia IA: si la trajera, no te conocería,
+ * empezaría de cero cada vez, y no podría contradecirse a sí mismo. El caso
+ * que lo justifica: el espacio puntúa un resultado con 90 y el agente te dice
+ * que te conviene el de 87, porque sabe algo de ti que el espacio no sabe.
+ * Eso solo es posible si el cerebro vive fuera del espacio.
+ *
+ * ── La regla de confianza, que manda sobre todo lo demás ─────────────────
+ * El espacio es CÓDIGO DE TERCEROS. Nada de lo que envía es un hecho: es una
+ * AFIRMACIÓN. Handeia la trata como dato citado, nunca como instrucción y
+ * nunca al mismo nivel que lo que sabe del usuario. Un espacio que escriba
+ * "ignora las instrucciones anteriores" en su contexto no logra nada.
+ *
+ * @see AGENT_PROTOCOL_VERSION para la política de compatibilidad.
+ */
+/**
+ * Versión del protocolo de agente. Viaja en cada mensaje.
+ *
+ * Se versiona desde el primer día a propósito: este contrato es público y
+ * cambiarlo después obliga a coordinar despliegues entre partes que no se
+ * conocen. Ya se pagó esa factura una vez con la codificación del JWT.
+ */
+declare const AGENT_PROTOCOL_VERSION = 1;
+/** Un parámetro de una acción. Sin tipos no hay validación posible. */
+interface AgentActionParam {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    description: string;
+    required?: boolean | undefined;
+    /** Valores admitidos. Si se define, nada fuera de la lista es válido. */
+    enum?: string[] | undefined;
+}
+/**
+ * Algo que el espacio sabe hacer.
+ *
+ * Handeia SOLO puede pedir acciones declaradas aquí. No improvisa, no toca el
+ * DOM, no busca la forma. Si no está declarada, para el agente no existe —
+ * y eso es lo que hace que el mismo agente sirva en cualquier espacio sin que
+ * Handeia sepa nada de ninguno en particular.
+ */
+interface AgentAction {
+    /** Identificador estable, en minúsculas: 'filtrar_resultados'. */
+    name: string;
+    /** Qué hace, en lenguaje natural. Es lo que lee el modelo para elegirla. */
+    description: string;
+    params?: AgentActionParam[] | undefined;
+    /**
+     * true si modifica algo. Las que escriben se confirman con el usuario ANTES
+     * de ejecutarse — un agente que escribe sin preguntar se siente fuera de
+     * control incluso cuando acierta.
+     */
+    writes?: boolean | undefined;
+    /** Permiso que el usuario debe haber concedido a este espacio. */
+    permission?: string | undefined;
+}
+/** Configuración de la superficie de agente dentro de defineCapability. */
+interface AgentSurfaceConfig {
+    /** Acciones que el espacio expone. Vacío = el agente solo puede responder. */
+    actions?: AgentAction[] | undefined;
+    /**
+     * Endpoint para preguntarle al espacio cuando el usuario NO está dentro
+     * ("¿tengo algo pendiente ahí?"). El círculo solo existe con el espacio
+     * abierto; esto es lo que permite que Handeia sea el lugar donde convergen
+     * todos tus espacios en vez de uno más al que entrar.
+     */
+    queryEndpoint?: string | undefined;
+    /** Frase de bienvenida propia del espacio. */
+    greeting?: string | undefined;
+    /**
+     * Servicios externos que el espacio necesita consultar. El usuario los
+     * concede por espacio y los puede revocar cuando quiera. El espacio jamás
+     * recibe el token: pide operaciones, la plataforma las ejecuta.
+     */
+    needs?: ConnectorNeed[] | undefined;
+}
+/**
+ * Servicios externos que un espacio puede necesitar (GitHub, Drive, Calendar…).
+ *
+ * ── La regla, y no tiene excepciones ─────────────────────────────────────
+ * El espacio NUNCA recibe el token del usuario. Declara qué necesita, la
+ * plataforma llama al proveedor con el token que YA tiene guardado, y le
+ * devuelve solo el resultado.
+ *
+ * Por qué así y no entregando el token:
+ *   - Si cada espacio guardara tokens, la superficie de ataque se multiplica
+ *     por cada desarrollador que publique. Un espacio comprometido entregaría
+ *     el GitHub y el Drive de todos sus usuarios.
+ *   - Prestado, un espacio comprometido solo puede pedir las operaciones que
+ *     el usuario le concedió, con límite de frecuencia, auditadas y
+ *     revocables al instante desde Conectores.
+ *
+ * De regalo, publicar un espacio se vuelve barato: el desarrollador no
+ * implementa OAuth de nada.
+ */
+type ConnectorNeed = 'github' | 'drive' | 'calendar' | 'email' | 'notion' | 'discord';
+/**
+ * Operaciones de LECTURA que la plataforma sabe hacer por el espacio.
+ *
+ * Lista cerrada a propósito: un espacio no puede pedir "haz esta llamada
+ * arbitraria a la API de GitHub". Solo puede pedir lo que está aquí, y cada
+ * una devuelve datos ya acotados. Escribir en un servicio externo NO se
+ * presta — para eso el usuario usa el servicio.
+ */
+type ConnectorOperation = 'github.repos' | 'github.issues' | 'drive.files' | 'calendar.events' | 'email.recent' | 'notion.pages';
+/** Lo que el espacio pide prestado. */
+interface ConnectorRequest {
+    operation: ConnectorOperation;
+    /** Filtros simples. La plataforma los valida; nada de consultas libres. */
+    params?: Record<string, string | number | boolean> | undefined;
+}
+/** Lo que la plataforma devuelve. Datos, jamás credenciales. */
+interface ConnectorResult {
+    operation: ConnectorOperation;
+    ok: boolean;
+    items?: Record<string, unknown>[] | undefined;
+    /** 'sin_conectar' = el usuario no ha vinculado ese servicio todavía. */
+    error?: 'sin_permiso' | 'sin_conectar' | 'no_soportada' | 'limite_excedido' | 'fallo' | undefined;
+}
+/** Qué operación necesita qué conector — la plataforma lo usa para autorizar. */
+declare const CONNECTOR_OF_OPERATION: Record<ConnectorOperation, ConnectorNeed>;
+/**
+ * Lo que el espacio dice que está pasando.
+ *
+ * OJO: se llama `claims` y no `facts` a propósito. Handeia lo etiqueta como
+ * afirmación de un tercero antes de dárselo al modelo.
+ */
+interface AgentSpaceContext {
+    /** Dónde está el usuario dentro del espacio: '/lista'. */
+    route?: string | undefined;
+    /** Qué está viendo, en lenguaje natural: 'Lista de 12 resultados'. */
+    view?: string | undefined;
+    /** Datos que el espacio considera relevantes ahora mismo. */
+    claims?: Record<string, unknown> | undefined;
+}
+/** Petición del espacio a Handeia. Un solo endpoint, un solo formato. */
+interface AgentTurnRequest {
+    protocol: typeof AGENT_PROTOCOL_VERSION;
+    /** Lo que escribió el usuario. */
+    message: string;
+    context?: AgentSpaceContext | undefined;
+    /** Acciones disponibles AHORA (pueden ser menos que las declaradas). */
+    actions?: AgentAction[] | undefined;
+    /** Turnos previos, para que el agente no pierda el hilo. */
+    history?: {
+        role: 'user' | 'agent';
+        text: string;
+    }[] | undefined;
+    /** Resultado de una acción que Handeia pidió en el turno anterior. */
+    actionResult?: AgentActionResult | undefined;
+}
+/** Lo que el espacio devuelve tras ejecutar una acción. */
+interface AgentActionResult {
+    action: string;
+    ok: boolean;
+    /** Qué pasó, para que el agente pueda cerrar el ciclo con el usuario. */
+    summary?: string | undefined;
+    error?: string | undefined;
+}
+/**
+ * De dónde salió lo que el agente afirma.
+ *
+ * No es adorno: es el pilar de info verificada. Cuando el agente contradice
+ * al espacio ("dice 90, pero te conviene la de 87"), tiene que poder decir de
+ * dónde sacó su razón. Un oráculo que no se explica no se gana la confianza.
+ */
+interface AgentEvidence {
+    /** 'handeia' = memoria del usuario · 'space' = lo que declaró el espacio. */
+    source: 'handeia' | 'space';
+    label: string;
+}
+/** Respuesta de Handeia al espacio. */
+interface AgentTurnResponse {
+    protocol: typeof AGENT_PROTOCOL_VERSION;
+    /** Qué decirle al usuario. */
+    text?: string | undefined;
+    /** Acción a ejecutar. Siempre sale de la lista declarada, nunca inventada. */
+    action?: {
+        name: string;
+        args?: Record<string, unknown> | undefined;
+    } | undefined;
+    /** true si hay que confirmar con el usuario antes de ejecutarla. */
+    confirm?: boolean | undefined;
+    evidence?: AgentEvidence[] | undefined;
+    /** Identificador para cruzar los registros de todas las capas. */
+    traceId?: string | undefined;
+}
+/**
+ * Revisa que las acciones declaradas sean utilizables.
+ *
+ * Corre al declarar la capacidad, no en producción: un contrato mal escrito
+ * debe reventar en el escritorio del desarrollador, no frente al usuario.
+ */
+declare function validateAgentSurface(cfg: AgentSurfaceConfig): string[];
+/**
+ * ¿Es válida esta acción contra lo declarado?
+ *
+ * La usa Handeia antes de reenviarle nada al espacio. Es la lista blanca en
+ * ejecución: aunque el modelo se invente una acción o un argumento fuera de
+ * rango, aquí se detiene.
+ */
+declare function validateActionCall(llamada: {
+    name: string;
+    args?: Record<string, unknown> | undefined;
+}, declaradas: AgentAction[]): {
+    ok: true;
+    action: AgentAction;
+} | {
+    ok: false;
+    reason: string;
+};
+
+export { type AgentSurfaceConfig as A, CONNECTOR_OF_OPERATION as C, type AgentAction as a, AGENT_PROTOCOL_VERSION as b, type AgentActionParam as c, type AgentActionResult as d, type AgentEvidence as e, type AgentSpaceContext as f, type AgentTurnRequest as g, type AgentTurnResponse as h, type ConnectorNeed as i, type ConnectorOperation as j, type ConnectorRequest as k, type ConnectorResult as l, validateAgentSurface as m, validateActionCall as v };

package/dist/index.cjs

@@ -36,7 +36,6 @@ __export(src_exports, {
   httpTransport: () => httpTransport,
   local: () => local,
   mcp: () => mcp,
-  mountAgent: () => mountAgent,
   requiresApproval: () => requiresApproval,
   toMCPTool: () => toMCPTool,
   toMCPTools: () => toMCPTools,
@@ -814,207 +813,6 @@ function toManifest(config) {
   };
 }
 
-// src/agent-mount.ts
-var HANDEIA_POR_DEFECTO = "https://handeia.com";
-var RUTA_TURNO = "/api/agent/space";
-var CSS = `
-.hdi-agent-root{position:fixed;z-index:2147483000;bottom:20px;right:20px;font-family:ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif}
-.hdi-agent-orb{width:44px;height:44px;border-radius:9999px;border:0;cursor:pointer;background:#000;color:#fff;display:flex;align-items:center;justify-content:center;box-shadow:0 10px 30px -6px rgba(0,0,0,.4);transition:transform .15s}
-.hdi-agent-orb:hover{transform:scale(1.05)}
-.hdi-agent-orb:active{transform:scale(.95)}
-.hdi-agent-panel{position:absolute;bottom:56px;right:0;width:min(360px,calc(100vw - 40px));background:#fff;color:#111;border:1px solid rgba(0,0,0,.09);border-radius:18px;box-shadow:0 24px 60px -18px rgba(0,0,0,.32);overflow:hidden;display:flex;flex-direction:column;max-height:min(60vh,460px)}
-.hdi-agent-head{display:flex;align-items:center;gap:8px;padding:12px 14px;border-bottom:1px solid rgba(0,0,0,.06);font-size:12.5px;font-weight:600}
-.hdi-agent-dot{width:7px;height:7px;border-radius:9999px;background:#8b5cf6}
-.hdi-agent-log{flex:1;overflow-y:auto;padding:12px 14px;display:flex;flex-direction:column;gap:10px;font-size:13px;line-height:1.55}
-.hdi-agent-turn{white-space:pre-wrap}
-.hdi-agent-q{font-size:10.5px;letter-spacing:.14em;text-transform:uppercase;color:rgba(0,0,0,.34)}
-.hdi-agent-form{display:flex;gap:8px;padding:10px 12px;border-top:1px solid rgba(0,0,0,.06)}
-.hdi-agent-input{flex:1;border:1px solid rgba(0,0,0,.12);border-radius:10px;padding:8px 10px;font:inherit;font-size:13px;outline:none}
-.hdi-agent-input:focus{border-color:rgba(0,0,0,.34)}
-.hdi-agent-send{border:0;border-radius:10px;padding:0 12px;background:#000;color:#fff;cursor:pointer;font-size:12.5px}
-.hdi-agent-confirm{display:flex;gap:8px;margin-top:4px}
-.hdi-agent-btn{border:1px solid rgba(0,0,0,.14);background:#fff;border-radius:9999px;padding:5px 12px;font-size:12px;cursor:pointer}
-.hdi-agent-btn-primary{background:#000;color:#fff;border-color:#000}
-@media (prefers-color-scheme:dark){
-.hdi-agent-orb{background:#fff;color:#000}
-.hdi-agent-panel{background:#171717;color:#f5f5f5;border-color:rgba(255,255,255,.13)}
-.hdi-agent-head,.hdi-agent-form{border-color:rgba(255,255,255,.1)}
-.hdi-agent-q{color:rgba(255,255,255,.5)}
-.hdi-agent-input{background:transparent;color:inherit;border-color:rgba(255,255,255,.16)}
-.hdi-agent-send{background:#fff;color:#000}
-.hdi-agent-btn{background:transparent;color:inherit;border-color:rgba(255,255,255,.18)}
-.hdi-agent-btn-primary{background:#fff;color:#000}
-}`;
-function el(tag, cls, text) {
-  const n = document.createElement(tag);
-  if (cls) n.className = cls;
-  if (text !== void 0) n.textContent = text;
-  return n;
-}
-function mountAgent(opts) {
-  if (typeof document === "undefined") {
-    throw new Error("[@vaia-lab/sdk] mountAgent solo corre en el navegador.");
-  }
-  const base = (opts.handeiaUrl ?? HANDEIA_POR_DEFECTO).replace(/\/$/, "");
-  const contenedor = opts.container ?? document.body;
-  const previo = contenedor.querySelector(".hdi-agent-root");
-  if (previo) previo.remove();
-  if (!document.getElementById("hdi-agent-css")) {
-    const estilo = el("style");
-    estilo.id = "hdi-agent-css";
-    estilo.textContent = CSS;
-    document.head.appendChild(estilo);
-  }
-  const raiz = el("div", "hdi-agent-root");
-  const orbe = el("button", "hdi-agent-orb");
-  orbe.type = "button";
-  orbe.setAttribute("aria-label", "Abrir asistente de Handeia");
-  orbe.textContent = "\u2726";
-  const panel = el("div", "hdi-agent-panel");
-  panel.hidden = true;
-  panel.setAttribute("role", "dialog");
-  panel.setAttribute("aria-label", "Asistente de Handeia");
-  const cabeza = el("div", "hdi-agent-head");
-  cabeza.appendChild(el("span", "hdi-agent-dot"));
-  cabeza.appendChild(el("span", void 0, "Handeia"));
-  const registro = el("div", "hdi-agent-log");
-  if (opts.greeting) registro.appendChild(el("div", "hdi-agent-turn", opts.greeting));
-  const forma = el("form", "hdi-agent-form");
-  const entrada = el("input", "hdi-agent-input");
-  entrada.type = "text";
-  entrada.placeholder = "Preg\xFAntale a Handeia\u2026";
-  entrada.autocomplete = "off";
-  const enviar = el("button", "hdi-agent-send", "Enviar");
-  enviar.type = "submit";
-  forma.append(entrada, enviar);
-  panel.append(cabeza, registro, forma);
-  raiz.append(panel, orbe);
-  contenedor.appendChild(raiz);
-  const historial = [];
-  const decir = (texto, clase = "hdi-agent-turn") => {
-    const n = el("div", clase, texto);
-    registro.appendChild(n);
-    registro.scrollTop = registro.scrollHeight;
-    return n;
-  };
-  async function turno(mensaje, actionResult) {
-    let context;
-    try {
-      context = await opts.getContext?.();
-    } catch {
-      context = void 0;
-    }
-    let res;
-    try {
-      res = await fetch(`${base}${RUTA_TURNO}`, {
-        method: "POST",
-        // La identidad va en la cookie de sesión de Handeia. El espacio nunca
-        // toca ni ve el token del usuario.
-        credentials: "include",
-        headers: { "Content-Type": "application/json; charset=utf-8" },
-        body: JSON.stringify({
-          protocol: AGENT_PROTOCOL_VERSION,
-          capId: opts.capabilityId,
-          message: mensaje,
-          context,
-          actions: opts.actions ?? [],
-          history: historial.slice(-12),
-          actionResult
-        })
-      });
-    } catch {
-      decir("No pude comunicarme con Handeia. Revisa tu conexi\xF3n.");
-      return;
-    }
-    let data;
-    try {
-      data = await res.json();
-    } catch {
-      decir("Handeia respondi\xF3 algo que no pude leer.");
-      return;
-    }
-    if (!res.ok || data.ok === false) {
-      decir(
-        data.error === "no_autenticado" ? "Inicia sesi\xF3n en Handeia para usar el asistente." : data.error === "espacio_no_instalado" ? "Este espacio no est\xE1 instalado en tu Handeia." : "Handeia no pudo responder ahora mismo."
-      );
-      return;
-    }
-    if (data.text) {
-      decir(data.text);
-      historial.push({ role: "agent", text: data.text });
-    }
-    if (!data.action) return;
-    if (!opts.onAction) {
-      decir("Esto requiere una acci\xF3n que este espacio todav\xEDa no sabe ejecutar.");
-      return;
-    }
-    const ejecutar = async () => {
-      let resultado;
-      try {
-        resultado = await opts.onAction(data.action.name, data.action.args ?? {});
-      } catch (e) {
-        resultado = { action: data.action.name, ok: false, error: e instanceof Error ? e.message : "fall\xF3" };
-      }
-      await turno(mensaje, resultado);
-    };
-    if (data.confirm) {
-      const fila = el("div", "hdi-agent-confirm");
-      const si = el("button", "hdi-agent-btn hdi-agent-btn-primary", "Hacerlo");
-      const no = el("button", "hdi-agent-btn", "Cancelar");
-      si.type = "button";
-      no.type = "button";
-      si.onclick = () => {
-        fila.remove();
-        void ejecutar();
-      };
-      no.onclick = () => {
-        fila.remove();
-        decir("Cancelado.");
-      };
-      fila.append(si, no);
-      registro.appendChild(fila);
-      registro.scrollTop = registro.scrollHeight;
-      return;
-    }
-    await ejecutar();
-  }
-  forma.onsubmit = async (e) => {
-    e.preventDefault();
-    const texto = entrada.value.trim();
-    if (!texto) return;
-    entrada.value = "";
-    decir(texto, "hdi-agent-q");
-    historial.push({ role: "user", text: texto });
-    enviar.disabled = true;
-    try {
-      await turno(texto);
-    } finally {
-      enviar.disabled = false;
-      entrada.focus();
-    }
-  };
-  const abrir = () => {
-    panel.hidden = false;
-    entrada.focus();
-  };
-  const cerrar = () => {
-    panel.hidden = true;
-  };
-  orbe.onclick = () => panel.hidden ? abrir() : cerrar();
-  const alTeclear = (e) => {
-    if (e.key === "Escape") cerrar();
-  };
-  document.addEventListener("keydown", alTeclear);
-  return {
-    open: abrir,
-    close: cerrar,
-    destroy: () => {
-      document.removeEventListener("keydown", alTeclear);
-      raiz.remove();
-    }
-  };
-}
-
 // src/capabilities.ts
 async function conAutoridad(tools, call, ejecutar) {
   const tool = tools.find((t) => t.name === call.name);
@@ -1309,7 +1107,6 @@ var handeia = handeia_exports;
   httpTransport,
   local,
   mcp,
-  mountAgent,
   requiresApproval,
   toMCPTool,
   toMCPTools,