@johpaz/hive-sdk 0.4.7 → 0.4.9

package/CHANGELOG.md

@@ -22,6 +22,74 @@
   `buildAgentContext`), de las que depende el aislamiento entre inquilinos del
   log causal descrito en *Corregido*.
 
+### WhatsApp por la API oficial de Meta
+
+- **Canal nuevo `whatsapp_cloud`**: WhatsApp Business por la Cloud API, que es
+  lo que puede usar una empresa. Incluye `WhatsAppCloudClient` (texto con
+  partido automático en 4096 caracteres, plantillas, audio, marcar leído con
+  "escribiendo…" y descarga de medios), las funciones de webhook
+  (`verifyWhatsAppSignature`, `verifyWhatsAppChallenge`, `parseWhatsAppWebhook`)
+  y el canal `WhatsAppCloudChannel`. Sin dependencias nuevas: sólo `fetch`.
+- El gateway enruta `GET|POST /webhooks/whatsapp-cloud/:accountId` cuando se le
+  pasa `channelManager`. Meta exige HTTPS público, así que hace falta un proxy
+  inverso o un túnel por delante.
+- La versión del Graph se resuelve en un solo lugar (`META_GRAPH_API_VERSION`,
+  por defecto **v26.0**). Cada versión caduca a los ~2 años y Meta redirige en
+  silencio a la más vieja que siga viva; tenerla centralizada es lo que evita
+  enterarse tarde.
+- Fuera de la ventana de 24 h el canal manda la plantilla de
+  `windowFallbackTemplate`, y si no hay ninguna configurada lanza un error que
+  lo dice (131047). La narración de progreso no se envía por defecto
+  (`sendProgress: false`): desde el 1/10/2026 Meta cobra cada mensaje de
+  servicio dentro de la ventana.
+- El parser recorre todas las `entry` y `changes` del webhook, y el canal
+  descarta los reintentos de Meta por id de mensaje.
+- **Baileys se carga recién al conectar el canal `whatsapp`.** Antes se
+  importaba al cargar el índice del SDK, así que cualquier consumidor —aunque
+  no usara canales— se traía Baileys entero y su parche de
+  `process.stderr.write` en cada proceso. Quien usa el canal por código QR no
+  ve ningún cambio.
+
+### Catálogo compartido entre inquilinos
+
+- **El catálogo se instala una sola vez.** `tools`, `skills` y `ethics` dejan de
+  copiarse en la partición de cada inquilino: su contenido vive en la colección
+  sin prefijo —la misma que ve una instalación local— y cada inquilino guarda
+  únicamente lo que activó, en `catalogActivations`. Un enjambre nuevo arranca
+  con **cero escrituras** de catálogo, y encender una tool guarda una fila de
+  elección en lugar de una copia de la fila entera.
+- **Providers y modelos ya no se resiembran dentro de un inquilino.** En un host
+  multi-inquilino el catálogo que vale es el del host, así que `seedAllData()`
+  saltea el estático cuando hay tenant activo. Antes borraba y recreaba los 139
+  modelos de `SEED_DATA` en la partición de cada enjambre, en cada arranque, para
+  que un instante después los pisara el host.
+- Lo que un inquilino **crea** sigue siendo suyo y privado: las tools de un
+  endpoint de API, o una skill o un código de ética propios, se escriben en su
+  partición como siempre. Editar el contenido de una fila del catálogo también
+  deja una copia privada, y borrarla la oculta sólo para él.
+- API nueva en `@johpaz/hive-sdk/storage`: `setCatalogActivation`,
+  `clearCatalogActivation`, `listCatalogActivations`, `sharedCatalogCol`,
+  `CATALOG_COLLECTIONS` y el tipo `DocStore`, que es lo que ahora devuelve
+  `col()` — la clase `Collection` de hive-db lo satisface tal cual, así que no
+  cambia nada para quien la recibe.
+- **Sin inquilino en scope no cambia nada**: una instalación local sigue viendo
+  una sola partición, con el catálogo y su `active` en la misma fila.
+- **El índice de capacidades también se comparte, y eso destapa dos fallas que
+  ya existían.** Todo documento declara ahora su ámbito —el inquilino que lo
+  escribió, o `_` si es del catálogo— y `searchCapabilities()` consulta los dos
+  cuando hay inquilino activo:
+  - Antes el catálogo se indexaba **sin** filtro de inquilino y la búsqueda
+    desde un enjambre filtraba **por** su inquilino, así que dentro de un
+    enjambre no se encontraba NADA del catálogo: ni una tool ni una skill. El
+    agente sólo descubría sus tools de MCP y las de sus endpoints.
+  - Y un reindexado del catálogo —el que corre en cada arranque del gateway—
+    borraba por `type` a secas, llevándose por delante lo que cada inquilino
+    tenía indexado. Ahora el borrado va acotado a su ámbito.
+  - Encima de la búsqueda manda la elección: una capacidad que el inquilino
+    apagó no se le ofrece, aunque esté en el catálogo y puntúe primero.
+  Cubierto por `packages/core/src/agent/capability-search.test.ts` y
+  `packages/core/src/storage/catalog.test.ts`.
+
 ### Corregido
 
 - **Con un tenant activo, el log causal se apagaba en lugar de acotarse.**
