neogram 9.3.0

package/src/TelegramObject.js

@@ -0,0 +1,106 @@
+export class TelegramObject {
+  /**
+   * Конструктор с поддержкой маппинга полей (from -> from_user, type -> type_val и т.д.)
+   */
+  constructor(data = {}) {
+    if (data && typeof data === 'object') {
+      for (const [key, value] of Object.entries(data)) {
+        // Применяем тот же маппинг что и в fromJSON
+        let field = key;
+        if (key === 'from') {
+          field = 'from_user';
+        } else if (key === 'type') {
+          field = 'type_val';
+        } else if (key === 'filter') {
+          field = 'filter_val';
+        }
+
+        this[field] = value;
+      }
+    }
+  }
+
+  /**
+   * Сериализация в JSON с учётом правил:
+   * - from_user -> from
+   * - type_val -> type
+   * - filter_val -> filter
+   */
+  toJSON() {
+    const result = {};
+    for (const [key, value] of Object.entries(this)) {
+      if (value === null || value === undefined) {
+        continue;
+      }
+
+      let outKey = key;
+      if (key === 'from_user') {
+        outKey = 'from';
+      } else if (key === 'type_val') {
+        outKey = 'type';
+      } else if (key === 'filter_val') {
+        outKey = 'filter';
+      }
+
+      result[outKey] = this.#clean(value);
+    }
+    return result;
+  }
+
+  #clean(val) {
+    if (val === null || val === undefined) {
+      return val;
+    }
+
+    if (Array.isArray(val)) {
+      return val.map(v => this.#clean(v));
+    }
+
+    if (val instanceof TelegramObject) {
+      return val.toJSON();
+    }
+
+    if (typeof val === 'object') {
+      const out = {};
+      for (const [k, v] of Object.entries(val)) {
+        if (v === null || v === undefined) {
+          continue;
+        }
+        out[k] = this.#clean(v);
+      }
+      return out;
+    }
+
+    return val;
+  }
+
+  /**
+   * Базовый fromJSON — просто маппит поля с учётом from/type/filter.
+   * Конкретные классы могут переопределить, если нужно создавать вложенные объекты.
+   */
+  static fromJSON(data) {
+    const obj = new this();
+    if (!data || typeof data !== 'object') {
+      return obj;
+    }
+
+    for (const [key, value] of Object.entries(data)) {
+      let field = key;
+      if (key === 'from') {
+        field = 'from_user';
+      } else if (key === 'type') {
+        field = 'type_val';
+      } else if (key === 'filter') {
+        field = 'filter_val';
+      }
+
+      if (field in obj) {
+        obj[field] = value;
+      } else {
+        // позволяем динамически добавлять поля, чтобы сохранить максимум данных
+        obj[field] = value;
+      }
+    }
+    return obj;
+  }
+}

package/src/ai/ChatGPT.js

@@ -0,0 +1,77 @@
+import axios from 'axios';
+
+export class ChatGPT {
+  constructor(url, headers = {}) {
+    this.url = url ? url.replace(/\/$/, '') : '';
+    this.headers = headers;
+  }
+
+  async _makeRequest(method, endpoint, data = null, files = null) {
+    try {
+      const url = `${this.url}/${endpoint.replace(/^\//, '')}`;
+      let response;
+      if (files) {
+        const FormData = (await import('form-data')).default;
+        const form = new FormData();
+        for (const [k, v] of Object.entries(data || {})) {
+          form.append(k, v);
+        }
+        for (const [k, v] of Object.entries(files)) {
+          form.append(k, v);
+        }
+        response = await axios.request({
+          method,
+          url,
+          headers: { ...this.headers, ...form.getHeaders() },
+          data: form,
+        });
+      } else {
+        response = await axios.request({
+          method,
+          url,
+          headers: {
+            ...this.headers,
+            'Content-Type': 'application/json',
+          },
+          data: data ? JSON.stringify(data) : undefined,
+        });
+      }
+      return response.data;
+    } catch (e) {
+      console.error(`ChatGPT(${endpoint}):`, e.message);
+      throw new Error(`ChatGPT API error: ${e.message}`);
+    }
+  }
+
+  async generateChatCompletion(model, messages, temperature = null, max_tokens = null, stream = false, ...kwargs) {
+    const data = { model, messages, temperature, max_tokens, stream, ...kwargs };
+    return await this._makeRequest('POST', 'chat/completions', data);
+  }
+
+  async generateImage(prompt, n = 1, size = '1024x1024', response_format = 'url', ...kwargs) {
+    const data = { prompt, n, size, response_format, ...kwargs };
+    return await this._makeRequest('POST', 'images/generations', data);
+  }
+
+  async generateEmbedding(model, input_i, user = null, ...kwargs) {
+    const data = { model, input: input_i, user, ...kwargs };
+    return await this._makeRequest('POST', 'embeddings', data);
+  }
+
+  async generateTranscription(file, model, language = null, prompt = null, response_format = 'json', temperature = 0, ...kwargs) {
+    const data = { model, language, prompt, response_format, temperature, ...kwargs };
+    const files = { file };
+    return await this._makeRequest('POST', 'audio/transcriptions', data, files);
+  }
+
+  async generateTranslation(file, model, prompt = null, response_format = 'json', temperature = 0, ...kwargs) {
+    const data = { model, prompt, response_format, temperature, ...kwargs };
+    const files = { file };
+    return await this._makeRequest('POST', 'audio/translations', data, files);
+  }
+
+  async getModels() {
+    return await this._makeRequest('GET', 'models');
+  }
+}
+

