@7ots/cli 0.1.0

package/server/platform/routes.mjs

@@ -0,0 +1,388 @@
+/**
+ * Rutas de la plataforma 7ots.com (PLATFORM=true).
+ *
+ * Públicas, una API de agente por ots (el widget las llama igual que /api/agent/*):
+ *   GET  /api/o/:id/config · /embed.js · /identity · /identity.vcf     (cualquier origen)
+ *   POST /api/o/:id/chat · /tts · /identity/call · /contact/*          (solo desde sus dominios)
+ *
+ * Dashboard (sesión de /auth/*; escrituras con X-7ots-Admin: 1 y mismo origen):
+ *   GET    /api/platform/me
+ *   GET    /api/platform/ots                 POST (crear)
+ *   GET    /api/platform/ots/:id             PATCH { name, status, domains } · DELETE
+ *   POST   /api/platform/ots/:id/duplicate
+ *   GET    /api/platform/ots/:id/conversations[?before]   GET|DELETE …/conversations/:cid
+ *   GET    /api/platform/ots/:id/usage
+ *   *      /api/platform/ots/:id/admin/*     misma forma que /api/agent/admin/* (el backoffice
+ *                                            edita un ots con ?ots=<id>)
+ */
+
+import { MEET_AVATARS, MEET_SCENES, OPENAI_VOICES, GROK_VOICES, defineIdentity, identityPrompt, publicIdentity, toVCard } from '../identity.mjs';
+import { errorText, reqT, requestLocale } from '../i18n.mjs';
+import { monthOf } from './db.mjs';
+import { randomIdentity, cleanSeed } from '../../src/identity/random.js';
+import { currentAccount } from './auth.mjs';
+import {
+  OTS_KEYS, MAX_OTS_PER_ACCOUNT, accountUsage, addUsage, cleanDomains, countOts, createOts, deleteConversation, deleteOts, duplicateOts,
+  getConversation, getOts, getOwnOts, listConversations, listOts, logTurn, originAllowed, publicAccount, updateOts, usageByOts, usageHistory,
+} from './store.mjs';
+import { freeMessages, freeTts, otsChannels, otsEnv, otsLlmInfo, otsStep, otsSynthesize, otsTtsProvider, stopOtsChannels } from './runtime.mjs';
+import '../../src/i18n/messages/platform.js';
+
+const penv = process.env;
+const OTS_RATE = () => Number(penv.PLATFORM_OTS_RATE_PER_MIN || 120);
+
+/**
+ * @param {object} deps  helpers HTTP de server.mjs
+ */
+export function createPlatform({ send, readJson, rateLimit, callLimit, originOf, embedScript, bundleVersion, relay, sendApumail, startApuchat }) {
+  const selfOrigins = (req) => new Set([originOf(req), penv.PLATFORM_URL && new URL(penv.PLATFORM_URL).origin].filter(Boolean));
+
+  // ───────────────────────────── API pública de cada ots ─────────────────────────────
+
+  const otsBuckets = new Map();
+  function otsRate(id) {
+    const now = Date.now();
+    const rate = OTS_RATE();
+    const b = otsBuckets.get(id) || { tokens: rate, at: now };
+    b.tokens = Math.min(rate, b.tokens + ((now - b.at) / 60000) * rate);
+    b.at = now;
+    if (b.tokens < 1) return false;
+    b.tokens -= 1;
+    otsBuckets.set(id, b);
+    if (otsBuckets.size > 10000) otsBuckets.clear();
+    return true;
+  }
+
+  function otsCors(req, res, ots) {
+    const origin = req.headers.origin;
+    if (!origin) return false; // el widget siempre manda Origin; sin él no se sirve la IA
+    if (!selfOrigins(req).has(origin) && !originAllowed(ots, origin)) return false;
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    res.setHeader('Vary', 'Origin');
+    res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Site-Key, Accept, Accept-Language');
+    res.setHeader('Access-Control-Max-Age', '600');
+    return true;
+  }
+
+  async function publicApi(req, res, id, path) {
+    const t = reqT(req);
+    const ots = getOts(id);
+    const open = ['/config', '/embed.js', '/identity', '/identity.vcf'].includes(path);
+    if (open) {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      if (req.method === 'OPTIONS') return send(res, 204);
+      if (req.method !== 'GET' && req.method !== 'HEAD') return send(res, 405, { error: t('server.http.methodNotAllowed') });
+      if (!ots) return send(res, 404, { error: t('platform.api.notFound') });
+      if (path === '/config') return send(res, 200, ots.widget);
+      if (path === '/embed.js') {
+        res.writeHead(200, { 'Content-Type': 'text/javascript; charset=utf-8', 'Cache-Control': 'no-cache' });
+        if (ots.status !== 'on') return res.end('/* 7ots: ots en pausa */');
+        return res.end(embedScript(ots.widget, await bundleVersion(), `/api/o/${ots.id}`));
+      }
+      const card = publicIdentity(ots.identity, otsChannels(ots).live());
+      if (path === '/identity.vcf') {
+        res.writeHead(200, { 'Content-Type': 'text/vcard; charset=utf-8', 'Content-Disposition': `inline; filename="${card.id}.vcf"`, 'Cache-Control': 'no-cache' });
+        return res.end(toVCard(card, { baseUrl: `${originOf(req)}/api/o/${ots.id}/identity.vcf` }));
+      }
+      return send(res, 200, card);
+    }
+
+    if (!ots) return send(res, 404, { error: t('platform.api.notFound') });
+    if (!otsCors(req, res, ots)) return send(res, 403, { error: t('platform.api.originNotAllowed') });
+    if (req.method === 'OPTIONS') return send(res, 204);
+    if (req.method !== 'POST') return send(res, 405, { error: t('server.http.methodNotAllowed') });
+    if (ots.status !== 'on') return send(res, 403, { error: t('platform.api.paused') });
+    if (!rateLimit(req)) return send(res, 429, { error: t('server.http.rateLimited') });
+    if (!otsRate(ots.id)) return send(res, 429, { error: t('platform.api.otsRateLimited') });
+
+    if (path === '/chat') {
+      const { system, messages, tools = [], session } = await readJson(req, 1024 * 1024);
+      if (typeof system !== 'string' || !Array.isArray(messages) || !messages.length || !Array.isArray(tools)) return send(res, 400, { error: t('server.http.badRequest') });
+      if (messages.length > 300 || tools.length > 128 || system.length > 30000) return send(res, 413, { error: t('server.http.tooLarge') });
+      const pre = [ots.settings.SERVER_INSTRUCTIONS, identityPrompt(ots.identity)].filter(Boolean).join('\n\n');
+      let out;
+      try {
+        out = await otsStep(ots, { system: `${pre}\n\n${system}`, messages, tools, locale: requestLocale(req) });
+      } catch (e) {
+        // Sin cupo: el visitante ve un aviso normal en el chat, no un error.
+        if (e.status !== 402) throw e;
+        out = { text: errorText(e, t), toolCalls: [], finishReason: 'quota', provider: '7ots' };
+      }
+      const last = messages[messages.length - 1];
+      const key = typeof session === 'string' && /^[\w-]{8,64}$/.test(session) ? session : null;
+      if (key) {
+        const seen = last?.role === 'user' ? visibleTurn(last.content) : { text: '', page: '' };
+        const { created } = logTurn(ots, { key, page: seen.page, origin: req.headers.origin || '', user: seen.text, reply: out.text || '' });
+        if (created) addUsage(ots, 'conversation');
+      }
+      return send(res, 200, out);
+    }
+
+    if (path === '/tts') {
+      const { text } = await readJson(req, 16 * 1024);
+      const { audio, contentType } = await otsSynthesize(ots, { text });
+      res.writeHead(200, { 'Content-Type': contentType, 'Content-Length': audio.length, 'Cache-Control': 'no-store' });
+      return res.end(audio);
+    }
+
+    if (path === '/identity/call') {
+      if (!callLimit(req)) return send(res, 429, { error: t('server.http.callLimited') });
+      const { motivo } = await readJson(req, 4 * 1024);
+      const call = await otsChannels(ots).openCall({ reason: String(motivo || '').slice(0, 200) });
+      addUsage(ots, 'call');
+      return send(res, 200, { call_url: call.call_url, expires_at: call.expires_at });
+    }
+
+    const { env } = otsEnv(ots);
+    if (path === '/contact/apumail') return send(res, 200, await sendApumail(await readJson(req, 128 * 1024), env));
+    if (path === '/contact/apuchat') return send(res, 200, await startApuchat(await readJson(req, 128 * 1024), env));
+    if (path === '/contact/apuchat/send') return send(res, 200, await relay.relaySend(await readJson(req, 16 * 1024)));
+    if (path === '/contact/apuchat/wait') return send(res, 200, await relay.relayWait(await readJson(req, 4 * 1024)));
+    if (path === '/contact/apuchat/end') return send(res, 200, await relay.relayEnd(await readJson(req, 4 * 1024)));
+    send(res, 404, { error: t('server.http.unknownRoute') });
+  }
+
+  // ───────────────────────────── dashboard ─────────────────────────────
+
+  function otsSummary(ots, usage = {}) {
+    const llm = otsLlmInfo(ots);
+    return {
+      id: ots.id,
+      name: ots.name,
+      status: ots.status,
+      domains: ots.domains,
+      identity: { name: ots.identity.name, role: ots.identity.role, look: ots.identity.look },
+      llm: `${llm.name}:${llm.model}`,
+      platformLlm: llm.platform,
+      tts: otsTtsProvider(ots),
+      usage,
+      createdAt: ots.createdAt,
+      updatedAt: ots.updatedAt,
+    };
+  }
+
+  /** Vista de ajustes con la forma de serverView() (el backoffice la pinta igual). */
+  function serverViewOf(ots) {
+    const values = {};
+    const secrets = {};
+    for (const [k, meta] of Object.entries(OTS_KEYS)) {
+      if (meta.secret) secrets[k] = { set: !!ots.secrets[k], source: ots.secrets[k] ? 'backoffice' : null, restart: false };
+      else values[k] = { value: ots.settings[k] ?? '', source: ots.settings[k] != null ? 'backoffice' : null, restart: false };
+    }
+    return { values, secrets };
+  }
+
+  function statusOf(ots) {
+    const ch = otsChannels(ots);
+    const { env, platformLlm, platformTts } = otsEnv(ots);
+    const llm = otsLlmInfo(ots);
+    return {
+      llm: `${llm.name}:${llm.model}`,
+      tts: otsTtsProvider(ots),
+      platform: { llm: platformLlm, tts: platformTts },
+      channels: ch.status(),
+      live: ch.live(),
+      contact: {
+        apumail: !!(env.APUMAIL_INBOX && env.APUMAIL_INBOX_TOKEN && env.APUMAIL_TO),
+        apuchatOperator: !!(env.APUCHAT_NOTIFIER_IDENTITY_KEY && env.APUCHAT_OPERATOR_HANDLE),
+      },
+    };
+  }
+
+  /** Guarda un ots y arranca/para sus canales según haga falta. */
+  async function save(ots, patch) {
+    const next = updateOts(ots.id, patch);
+    if (next.status !== 'on') await stopOtsChannels(next.id);
+    else otsChannels(next); // reinicia solo si cambió su configuración de canales
+    return next;
+  }
+
+  async function adminApi(req, res, ots, route) {
+    const t = reqT(req);
+    if (route === '/session' && req.method === 'GET') return send(res, 200, { authed: true, mode: 'platform' });
+    if (route === '/login' || route === '/logout') return send(res, 400, { error: t('platform.api.login') });
+    if (route === '/state' && req.method === 'GET') {
+      return send(res, 200, {
+        ots: otsSummary(ots),
+        identity: ots.identity,
+        widget: ots.widget,
+        server: serverViewOf(ots),
+        status: statusOf(ots),
+        options: { meetAvatars: MEET_AVATARS, meetScenes: MEET_SCENES, openaiVoices: OPENAI_VOICES, grokVoices: GROK_VOICES },
+      });
+    }
+    if (route === '/identity' && req.method === 'PUT') {
+      const identity = defineIdentity(await readJson(req, 256 * 1024), ots.identity);
+      return send(res, 200, { identity: (await save(ots, { identity })).identity });
+    }
+    if (route === '/widget' && req.method === 'PUT') {
+      const w = await readJson(req, 256 * 1024);
+      if (!w || typeof w !== 'object' || Array.isArray(w)) return send(res, 400, { error: t('server.admin.invalidWidget') });
+      return send(res, 200, { widget: (await save(ots, { widget: sanitizeWidget(w) })).widget });
+    }
+    if (route === '/server' && req.method === 'PUT') {
+      const { values = {}, secrets = {} } = await readJson(req, 256 * 1024);
+      const settings = { ...ots.settings };
+      const sec = { ...ots.secrets };
+      const changed = [];
+      for (const [k, v] of Object.entries(values || {})) {
+        const meta = OTS_KEYS[k];
+        if (!meta || meta.secret) continue;
+        const before = settings[k];
+        if (v === null || v === '') delete settings[k];
+        else settings[k] = String(v).slice(0, 20000);
+        if (before !== settings[k]) changed.push(k);
+      }
+      for (const [k, v] of Object.entries(secrets || {})) {
+        const meta = OTS_KEYS[k];
+        if (!meta?.secret || v === '') continue;
+        const before = sec[k];
+        if (v === null) delete sec[k];
+        else sec[k] = String(v).trim().slice(0, 4000);
+        if (before !== sec[k]) changed.push(k);
+      }
+      const next = await save(ots, { settings, secrets: sec });
+      return send(res, 200, { changed, channels: changed.some((k) => OTS_KEYS[k].channels), restart: [], server: serverViewOf(next), status: statusOf(next) });
+    }
+    if (route === '/test/llm' && req.method === 'POST') {
+      const t0 = Date.now();
+      try {
+        const out = await otsStep(ots, { system: t('server.admin.testSystem'), messages: [{ role: 'user', content: t('server.admin.testPrompt') }], tools: [], locale: requestLocale(req) });
+        const llm = otsLlmInfo(ots);
+        return send(res, 200, { ok: true, text: out.text, ms: Date.now() - t0, llm: `${llm.name}:${llm.model}` });
+      } catch (e) {
+        return send(res, 200, { ok: false, error: errorText(e, t).slice(0, 300), ms: Date.now() - t0 });
+      }
+    }
+    if (route === '/test/tts' && req.method === 'POST') {
+      const { text, voice } = await readJson(req, 16 * 1024);
+      const { audio, contentType } = await otsSynthesize(ots, { text: String(text || t('server.admin.ttsSample')).slice(0, 300), voice: voice || ots.identity.voice });
+      res.writeHead(200, { 'Content-Type': contentType, 'Content-Length': audio.length, 'Cache-Control': 'no-store' });
+      return res.end(audio);
+    }
+    if (route === '/status' && req.method === 'GET') return send(res, 200, statusOf(ots));
+    send(res, 404, { error: t('server.admin.unknownRoute') });
+  }
+
+  async function dashboardApi(req, res, path) {
+    const t = reqT(req);
+    const origin = req.headers.origin;
+    if (origin && !selfOrigins(req).has(origin)) return send(res, 403, { error: t('server.admin.sameOrigin') });
+    res.setHeader('X-Frame-Options', 'DENY');
+    if (req.method !== 'GET' && req.method !== 'HEAD' && req.headers['x-7ots-admin'] !== '1') return send(res, 403, { error: t('server.admin.missingHeader') });
+    const account = currentAccount(req);
+    if (!account) return send(res, 401, { error: t('platform.api.login') });
+
+    if (path === '/me' && req.method === 'GET') {
+      return send(res, 200, {
+        account: publicAccount(account),
+        limits: { maxOts: MAX_OTS_PER_ACCOUNT(), freeMessages: freeMessages(), freeTts: freeTts(), platformLlm: !!process.env.PLATFORM_ANTHROPIC_API_KEY },
+        usage: { month: monthOf(), llm_platform: accountUsage(account.id, 'llm_platform'), tts_platform: accountUsage(account.id, 'tts_platform') },
+      });
+    }
+
+    if (path === '/ots' && req.method === 'GET') {
+      const usage = usageByOts(account.id);
+      return send(res, 200, { ots: listOts(account.id).map((o) => otsSummary(o, usage[o.id] || {})) });
+    }
+    if (path === '/ots' && req.method === 'POST') {
+      if (countOts(account.id) >= MAX_OTS_PER_ACCOUNT()) return send(res, 403, { error: t('platform.api.tooManyOts', { max: MAX_OTS_PER_ACCOUNT() }) });
+      const { name, language, seed, otName } = await readJson(req, 16 * 1024);
+      const lang = ['es', 'en', 'pt'].includes(language) ? language : requestLocale(req);
+      // From the 7ots.com hero: the same ot the visitor just rolled (seed + optional name).
+      const rolled = cleanSeed(seed) ? randomIdentity(cleanSeed(seed), { lang, name: String(otName || '').trim().slice(0, 40) || undefined }) : null;
+      const identity = rolled ? { ...STARTER[lang], ...rolled } : { language: lang, voice: { lang: { es: 'es-ES', en: 'en-US', pt: 'pt-BR' }[lang] }, ...STARTER[lang] };
+      const ots = createOts(account.id, { name, identity });
+      return send(res, 201, { ots: otsSummary(ots) });
+    }
+
+    const m = path.match(/^\/ots\/([a-z0-9_]{4,40})(\/.*)?$/);
+    if (!m) return send(res, 404, { error: t('server.http.unknownRoute') });
+    const ots = getOwnOts(account.id, m[1]);
+    if (!ots) return send(res, 404, { error: t('platform.api.notFound') });
+    const sub = m[2] || '';
+
+    if (sub.startsWith('/admin/')) return adminApi(req, res, ots, sub.slice('/admin'.length));
+
+    if (sub === '' && req.method === 'GET') return send(res, 200, { ots: otsSummary(ots, usageByOts(account.id)[ots.id] || {}) });
+    if (sub === '' && req.method === 'PATCH') {
+      const body = await readJson(req, 16 * 1024);
+      const patch = {};
+      if (typeof body.name === 'string') patch.name = body.name;
+      if (body.status === 'on' || body.status === 'off') patch.status = body.status;
+      if (body.domains !== undefined) {
+        const list = Array.isArray(body.domains) ? body.domains : String(body.domains).split(/[\s,]+/).filter(Boolean);
+        patch.domains = cleanDomains(list);
+        if (patch.domains.length < list.length) return send(res, 400, { error: t('platform.api.badDomains') });
+      }
+      return send(res, 200, { ots: otsSummary(await save(ots, patch)) });
+    }
+    if (sub === '' && req.method === 'DELETE') {
+      await stopOtsChannels(ots.id);
+      deleteOts(ots.id);
+      return send(res, 200, { ok: true });
+    }
+    if (sub === '/duplicate' && req.method === 'POST') {
+      if (countOts(account.id) >= MAX_OTS_PER_ACCOUNT()) return send(res, 403, { error: t('platform.api.tooManyOts', { max: MAX_OTS_PER_ACCOUNT() }) });
+      return send(res, 201, { ots: otsSummary(duplicateOts(account.id, ots)) });
+    }
+    if (sub === '/usage' && req.method === 'GET') return send(res, 200, { months: usageHistory(ots.id) });
+    if (sub === '/conversations' && req.method === 'GET') {
+      const url = new URL(req.url, 'http://x');
+      return send(res, 200, { conversations: listConversations(ots.id, { before: url.searchParams.get('before'), limit: url.searchParams.get('limit') }) });
+    }
+    const c = sub.match(/^\/conversations\/(c_[A-Za-z0-9_-]{10,40})$/);
+    if (c && req.method === 'GET') {
+      const conv = getConversation(ots.id, c[1]);
+      return conv ? send(res, 200, { conversation: conv }) : send(res, 404, { error: t('server.http.notFound') });
+    }
+    if (c && req.method === 'DELETE') return send(res, 200, { ok: deleteConversation(ots.id, c[1]) });
+    send(res, 404, { error: t('server.http.unknownRoute') });
+  }
+
+  /** @returns {Promise<boolean>} true si atendió la ruta */
+  return async function handle(req, res, url) {
+    const p = url.pathname;
+    const m = p.match(/^\/api\/o\/([a-z0-9_]{4,40})(\/.*)$/);
+    if (m) {
+      await publicApi(req, res, m[1], m[2]);
+      return true;
+    }
+    if (p.startsWith('/api/platform/')) {
+      await dashboardApi(req, res, p.slice('/api/platform'.length));
+      return true;
+    }
+    return false;
+  };
+}
+
+/** Rol y tono de partida de un ots nuevo, en su idioma (los defectos del esquema son en español). */
+const STARTER = {
+  es: { role: 'asistente virtual', personality: { tone: 'cercano y claro' } },
+  en: { role: 'virtual assistant', personality: { tone: 'friendly and clear' } },
+  pt: { role: 'assistente virtual', personality: { tone: 'próximo e claro' } },
+};
+
+/**
+ * Lo que de verdad escribió el visitante en un mensaje del widget: sin el <page_context> ni el
+ * <user_state> que añade AgentBrain. Los eventos proactivos (<evento_del_sistema>) y los
+ * resultados de herramientas (contenido no textual) no son texto del visitante.
+ */
+function visibleTurn(content) {
+  if (typeof content !== 'string') return { text: '', page: '' };
+  const page = /<page_context>[\s\S]*?^URL: (\S+)/m.exec(content)?.[1] || '';
+  if (content.includes('<evento_del_sistema>')) return { text: '', page };
+  const text = content
+    .replace(/<page_context>[\s\S]*?<\/page_context>/g, '')
+    .replace(/<user_state>[\s\S]*?<\/user_state>/g, '')
+    .trim();
+  return { text, page: page.slice(0, 500) };
+}
+
+/** Igual que settings.mjs: solo datos y nada que tenga que fijar el servidor. */
+function sanitizeWidget(w) {
+  const out = JSON.parse(JSON.stringify(w));
+  for (const k of ['endpoint', 'llm', 'auth', 'templates', 'actions', 'identity']) delete out[k];
+  return out;
+}