@@ -511,6 +579,29 @@
   job que genera un scaffold con `create-app` y lo typechequea contra el SDK de
   ese commit.
 
+## 0.4.9
+
+### Corregido
+
+- **La compactación de historial dejaba de ser excepcional y corría casi en cada
+  turno.** `agent.context.compactionThreshold` es una proporción de la ventana
+  del modelo —su valor por defecto es `0.8`, o sea el 80 %— pero se leía como un
+  número de tokens: el umbral efectivo quedaba en 0.8 tokens. Cualquier hilo con
+  más de cinco mensajes se resumía en cada turno, lo que cuesta una llamada extra
+  al modelo por mensaje y reemplaza el historial por un resumen desde el primer
+  intercambio. Ahora un valor menor o igual a 1 se aplica sobre la ventana del
+  modelo y uno mayor se sigue leyendo como tokens, para quien fijó un número
+  absoluto. El umbral se calcula además con la ventana del modelo que corre el
+  turno, no con la del coordinador.
+- **El resumen se pedía con una credencial global.** `compactThread` resolvía el
+  modelo con `getDefaultLLM()` y llamaba a `resolveProviderConfig` sin
+  credenciales, así que la llave salía del secret store, del llavero del sistema
+  o del entorno del proceso. En una instalación de un solo usuario da igual; en
+  una multi-inquilino significa resumir la conversación de un cliente con la
+  llave de la plataforma o de otro cliente. `maybeCompact` y `compactThread`
+  aceptan ahora el modelo y las credenciales del turno (`CompactionLLM`), y el
+  agent loop les pasa los suyos. Sin ese dato se comportan como antes.
+
 ## 0.1.5
 
 Sincronización del SDK con el runtime de agentes de `hive`. **Trae rupturas de

package/README.md

@@ -271,4 +271,4 @@ npm view @johpaz/hive-sdk dist-tags   # verificar después del release
 
 ---
 
-*Hive SDK v0.4.7 — MIT*
+*Hive SDK v0.4.9 — MIT*

package/docs/API-TOOLS-SKILLS-CHANNELS.md

