@nocobase/plugin-ai-gigachat 2.0.3

package/dist/node_modules/gigachat/src/api/stream_chat.ts

@@ -0,0 +1,164 @@
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { buildHeaders, buildXHeaders, parseChunk } from './utils';
+import { AuthenticationError, ResponseError } from '../exceptions';
+import { Chat, ChatCompletionChunk } from '../interfaces';
+import { EventEmitter } from 'events';
+
+const EVENT_STREAM = 'text/event-stream';
+
+interface GetChatStreamArgs {
+  chat: Chat;
+  accessToken?: string;
+}
+
+function getRequestConfig(
+  { chat, accessToken }: GetChatStreamArgs,
+  isBrowser: boolean = false,
+  abortSignal?: AbortSignal,
+): AxiosRequestConfig {
+  const headers = buildHeaders(accessToken);
+  if (!isBrowser) {
+    headers['Accept'] = EVENT_STREAM;
+    headers['Cache-Control'] = 'no-store';
+  }
+
+  const config = {
+    method: 'POST',
+    url: '/chat/completions',
+    responseType: 'stream',
+    data: { ...chat, ...{ stream: true } },
+    headers: headers,
+    signal: abortSignal,
+  } as AxiosRequestConfig;
+  if (isBrowser) {
+    config.adapter = 'fetch';
+  }
+
+  return config;
+}
+
+function checkContentType(response: AxiosResponse): void {
+  const contentType = response.headers['content-type']?.split(';')[0];
+  if (contentType !== EVENT_STREAM) {
+    throw new Error(`Expected response Content-Type to be '${EVENT_STREAM}', got '${contentType}'`);
+  }
+}
+
+function checkResponse(response: AxiosResponse): void {
+  if (response.status === 200) {
+    checkContentType(response);
+  } else if (response.status === 401) {
+    console.error(response.data);
+    throw new AuthenticationError(response);
+  } else {
+    console.error(response.data);
+    throw new ResponseError(response);
+  }
+}
+
+function splitLines(data: string): string[] {
+  return data.split(/\r?\n/).filter((line) => line.trim() !== '');
+}
+
+export async function stream_chat(
+  client: AxiosInstance,
+  args: GetChatStreamArgs,
+  isBrowser: boolean = false,
+  abortSignal?: AbortSignal,
+): Promise<any> {
+  let done = false;
+  const pushQueue: ChatCompletionChunk[] = [];
+  const readQueue: {
+    resolve: (chunk: ChatCompletionChunk | undefined) => void;
+    reject: (err: unknown) => void;
+  }[] = [];
+  const readable = await stream_chat_readable(client, args, isBrowser, abortSignal);
+  function t() {
+    return {
+      next() {
+        if (!pushQueue.length) {
+          if (done) {
+            return { value: undefined, done: true };
+          }
+          return new Promise<ChatCompletionChunk | undefined>((resolve, reject) =>
+            readQueue.push({ resolve, reject }),
+          ).then((chunk) => (chunk ? { value: chunk, done: false } : { value: undefined, done: true }));
+        }
+        const chunk = pushQueue.shift()!;
+        return { value: chunk, done: false };
+      },
+    };
+  }
+  const iterable = {
+    [Symbol.asyncIterator]: t,
+  };
+  readable.on('chunk', (chunk: any) => {
+    const reader = readQueue.shift();
+    if (reader) {
+      reader.resolve(chunk);
+    } else {
+      pushQueue.push(chunk);
+    }
+  });
+  readable.on('end', (chunk: any) => {
+    done = true;
+    for (const reader of readQueue) {
+      reader.resolve(undefined);
+    }
+    readQueue.length = 0;
+  });
+  return iterable;
+}
+
+export async function stream_chat_readable(
+  client: AxiosInstance,
+  args: GetChatStreamArgs,
+  isBrowser: boolean = false,
+  abortSignal?: AbortSignal,
+): Promise<EventEmitter> {
+  const config = getRequestConfig(args, isBrowser, abortSignal);
+  const emitter = new EventEmitter();
+
+  const response = await client.request(config);
+  checkResponse(response);
+
+  if (isBrowser) {
+    const reader = response.data.getReader();
+    reader.read().then(function pump({ done, value }: { done: boolean; value: Uint8Array }) {
+      if (done) {
+        emitter.emit('end');
+        return;
+      } else {
+        const chunk = new TextDecoder().decode(value);
+        const lines = splitLines(chunk.toString());
+        lines.forEach((line) => {
+          const chatChunk = parseChunk(line);
+          if (chatChunk) {
+            emitter.emit('chunk', buildXHeaders(response, chatChunk as ChatCompletionChunk)); // Отправка события с новым чанком
+          }
+        });
+      }
+      return reader.read().then(pump);
+    });
+  } else {
+    response.data.on('data', (chunk: Buffer) => {
+      const lines = splitLines(chunk.toString());
+      lines.forEach((line) => {
+        const chatChunk = parseChunk(line);
+        if (chatChunk) {
+          emitter.emit('chunk', buildXHeaders(response, chatChunk as ChatCompletionChunk)); // Отправка события с новым чанком
+        }
+      });
+    });
+    response.data.on('end', () => {
+      emitter.emit('end'); // Отправка события завершения
+    });
+    response.data.on('error', (error: any) => {
+      if (!axios.isCancel(error)) {
+        emitter.emit('error', error); // Отправка события ошибки
+      }
+    });
+  }
+
+  return emitter;
+}