package/server/platform/runtime.mjs

@@ -0,0 +1,180 @@
+/**
+ * Runtime de cada ots en la plataforma: su entorno, su LLM, su voz y sus canales.
+ *
+ * Cada ots tiene un "entorno" propio (un objeto, nunca process.env) hecho de:
+ *   1. lo que fija la plataforma (hub de apuchat, API de apumail, servicio de voz),
+ *   2. sus ajustes y claves (solo las de OTS_KEYS),
+ *   3. si no trae clave de IA o de voz, la de la plataforma, con cupo gratis por cuenta y mes:
+ *        PLATFORM_ANTHROPIC_API_KEY   · PLATFORM_LLM_MODEL (defecto claude-sonnet-5-5)
+ *        PLATFORM_FREE_MESSAGES       respuestas de IA gratis por cuenta y mes (defecto 100)
+ *        PLATFORM_APUCHAT_VOICE_TOKEN · PLATFORM_FREE_TTS (audios gratis por cuenta y mes, defecto 100)
+ * Así un ots nunca ve las claves del proceso ni las de otro ots.
+ */
+
+import { createLLM } from '../llm.mjs';
+import { synthesize as synthesizeWith, ttsProvider } from '../tts.mjs';
+import { startAgentChannels } from '../channels/index.mjs';
+import { apumailConfigFromEnv } from '../channels/apumail.mjs';
+import { apuchatConfigFromEnv } from '../channels/apuchat.mjs';
+import { i18nError } from '../i18n.mjs';
+import { OTS_KEYS, accountUsage, addUsage, allLiveOts, getOts } from './store.mjs';
+
+const penv = process.env;
+const FIXED = ['APUCHAT_HUB', 'APUMAIL_API', 'APUCHAT_VOICE_URL'];
+const LLM_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY'];
+const TTS_KEYS = ['APUCHAT_VOICE_TOKEN', 'ELEVENLABS_API_KEY', 'XAI_API_KEY', 'FISH_API_KEY', 'OPENAI_API_KEY'];
+
+export const freeMessages = () => Number(penv.PLATFORM_FREE_MESSAGES ?? 100);
+export const freeTts = () => Number(penv.PLATFORM_FREE_TTS ?? 100);
+
+/**
+ * Entorno del ots.
+ * @returns {{ env: object, platformLlm: boolean, platformTts: boolean }}
+ */
+export function otsEnv(ots) {
+  const env = {};
+  for (const k of FIXED) if (penv[k]) env[k] = penv[k];
+  for (const [k, meta] of Object.entries(OTS_KEYS)) {
+    const v = meta.secret ? ots.secrets[k] : ots.settings[k];
+    if (v == null || v === '') continue;
+    env[k] = meta.max ? String(Math.min(meta.max, Math.max(0, Number(v) || 0))) : String(v);
+  }
+
+  // IA: la suya o la de la plataforma (modelo fijo para controlar el coste).
+  let platformLlm = false;
+  const provider = (env.LLM_PROVIDER || '').toLowerCase();
+  const ownLlm = provider === 'openai' ? !!env.OPENAI_API_KEY : provider === 'anthropic' ? !!env.ANTHROPIC_API_KEY : LLM_KEYS.some((k) => env[k]);
+  if (provider === 'mock') {
+    // Modo de pruebas: sin IA real.
+  } else if (!ownLlm && penv.PLATFORM_ANTHROPIC_API_KEY) {
+    platformLlm = true;
+    Object.assign(env, { LLM_PROVIDER: 'anthropic', ANTHROPIC_API_KEY: penv.PLATFORM_ANTHROPIC_API_KEY, LLM_MODEL: penv.PLATFORM_LLM_MODEL || 'claude-sonnet-5-5', LLM_EFFORT: 'low', LLM_MAX_TOKENS: '4000' });
+  } else if (!ownLlm) {
+    env.LLM_PROVIDER = 'mock';
+  }
+
+  // Voz: la suya o la de apuchat de la plataforma.
+  let platformTts = false;
+  if (!env.TTS_PROVIDER && !TTS_KEYS.some((k) => env[k]) && penv.PLATFORM_APUCHAT_VOICE_TOKEN) {
+    platformTts = true;
+    Object.assign(env, { TTS_PROVIDER: 'apuchat', APUCHAT_VOICE_TOKEN: penv.PLATFORM_APUCHAT_VOICE_TOKEN });
+  }
+  return { env, platformLlm, platformTts };
+}
+
+// ───────────────────────────── LLM con cupo ─────────────────────────────
+
+const llms = new Map(); // ots.id → { stamp, llm }
+
+/** LLM del ots (se rehace cuando cambia el ots). */
+function rawLlm(ots) {
+  const stamp = ots.updatedAt;
+  const hit = llms.get(ots.id);
+  if (hit?.stamp === stamp) return hit;
+  const { env, platformLlm } = otsEnv(ots);
+  const entry = { stamp, llm: createLLM(env), platformLlm };
+  if (llms.size > 2000) llms.clear();
+  llms.set(ots.id, entry);
+  return entry;
+}
+
+/** ¿Le queda cupo gratis a la cuenta? */
+export function llmAllowed(ots) {
+  const { platformLlm } = rawLlm(ots);
+  return !platformLlm || accountUsage(ots.accountId, 'llm_platform') < freeMessages();
+}
+
+/**
+ * Un paso de LLM para este ots, contando el uso.
+ * Sin cupo lanza 402 con clave `platform.quota.llm` (la ruta lo convierte en una respuesta amable).
+ */
+export async function otsStep(ots, args) {
+  const { llm, platformLlm } = rawLlm(ots);
+  if (platformLlm && accountUsage(ots.accountId, 'llm_platform') >= freeMessages()) throw i18nError(402, 'platform.quota.llm');
+  const out = await llm.step(args);
+  addUsage(ots, 'llm');
+  if (platformLlm) addUsage(ots, 'llm_platform');
+  return out;
+}
+
+export function otsLlmInfo(ots) {
+  const { llm, platformLlm } = rawLlm(ots);
+  return { name: llm.name, model: llm.model, platform: platformLlm };
+}
+
+// ───────────────────────────── voz ─────────────────────────────
+
+export async function otsSynthesize(ots, { text, voice = ots.identity.voice }) {
+  const { env, platformTts } = otsEnv(ots);
+  if (platformTts && accountUsage(ots.accountId, 'tts_platform') >= freeTts()) throw i18nError(402, 'platform.quota.tts');
+  const out = await synthesizeWith({ text, voice, env });
+  addUsage(ots, 'tts');
+  if (platformTts) addUsage(ots, 'tts_platform');
+  return out;
+}
+
+export function otsTtsProvider(ots) {
+  return ttsProvider(otsEnv(ots).env);
+}
+
+// ───────────────────────────── canales ─────────────────────────────
+
+const channels = new Map(); // ots.id → { stamp, ch }
+const NO_CHANNELS = {
+  handle: async () => false,
+  live: () => ({ email: false, apuchat: null, meet: false }),
+  openCall: () => {
+    throw i18nError(501, 'server.channels.noApuchat');
+  },
+  status: () => ({ apumail: false, apuchat: false }),
+  stop: async () => {},
+};
+
+/** Clave que identifica la configuración de canales (si no cambia, no se reinician). */
+function channelStamp(ots) {
+  const { env } = otsEnv(ots);
+  return JSON.stringify([ots.status, ...Object.keys(OTS_KEYS).filter((k) => OTS_KEYS[k].channels).map((k) => env[k] || '')]);
+}
+
+/** Canales del ots (apumail/apuchat), arrancándolos o reiniciándolos si hace falta. */
+export function otsChannels(ots) {
+  if (!ots || ots.status !== 'on') return NO_CHANNELS;
+  const stamp = channelStamp(ots);
+  const hit = channels.get(ots.id);
+  if (hit?.stamp === stamp) return hit.ch;
+  hit?.ch.stop().catch(() => {});
+  const { env } = otsEnv(ots);
+  const id = ots.id;
+  // Siempre la versión vigente del ots: identidad e instrucciones cambian sin reiniciar.
+  const current = () => getOts(id) || ots;
+  const ch = startAgentChannels({
+    llm: { get name() { return otsLlmInfo(current()).name; }, get model() { return otsLlmInfo(current()).model; }, step: (a) => otsStep(current(), a) },
+    identity: () => current().identity,
+    instructions: () => current().settings.SERVER_INSTRUCTIONS || '',
+    config: { apumail: { ...apumailConfigFromEnv(env), webhookSecret: '' }, apuchat: apuchatConfigFromEnv(env) },
+    log: (...a) => console.log(`[7ots:${id}]`, ...a),
+  });
+  channels.set(id, { stamp, ch });
+  return ch;
+}
+
+/** Para los canales de un ots (al pausarlo o borrarlo). */
+export async function stopOtsChannels(id) {
+  const hit = channels.get(id);
+  channels.delete(id);
+  llms.delete(id);
+  await hit?.ch.stop().catch(() => {});
+}
+
+/** Arranca los canales de todos los ots encendidos que los tengan configurados. */
+export function startAllChannels() {
+  for (const ots of allLiveOts()) {
+    const s = ots.settings;
+    const sec = ots.secrets;
+    if ((s.APUMAIL_AGENT_INBOX && sec.APUMAIL_AGENT_TOKEN) || sec.APUCHAT_AGENT_IDENTITY_KEY) otsChannels(ots);
+  }
+}
+
+export async function stopAllChannels() {
+  await Promise.all([...channels.keys()].map(stopOtsChannels));
+}