@@ -353,6 +353,7 @@ await manager.initialize();
 import {
   TelegramChannel,
   DiscordChannel,
+  WhatsAppCloudChannel,
   WhatsAppChannel,
   SlackChannel,
   WebChatChannel,
@@ -364,8 +365,20 @@ const telegram = new TelegramChannel({ botToken: process.env.TELEGRAM_BOT_TOKEN!
 // Discord
 const discord = new DiscordChannel({ botToken: process.env.DISCORD_BOT_TOKEN! });
 
-// WhatsApp
-const whatsapp = new WhatsAppChannel();
+// WhatsApp por la API oficial de Meta — el camino para un negocio
+const whatsapp = new WhatsAppCloudChannel({
+  enabled: true,
+  accountId: "ventas",
+  phoneNumberId: process.env.WHATSAPP_PHONE_NUMBER_ID!,
+  accessToken: process.env.WHATSAPP_ACCESS_TOKEN!,
+  appSecret: process.env.WHATSAPP_APP_SECRET!,
+  verifyToken: process.env.WHATSAPP_VERIFY_TOKEN!,
+  dmPolicy: "open",
+  allowFrom: [],
+});
+
+// WhatsApp por código QR (Baileys). No es oficial: uso personal.
+const whatsappQr = new WhatsAppChannel();
 
 // Slack
 const slack = new SlackChannel({ botToken: process.env.SLACK_BOT_TOKEN! });
@@ -374,6 +387,45 @@ const slack = new SlackChannel({ botToken: process.env.SLACK_BOT_TOKEN! });
 const webchat = new WebChatChannel();
 ```
 
+### WhatsApp: cuál de los dos
+
+| | `whatsapp_cloud` | `whatsapp` |
+|---|---|---|
+| Qué es | La API oficial de Meta (Cloud API) | Baileys, WhatsApp Web por código QR |
+| Para quién | Un negocio: número de WhatsApp Business propio, plantillas de marketing y atribución de los anuncios que abren la conversación | Uso personal |
+| Riesgo | Ninguno: es el camino soportado | Va contra los términos de WhatsApp; el número puede terminar bloqueado |
+| Cómo recibe | Webhook: hace falta una URL HTTPS pública | Conexión propia, sin URL pública |
+
+El canal oficial no abre ninguna conexión: Meta empuja los mensajes a una URL.
+El gateway la sirve en `/webhooks/whatsapp-cloud/<cuenta>` si se le pasa el
+manager, y esa es la que se registra en el panel de Meta junto con el
+`verifyToken`.
+
+```typescript
+const channelManager = new ChannelManager(await loadConfig());
+await channelManager.initialize();
+
+// Sin esto, el gateway no tiene a quién entregarle lo que manda Meta.
+await startGateway({ channelManager });
+```
+
+Tres cosas que conviene saber antes de ponerlo en producción:
+
+- **La ventana de 24 h.** Pasado ese tiempo desde el último mensaje del cliente,
+  Meta sólo acepta plantillas aprobadas (error 131047). Con
+  `windowFallbackTemplate` el canal manda esa plantilla; sin ella, lanza un
+  error que lo explica en vez de fallar en silencio.
+- **Cada mensaje se cobra.** Desde el 1 de octubre de 2026 los mensajes de
+  servicio dentro de la ventana también se pagan, así que la narración de
+  progreso del agente no se envía salvo que se encienda `sendProgress`. En su
+  lugar se renueva el "escribiendo…", que es gratis.
+- **4096 caracteres por mensaje.** El cliente parte las respuestas largas solo,
+  cortando entre párrafos.
+
+La versión del Graph sale de `META_GRAPH_API_VERSION` (por defecto la estable
+más reciente). Conviene fijarla a conciencia: cada versión caduca a los ~2 años
+y Meta redirige las llamadas a la más vieja que siga viva, sin avisar.
+
 ---
 
 ## Tool Runtime
@@ -483,6 +535,33 @@ const skills = await selectSkills("investigar en la web");
 Una tool declarada con `defineTool` y pasada a `createAgent` queda indexada
 automáticamente, así que el modelo puede descubrirla igual que a las nativas.
 
+### Catálogo compartido entre inquilinos
+
+En un host multi-inquilino (varios enjambres en una sola HiveDB, ver
+`runInTenant`) el catálogo —`tools`, `skills` y `ethics`— es contenido de la
+INSTALACIÓN, no de cada inquilino: su contenido se instala una sola vez en la
+colección sin prefijo, y cada inquilino guarda únicamente lo que activó.
+
+```typescript
+import { col, runInTenant, setCatalogActivation } from "@johpaz/hive-sdk";
+
+// Sin inquilino: esto instala el catálogo, una vez para todos.
+await ensureHiveDb();
+
+await runInTenant(tenantKey, async () => {
+  const tools = await col<ToolDoc>("tools");
+  await tools.scan({});                              // ve el catálogo entero
+
+  // Encender una tool para ESTE inquilino: guarda su elección, no una copia.
+  await setCatalogActivation("tools", "web_search", { active: true });
+});
+```
+
+Lo que el inquilino crea —la tool de un endpoint de API, una skill propia— se
+escribe en su partición y no lo ve nadie más. Editar el contenido de una fila del
+catálogo deja una copia privada; borrarla la oculta sólo para él. Sin inquilino
+en scope nada de esto se activa y `col()` se comporta como siempre.
+
 ---
 
 ## Config

package/docs/SECURITY-GUARDRAILS.md

@@ -14,13 +14,33 @@ de proceso.
 - SheetJS CE se instala desde la distribución oficial 0.20.3; el paquete npm
   abandonado en 0.18.5 no forma parte del grafo.
 - Baileys está fijado exactamente en `7.0.0-rc14` para evitar retroceder a una
-  release candidate vulnerable.
+  release candidate vulnerable. Además se **carga bajo demanda**: entra en el
+  proceso sólo si alguien conecta el canal `whatsapp` por código QR. Un
+  consumidor que no lo use —hive-cloud, por ejemplo, que usa el canal oficial—
+  no carga su grafo ni su parche de `process.stderr.write`.
 - PptxGenJS 4.0.1 se conserva como artefacto ESM vendorizado, con licencia,
   procedencia y SHA-256. No se instala su dependencia muerta `image-size`.
 
 Toda actualización del artefacto PPTX debe verificar su origen y hash, ejecutar
 la prueba OOXML y volver a ejecutar el audit.
 
+## Webhooks de WhatsApp (Cloud API)
+
+El canal `whatsapp_cloud` recibe por una URL pública, así que todo lo que llega
+es no confiable hasta comprobar dos cosas:
+
+- **La firma.** `verifySignature` recalcula el HMAC-SHA256 del cuerpo **crudo**
+  con el secreto de la app de Meta y lo compara con `X-Hub-Signature-256`
+  usando `timingSafeEqual`. Sin cabecera, sin secreto o con una firma que no
+  coincide, el webhook responde 401 y no se procesa nada. El cuerpo se lee como
+  texto antes de parsearlo: firmar el JSON reserializado daría distinto.
+- **El token de verificación.** El `hub.verify_token` del alta se compara
+  también con `timingSafeEqual`; si no coincide, 403.
+
+El canal además sólo atiende eventos de su propio `phone_number_id` —una misma
+cuenta de WhatsApp Business puede tener varios números apuntando a la misma
+URL— y descarta por id los reintentos de Meta.
+
 ## Archivos PDF
 
 Antes de leer un PDF, `office_leer_pdf` exige un archivo regular y limita el

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-sdk",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "private": false,
   "description": "Hive SDK — The Agent Harness SDK. Build, deploy, and scale AI agent applications with multi-channel support, context engineering, and swarm orchestration.",
   "license": "MIT",

package/packages/cli/templates/hive-app/hive.config.ts

@@ -16,6 +16,13 @@ export default {
     webchat: { enabled: true },
     telegram: { enabled: false },
     discord: { enabled: false },
+    // WhatsApp por la API oficial de Meta. Es el camino para un negocio:
+    // número propio de WhatsApp Business, plantillas y atribución de los
+    // anuncios que abren la conversación. Recibe por webhook, así que hace
+    // falta exponer `/webhooks/whatsapp-cloud/<cuenta>` con HTTPS público.
+    whatsapp_cloud: { enabled: false },
+    // WhatsApp por código QR (Baileys). No es oficial: sirve para uso
+    // personal, no para un negocio, y el número puede terminar bloqueado.
     whatsapp: { enabled: false },
     slack: { enabled: false },
   },

package/packages/cli/templates/hive-app/src/main.ts

@@ -31,6 +31,9 @@ async function main() {
     host: config.gateway?.host,
     port: config.gateway?.port,
     agentId: coordinatorAgent.id,
+    // Los canales que reciben por webhook —WhatsApp por la API oficial de
+    // Meta— entran por el gateway, así que necesita el manager.
+    channelManager,
   });
 
   log.info(`{{APP_NAME}} is running at http://${gateway.hostname}:${gateway.port}`);

package/packages/core/src/agent/agent-loop.ts

@@ -357,12 +357,20 @@ export async function* runAgent(
       channel: opts.channel,
       source: opts.historySource ?? "message",
     })
-    // Run compaction if conversation history is getting large
+    // Run compaction if conversation history is getting large.
+    // El modelo del turno viaja con sus credenciales: el resumen es una llamada
+    // al modelo como cualquier otra y tiene que cobrarse a la misma cuenta.
     await maybeCompact(
       opts.threadId,
       opts.channel && opts.userId
         ? { channel: opts.channel, userId: opts.userId }
-        : undefined
+        : undefined,
+      {
+        provider: providerCfg.provider,
+        model: providerCfg.model,
+        credentials: opts.credentials,
+        contextWindow: providerCfg.contextWindow,
+      }
     )
   }
 

package/packages/core/src/agent/capability-search.ts

@@ -21,10 +21,27 @@
 import type { IndexDoc } from "@johpaz/hive-db";
 import { getHiveDb } from "../storage/hivedb.ts";
 import { currentTenant, qualifyDocId, unqualifyDocId, scopedFilterValue } from "../storage/tenant.ts";
+import { listCatalogActivations } from "../storage/catalog.ts";
 import { logger } from "../utils/logger.ts";
 
 const log = logger.child("capability-search");
 
+/**
+ * Ámbito de los documentos que no son de ningún inquilino: el catálogo.
+ *
+ * Es el mismo `"_"` que `scopedFilterValue()` usa cuando no hay tenant, y por
+ * eso sirve de las dos maneras: como valor del filtro `tenant` para poder
+ * BUSCAR el catálogo desde dentro de un inquilino, y como parte de
+ * `tenant__type` para que un reindexado del catálogo BORRE sólo lo suyo.
+ *
+ * Antes el catálogo se indexaba sin filtro `tenant` alguno, y eso rompía las dos
+ * cosas: desde un enjambre la búsqueda filtraba por su tenant y no encontraba
+ * NADA del catálogo —ni una tool, ni una skill—, y un reindexado desde fuera
+ * borraba por `type` a secas, llevándose por delante los documentos de todos los
+ * inquilinos (las tools de sus endpoints, sus tools de MCP).
+ */
+const CATALOGO = "_";
+
 export type CapabilityType = "tool" | "skill" | "playbook" | "mcp" | "agent";
 
 export interface CapabilityHit {
@@ -91,17 +108,22 @@ export async function searchCapabilities(
   // type; the single-type and all-types cases are one engine call.
   //
   // El índice semántico es UNO solo para todos los inquilinos (no hay
-  // "colección" que prefijar), así que el tenant entra como un filtro más que
-  // el motor AND-ea con el resto. Sin tenant no se añade nada: así un índice ya
-  // construido por la app de escritorio sigue respondiendo igual.
+  // "colección" que prefijar), así que el ámbito entra como un filtro más que el
+  // motor AND-ea con el resto.
+  //
+  // Con inquilino activo se consulta DOS veces: lo suyo —las tools de sus
+  // endpoints, sus tools de MCP— y el catálogo compartido, que se instala una
+  // sola vez y es de todos (ver storage/catalog.ts). Sin inquilino se consulta
+  // sin filtro de ámbito: una instalación local tiene una sola partición y así
+  // un índice ya construido sigue respondiendo igual.
   const tenant = currentTenant();
-  const tenantFilter = tenant ? [{ field: "tenant", value: tenant }] : [];
-  const queries = types
-    ? types.map((t) => ({
-        type: t,
-        filters: [...tenantFilter, { field: "type", value: t }],
-      }))
-    : [{ type: undefined, filters: tenantFilter.length ? tenantFilter : undefined }];
+  const ambitos = tenant ? [tenant, CATALOGO] : [null];
+  const queries = ambitos.flatMap((ambito) => {
+    const filtroAmbito = ambito ? [{ field: "tenant", value: ambito }] : [];
+    return types
+      ? types.map((t) => ({ filters: [...filtroAmbito, { field: "type", value: t }] }))
+      : [{ filters: filtroAmbito.length ? filtroAmbito : undefined }];
+  });
 
   const merged = new Map<string, CapabilityHit>();
   for (const q of queries) {
@@ -129,7 +151,10 @@ export async function searchCapabilities(
     }
   }
 
+  const apagados = tenant && merged.size > 0 ? await apagadosParaElInquilino() : null;
+
   const results = Array.from(merged.values())
+    .filter((hit) => !apagados?.has(hit.id))
     .sort((a, b) => b.score - a.score)
     .slice(0, k);
 
@@ -140,6 +165,27 @@ export async function searchCapabilities(
   return results;
 }
 
+/**
+ * Lo que este inquilino apagó del catálogo compartido.
+ *
+ * El índice del catálogo es uno solo, así que no puede llevar la elección de
+ * nadie: se filtra al leer. Sólo se descarta lo que el inquilino decidió
+ * explícitamente —apagar u ocultar—; lo que nunca tocó hereda lo que diga el
+ * catálogo, igual que en la colección (ver storage/catalog.ts).
+ *
+ * Ofrecerle al modelo una capacidad que su workspace apagó es hacerle perder un
+ * turno, además de contarle que existe algo que no puede usar.
+ */
+async function apagadosParaElInquilino(): Promise<Set<string>> {
+  const apagados = new Set<string>();
+  for (const [tipo, coleccion] of [["tool", "tools"], ["skill", "skills"]] as const) {
+    for (const eleccion of await listCatalogActivations(coleccion)) {
+      if (!eleccion.active || eleccion.hidden) apagados.add(`${tipo}:${eleccion.itemId}`);
+    }
+  }
+  return apagados;
+}
+
 /**
  * Keep only hits scoring at least `ratio` of the top hit. This replaces the
  * old absolute negative-bm25 thresholds: relevance is relative to the best
@@ -169,12 +215,12 @@ export async function replaceCapabilityDocs(
   // `deleteByFilter` acepta UN SOLO filtro, así que en una base compartida
   // borrar por `type` se llevaría por delante los documentos de todos los
   // inquilinos. El campo sintético `tenant__type` (ver scopedFilterValue)
-  // mantiene el borrado en un filtro y acotado a este tenant.
-  await db.deleteByFilter(
-    currentTenant()
-      ? { field: "tenant__type", value: scopedFilterValue(type) }
-      : { field: "type", value: type }
-  );
+  // mantiene el borrado en un filtro y acotado a un ámbito.
+  //
+  // Sin inquilino el ámbito es el catálogo (`_`), no "todo": reindexar el
+  // catálogo al arrancar borraba las tools de los endpoints y las de MCP de cada
+  // inquilino, que nadie volvía a escribir hasta que ese enjambre se reconectara.
+  await db.deleteByFilter({ field: "tenant__type", value: scopedFilterValue(type) });
   if (docs.length === 0) return;
   await db.upsertBatch(docs.map(toIndexDoc));
 }
@@ -198,7 +244,6 @@ export async function deleteCapabilitiesByServer(serverId: string): Promise<void
 
 function toIndexDoc(doc: CapabilityDoc): IndexDoc {
   const extra = doc.extraFilters ?? [];
-  const tenant = currentTenant();
   return {
     id: qualifyDocId(`${doc.type}:${doc.rawId}`),
     name: doc.name,
@@ -207,20 +252,16 @@ function toIndexDoc(doc: CapabilityDoc): IndexDoc {
     filters: [
       { field: "type", value: doc.type },
       ...extra,
-      // Con tenant activo, cada filtro lleva además un gemelo `tenant__<campo>`.
-      // Es lo que permite que los borrados masivos —que sólo aceptan un
-      // filtro— sigan acotados a este inquilino. Sin tenant no se emite nada,
-      // así que un índice ya construido conserva exactamente su forma.
-      ...(tenant
-        ? [
-            { field: "tenant", value: tenant },
-            { field: "tenant__type", value: scopedFilterValue(doc.type) },
-            ...extra.map((f) => ({
-              field: `tenant__${f.field}`,
-              value: scopedFilterValue(f.value),
-            })),
-          ]
-        : []),
+      // Todo documento declara su ámbito —el inquilino que lo escribió, o `_` si
+      // es del catálogo—, y cada filtro lleva además su gemelo
+      // `tenant__<campo>`. Con eso la búsqueda puede pedir un ámbito concreto y
+      // los borrados masivos —que aceptan un solo filtro— quedan acotados a él.
+      { field: "tenant", value: currentTenant() ?? CATALOGO },
+      { field: "tenant__type", value: scopedFilterValue(doc.type) },
+      ...extra.map((f) => ({
+        field: `tenant__${f.field}`,
+        value: scopedFilterValue(f.value),
+      })),
     ],
   };
 }

package/packages/core/src/agent/compaction.ts

@@ -26,7 +26,10 @@ import {
   type StoredMessage,
 } from "./conversation-store.ts"
 import { estimateTokens } from "../utils/toon.ts"
-import { callLLM, resolveProviderConfig, getDefaultLLM, type ContentPart } from "./llm-client.ts"
+import {
+  callLLM, resolveProviderConfig, getDefaultLLM,
+  type ContentPart, type ProviderCredentials,
+} from "./llm-client.ts"
 import { col, fromIndexable } from "../storage/hive.ts"
 import type { AgentDoc, ModelDoc } from "../storage/collections.ts"
 import { loadConfig } from "../config/loader.ts"
@@ -41,6 +44,61 @@ const KEEP_LAST_N_MESSAGES = 5         // always keep most recent N messages
 const TOOL_RESULT_MAX_CHARS = 200      // max chars for old tool results after clearing
 const MAX_TRANSCRIPT_MSGS = 30         // cap messages sent to summarizer (avoids OOM on small models)
 const MAX_MSG_CHARS = 300              // chars per message in transcript
+/** Ventana asumida cuando no se conoce la del modelo: `COMPACT_TOKEN_THRESHOLD` es su 25 %. */
+const ASSUMED_CONTEXT_WINDOW = 128_000
+const DEFAULT_CONTEXT_RATIO = 0.25
+
+/**
+ * El modelo con el que se pide el resumen: el del turno que disparó la
+ * compactación, con SUS credenciales.
+ */
+export interface CompactionLLM {
+  provider?: string
+  model?: string
+  /** En multi-inquilino, la llave del cliente. Sin esto se usaría una global. */
+  credentials?: ProviderCredentials
+  /** La ventana del modelo, si quien llama ya la resolvió. */
+  contextWindow?: number
+}
+
+/**
+ * A partir de cuántos tokens de historial se compacta.
+ *
+ * `agent.context.compactionThreshold` es una PROPORCIÓN de la ventana del
+ * modelo —su valor por defecto es 0.8, o sea el 80 %—, pero se leía como si
+ * fueran tokens. Con la configuración por defecto el umbral quedaba en 0.8
+ * tokens: cualquier hilo con más de cinco mensajes se resumía en cada turno,
+ * pagando una llamada extra al modelo y reemplazando el historial por un
+ * resumen desde el primer intercambio. Un valor mayor que 1 se sigue leyendo
+ * como tokens, que es lo que espera quien fijó un número absoluto.
+ */
+export function resolveCompactionThreshold(configured: number | undefined, contextWindow?: number): number {
+  const known = contextWindow && contextWindow > 0 ? contextWindow : undefined
+  if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+    return configured <= 1
+      ? Math.floor((known ?? ASSUMED_CONTEXT_WINDOW) * configured)
+      : Math.floor(configured)
+  }
+  return known ? Math.floor(known * DEFAULT_CONTEXT_RATIO) : COMPACT_TOKEN_THRESHOLD
+}
+
+/** La ventana del modelo del turno; si no se sabe cuál es, la del coordinador. */
+async function modelContextWindow(modelId?: string): Promise<number | undefined> {
+  try {
+    const modelsCol = await col<ModelDoc>("models")
+    if (modelId) return (await modelsCol.get(modelId))?.doc.context_window || undefined
+    const agentsCol = await col<AgentDoc>("agents")
+    const coordinators = await agentsCol.findBy("role", "coordinator", { limit: 1 })
+    // El id se busca completo: recortar el primer segmento rompía cualquier
+    // modelo cuyo nombre lleve barra (meta/llama-3.3-70b-instruct buscaba
+    // "llama-3.3-70b-instruct", no encontraba nada y caía al default).
+    const id = fromIndexable(coordinators[0]?.doc.model_id ?? null)
+    if (!id) return undefined
+    return (await modelsCol.get(id))?.doc.context_window || undefined
+  } catch {
+    return undefined
+  }
+}
 
 /**
  * Check if compaction is needed and run it if so.
@@ -48,37 +106,16 @@ const MAX_MSG_CHARS = 300              // chars per message in transcript
  */
 export async function maybeCompact(
   threadId: string,
-  notify?: { channel: string; userId: string }
+  notify?: { channel: string; userId: string },
+  llm?: CompactionLLM
 ): Promise<void> {
   try {
     const totalTokens = await getTotalTokens(threadId)
-
-    // Orden de precedencia: lo que el usuario configuró gana sobre lo que se
-    // deduce del modelo, y eso gana sobre la constante.
-    //
-    // `agent.context.compactionThreshold` estaba en el esquema de configuración
-    // y **no lo leía nadie**: alguien podía ajustarlo y no pasaba nada. Una
-    // opción que no hace nada es peor que no tenerla, porque el usuario cree
-    // que cambió algo.
-    let effectiveThreshold = COMPACT_TOKEN_THRESHOLD
-    const configurado = loadConfig().agent?.context?.compactionThreshold
-    try {
-      const agentsCol = await col<AgentDoc>("agents")
-      const coordinators = await agentsCol.findBy("role", "coordinator", { limit: 1 })
-      const modelId = fromIndexable(coordinators[0]?.doc.model_id ?? null)
-      if (modelId) {
-        const modelsCol = await col<ModelDoc>("models")
-        // El id se busca completo: recortar el primer segmento rompía cualquier
-        // modelo cuyo nombre lleve barra (meta/llama-3.3-70b-instruct buscaba
-        // "llama-3.3-70b-instruct", no encontraba nada y caía al default).
-        const modelEntry = await modelsCol.get(modelId)
-        if (modelEntry?.doc.context_window) {
-          effectiveThreshold = Math.floor(modelEntry.doc.context_window * 0.25)
-        }
-      }
-    } catch { /* use default threshold */ }
-
-    if (configurado && configurado > 0) effectiveThreshold = configurado
+    const contextWindow = llm?.contextWindow ?? (await modelContextWindow(llm?.model))
+    const effectiveThreshold = resolveCompactionThreshold(
+      loadConfig().agent?.context?.compactionThreshold,
+      contextWindow,
+    )
 
     if (totalTokens < effectiveThreshold) return
 
@@ -96,8 +133,8 @@ export async function maybeCompact(
     // Already summarized up to near the current state
     if (summary && summary.last_message_id > totalMessages - KEEP_LAST_N_MESSAGES) return
 
-    log.info(`[compaction] Compacting thread=${threadId} tokens=${totalTokens}`)
-    await compactThread(threadId, notify)
+    log.info(`[compaction] Compacting thread=${threadId} tokens=${totalTokens} threshold=${effectiveThreshold}`)
+    await compactThread(threadId, notify, llm)
   } catch (err) {
     log.warn("[compaction] Error during compaction check:", err)
   }
@@ -139,7 +176,8 @@ export function renderTranscript(rows: StoredMessage[], maxMsgChars = MAX_MSG_CH
  */
 export async function compactThread(
   threadId: string,
-  notify?: { channel: string; userId: string }
+  notify?: { channel: string; userId: string },
+  llm?: CompactionLLM
 ): Promise<void> {
   const allMessages = await getHistory(threadId)
   if (allMessages.length <= KEEP_LAST_N_MESSAGES) return
@@ -162,10 +200,18 @@ export async function compactThread(
   const capped = toSummarize.slice(-MAX_TRANSCRIPT_MSGS)
   const transcript = renderTranscript(capped)
 
-  const defaultLLM = await getDefaultLLM()
-  if (!defaultLLM) throw new Error("No active LLM providers/models configured in the database")
+  // El modelo del turno y SUS credenciales. Antes el resumen se pedía siempre
+  // con `getDefaultLLM()` y sin credenciales, así que `resolveProviderConfig`
+  // caía al secret store, al llavero del sistema o al entorno: en una
+  // instalación multi-inquilino eso resume la conversación de un cliente con
+  // la llave de la plataforma (o de otro cliente). Sin `llm` se comporta como
+  // antes, que es lo que necesita una instalación de un solo usuario.
+  const target = llm?.provider && llm.model
+    ? { provider: llm.provider, model: llm.model }
+    : await getDefaultLLM()
+  if (!target) throw new Error("No active LLM providers/models configured in the database")
 
-  const providerCfg = await resolveProviderConfig(defaultLLM.provider, defaultLLM.model)
+  const providerCfg = await resolveProviderConfig(target.provider, target.model, llm?.credentials)
 
   const summaryResponse = await callLLM({
     ...providerCfg,

package/packages/core/src/channels/index.ts

@@ -3,5 +3,6 @@ export * from "./telegram.ts";
 export * from "./discord.ts";
 export * from "./webchat.ts";
 export * from "./whatsapp.ts";
+export * from "./whatsapp-cloud/index.ts";
 export * from "./slack.ts";
 export * from "./manager.ts";