package/dist/node_modules/gigachat/src/api/utils.ts

@@ -0,0 +1,66 @@
+import { USER_AGENT } from '../constants';
+import { AxiosResponse } from 'axios';
+import { WithXHeaders } from 'gigachat/interfaces';
+
+export function buildHeaders(accessToken?: string): Record<string, string> {
+  const headers: Record<string, string> = {};
+
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`;
+  }
+  if (!isRunningInBrowser()) {
+    headers['User-Agent'] = USER_AGENT;
+  } else {
+    headers['X-User-Agent'] = USER_AGENT;
+  }
+
+  return headers;
+}
+
+export function parseChunk<T>(line: string): T | null {
+  try {
+    const [name, value] = line.split(': ');
+    if (name === 'data') {
+      if (value === '[DONE]') {
+        return null;
+      } else {
+        return value ? JSON.parse(value) : null;
+      }
+    }
+  } catch (e) {
+    console.error(`Error parsing chunk from server: ${e}, raw value: ${line}`);
+    throw e;
+  }
+  return null;
+}
+
+export function buildXHeaders<T>(response: AxiosResponse, data: T): T & WithXHeaders {
+  const headers = response.headers;
+  const withXHeaders: WithXHeaders = {
+    xHeaders: {},
+  };
+  if (headers) {
+    withXHeaders.xHeaders = {
+      xRequestID: headers['x-request-id'],
+      xSessionID: headers['x-session-id'],
+      xClientID: headers['x-client-id'],
+    };
+  }
+  return {
+    ...data,
+    ...withXHeaders,
+  };
+}
+
+export function isRunningInBrowser() {
+  return (
+    // @ts-ignore
+    typeof window !== 'undefined' &&
+    // @ts-ignore
+    typeof window.document !== 'undefined' &&
+    // @ts-ignore
+    typeof navigator !== 'undefined'
+  );
+}
+
+export { USER_AGENT };

package/dist/node_modules/gigachat/src/constants.ts

@@ -0,0 +1,3 @@
+const USER_AGENT = 'GigaChat-js-lib';
+
+export { USER_AGENT };

package/dist/node_modules/gigachat/src/exceptions.ts

@@ -0,0 +1,25 @@
+import { AxiosResponse } from 'axios';
+
+export class GigaChatException extends Error {
+  public response: AxiosResponse;
+
+  constructor(response: AxiosResponse) {
+    super(response.data);
+    this.name = 'GigaChatException';
+    this.response = response;
+  }
+}
+
+export class ResponseError extends GigaChatException {
+  constructor(response: AxiosResponse) {
+    super(response);
+    this.name = 'ResponseError';
+  }
+}
+
+export class AuthenticationError extends ResponseError {
+  constructor(response: AxiosResponse) {
+    super(response);
+    this.name = 'AuthenticationError';
+  }
+}

package/dist/node_modules/gigachat/src/index.ts

@@ -0,0 +1,389 @@
+import axios, { AxiosInstance, CreateAxiosDefaults } from 'axios';
+
+import { AuthenticationError } from './exceptions';
+import {
+  get_balance,
+  get_image,
+  get_model,
+  get_models,
+  get_file,
+  get_files,
+  post_ai_check,
+  post_auth,
+  post_chat,
+  post_embeddings,
+  post_files,
+  post_files_delete,
+  post_token,
+  post_tokens_count,
+  stream_chat,
+  stream_chat_readable,
+} from './api';
+import {
+  AccessToken,
+  AICheckResult,
+  Balance,
+  Chat,
+  ChatCompletion,
+  ChatCompletionChunk,
+  DeletedFile,
+  Embeddings,
+  Image,
+  Model,
+  Models,
+  Token,
+  Tokens,
+  UploadedFile,
+  UploadedFiles,
+  WithXHeaders,
+} from './interfaces';
+import { getDefaultSettings, Settings } from './settings';
+import { EventEmitter } from 'events';
+import { isRunningInBrowser } from './api/utils';
+
+const GIGACHAT_MODEL = 'GigaChat';
+
+export interface GigaChatClientConfig {
+  /** Адрес относительно которого выполняются запросы */
+  baseUrl?: string;
+  /** Адрес для запроса токена доступа OAuth 2.0 */
+  authUrl?: string;
+  /** Авторизационные данные */
+  credentials?: string;
+  /** Версия API, к которой предоставляется доступ */
+  scope?: string;
+  /** JWE токен */
+  accessToken?: string;
+  /** Название модели, от которой нужно получить ответ */
+  model?: string;
+  /** Параметр цензуры */
+  profanityCheck?: boolean;
+  /** Имя пользователя */
+  user?: string;
+  /** Пароль */
+  password?: string;
+  /** Таймаут в секундах */
+  timeout?: number;
+  /** Детализация запросов в консоли */
+  verbose?: boolean;
+  /** Флаги, включающие особенные фичи */
+  flags?: string[];
+  /** HTTPS Agent, который прокидывается в Axios клиент */
+  httpsAgent?: any;
+  /** Включает работу библиотеку в браузере */
+  dangerouslyAllowBrowser?: boolean;
+}
+
+export interface DetectedImage {
+  uuid?: string;
+  postfix?: string;
+}
+
+export interface DetectedVideo {
+  uuid?: string;
+  cover_uuid?: string;
+  postfix?: string;
+}
+
+export function detectImage(message: string): DetectedImage | null {
+  const regex = /<img\ssrc="(?<uuid>.+?)"\sfuse="true"\/>(?<postfix>.*)?/ms;
+  const match = regex.exec(message);
+  if (!match || !match.groups) return null;
+  return {
+    uuid: match.groups['uuid'],
+    postfix: match.groups['postfix'],
+  };
+}
+
+export function detectVideo(message: string): DetectedVideo | null {
+  const regex = /<video\scover="(?<cover_uuid>.+?)"\ssrc="(?<uuid>.+?)"\sfuse="true"\/>(?<postfix>.+)?/ms;
+  const match = regex.exec(message);
+  if (!match || !match.groups) return null;
+  return {
+    uuid: match.groups['uuid'],
+    cover_uuid: match.groups['cover_uuid'],
+    postfix: match.groups['postfix'],
+  };
+}
+
+export class GigaChat {
+  public _client: AxiosInstance;
+  public _authClient: AxiosInstance;
+  public _settings: Settings;
+  protected _accessToken?: AccessToken;
+
+  constructor(config: GigaChatClientConfig) {
+    this._settings = { ...getDefaultSettings(), ...config } as Settings;
+    if (!this._settings.dangerouslyAllowBrowser && isRunningInBrowser()) {
+      throw new Error(
+        'Скорее всего вы пытаетесь запустить библиотеку GigaChat в браузере. Такое использование выключено по умолчанию, так как при таком использовании вы рискуете разоблачить ваш токен GigaChat третьим лицам! Чтобы включить использование библиотеки проставьте параметр dangerouslyAllowBrowser. ',
+      );
+    }
+
+    if (this._settings.accessToken) {
+      this._accessToken = {
+        access_token: this._settings.accessToken,
+        expires_at: 0,
+      };
+    }
+    this._client = axios.create(this._getAxiosConfig());
+    this._authClient = axios.create(this._getAuthAxiosConfig());
+
+    if (this._settings.accessToken) {
+      this._accessToken = {
+        access_token: this._settings.accessToken,
+        expires_at: 0,
+      };
+    }
+  }
+
+  protected get token(): string | undefined {
+    return this._accessToken?.access_token;
+  }
+
+  protected get useAuth(): boolean {
+    return Boolean(this._settings.credentials || (this._settings.user && this._settings.password));
+  }
+
+  protected checkValidityToken(): boolean {
+    /** Проверить время завершения действия токена */
+    return !!this._accessToken;
+  }
+
+  protected resetToken(): void {
+    /** Сбросить токен */
+    this._accessToken = undefined;
+  }
+
+  protected parseChat(payload: Chat | Record<string, any> | string): Chat {
+    let chat: Chat;
+    if (typeof payload === 'string') {
+      chat = {
+        messages: [{ role: 'user', content: payload }],
+      };
+    } else {
+      chat = payload as Chat;
+    }
+
+    chat.model = chat.model ?? this._settings.model ?? GIGACHAT_MODEL;
+    chat.profanity_check = chat.profanity_check ?? this._settings.profanityCheck;
+    chat.flags = chat.flags ?? this._settings.flags;
+    return chat;
+  }
+
+  private _getAxiosConfig(): CreateAxiosDefaults {
+    return {
+      baseURL: this._settings.baseUrl,
+      timeout: this._settings.timeout * 1000,
+      httpsAgent: this._settings.httpsAgent,
+      validateStatus: () => true,
+    };
+  }
+
+  private _getAuthAxiosConfig(): CreateAxiosDefaults {
+    return {
+      httpsAgent: this._settings.httpsAgent,
+      timeout: this._settings.timeout * 1000,
+      validateStatus: () => true,
+    };
+  }
+
+  public async updateToken(): Promise<void> {
+    // if (authorization_cvar.get() !== undefined) {
+    //     return;
+    // }
+    if (this._settings.credentials) {
+      const credData = await post_auth(this._authClient, {
+        url: this._settings.authUrl,
+        credentials: this._settings.credentials,
+        scope: this._settings.scope,
+      });
+      if ('tok' in credData) {
+        // @ts-ignore
+        this._accessToken = this._buildAccessToken(credData);
+      } else {
+        this._accessToken = credData;
+      }
+      console.info('OAUTH UPDATE TOKEN');
+    } else if (this._settings.user && this._settings.password) {
+      const token = await post_token(this._client, {
+        user: this._settings.user,
+        password: this._settings.password,
+      });
+      this._accessToken = this._buildAccessToken(token);
+      console.info('UPDATE TOKEN');
+    }
+  }
+
+  private async _decorator<T>(call: () => Promise<T>): Promise<T> {
+    if (this.useAuth) {
+      if (this.checkValidityToken()) {
+        try {
+          return await call();
+        } catch (error) {
+          if (error instanceof AuthenticationError) {
+            console.warn('AUTHENTICATION ERROR');
+            this.resetToken();
+          } else {
+            throw error;
+          }
+        }
+      }
+      await this.updateToken();
+    }
+    return await call();
+  }
+
+  public async tokensCount(input: string[], model?: string): Promise<Tokens & WithXHeaders> {
+    if (!model) {
+      model = this._settings.model || GIGACHAT_MODEL;
+    }
+    return this._decorator(() =>
+      post_tokens_count(this._client, {
+        input,
+        model: model || this._settings.model || GIGACHAT_MODEL,
+        accessToken: this.token,
+      }),
+    );
+  }
+
+  public async aiCheck(input: string, model: string): Promise<AICheckResult & WithXHeaders> {
+    return this._decorator(() =>
+      post_ai_check(this._client, {
+        input,
+        model,
+        accessToken: this.token,
+      }),
+    );
+  }
+
+  public async balance(): Promise<Balance & WithXHeaders> {
+    return this._decorator(() => get_balance(this._client, { accessToken: this.token }));
+  }
+
+  public async embeddings(texts: string[], model: string = 'Embeddings'): Promise<Embeddings> {
+    return this._decorator(() =>
+      post_embeddings(this._client, {
+        accessToken: this.token,
+        input: texts,
+        model,
+      }),
+    );
+  }
+
+  public async getModels(): Promise<Models> {
+    return this._decorator(() => get_models(this._client, { accessToken: this.token }));
+  }
+
+  public async getModel(model: string): Promise<Model> {
+    return this._decorator(() =>
+      get_model(this._client, {
+        model,
+        accessToken: this.token,
+      }),
+    );
+  }
+
+  public async getImage(fileId: string): Promise<Image> {
+    return this._decorator(() =>
+      get_image(this._client, {
+        fileId,
+        accessToken: this.token,
+      }),
+    );
+  }
+
+  public async uploadFile(file: File, purpose: 'general' | 'assistant' = 'general'): Promise<UploadedFile> {
+    return this._decorator(() => post_files(this._client, { file, purpose, accessToken: this.token }));
+  }
+
+  public async getFile(file: string): Promise<UploadedFile> {
+    return this._decorator(() => get_file(this._client, { file, accessToken: this.token }));
+  }
+
+  public async getFiles(): Promise<UploadedFiles> {
+    return this._decorator(() => get_files(this._client, { accessToken: this.token }));
+  }
+
+  public async deleteFile(file: string): Promise<DeletedFile> {
+    return this._decorator(() => post_files_delete(this._client, { file, accessToken: this.token }));
+  }
+
+  public async chat(payload: Chat | Record<string, any> | string): Promise<ChatCompletion & WithXHeaders> {
+    const chat = this.parseChat(payload);
+    return this._decorator(() =>
+      post_chat(this._client, {
+        chat,
+        accessToken: this.token,
+      }),
+    );
+  }
+
+  public async stream_readable(
+    payload: Chat | Record<string, any> | string,
+    abortSignal?: AbortSignal,
+  ): Promise<EventEmitter> {
+    const chat = this.parseChat(payload);
+    return this._decorator(() =>
+      stream_chat_readable(
+        this._client,
+        {
+          chat,
+          accessToken: this.token,
+        },
+        this._settings.dangerouslyAllowBrowser,
+        abortSignal,
+      ),
+    );
+  }
+
+  public async *stream(
+    payload: Chat | Record<string, any> | string,
+    abortSignal?: AbortSignal,
+  ): AsyncIterable<ChatCompletionChunk & WithXHeaders> {
+    const chat = this.parseChat(payload);
+
+    if (this.useAuth) {
+      if (this.checkValidityToken()) {
+        try {
+          const stream = await stream_chat(
+            this._client,
+            { chat, accessToken: this.token },
+            this._settings.dangerouslyAllowBrowser,
+            abortSignal,
+          );
+          for await (const chunk of stream) {
+            yield chunk;
+          }
+          return;
+        } catch (error) {
+          if (error instanceof AuthenticationError) {
+            console.warn('AUTHENTICATION ERROR');
+            this.resetToken();
+          } else {
+            throw error;
+          }
+        }
+      }
+      await this.updateToken();
+    }
+    const stream = await stream_chat(
+      this._client,
+      { chat, accessToken: this.token },
+      this._settings.dangerouslyAllowBrowser,
+      abortSignal,
+    );
+    for await (const chunk of stream) {
+      yield chunk;
+    }
+  }
+
+  private _buildAccessToken(token: Token): AccessToken {
+    return {
+      access_token: token.tok,
+      expires_at: token.exp,
+    };
+  }
+}
+
+export default GigaChat;

package/dist/node_modules/gigachat/src/interfaces/access_token.ts

@@ -0,0 +1,9 @@
+interface AccessToken {
+  /** Сгенерированный Access Token */
+  access_token: string;
+
+  /** Unix-время завершения действия Access Token в миллисекундах */
+  expires_at: number;
+}
+
+export type { AccessToken };

package/dist/node_modules/gigachat/src/interfaces/ai_check_result.ts

@@ -0,0 +1,16 @@
+interface AICheckResult {
+  /** Результат проверки текста. Возможные значения: [ai, human, mixed] */
+  category: string;
+
+  /** Количество символов в переданном тексте. */
+  characters: number;
+
+  /** Количество токенов в переданном тексте. */
+  tokens: number;
+
+  /** Части текста, сгенерированные моделью.
+   *  Обозначаются индексами символов, с которых начинаются и заканчиваются сгенерированные фрагменты. */
+  ai_intervals?: number[][];
+}
+
+export type { AICheckResult };

package/dist/node_modules/gigachat/src/interfaces/balance.ts

@@ -0,0 +1,11 @@
+export interface BalanceValue {
+  /** Наименование услуги */
+  usage: string;
+  /** Количество доступных токенов */
+  value: number;
+}
+
+export interface Balance {
+  /** Список объектов BalanceValue */
+  balance: BalanceValue[];
+}