@kevisual/api 0.0.42 → 0.0.43

package/dist/query-ai.d.ts

@@ -0,0 +1,78 @@
+import { Query, BaseQuery, DataOpts } from '@kevisual/query/query';
+
+type Message = {
+    role?: 'user' | 'assistant' | 'system' | 'tool';
+    content?: string;
+    name?: string;
+};
+type PostChat = {
+    messages?: Message[];
+    model?: string;
+    group?: string;
+    user?: string;
+};
+type ChatDataOpts = {
+    id?: string;
+    title?: string;
+    messages?: any[];
+    data?: any;
+    type?: 'temp' | 'keep' | string;
+};
+type ChatOpts = {
+    username: string;
+    model: string;
+    /**
+     * 获取完整消息回复
+     */
+    getFull?: boolean;
+    group: string;
+    /**
+     * openai的参数
+     */
+    options?: any;
+};
+declare const appDefine: any;
+
+declare class QueryApp<T extends Query = Query> extends BaseQuery<T, typeof appDefine> {
+    constructor(opts?: {
+        query: T;
+    });
+    /**
+     * 与 AI 进行对话, 调用 GPT 的AI 服务，生成结果，并返回。
+     * @param data
+     * @param opts
+     * @returns
+     */
+    postChat(data: PostChat, opts?: DataOpts): any;
+    /**
+     * 获取模型列表
+     * @param opts
+     * @returns
+     */
+    getModelList(data?: {
+        usernames?: string[];
+    }, opts?: DataOpts): any;
+    /**
+     * 聊天对话模型
+     * @param data
+     * @param chatOpts
+     * @param opts
+     * @returns
+     */
+    chat(data: ChatDataOpts, chatOpts: ChatOpts, opts?: DataOpts): any;
+    clearConfigCache(opts?: DataOpts): any;
+    /**
+     * 获取聊天使用情况
+     * @param opts
+     * @returns
+     */
+    getChatUsage(opts?: DataOpts): any;
+    /**
+     * 清除当前用户模型自己的统计
+     * @param opts
+     * @returns
+     */
+    clearSelfUsage(opts?: DataOpts): any;
+}
+
+export { QueryApp, appDefine };

package/dist/query-ai.js