package/src/ai/Deef.js

@@ -0,0 +1,170 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import fs from 'fs';
+
+export class Deef {
+  async translate(text = null, lang = 'en') {
+    try {
+      if (!text) {
+        throw new Error('Text parameter is required');
+      }
+      const url = `https://translate.google.com/m?tl=${encodeURIComponent(lang)}&sl=auto&q=${encodeURIComponent(text)}`;
+      const { data } = await axios.get(url, {
+        timeout: 10000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; Deef/1.0)',
+        },
+      });
+      const $ = cheerio.load(data);
+      const div = $('div.result-container').first();
+      return div.text() || text;
+    } catch (e) {
+      console.error('Deef translate error:', e.message);
+      throw new Error(`Translation failed: ${e.message}`);
+    }
+  }
+
+  async shortUrl(longUrl = null) {
+    try {
+      if (!longUrl) {
+        throw new Error('URL parameter is required');
+      }
+      const { data } = await axios.get(`https://clck.ru/--?url=${encodeURIComponent(longUrl)}`, {
+        timeout: 5000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; Deef/1.0)',
+        },
+      });
+      return (data || '').toString().trim();
+    } catch (e) {
+      console.error('Deef shortUrl error:', e.message);
+      throw new Error(`URL shortening failed: ${e.message}`);
+    }
+  }
+
+  runInBg(func, ...args) {
+    (async() => {
+      try {
+        await func(...args);
+      } catch (e) {
+        console.log(`Error[${func}]:`, e.message);
+      }
+    })();
+  }
+
+  async encodeBase64(path = null) {
+    try {
+      if (!path) {
+        throw new Error('Path parameter is required');
+      }
+      const buf = await fs.promises.readFile(path);
+      return buf.toString('base64');
+    } catch (e) {
+      console.error('Deef encodeBase64 error:', e.message);
+      throw new Error(`File encoding failed: ${e.message}`);
+    }
+  }
+
+  async genAiResponse(model = 'Qwen3 235B', messages = null) {
+    try {
+      if (!messages) {
+        throw new Error('Messages parameter is required');
+      }
+      const modelToCluster = { 'Qwen3 235B': 'hybrid', 'GPT OSS 120B': 'nvidia' };
+      const clusterMode = modelToCluster[model];
+      if (!clusterMode) {
+        throw new Error(`Unknown model: ${model}. Available models: ${Object.keys(modelToCluster).join(', ')}`);
+      }
+      const payload = {
+        model,
+        clusterMode,
+        messages,
+        enableThinking: true,
+      };
+      const response = await axios.post('https://chat.gradient.network/api/generate', payload, {
+        responseType: 'stream',
+        timeout: 30000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; Deef/1.0)',
+        },
+      });
+
+      const result = { reasoning: '', answer: '', status: 'unknown', cluster_info: null };
+
+      // Handle streaming response properly
+      if (response.data && typeof response.data.pipe === 'function') {
+        // It's a stream
+        const chunks = [];
+        for await (const chunk of response.data) {
+          chunks.push(chunk);
+        }
+        const fullData = Buffer.concat(chunks).toString('utf8');
+        const lines = fullData.split('\n').filter(Boolean);
+
+        for (const line of lines) {
+          try {
+            const jsonObj = JSON.parse(line);
+            const type = jsonObj.type;
+            if (type === 'reply') {
+              const dc = jsonObj.data || {};
+              if (dc.reasoningContent) {
+                result.reasoning += dc.reasoningContent;
+              }
+              if (dc.content) {
+                result.answer += dc.content;
+              }
+            } else if (type === 'jobInfo') {
+              const status = jsonObj.data?.status;
+              result.status = status;
+              if (status === 'completed') {
+                break;
+              }
+            } else if (type === 'clusterInfo') {
+              result.cluster_info = jsonObj.data || null;
+            }
+          } catch (_parseError) {
+            // Skip invalid JSON lines
+            continue;
+          }
+        }
+      } else {
+        // Handle non-streaming response
+        throw new Error('Expected streaming response');
+      }
+
+      return result;
+    } catch (e) {
+      console.error('Deef(genAiResponse):', e.message);
+      throw new Error(`AI response generation failed: ${e.message}`);
+    }
+  }
+
+  async genGpt(messages = null) {
+    try {
+      if (!messages) {
+        throw new Error('Messages parameter is required');
+      }
+      const { data, status } = await axios.post(
+        'https://italygpt.it/api/chat',
+        { messages, stream: true },
+        {
+          timeout: 30000,
+          headers: {
+            'User-Agent':
+              'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36',
+            'Accept': 'text/event-stream',
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+      if (status === 200) {
+        return data.toString();
+      }
+      throw new Error(`API returned status ${status}`);
+    } catch (e) {
+      console.error('Deef(genGpt):', e.message);
+      throw new Error(`GPT generation failed: ${e.message}`);
+    }
+  }
+}
+

package/src/ai/OnlySQ.js

@@ -0,0 +1,126 @@
+import axios from 'axios';
+import fs from 'fs';
+
+export class OnlySQ {
+  async getModels({
+    modality = null,
+    can_tools = null,
+    can_stream = null,
+    status = null,
+    max_cost = null,
+    return_names = false,
+  } = {}) {
+    try {
+      const { data } = await axios.get('https://api.onlysq.ru/ai/models', {
+        timeout: 10000,
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; OnlySQ/1.0)',
+        },
+      });
+      const models = data?.models || {};
+      const out = [];
+      for (const [key, model] of Object.entries(models)) {
+        let ok = true;
+        if (modality !== null) {
+          const mods = Array.isArray(modality) ? modality : [modality];
+          if (!mods.includes(model.modality)) {
+            ok = false;
+          }
+        }
+        if (ok && can_tools !== null) {
+          const val = model['can-tools'] ?? false;
+          if (val !== can_tools) {
+            ok = false;
+          }
+        }
+        if (ok && can_stream !== null) {
+          const val = model['can-stream'] ?? false;
+          if (val !== can_stream) {
+            ok = false;
+          }
+        }
+        if (ok && status !== null) {
+          if ((model.status ?? '') !== status) {
+            ok = false;
+          }
+        }
+        if (ok && max_cost !== null) {
+          const cost = parseFloat(model.cost ?? Number.POSITIVE_INFINITY);
+          if (cost > max_cost) {
+            ok = false;
+          }
+        }
+        if (ok) {
+          out.push(return_names ? model.name : key);
+        }
+      }
+      return out;
+    } catch (e) {
+      console.error('OnlySQ(getModels):', e.message);
+      throw new Error(`Failed to get models: ${e.message}`);
+    }
+  }
+
+  async generateAnswer(model = 'gpt-5.2-chat', messages = null) {
+    try {
+      if (!messages) {
+        throw new Error('Messages parameter is required');
+      }
+      const payload = { model, request: { messages } };
+      const { data } = await axios.post('https://api.onlysq.ru/ai/v2', payload, {
+        timeout: 30000,
+        headers: {
+          'Authorization': 'Bearer openai',
+          'Content-Type': 'application/json',
+          'User-Agent': 'Mozilla/5.0 (compatible; OnlySQ/1.0)',
+        },
+      });
+
+      if (!data?.choices?.[0]?.message?.content) {
+        throw new Error('Invalid API response format');
+      }
+
+      return data.choices[0].message.content;
+    } catch (e) {
+      console.error('OnlySQ(generateAnswer):', e.message);
+      throw new Error(`Answer generation failed: ${e.message}`);
+    }
+  }
+
+  async generateImage(model = 'flux', prompt = null, ratio = '16:9', filename = 'image.png') {
+    try {
+      if (!prompt) {
+        throw new Error('Prompt parameter is required');
+      }
+      if (!filename) {
+        throw new Error('Filename parameter is required');
+      }
+
+      const payload = { model, prompt, ratio };
+      const { data, status } = await axios.post(
+        'https://api.onlysq.ru/ai/imagen',
+        payload,
+        {
+          timeout: 60000, // Image generation can take longer
+          headers: {
+            'Authorization': 'Bearer openai',
+            'Content-Type': 'application/json',
+            'User-Agent': 'Mozilla/5.0 (compatible; OnlySQ/1.0)',
+          },
+        },
+      );
+
+      if (status === 200 && data?.files?.[0]) {
+        const buf = Buffer.from(data.files[0], 'base64');
+        await fs.promises.writeFile(filename, buf);
+        return true;
+      }
+
+      throw new Error('Invalid API response or no image generated');
+    } catch (e) {
+      console.error('OnlySQ(generateImage):', e.message);
+      throw new Error(`Image generation failed: ${e.message}`);
+    }
+  }
+}
+