kingkont 0.6.2 → 0.7.0

package/server.js

@@ -28,6 +28,11 @@ const KIE_BASE = 'https://api.kie.ai';
 const ELEVEN_BASE = 'https://api.elevenlabs.io';
 const ROOT = __dirname;
 
+// Источник live-настроек (use*-флаги, chatium token). Подставляется через
+// start({ getSettings }) из main.js. Если не передан — fallback на пустые
+// настройки, и server.js работает как раньше через прямые провайдеры.
+let getSettings = () => ({});
+
 const MIME = {
   '.html': 'text/html; charset=utf-8',
   '.css':  'text/css; charset=utf-8',
@@ -45,6 +50,142 @@ const MIME = {
 };
 
 // ---------- helpers ----------
+// Логирует каждый исходящий запрос провайдеру. Видно в npm start output —
+// это даёт чёткую картину «куда server.js реально пытается отправить данные».
+function logProviderCall(method, provider, target, extra = '') {
+  const ts = new Date().toLocaleTimeString();
+  console.log(`[${ts}] → ${method.padEnd(4)} ${provider.padEnd(11)} ${target}${extra ? '  ' + extra : ''}`);
+}
+
+// =====  Chatium proxy helpers  ==============================================
+// Архитектура: Chatium API асинхронный. POST /api/text|audio|video возвращает
+// taskId сразу, callback @start/sdk через несколько секунд (или минут для
+// видео) пишет результат в proxy_tasks. Здесь мы поллим /api/poll до готовности.
+//
+// Возвращаем результат клиенту в его «синхронном» формате — он не знает о
+// chatium-async. Для long-running'а (видео) клиент сам так задумано работает
+// через /api/generate + /api/poll, поэтому видео мы НЕ ждём здесь, а отдаём
+// клиенту taskId с префиксом «chatium:» и эмулируем KIE poll.
+
+const CHATIUM_PATHS = {
+  text: '/app/spaces/server/api/text',
+  audio: '/app/spaces/server/api/audio',
+  image: '/app/spaces/server/api/image',
+  video: '/app/spaces/server/api/video',
+  poll: '/app/spaces/server/api/poll',
+  balance: '/app/spaces/server/api/balance',
+  transactions: '/app/spaces/server/api/transactions',
+  uploadUrl: '/app/spaces/server/api/upload_url',
+};
+
+// CDN-домен Chatium для готовых ссылок после upload. Подтверждено в
+// useImageEditorSave.ts (`https://sel.cdn-chatium.io/get/...`) и
+// в chatium-sync.sh (`https://fs.chatium.ru/get/...`). Оба работают
+// (alias'ы), используем fs.chatium.ru — он public-доступен и фигурирует
+// в getThumbnailUrl-helper'е тоже.
+const CHATIUM_CDN = 'https://fs.chatium.ru/get';
+
+async function chatiumStart(s, kind, body) {
+  const url = s.chatium.base.replace(/\/$/, '') + CHATIUM_PATHS[kind];
+  logProviderCall('POST', 'Chatium', url, summarizeBody(body));
+  const r = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${s.chatium.token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await r.text();
+  let data; try { data = JSON.parse(text); } catch { data = { raw: text }; }
+  if (!r.ok) {
+    const reason = data?.reason || data?.error || data?.raw || `HTTP ${r.status}`;
+    throw new Error(`Chatium /api/${kind} HTTP ${r.status}: ${String(reason).slice(0, 300)}`);
+  }
+  if (!data.taskId) throw new Error(`Chatium /api/${kind} вернул без taskId: ${text.slice(0, 200)}`);
+  return data.taskId;
+}
+
+async function chatiumPoll(s, taskId) {
+  const url = `${s.chatium.base.replace(/\/$/, '')}${CHATIUM_PATHS.poll}?taskId=${encodeURIComponent(taskId)}`;
+  const r = await fetch(url, {
+    headers: { 'Authorization': `Bearer ${s.chatium.token}` },
+  });
+  const text = await r.text();
+  let data; try { data = JSON.parse(text); } catch { data = { raw: text }; }
+  if (!r.ok) {
+    const reason = data?.reason || data?.error || data?.raw || `HTTP ${r.status}`;
+    throw new Error(`Chatium /api/poll HTTP ${r.status}: ${String(reason).slice(0, 300)}`);
+  }
+  return data;
+}
+
+/**
+ * Поллит до готовности. Используется для коротких генераций (text, audio).
+ *
+ * Grace-period: для media (audio/image/video) cost приходит в @start через
+ * ОТДЕЛЬНЫЙ /onMediaBilled callback, иногда позже /onCompleted. Если task
+ * уже completed но creditsCharged ещё null — даём 5 сек чтобы billed
+ * подоспел и мы могли отдать клиенту корректную стоимость генерации.
+ */
+async function chatiumWait(s, taskId, timeoutMs = 120000, billedGraceMs = 5000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = null;
+  while (Date.now() < deadline) {
+    const d = await chatiumPoll(s, taskId);
+    if (d.status !== lastStatus) {
+      console.log(`[chatium] task ${taskId.slice(0,8)}… status=${d.status}`);
+      lastStatus = d.status;
+    }
+    if (d.status === 'completed') {
+      if (typeof d.creditsCharged === 'number') return d;
+      // Status completed, ждём billed-callback (≤ billedGraceMs).
+      const graceUntil = Date.now() + billedGraceMs;
+      while (Date.now() < graceUntil) {
+        await new Promise(s2 => setTimeout(s2, 800));
+        const d2 = await chatiumPoll(s, taskId);
+        if (typeof d2.creditsCharged === 'number') {
+          console.log(`[chatium] task ${taskId.slice(0,8)}… billed=${d2.creditsCharged}`);
+          return d2;
+        }
+      }
+      console.log(`[chatium] task ${taskId.slice(0,8)}… billed timeout, cost unknown`);
+      return d;
+    }
+    if (d.status === 'failed') throw new Error(d.error || 'chatium task failed');
+    await new Promise(s2 => setTimeout(s2, 1500));
+  }
+  throw new Error(`chatium poll timeout after ${timeoutMs / 1000}s`);
+}
+
+function summarizeBody(body) {
+  if (!body) return '';
+  const parts = [];
+  if (body.model) parts.push(`model=${body.model}`);
+  if (body.kind) parts.push(`kind=${body.kind}`);
+  if (typeof body.prompt === 'string') parts.push(`prompt=${body.prompt.length}ch`);
+  if (typeof body.text === 'string') parts.push(`text=${body.text.length}ch`);
+  if (Array.isArray(body.imageInputs)) parts.push(`imgs=${body.imageInputs.length}`);
+  return parts.join(' ');
+}
+
+/**
+ * Скачать URL и стримить в response (для аудио/видео из Chatium —
+ * клиент ждёт audio/mpeg, а Chatium отдаёт URL).
+ */
+async function streamUrlToResponse(url, res, contentType = 'audio/mpeg', extraHeaders = {}) {
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(`download ${r.status} for ${url.slice(0, 100)}`);
+  res.writeHead(200, { 'Content-Type': contentType, ...extraHeaders });
+  const reader = r.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(Buffer.from(value));
+  }
+  res.end();
+}
+
 function send(res, status, body, headers = {}) {
   const isStr = typeof body === 'string';
   res.writeHead(status, {
@@ -98,11 +239,89 @@ const VIDEO_MODELS = {
   'seedance-2':    'bytedance/seedance-2',
 };
 
+// Маппинг для Chatium-маршрута. У Chatium свой набор моделей через
+// @start/sdk — отличается от KIE: например, у KIE 'seedream/4.5-text-to-image',
+// у Chatium 'bytedance/seedream-5-lite' (с префиксом vendor'а).
+// Источники: spaces/api/execImageRunners.ts, spaces/api/execVideoRunners.ts.
+const CHATIUM_IMAGE_MODELS = {
+  'nano-banana-2':    'nano-banana-2',
+  'nano-banana-pro':  'nano-banana-pro',
+  'grok':             'grok-imagine/text-to-image',
+  'grok-i2i':         'grok-imagine/image-to-image',
+  'seedream-5-lite':  'bytedance/seedream-5-lite',
+};
+const CHATIUM_VIDEO_MODELS = {
+  'seedance-2':       'bytedance/seedance-2',
+  'seedance-2-fast':  'bytedance/seedance-2-fast',
+  'veo-3.1':          'google/veo-3.1',
+  'kling-o1':         'kwaivgi/kling-o1',
+  'kling-3.0':        'kling-3.0/video',
+  'wan-2.7-i2v':      'wan/2-7-image-to-video',
+  'runway':           'runway',
+  'grok-i2v':         'grok-imagine/image-to-video',
+  'grok-t2v':         'grok-imagine/text-to-video',
+};
+
 // ---------- /api/generate ----------
 async function handleGenerate(req, res) {
-  const { kind, prompt, imageInputs, videoInputs, aspectRatio, resolution, model: modelKey } = await readJson(req);
+  const body = await readJson(req);
+  const { kind, prompt, imageInputs, videoInputs, aspectRatio, resolution, duration, model: modelKey } = body;
   if (!prompt || !prompt.trim()) return send(res, 400, { error: 'prompt обязателен' });
 
+  const s = getSettings();
+
+  // Chatium-путь для image и video.
+  if ((kind === 'video' || kind === 'image') && s.useChatium && s.chatium?.token && s.chatium?.base) {
+    // Отдельный mapping для Chatium — у него другой набор моделей.
+    const map = kind === 'video' ? CHATIUM_VIDEO_MODELS : CHATIUM_IMAGE_MODELS;
+    let fullModel;
+    if (modelKey) {
+      // Принимаем как короткий ключ (nano-banana-2), так и полный slug
+      // (bytedance/seedream-5-lite) — клиент может прислать любой формат.
+      fullModel = map[modelKey] || (Object.values(map).includes(modelKey) ? modelKey : null);
+      if (!fullModel) {
+        const known = Object.keys(map).join(', ');
+        return send(res, 400, {
+          error: `Модель "${modelKey}" не поддерживается Chatium для ${kind}. Доступны: ${known}. Чтобы использовать KIE-модели — отключите Chatium в настройках.`,
+        });
+      }
+    }
+    try {
+      const chatiumKind = kind === 'video' ? 'video' : 'image';
+      let chatiumBody;
+      if (kind === 'video') {
+        chatiumBody = { prompt, model: fullModel, imageInputs, videoInputs, aspectRatio, resolution, duration };
+      } else {
+        // Per-model особенности (см. spaces/api/execImageRunners.ts):
+        //  - seedream-5-lite: только text-to-image (без imageInputs),
+        //    output_format только 'jpeg' (не 'jpg').
+        //  - nano-banana-2: jpg/png; image_input ОК.
+        //  - grok-imagine: image_input игнорится для text-to-image.
+        const isSeedream = fullModel?.includes('seedream');
+        chatiumBody = {
+          prompt, model: fullModel,
+          aspectRatio, resolution,
+          outputFormat: isSeedream ? 'jpeg' : 'jpg',
+        };
+        if (!isSeedream && Array.isArray(imageInputs) && imageInputs.length) {
+          chatiumBody.imageInputs = imageInputs;
+        }
+      }
+      const taskId = await chatiumStart(s, chatiumKind, chatiumBody);
+      return send(res, 200, { taskId: 'chatium:' + taskId }, { 'X-Provider': 'chatium' });
+    } catch (e) {
+      logProviderCall('ERR ', 'Chatium', `/api/${kind}`, e.message);
+      return send(res, 502, { error: 'Chatium: ' + e.message }, { 'X-Provider': 'chatium' });
+    }
+  }
+
+  // Прямой KIE (image и video).
+  if (!s.useKie) {
+    return send(res, 503, { error: kind === 'video'
+      ? 'Видео-коннектор отключён. Включите Chatium или KIE.'
+      : 'Картиночный коннектор отключён. Включите Chatium или KIE.' });
+  }
+
   const input = { prompt };
   let model;
 
@@ -138,53 +357,149 @@ async function handleGenerate(req, res) {
     if (videoInputs?.length) input.reference_video_urls = videoInputs;
     if (aspectRatio) input.aspect_ratio = aspectRatio;
     if (resolution) input.resolution = resolution;
+    if (duration) input.duration = +duration;
   } else {
     return send(res, 400, { error: `unknown kind: ${kind}` });
   }
 
+  logProviderCall('POST', 'KIE', `${KIE_BASE}/api/v1/jobs/createTask`, `model=${model} kind=${kind}`);
   const data = await kieFetch('/api/v1/jobs/createTask', {
     method: 'POST',
     body: JSON.stringify({ model, input }),
   });
-  send(res, 200, { taskId: data.data?.taskId });
+  send(res, 200, { taskId: data.data?.taskId }, { 'X-Provider': 'kie' });
 }
 
 // ---------- /api/poll ----------
 async function handlePoll(res, url) {
   const taskId = url.searchParams.get('taskId');
   if (!taskId) return send(res, 400, { error: 'нужен taskId' });
+
+  // Chatium-задача — определяем по префиксу «chatium:» который мы выставили
+  // в handleGenerate. Делегируем на chatiumPoll, мапим формат под клиент
+  // (он ждёт {status: 'done'|'error'|'pending', url, error, state}).
+  if (taskId.startsWith('chatium:')) {
+    const realId = taskId.slice('chatium:'.length);
+    const s = getSettings();
+    if (!s.chatium?.token || !s.chatium?.base) {
+      return send(res, 401, { status: 'error', error: 'Нет Chatium-сессии' }, { 'X-Provider': 'chatium' });
+    }
+    try {
+      let d = await chatiumPoll(s, realId);
+      const provider = { 'X-Provider': 'chatium' };
+      if (d.status === 'completed') {
+        const url2 = d.result?.urls?.[0];
+        if (!url2) return send(res, 200, { status: 'error', error: 'Chatium вернул без URL' }, provider);
+        // Билинг приходит ОТДЕЛЬНЫМ callback'ом. Если creditsCharged ещё
+        // null, ждём до 5 сек — обычно billed подоспеет за секунду-две.
+        if (typeof d.creditsCharged !== 'number') {
+          const graceUntil = Date.now() + 5000;
+          while (Date.now() < graceUntil) {
+            await new Promise(r => setTimeout(r, 800));
+            const d2 = await chatiumPoll(s, realId);
+            if (typeof d2.creditsCharged === 'number') { d = d2; break; }
+          }
+        }
+        return send(res, 200, {
+          status: 'done',
+          url: url2,
+          cost: typeof d.creditsCharged === 'number' ? d.creditsCharged : null,
+        }, provider);
+      }
+      if (d.status === 'failed') {
+        return send(res, 200, { status: 'error', error: d.error || 'failed' }, provider);
+      }
+      return send(res, 200, { status: 'pending', state: d.status }, provider);
+    } catch (e) {
+      return send(res, 502, { status: 'error', error: 'Chatium: ' + e.message }, { 'X-Provider': 'chatium' });
+    }
+  }
+
+  // KIE-задача (старый путь).
+  logProviderCall('GET ', 'KIE', `${KIE_BASE}/api/v1/jobs/recordInfo`, `taskId=${taskId}`);
   const data = await kieFetch(`/api/v1/jobs/recordInfo?taskId=${encodeURIComponent(taskId)}`);
   const d = data.data || {};
   const st = d.state;
 
+  const provider = { 'X-Provider': 'kie' };
   if (st === 'success') {
     let urls = [];
     try {
       const parsed = JSON.parse(d.resultJson || '{}');
       urls = parsed.resultUrls || [];
     } catch {}
-    if (!urls.length) return send(res, 200, { status: 'error', error: 'KIE вернул успех, но без URL' });
-    send(res, 200, { status: 'done', url: urls[0] });
+    if (!urls.length) return send(res, 200, { status: 'error', error: 'KIE вернул успех, но без URL' }, provider);
+    send(res, 200, { status: 'done', url: urls[0] }, provider);
   } else if (st === 'fail') {
-    send(res, 200, { status: 'error', error: d.failMsg || d.failCode || 'generation failed' });
+    send(res, 200, { status: 'error', error: d.failMsg || d.failCode || 'generation failed' }, provider);
   } else {
-    send(res, 200, { status: 'pending', state: st });
+    send(res, 200, { status: 'pending', state: st }, provider);
   }
 }
 
-// ---------- /api/upload (загружает файл в KIE, возвращает публичный URL) ----------
+// ---------- /api/upload (Chatium-storage ИЛИ KIE) ----------
 async function handleUpload(req, res) {
   const filename = decodeURIComponent(req.headers['x-file-name'] || 'upload.bin');
   const mimeType = (req.headers['content-type'] || 'application/octet-stream').split(';')[0].trim();
   const buf = await readBody(req);
   if (!buf.length) return send(res, 400, { error: 'пустой файл' });
-  // KIE base64 endpoint рекомендован для файлов < 10MB
+  if (buf.length > 50 * 1024 * 1024) {
+    return send(res, 413, { error: `файл слишком большой (${(buf.length/1024/1024).toFixed(1)} MB), лимит 50MB` });
+  }
+
+  const s = getSettings();
+
+  // Chatium-путь: получаем upload-URL → POST multipart Filedata → hash → URL.
+  if (s.useChatium && s.chatium?.token && s.chatium?.base) {
+    try {
+      // 1) Берём свежий upload-URL (он одноразовый, см. obtainStorageFilePutUrl).
+      const urlRequest = s.chatium.base.replace(/\/$/, '') + CHATIUM_PATHS.uploadUrl;
+      const ru = await fetch(urlRequest, {
+        headers: { 'Authorization': `Bearer ${s.chatium.token}` },
+      });
+      if (!ru.ok) {
+        const t = await ru.text();
+        return send(res, ru.status, { error: 'Chatium upload-url: ' + t.slice(0, 200) }, { 'X-Provider': 'chatium' });
+      }
+      const { uploadUrl } = await ru.json();
+      if (!uploadUrl) {
+        return send(res, 502, { error: 'Chatium не вернул uploadUrl' }, { 'X-Provider': 'chatium' });
+      }
+      // 2) Multipart-POST с полем "Filedata" — формат Chatium-fileservice.
+      logProviderCall('POST', 'Chatium', uploadUrl, `file=${filename} size=${buf.length}`);
+      const fd = new FormData();
+      fd.append('Filedata', new Blob([buf], { type: mimeType }), filename);
+      const ru2 = await fetch(uploadUrl, { method: 'POST', body: fd });
+      const hashOrErr = (await ru2.text()).trim();
+      if (!ru2.ok || !hashOrErr) {
+        return send(res, ru2.status || 502, {
+          error: `Chatium upload HTTP ${ru2.status}: ${hashOrErr.slice(0, 200)}`,
+        }, { 'X-Provider': 'chatium' });
+      }
+      // Response = plain text hash.
+      return send(res, 200, {
+        url: `${CHATIUM_CDN}/${hashOrErr}`,
+        fileName: filename,
+        size: buf.length,
+        hash: hashOrErr,
+      }, { 'X-Provider': 'chatium' });
+    } catch (e) {
+      logProviderCall('ERR ', 'Chatium', '/api/upload', e.message);
+      return send(res, 502, { error: 'Chatium upload: ' + e.message }, { 'X-Provider': 'chatium' });
+    }
+  }
+
+  // Прямой KIE (fallback).
+  if (!s.useKie) {
+    return send(res, 503, { error: 'Upload-коннектор отключён. Включите Chatium или KIE.' });
+  }
   if (buf.length > 10 * 1024 * 1024) {
-    return send(res, 413, { error: `файл слишком большой (${(buf.length/1024/1024).toFixed(1)} MB), лимит 10MB` });
+    return send(res, 413, { error: `файл слишком большой для KIE (${(buf.length/1024/1024).toFixed(1)} MB), лимит 10MB` });
   }
   const dataUrl = `data:${mimeType};base64,${buf.toString('base64')}`;
   const key = process.env.KIE_API_KEY;
   if (!key) return send(res, 500, { error: 'KIE_API_KEY не задан' });
+  logProviderCall('POST', 'KIE', 'https://kieai.redpandaai.co/api/file-base64-upload', `file=${filename} size=${buf.length}`);
   const r = await fetch('https://kieai.redpandaai.co/api/file-base64-upload', {
     method: 'POST',
     headers: {
@@ -202,7 +517,7 @@ async function handleUpload(req, res) {
   if (!r.ok || !data.success) {
     return send(res, r.status || 500, { error: data.msg || `upload failed: ${text.slice(0, 200)}` });
   }
-  send(res, 200, { url: data.data.downloadUrl, fileName: data.data.fileName, size: data.data.fileSize });
+  send(res, 200, { url: data.data.downloadUrl, fileName: data.data.fileName, size: data.data.fileSize }, { 'X-Provider': 'kie' });
 }
 
 // ---------- /api/proxy?url=...  (стрим бинарных данных через бэк, минуя CORS) ----------
@@ -232,6 +547,7 @@ async function handleProxy(res, url) {
 async function handleVoices(req, res) {
   const key = process.env.ELEVENLABS_API_KEY;
   if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
+  logProviderCall('GET ', 'ElevenLabs', `${ELEVEN_BASE}/v1/voices`);
   const r = await fetch(`${ELEVEN_BASE}/v1/voices`, { headers: { 'xi-api-key': key } });
   const text = await r.text();
   let data; try { data = JSON.parse(text); } catch { data = {}; }
@@ -243,18 +559,49 @@ async function handleVoices(req, res) {
     labels: v.labels || {},
     preview: v.preview_url,
   }));
-  send(res, 200, { voices });
+  send(res, 200, { voices }, { 'X-Provider': 'elevenlabs' });
 }
 
-// ---------- /api/text (OpenRouter chat completion) ----------
+// ---------- /api/text (Chatium proxy ИЛИ OpenRouter) ----------
 // Тело: {prompt, model?, system?, images?: [{url}]}
-// images.url — data:image/...;base64,... либо http(s) URL. Если массив не
-// пустой, отправляем content[] с image_url-блоками (vision).
 async function handleText(req, res) {
+  const body = await readJson(req);
+  const { prompt, model = 'anthropic/claude-sonnet-4', system, images } = body;
+  if (!prompt) return send(res, 400, { error: 'нужен prompt' });
+
+  const s = getSettings();
+
+  // Chatium-путь: useChatium=true И есть валидный токен.
+  if (s.useChatium && s.chatium?.token && s.chatium?.base) {
+    try {
+      // Chatium ждёт messages в @start/sdk-формате (image как { type: 'image',
+      // source: { type: 'url', url } }). Если у клиента images — конвертируем.
+      const chatiumBody = {
+        prompt,
+        model,
+        system,
+        images: Array.isArray(images) ? images.filter(i => i?.url) : undefined,
+      };
+      const taskId = await chatiumStart(s, 'text', chatiumBody);
+      const result = await chatiumWait(s, taskId, 120000);
+      return send(res, 200, {
+        text: result.result?.text || '',
+        model,
+        cost: typeof result.creditsCharged === 'number' ? result.creditsCharged : null,
+      }, { 'X-Provider': 'chatium' });
+    } catch (e) {
+      logProviderCall('ERR ', 'Chatium', '/api/text', e.message);
+      return send(res, 502, { error: 'Chatium: ' + e.message }, { 'X-Provider': 'chatium' });
+    }
+  }
+
+  // Прямой OpenRouter (если useOpenrouter включён).
+  if (!s.useOpenrouter) {
+    return send(res, 503, { error: 'Текстовый коннектор отключён в настройках. Включите Chatium или OpenRouter.' });
+  }
   const key = process.env.OPENROUTER_API_KEY;
   if (!key) return send(res, 500, { error: 'OPENROUTER_API_KEY не задан' });
-  const { prompt, model = 'anthropic/claude-sonnet-4', system, images } = await readJson(req);
-  if (!prompt) return send(res, 400, { error: 'нужен prompt' });
+
   const messages = [];
   if (system) messages.push({ role: 'system', content: system });
   if (Array.isArray(images) && images.length) {
@@ -267,6 +614,7 @@ async function handleText(req, res) {
   } else {
     messages.push({ role: 'user', content: prompt });
   }
+  logProviderCall('POST', 'OpenRouter', 'https://openrouter.ai/api/v1/chat/completions', `model=${model} prompt=${prompt.length}ch images=${images?.length || 0}`);
   const r = await fetch('https://openrouter.ai/api/v1/chat/completions', {
     method: 'POST',
     headers: {
@@ -283,17 +631,74 @@ async function handleText(req, res) {
     return send(res, r.status, { error: data?.error?.message || data?.raw || `HTTP ${r.status}` });
   }
   const content = data?.choices?.[0]?.message?.content || '';
-  send(res, 200, { text: content, model: data?.model || model });
+  send(res, 200, { text: content, model: data?.model || model }, { 'X-Provider': 'openrouter' });
+}
+
+// ---------- /api/transactions (только Chatium) — история списаний ----------
+async function handleTransactions(req, res) {
+  const s = getSettings();
+  if (!s.useChatium || !s.chatium?.token || !s.chatium?.base) {
+    return send(res, 503, { error: 'Chatium не подключён' });
+  }
+  const url = s.chatium.base.replace(/\/$/, '') + CHATIUM_PATHS.transactions;
+  logProviderCall('GET ', 'Chatium', url);
+  try {
+    const r = await fetch(url, { headers: { 'Authorization': `Bearer ${s.chatium.token}` } });
+    const text = await r.text();
+    let data; try { data = JSON.parse(text); } catch { data = { raw: text }; }
+    if (!r.ok) {
+      return send(res, r.status, {
+        error: data?.reason || data?.error || `HTTP ${r.status}`,
+      }, { 'X-Provider': 'chatium' });
+    }
+    send(res, 200, data, { 'X-Provider': 'chatium' });
+  } catch (e) {
+    send(res, 502, { error: 'Chatium: ' + e.message }, { 'X-Provider': 'chatium' });
+  }
 }
 
-// ---------- /api/sfx (ElevenLabs Sound Effects) ----------
+// ---------- /api/balance (только Chatium) ----------
+async function handleBalance(req, res) {
+  const s = getSettings();
+  if (!s.useChatium || !s.chatium?.token || !s.chatium?.base) {
+    return send(res, 503, { error: 'Chatium не подключён' });
+  }
+  const url = s.chatium.base.replace(/\/$/, '') + CHATIUM_PATHS.balance;
+  logProviderCall('GET ', 'Chatium', url);
+  try {
+    const r = await fetch(url, {
+      headers: { 'Authorization': `Bearer ${s.chatium.token}` },
+    });
+    const text = await r.text();
+    let data; try { data = JSON.parse(text); } catch { data = { raw: text }; }
+    if (!r.ok) {
+      return send(res, r.status, {
+        error: data?.reason || data?.error || `HTTP ${r.status}`,
+      }, { 'X-Provider': 'chatium' });
+    }
+    send(res, 200, data, { 'X-Provider': 'chatium' });
+  } catch (e) {
+    send(res, 502, { error: 'Chatium: ' + e.message }, { 'X-Provider': 'chatium' });
+  }
+}
+
+// ---------- /api/sfx (Chatium ИЛИ ElevenLabs Sound Effects) ----------
 async function handleSfx(req, res) {
-  const key = process.env.ELEVENLABS_API_KEY;
-  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
   const { text, durationSeconds, promptInfluence = 0.3 } = await readJson(req);
   if (!text) return send(res, 400, { error: 'нужен text' });
+  const s = getSettings();
+
+  if (s.useChatium && s.chatium?.token && s.chatium?.base) {
+    return handleAudioViaChatium(res, s, { kind: 'sfx', text, durationSeconds });
+  }
+  if (!s.useElevenlabs) {
+    return send(res, 503, { error: 'Аудио-коннектор отключён. Включите Chatium или ElevenLabs.' });
+  }
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
   const body = { text, prompt_influence: promptInfluence };
   if (durationSeconds) body.duration_seconds = +durationSeconds;
+  logProviderCall('POST', 'ElevenLabs', `${ELEVEN_BASE}/v1/sound-generation`, `text=${text.length}ch dur=${durationSeconds || '-'}`);
   const r = await fetch(`${ELEVEN_BASE}/v1/sound-generation`, {
     method: 'POST',
     headers: { 'xi-api-key': key, 'Content-Type': 'application/json', 'Accept': 'audio/mpeg' },
@@ -303,24 +708,27 @@ async function handleSfx(req, res) {
     const t = await r.text();
     return send(res, r.status, { error: t.slice(0, 400) });
   }
-  res.writeHead(200, { 'Content-Type': 'audio/mpeg' });
-  const reader = r.body.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    res.write(Buffer.from(value));
-  }
-  res.end();
+  res.writeHead(200, { 'Content-Type': 'audio/mpeg', 'X-Provider': 'elevenlabs' });
+  await streamReaderToResponse(r.body.getReader(), res);
 }
 
-// ---------- /api/music (ElevenLabs Music) ----------
+// ---------- /api/music (Chatium ИЛИ ElevenLabs Music) ----------
 async function handleMusic(req, res) {
-  const key = process.env.ELEVENLABS_API_KEY;
-  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
   const { prompt, durationMs } = await readJson(req);
   if (!prompt) return send(res, 400, { error: 'нужен prompt' });
+  const s = getSettings();
+
+  if (s.useChatium && s.chatium?.token && s.chatium?.base) {
+    return handleAudioViaChatium(res, s, { kind: 'music', prompt, durationMs });
+  }
+  if (!s.useElevenlabs) {
+    return send(res, 503, { error: 'Аудио-коннектор отключён. Включите Chatium или ElevenLabs.' });
+  }
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
   const body = { prompt };
   if (durationMs) body.music_length_ms = +durationMs;
+  logProviderCall('POST', 'ElevenLabs', `${ELEVEN_BASE}/v1/music`, `prompt=${prompt.length}ch dur_ms=${durationMs || '-'}`);
   const r = await fetch(`${ELEVEN_BASE}/v1/music`, {
     method: 'POST',
     headers: { 'xi-api-key': key, 'Content-Type': 'application/json', 'Accept': 'audio/mpeg' },
@@ -330,22 +738,25 @@ async function handleMusic(req, res) {
     const t = await r.text();
     return send(res, r.status, { error: t.slice(0, 400) });
   }
-  res.writeHead(200, { 'Content-Type': 'audio/mpeg' });
-  const reader = r.body.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    res.write(Buffer.from(value));
-  }
-  res.end();
+  res.writeHead(200, { 'Content-Type': 'audio/mpeg', 'X-Provider': 'elevenlabs' });
+  await streamReaderToResponse(r.body.getReader(), res);
 }
 
-// ---------- /api/tts (ElevenLabs v3) ----------
+// ---------- /api/tts (Chatium ИЛИ ElevenLabs v3) ----------
 async function handleTts(req, res) {
-  const key = process.env.ELEVENLABS_API_KEY;
-  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
   const { text, voiceId = 'JBFqnCBsd6RMkjVDRZzb', modelId = 'eleven_v3' } = await readJson(req);
   if (!text) return send(res, 400, { error: 'нужен text' });
+  const s = getSettings();
+
+  if (s.useChatium && s.chatium?.token && s.chatium?.base) {
+    return handleAudioViaChatium(res, s, { kind: 'tts', text, voice: voiceId, model: modelId });
+  }
+  if (!s.useElevenlabs) {
+    return send(res, 503, { error: 'Аудио-коннектор отключён. Включите Chatium или ElevenLabs.' });
+  }
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) return send(res, 500, { error: 'ELEVENLABS_API_KEY не задан' });
+  logProviderCall('POST', 'ElevenLabs', `${ELEVEN_BASE}/v1/text-to-speech/${voiceId}`, `model=${modelId} text=${text.length}ch`);
   const r = await fetch(`${ELEVEN_BASE}/v1/text-to-speech/${voiceId}`, {
     method: 'POST',
     headers: { 'xi-api-key': key, 'Content-Type': 'application/json', 'Accept': 'audio/mpeg' },
@@ -355,8 +766,37 @@ async function handleTts(req, res) {
     const t = await r.text();
     return send(res, r.status, { error: t.slice(0, 300) });
   }
-  res.writeHead(200, { 'Content-Type': 'audio/mpeg' });
-  const reader = r.body.getReader();
+  res.writeHead(200, { 'Content-Type': 'audio/mpeg', 'X-Provider': 'elevenlabs' });
+  await streamReaderToResponse(r.body.getReader(), res);
+}
+
+// Шлём audio-задачу в Chatium /api/audio, ждём готовности, скачиваем URL и
+// стримим клиенту как audio/mpeg (клиент ожидает blob, не URL).
+async function handleAudioViaChatium(res, s, body) {
+  try {
+    const taskId = await chatiumStart(s, 'audio', body);
+    const result = await chatiumWait(s, taskId, 180000);
+    const url = result.result?.urls?.[0];
+    if (!url) {
+      return send(res, 502, { error: 'Chatium завершил аудио-задачу без URL результата' }, { 'X-Provider': 'chatium' });
+    }
+    logProviderCall('GET ', 'Chatium', url, '(downloading audio)');
+    const headers = { 'X-Provider': 'chatium' };
+    if (typeof result.creditsCharged === 'number') {
+      headers['X-Cost-Credits'] = String(result.creditsCharged);
+    }
+    await streamUrlToResponse(url, res, 'audio/mpeg', headers);
+  } catch (e) {
+    logProviderCall('ERR ', 'Chatium', '/api/audio', e.message);
+    if (!res.headersSent) {
+      send(res, 502, { error: 'Chatium: ' + e.message }, { 'X-Provider': 'chatium' });
+    } else {
+      res.end();
+    }
+  }
+}
+
+async function streamReaderToResponse(reader, res) {
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
@@ -395,6 +835,8 @@ const server = createServer(async (req, res) => {
     if (req.method === 'POST' && url.pathname === '/api/sfx')      return handleSfx(req, res);
     if (req.method === 'POST' && url.pathname === '/api/music')    return handleMusic(req, res);
     if (req.method === 'POST' && url.pathname === '/api/text')     return handleText(req, res);
+    if (req.method === 'GET'  && url.pathname === '/api/balance')  return handleBalance(req, res);
+    if (req.method === 'GET'  && url.pathname === '/api/transactions') return handleTransactions(req, res);
     if (req.method === 'GET') return serveStatic(res, url);
     send(res, 404, 'not found');
   } catch (e) {
@@ -407,7 +849,10 @@ const server = createServer(async (req, res) => {
 process.on('unhandledRejection', (err) => console.error('[unhandledRejection]', err));
 process.on('uncaughtException',  (err) => console.error('[uncaughtException]', err));
 
-function start(port = PORT) {
+function start(port = PORT, opts = {}) {
+  if (typeof opts.getSettings === 'function') {
+    getSettings = opts.getSettings;
+  }
   return new Promise((resolveOk, reject) => {
     server.once('error', reject);
     server.listen(port, () => {
@@ -415,6 +860,8 @@ function start(port = PORT) {
       console.log(`▶  http://localhost:${addr.port}`);
       console.log(`   KIE_API_KEY:        ${process.env.KIE_API_KEY ? '✓' : '✗ missing'}`);
       console.log(`   ELEVENLABS_API_KEY: ${process.env.ELEVENLABS_API_KEY ? '✓' : '✗ missing'}`);
+      const s = getSettings();
+      console.log(`   providers:          chatium=${s.useChatium !== false ? '✓' : '✗'} openrouter=${s.useOpenrouter !== false ? '✓' : '✗'} elevenlabs=${s.useElevenlabs !== false ? '✓' : '✗'} kie=${s.useKie !== false ? '✓' : '✗'}`);
       resolveOk(addr.port);
     });
   });