@@ -0,0 +1,472 @@
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query-browser.js
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
+};
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = window?.location?.origin || "http://localhost:51515";
+    url = new URL(opts.url, origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
+        }
+      }
+    }
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    headers = {
+      "Content-Type": "application/json",
+      ...headers
+    };
+    body = JSON.stringify(opts.body);
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
+    }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    success: false,
+    message: message || "api request error",
+    showError: (fn) => {},
+    noMsg: true
+  };
+  return result;
+};
+
+class Query {
+  adapter;
+  url;
+  beforeRequest;
+  afterResponse;
+  headers;
+  timeout;
+  stop;
+  qws;
+  isClient = false;
+  constructor(opts) {
+    this.adapter = opts?.adapter || adapter;
+    const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
+    this.url = opts?.url || defaultURL;
+    this.headers = opts?.headers || {
+      "Content-Type": "application/json"
+    };
+    this.timeout = opts?.timeout || 60000 * 3;
+    if (opts.beforeRequest) {
+      this.beforeRequest = opts.beforeRequest;
+    } else {
+      this.beforeRequest = async (opts2) => {
+        const token = globalThis?.localStorage?.getItem("token");
+        if (token) {
+          opts2.headers = {
+            ...opts2.headers,
+            Authorization: `Bearer ${token}`
+          };
+        }
+        return opts2;
+      };
+    }
+  }
+  setQueryWs(qws) {
+    this.qws = qws;
+  }
+  setStop(stop) {
+    this.stop = stop;
+  }
+  async get(params, options) {
+    return this.post(params, options);
+  }
+  async post(body, options) {
+    const url = options?.url || this.url;
+    const { headers, adapter: adapter2, beforeRequest, afterResponse, timeout, ...rest } = options || {};
+    const _headers = { ...this.headers, ...headers };
+    const _adapter = adapter2 || this.adapter;
+    const _beforeRequest = beforeRequest || this.beforeRequest;
+    const _afterResponse = afterResponse || this.afterResponse;
+    const _timeout = timeout || this.timeout;
+    const req = {
+      url,
+      headers: _headers,
+      body,
+      timeout: _timeout,
+      ...rest
+    };
+    try {
+      if (_beforeRequest) {
+        const res = await _beforeRequest(req);
+        if (res === false) {
+          return wrapperError({
+            code: 500,
+            message: "request is cancel",
+            req
+          });
+        }
+      }
+    } catch (e) {
+      console.error("request beforeFn error", e, req);
+      return wrapperError({
+        code: 500,
+        message: "api request beforeFn error"
+      });
+    }
+    if (this.stop && !options?.noStop) {
+      const that = this;
+      await new Promise((resolve) => {
+        let timer = 0;
+        const detect = setInterval(() => {
+          if (!that.stop) {
+            clearInterval(detect);
+            resolve(true);
+          }
+          timer++;
+          if (timer > 30) {
+            console.error("request stop: timeout", req.url, timer);
+          }
+        }, 1000);
+      });
+    }
+    return _adapter(req).then(async (res) => {
+      try {
+        if (_afterResponse) {
+          return await _afterResponse(res, {
+            req,
+            res,
+            fetch: adapter2
+          });
+        }
+        return res;
+      } catch (e) {
+        console.error("request afterFn error", e, req);
+        return wrapperError({
+          code: 500,
+          message: "api request afterFn error"
+        });
+      }
+    });
+  }
+  before(fn) {
+    this.beforeRequest = fn;
+  }
+  after(fn) {
+    this.afterResponse = fn;
+  }
+  async fetchText(urlOrOptions, options) {
+    let _options = { ...options };
+    if (typeof urlOrOptions === "string" && !_options.url) {
+      _options.url = urlOrOptions;
+    }
+    if (typeof urlOrOptions === "object") {
+      _options = { ...urlOrOptions, ..._options };
+    }
+    const res = await adapter({
+      method: "GET",
+      ..._options,
+      headers: {
+        ...this.headers,
+        ..._options?.headers || {}
+      }
+    });
+    if (res && !res.code) {
+      return {
+        code: 200,
+        data: res
+      };
+    }
+    return res;
+  }
+}
+
+// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-define.js
+class Chain {
+  object;
+  app;
+  constructor(object, opts) {
+    this.object = object;
+    this.app = opts?.app;
+  }
+  get key() {
+    return this.object.key;
+  }
+  get path() {
+    return this.object.path;
+  }
+  setDescription(desc) {
+    this.object.description = desc;
+    return this;
+  }
+  setMeta(metadata) {
+    this.object.metadata = metadata;
+    return this;
+  }
+  setPath(path) {
+    this.object.path = path;
+    return this;
+  }
+  setMiddleware(middleware) {
+    this.object.middleware = middleware;
+    return this;
+  }
+  setKey(key) {
+    this.object.key = key;
+    return this;
+  }
+  setId(key) {
+    this.object.id = key;
+    return this;
+  }
+  setRun(run) {
+    this.object.run = run;
+    return this;
+  }
+  define(run) {
+    this.object.run = run;
+    return this;
+  }
+  createRoute() {
+    this.app.route(this.object).addTo(this.app);
+    return this;
+  }
+}
+
+class QueryChain {
+  obj = {};
+  query;
+  omitKeys = ["metadata", "description", "validator"];
+  constructor(value, opts) {
+    this.obj = value || {};
+    this.query = opts?.query;
+    if (opts?.omitKeys)
+      this.omitKeys = opts.omitKeys;
+  }
+  omit(obj, key = []) {
+    const newObj = { ...obj };
+    key.forEach((k) => {
+      delete newObj[k];
+    });
+    return newObj;
+  }
+  getKey(queryData) {
+    const obj = this.omit(this.obj, this.omitKeys);
+    return {
+      ...obj,
+      ...queryData
+    };
+  }
+  post(data, options) {
+    const _queryData = this.getKey(data);
+    return this.query.post(_queryData, options);
+  }
+  get(data, options) {
+    const _queryData = this.getKey(data);
+    return this.query.get(_queryData, options);
+  }
+}
+class QueryUtil {
+  obj;
+  app;
+  query;
+  constructor(object, opts) {
+    this.obj = object;
+    this.app = opts?.app;
+    this.query = opts?.query;
+  }
+  static createFormObj(object, opts) {
+    return new QueryUtil(object, opts);
+  }
+  static create(value, opts) {
+    const obj = value;
+    return new QueryUtil(obj, opts);
+  }
+  get(key) {
+    return this.obj[key];
+  }
+  chain(key, opts) {
+    const obj = this.obj[key];
+    let newOpts = { app: this.app, ...opts };
+    return new QueryUtil.Chain(obj, newOpts);
+  }
+  queryChain(key, opts) {
+    const value = this.obj[key];
+    let newOpts = { query: this.query, ...opts };
+    return new QueryUtil.QueryChain(value, newOpts);
+  }
+  static Chain = Chain;
+  static QueryChain = QueryChain;
+  get routeObject() {
+    return this.obj;
+  }
+}
+
+// query/index.ts
+var query = new Query;
+var clientQuery = new Query({ url: "/client/router" });
+
+// query/query-ai/defines/ai.ts
+var appDefine = QueryUtil.create({
+  chat: {
+    path: "ai",
+    key: "chat",
+    description: "与 AI 进行对话, 调用 GPT 的AI 服务，生成结果，并返回。"
+  }
+});
+
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query.js
+class BaseQuery {
+  query;
+  queryDefine;
+  constructor(opts) {
+    if (opts?.clientQuery) {
+      this.query = opts.clientQuery;
+    } else {
+      this.query = opts?.query;
+    }
+    if (opts.queryDefine) {
+      this.queryDefine = opts.queryDefine;
+      this.queryDefine.query = this.query;
+    }
+  }
+  get chain() {
+    return this.queryDefine.queryChain;
+  }
+  post(data, options) {
+    return this.query.post(data, options);
+  }
+  get(data, options) {
+    return this.query.get(data, options);
+  }
+}
+
+// query/query-ai/query-ai.ts
+class QueryApp extends BaseQuery {
+  constructor(opts) {
+    super({
+      ...opts,
+      query: opts?.query,
+      queryDefine: appDefine
+    });
+  }
+  postChat(data, opts) {
+    return this.chain("chat").post(data, opts);
+  }
+  getModelList(data, opts) {
+    return this.query.post({
+      path: "ai",
+      key: "get-model-list",
+      data
+    }, opts);
+  }
+  chat(data, chatOpts, opts) {
+    const { username, model, group, getFull = true } = chatOpts;
+    if (!username || !model || !group) {
+      throw new Error("username, model, group is required");
+    }
+    return this.query.post({
+      path: "ai",
+      key: "chat",
+      ...chatOpts,
+      getFull,
+      data
+    }, opts);
+  }
+  clearConfigCache(opts) {
+    return this.query.post({
+      path: "ai",
+      key: "clear-cache"
+    }, opts);
+  }
+  getChatUsage(opts) {
+    return this.query.post({
+      path: "ai",
+      key: "get-chat-usage"
+    }, opts);
+  }
+  clearSelfUsage(opts) {
+    return this.query.post({
+      path: "ai",
+      key: "clear-chat-limit"
+    }, opts);
+  }
+}
+export {
+  appDefine,
+  QueryApp
+};

package/dist/query-app.d.ts

@@ -0,0 +1,18 @@
+import { BaseQuery, Query, DataOpts } from '@kevisual/query/query';
+
+declare const appDefine: any;
+
+declare const userAppDefine: any;
+
+declare class QueryApp extends BaseQuery {
+    appDefine: any;
+    userAppDefine: any;
+    constructor(opts?: {
+        query: Query;
+    });
+    getList(data: any, opts?: DataOpts): any;
+    getPublicApp(data: any, opts?: DataOpts): any;
+    getApp(data: any, opts?: DataOpts): any;
+}
+
+export { QueryApp, appDefine, userAppDefine };