admin/Z.AI-Chat-for-Android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 8 Wiki Activity
Files
1026259a2080657d848204e478706940c220406a
Z.AI-Chat-for-Android/node_modules/@nicepkg/gpt-runner-shared/dist/shared/gpt-runner-shared.79ccd90a.cjs

1507 lines
49 KiB
JavaScript
Raw Blame History

'use strict';
const minimatch = require('minimatch');
const debug = require('debug');
const zodToJsonSchema = require('zod-to-json-schema');
const zod = require('zod');
const axios = require('axios');
const jsonc = require('jsonc-parser');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
const n = Object.create(null);
if (e) {
for (const k in e) {
n[k] = e[k];
}
}
n["default"] = e;
return n;
}
const debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
const jsonc__namespace = /*#__PURE__*/_interopNamespace(jsonc);
function sleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
function hasOwn(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
function formatSourceValue(value) {
let result;
if (value === "true") {
result = true;
} else if (value === "false") {
result = false;
} else if (/^-?\d*\.?\d+$/.test(value)) {
result = parseFloat(value);
} else if (/^-?\d+$/.test(value)) {
result = parseInt(value, 10);
} else {
result = value;
}
return result;
}
function travelTree(tree, callback) {
const travel = (tree2, parent) => {
const result = [];
tree2.forEach((item) => {
const callbackResult = callback(item, parent);
const finalItem = callbackResult === void 0 ? item : callbackResult;
if (finalItem && item.children)
finalItem.children = travel(item.children, item);
if (finalItem !== null)
result.push(finalItem);
});
return result;
};
return travel(tree);
}
function travelTreeDeepFirst(tree, callback) {
const travel = (tree2, parent) => {
const result = [];
tree2.forEach((item) => {
let children;
if (item.children)
children = travel(item.children, item);
const callbackResult = callback({ ...item, children }, parent);
const finalItem = callbackResult === void 0 ? item : callbackResult;
if (finalItem !== null)
result.push(finalItem);
});
return result;
};
return travel(tree);
}
function tryParseJson(str, supportJsonc = false) {
try {
const target = str?.trim() ?? "";
return supportJsonc ? jsonc__namespace.parse(target) : JSON.parse(target);
} catch (e) {
console.error("tryParseJson error: ", str, e);
return {};
}
}
function tryStringifyJson(obj, ignoreError = false) {
try {
return JSON.stringify(obj);
} catch (e) {
!ignoreError && console.error("tryStringifyJson error: ", e);
return "";
}
}
function debounce(callback, wait) {
let timeout;
return function(...args) {
const context = this;
const later = function() {
timeout = void 0;
callback.apply(context, args);
};
clearTimeout(timeout);
timeout = setTimeout(later, wait);
};
}
const keyIsCalledMap = /* @__PURE__ */ new Map();
function runOnceByKey(callback, key) {
return function(...args) {
const context = this;
const keyIsCalled = keyIsCalledMap.get(key);
if (keyIsCalled)
return;
const result = callback?.apply(context, args);
if (result instanceof Promise) {
result?.then?.(() => {
keyIsCalledMap.set(key, true);
});
} else {
keyIsCalledMap.set(key, true);
}
return result;
};
}
function urlRemoveLocalhost(url) {
if (typeof window === "undefined")
return url || "";
if (!url)
return "";
try {
const uri = new URL(url);
let result = url;
const currentHostname = window.location.hostname;
const currentPort = window.location.port;
if (["localhost", "127.0.0.1"].includes(uri.hostname))
uri.hostname = currentHostname;
if (!currentPort || [80, 443].includes(Number(currentPort)))
uri.port = currentPort;
uri.protocol = window.location.protocol;
result = uri.toString();
if (!url.endsWith("/"))
result = result.replace(/\/$/, "");
return result;
} catch {
return url;
}
}
function objectToQueryString(obj, prefix) {
const queryStringArray = [];
for (const key in obj) {
if (hasOwn(obj, key)) {
const value = obj[key];
const encodedKey = encodeURIComponent(prefix ? `${prefix}[${key}]` : key);
if (Array.isArray(value)) {
for (const item of value) {
queryStringArray.push(
`${encodedKey}[]=${encodeURIComponent(item)}`
);
}
} else if (typeof value === "object" && value !== null) {
queryStringArray.push(objectToQueryString(value, encodedKey));
} else {
queryStringArray.push(`${encodedKey}=${encodeURIComponent(value)}`);
}
}
}
return queryStringArray.join("&");
}
function toUnixPath(path) {
if (!path)
return "";
return path.replace(/\\+/g, "/");
}
function getProcessCwd() {
try {
return toUnixPath(process.cwd());
} catch (e) {
return void 0;
}
}
function getErrorMsg(error) {
const errorMessage = String(
error instanceof axios.AxiosError ? error.response?.data?.message : error?.message || error || ""
);
return errorMessage;
}
function waitForCondition(conditionFn, timeout = 1e4) {
return new Promise((resolve, reject) => {
const startTime = Date.now();
const interval = setInterval(() => {
if (conditionFn()) {
clearInterval(interval);
resolve();
} else if (Date.now() - startTime > timeout) {
clearInterval(interval);
console.warn("waitForCondition timeout with function", conditionFn.toString());
reject(new Error("waitForCondition timeout"));
}
}, 100);
});
}
function isChineseCharacter(char) {
const charCode = char.charCodeAt(0);
return charCode >= 19968 && charCode <= 40959 || charCode >= 13312 && charCode <= 19903 || charCode >= 131072 && charCode <= 173791 || charCode >= 173824 && charCode <= 177983 || charCode >= 177984 && charCode <= 178207 || charCode >= 178208 && charCode <= 183983 || charCode >= 63744 && charCode <= 64255 || charCode >= 194560 && charCode <= 195103;
}
var ChatModelType = /* @__PURE__ */ ((ChatModelType2) => {
ChatModelType2["Openai"] = "openai";
ChatModelType2["HuggingFace"] = "huggingFace";
ChatModelType2["Anthropic"] = "anthropic";
return ChatModelType2;
})(ChatModelType || {});
var ChatRole = /* @__PURE__ */ ((ChatRole2) => {
ChatRole2["User"] = "user";
ChatRole2["Assistant"] = "assistant";
ChatRole2["System"] = "system";
return ChatRole2;
})(ChatRole || {});
var ChatMessageStatus = /* @__PURE__ */ ((ChatMessageStatus2) => {
ChatMessageStatus2["Pending"] = "pending";
ChatMessageStatus2["Success"] = "success";
ChatMessageStatus2["Error"] = "error";
return ChatMessageStatus2;
})(ChatMessageStatus || {});
var ClientEventName = /* @__PURE__ */ ((ClientEventName2) => {
ClientEventName2["InitSuccess"] = "initSuccess";
ClientEventName2["RefreshTree"] = "refreshTree";
ClientEventName2["RefreshChatTree"] = "refreshChatTree";
ClientEventName2["RefreshFileTree"] = "refreshFileTree";
ClientEventName2["InsertCodes"] = "insertCodes";
ClientEventName2["DiffCodes"] = "diffCodes";
ClientEventName2["UpdateIdeOpeningFiles"] = "updateIdeOpeningFiles";
ClientEventName2["UpdateIdeActiveFilePath"] = "updateIdeActiveFilePath";
ClientEventName2["UpdateUserSelectedText"] = "updateUserSelectedText";
ClientEventName2["OpenFileInIde"] = "openFileInIde";
ClientEventName2["OpenFileInFileEditor"] = "openFileInFileEditor";
ClientEventName2["GoToChatPanel"] = "goToChatPanel";
return ClientEventName2;
})(ClientEventName || {});
var GptFileTreeItemType = /* @__PURE__ */ ((GptFileTreeItemType2) => {
GptFileTreeItemType2["Folder"] = "folder";
GptFileTreeItemType2["File"] = "file";
GptFileTreeItemType2["Chat"] = "chat";
return GptFileTreeItemType2;
})(GptFileTreeItemType || {});
var ServerStorageName = /* @__PURE__ */ ((ServerStorageName2) => {
ServerStorageName2["FrontendState"] = "frontend-state";
ServerStorageName2["SecretsConfig"] = "secrets-config";
ServerStorageName2["GlobalState"] = "global-state";
ServerStorageName2["WebPreset"] = "web-preset";
return ServerStorageName2;
})(ServerStorageName || {});
var WssActionName = /* @__PURE__ */ ((WssActionName2) => {
WssActionName2["Error"] = "error";
WssActionName2["StorageGetItem"] = "storageGetItem";
WssActionName2["StorageSetItem"] = "storageSetItem";
WssActionName2["StorageRemoveItem"] = "storageRemoveItem";
WssActionName2["StorageClear"] = "storageClear";
return WssActionName2;
})(WssActionName || {});
var LocaleLang = /* @__PURE__ */ ((LocaleLang2) => {
LocaleLang2["English"] = "en";
LocaleLang2["ChineseSimplified"] = "zh_CN";
LocaleLang2["ChineseTraditional"] = "zh_Hant";
LocaleLang2["Japanese"] = "ja";
LocaleLang2["German"] = "de";
return LocaleLang2;
})(LocaleLang || {});
var SecretStorageKey = /* @__PURE__ */ ((SecretStorageKey2) => {
SecretStorageKey2["Anthropic"] = "anthropic";
SecretStorageKey2["HuggingFace"] = "huggingFace";
SecretStorageKey2["Openai"] = "openai";
SecretStorageKey2["Proxy"] = "proxy";
return SecretStorageKey2;
})(SecretStorageKey || {});
var VendorTag = /* @__PURE__ */ ((VendorTag2) => {
VendorTag2["Free"] = "free";
VendorTag2["Official"] = "official";
VendorTag2["Unofficial"] = "unofficial";
VendorTag2["Recommended"] = "recommended";
return VendorTag2;
})(VendorTag || {});
const MIN_NODE_VERSION = "16.15.0";
const SECRET_KEY_PLACEHOLDER = "********";
const STREAM_DONE_FLAG = "[DONE]";
const GPT_RUNNER_OFFICIAL_FOLDER = ".gpt-runner";
const DEFAULT_API_BASE_PATH = {
[ChatModelType.Anthropic]: "https://api.anthropic.com",
[ChatModelType.HuggingFace]: "https://api-inference.huggingface.co",
[ChatModelType.Openai]: "https://api.openai.com/v1"
};
const DEFAULT_MODEL_NAMES_FOR_CHOOSE = {
[ChatModelType.Anthropic]: [
"claude-2",
"claude-instant-1"
],
[ChatModelType.HuggingFace]: [],
[ChatModelType.Openai]: [
"gpt-3.5-turbo-16k",
"gpt-4",
"gpt-4-32k",
"gpt-3.5-turbo"
]
};
const DEFAULT_EXCLUDE_FILES = [
"**/node_modules",
"**/.git",
"**/__pycache__",
"**/.Python",
"**/.DS_Store",
"**/.cache",
"**/.next",
"**/.nuxt",
"**/.out",
"**/dist",
"**/.serverless",
"**/.parcel-cache"
];
const DEFAULT_EXCLUDE_FILE_EXTS = [
".jpg",
".png",
".gif",
".jpeg",
".svg",
".mp4",
".mp3",
".wav",
".flac",
".ogg",
".webm",
".ico",
".pdf",
".doc",
".docx",
".xls",
".xlsx",
".ppt",
".pptx",
".zip",
".rar",
".7z",
".tar",
".gz",
".tgz",
".bz2",
".xz",
".exe",
".dmg",
".pkg",
".deb",
".rpm",
".msi",
".apk",
".ipa",
".iso",
".img",
".bin",
".dll",
".so",
".dylib",
".a",
".lib",
".o",
".obj",
".class",
".jar",
".war",
".ear",
".swf",
".fla",
".as",
".as3",
".mxml",
".swc",
".swd",
".swz",
".swt",
".air",
".ane",
".ttf",
".woff",
".woff2",
".eot",
".otf",
".psd",
".ai",
".sketch",
".fig",
".xd",
".blend",
".fbx",
".obj",
".mtl",
".stl",
".3ds",
".dae",
".max",
".ma",
".mb",
".lwo",
".lws",
".lxo",
".c4d",
".csv",
".tsv",
".pth",
".pt",
".h5",
".hdf5",
".ckpt",
".ckpt.index"
];
const config = {
NODE_ENV: {
defaultValue: "production"
},
OPENAI_API_KEY: {
serverSideOnly: true
},
GPTR_DEFAULT_ROOT_PATH: {
defaultValue: getProcessCwd()
},
GPTR_ONLY_LOAD_CONFIG_PATH: {},
GPTR_BASE_SERVER_URL: {
defaultValue: "http://localhost:3003"
}
};
class EnvConfig {
static get(key) {
const envVarConfig = config[key];
if (!envVarConfig)
return "";
const { defaultValue, serverSideOnly = false } = envVarConfig;
if (typeof window !== "undefined" && !serverSideOnly)
return window?.__env__?.[key] ?? defaultValue ?? "";
return process.env[key] ?? defaultValue ?? "";
}
static getAllEnvVarsOnScopes(type, getWays = "all") {
const envVars = {};
for (const _key in config) {
const key = _key;
const keyConfig = config[key];
if (!keyConfig)
continue;
const { serverSideOnly } = keyConfig;
if (serverSideOnly && type === "client")
continue;
envVars[key] = getWays === "all" ? EnvConfig.get(key) : process.env[key];
}
return envVars;
}
static logServerSideEnvVars() {
const envVars = EnvConfig.getAllEnvVarsOnScopes("server");
console.log(
"Server side environment variables:",
JSON.stringify(envVars, null, 2)
);
}
static logClientSideEnvVars() {
const envVars = EnvConfig.getAllEnvVarsOnScopes("client");
console.log(
"Client side environment variables:",
JSON.stringify(envVars, null, 2)
);
}
static getClientEnvVarsInServerSide() {
return EnvConfig.getAllEnvVarsOnScopes("client", "all");
}
}
function createFilterByPattern(pattern) {
if (pattern === null || pattern === void 0)
return () => true;
if (typeof pattern === "function")
return pattern;
if (typeof pattern === "string")
return (source) => minimatch.minimatch(source, pattern);
if (pattern instanceof RegExp)
return (source) => pattern.test(source);
if (Array.isArray(pattern)) {
const matchers = pattern.map((p) => createFilterByPattern(p));
return (source) => matchers.some((matcher) => matcher(source));
}
throw new Error(`Invalid pattern: ${pattern}`);
}
class Debug {
constructor(label) {
this.label = `gpt-runner:${label}`;
if (process.env.DEBUG)
debug__default.enable(this.label);
this.debugger = debug__default(this.label);
this.debugger.useColors = true;
this.debugger.color = String(debug__default.selectColor(this.label));
}
static getInstance(label = "default") {
if (!Debug.instance)
Debug.instance = new Debug(label);
return Debug.instance;
}
log(message, ...args) {
this.debugger(message, ...args);
}
warn(message, ...args) {
this.debugger(`[WARN]: ${message}`, ...args);
}
error(message, ...args) {
this.debugger(`[ERROR]: ${message}`, ...args);
}
}
function buildSuccessResponse(options) {
return {
type: "Success",
status: options.status || 200,
...options
};
}
function buildFailResponse(options) {
return {
type: "Fail",
status: options.status || 400,
...options
};
}
// Unique ID creation requires a high quality random # generator. In the browser we therefore
// require the crypto API and do not support built-in fallback to lower quality random number
// generators (like Math.random()).
let getRandomValues;
const rnds8 = new Uint8Array(16);
function rng() {
// lazy load so that environments that need to polyfill have a chance to do so
if (!getRandomValues) {
// getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
if (!getRandomValues) {
throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
}
}
return getRandomValues(rnds8);
}
const REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
function validate(uuid) {
return typeof uuid === 'string' && REGEX.test(uuid);
}
/**
* Convert array of 16 byte values to UUID string format of the form:
* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
*/
const byteToHex = [];
for (let i = 0; i < 256; ++i) {
byteToHex.push((i + 0x100).toString(16).slice(1));
}
function unsafeStringify(arr, offset = 0) {
// Note: Be careful editing this code! It's been tuned for performance
// and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
}
function parse(uuid) {
if (!validate(uuid)) {
throw TypeError('Invalid UUID');
}
let v;
const arr = new Uint8Array(16); // Parse ########-....-....-....-............
arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
arr[1] = v >>> 16 & 0xff;
arr[2] = v >>> 8 & 0xff;
arr[3] = v & 0xff; // Parse ........-####-....-....-............
arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
arr[5] = v & 0xff; // Parse ........-....-####-....-............
arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
arr[7] = v & 0xff; // Parse ........-....-....-####-............
arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
arr[9] = v & 0xff; // Parse ........-....-....-....-############
// (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
arr[11] = v / 0x100000000 & 0xff;
arr[12] = v >>> 24 & 0xff;
arr[13] = v >>> 16 & 0xff;
arr[14] = v >>> 8 & 0xff;
arr[15] = v & 0xff;
return arr;
}
function stringToBytes(str) {
str = unescape(encodeURIComponent(str)); // UTF8 escape
const bytes = [];
for (let i = 0; i < str.length; ++i) {
bytes.push(str.charCodeAt(i));
}
return bytes;
}
const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
const URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
function v35(name, version, hashfunc) {
function generateUUID(value, namespace, buf, offset) {
var _namespace;
if (typeof value === 'string') {
value = stringToBytes(value);
}
if (typeof namespace === 'string') {
namespace = parse(namespace);
}
if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
} // Compute hash of namespace and value, Per 4.3
// Future: Use spread syntax when supported on all platforms, e.g. `bytes =
// hashfunc([...namespace, ... value])`
let bytes = new Uint8Array(16 + value.length);
bytes.set(namespace);
bytes.set(value, namespace.length);
bytes = hashfunc(bytes);
bytes[6] = bytes[6] & 0x0f | version;
bytes[8] = bytes[8] & 0x3f | 0x80;
if (buf) {
offset = offset || 0;
for (let i = 0; i < 16; ++i) {
buf[offset + i] = bytes[i];
}
return buf;
}
return unsafeStringify(bytes);
} // Function#name is not settable on some platforms (#270)
try {
generateUUID.name = name; // eslint-disable-next-line no-empty
} catch (err) {} // For CommonJS default export support
generateUUID.DNS = DNS;
generateUUID.URL = URL$1;
return generateUUID;
}
/*
* Browser-compatible JavaScript MD5
*
* Modification of JavaScript MD5
* https://github.com/blueimp/JavaScript-MD5
*
* Copyright 2011, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* https://opensource.org/licenses/MIT
*
* Based on
* A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
* Digest Algorithm, as defined in RFC 1321.
* Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/
function md5(bytes) {
if (typeof bytes === 'string') {
const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
bytes = new Uint8Array(msg.length);
for (let i = 0; i < msg.length; ++i) {
bytes[i] = msg.charCodeAt(i);
}
}
return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
}
/*
* Convert an array of little-endian words to an array of bytes
*/
function md5ToHexEncodedArray(input) {
const output = [];
const length32 = input.length * 32;
const hexTab = '0123456789abcdef';
for (let i = 0; i < length32; i += 8) {
const x = input[i >> 5] >>> i % 32 & 0xff;
const hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
output.push(hex);
}
return output;
}
/**
* Calculate output length with padding and bit length
*/
function getOutputLength(inputLength8) {
return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
}
/*
* Calculate the MD5 of an array of little-endian words, and a bit length.
*/
function wordsToMd5(x, len) {
/* append padding */
x[len >> 5] |= 0x80 << len % 32;
x[getOutputLength(len) - 1] = len;
let a = 1732584193;
let b = -271733879;
let c = -1732584194;
let d = 271733878;
for (let i = 0; i < x.length; i += 16) {
const olda = a;
const oldb = b;
const oldc = c;
const oldd = d;
a = md5ff(a, b, c, d, x[i], 7, -680876936);
d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
b = md5gg(b, c, d, a, x[i], 20, -373897302);
a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
d = md5hh(d, a, b, c, x[i], 11, -358537222);
c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
a = md5ii(a, b, c, d, x[i], 6, -198630844);
d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
a = safeAdd(a, olda);
b = safeAdd(b, oldb);
c = safeAdd(c, oldc);
d = safeAdd(d, oldd);
}
return [a, b, c, d];
}
/*
* Convert an array bytes to an array of little-endian words
* Characters >255 have their high-byte silently ignored.
*/
function bytesToWords(input) {
if (input.length === 0) {
return [];
}
const length8 = input.length * 8;
const output = new Uint32Array(getOutputLength(length8));
for (let i = 0; i < length8; i += 8) {
output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
}
return output;
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safeAdd(x, y) {
const lsw = (x & 0xffff) + (y & 0xffff);
const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return msw << 16 | lsw & 0xffff;
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bitRotateLeft(num, cnt) {
return num << cnt | num >>> 32 - cnt;
}
/*
* These functions implement the four basic operations the algorithm uses.
*/
function md5cmn(q, a, b, x, s, t) {
return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
}
function md5ff(a, b, c, d, x, s, t) {
return md5cmn(b & c | ~b & d, a, b, x, s, t);
}
function md5gg(a, b, c, d, x, s, t) {
return md5cmn(b & d | c & ~d, a, b, x, s, t);
}
function md5hh(a, b, c, d, x, s, t) {
return md5cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5ii(a, b, c, d, x, s, t) {
return md5cmn(c ^ (b | ~d), a, b, x, s, t);
}
v35('v3', 0x30, md5);
const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
const native = {
randomUUID
};
function v4(options, buf, offset) {
if (native.randomUUID && !buf && !options) {
return native.randomUUID();
}
options = options || {};
const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
rnds[6] = rnds[6] & 0x0f | 0x40;
rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
if (buf) {
offset = offset || 0;
for (let i = 0; i < 16; ++i) {
buf[offset + i] = rnds[i];
}
return buf;
}
return unsafeStringify(rnds);
}
// Adapted from Chris Veness' SHA1 code at
// http://www.movable-type.co.uk/scripts/sha1.html
function f(s, x, y, z) {
switch (s) {
case 0:
return x & y ^ ~x & z;
case 1:
return x ^ y ^ z;
case 2:
return x & y ^ x & z ^ y & z;
case 3:
return x ^ y ^ z;
}
}
function ROTL(x, n) {
return x << n | x >>> 32 - n;
}
function sha1(bytes) {
const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
if (typeof bytes === 'string') {
const msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
bytes = [];
for (let i = 0; i < msg.length; ++i) {
bytes.push(msg.charCodeAt(i));
}
} else if (!Array.isArray(bytes)) {
// Convert Array-like to Array
bytes = Array.prototype.slice.call(bytes);
}
bytes.push(0x80);
const l = bytes.length / 4 + 2;
const N = Math.ceil(l / 16);
const M = new Array(N);
for (let i = 0; i < N; ++i) {
const arr = new Uint32Array(16);
for (let j = 0; j < 16; ++j) {
arr[j] = bytes[i * 64 + j * 4] << 24 | bytes[i * 64 + j * 4 + 1] << 16 | bytes[i * 64 + j * 4 + 2] << 8 | bytes[i * 64 + j * 4 + 3];
}
M[i] = arr;
}
M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
M[N - 1][14] = Math.floor(M[N - 1][14]);
M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
for (let i = 0; i < N; ++i) {
const W = new Uint32Array(80);
for (let t = 0; t < 16; ++t) {
W[t] = M[i][t];
}
for (let t = 16; t < 80; ++t) {
W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
}
let a = H[0];
let b = H[1];
let c = H[2];
let d = H[3];
let e = H[4];
for (let t = 0; t < 80; ++t) {
const s = Math.floor(t / 20);
const T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t] >>> 0;
e = d;
d = c;
c = ROTL(b, 30) >>> 0;
b = a;
a = T;
}
H[0] = H[0] + a >>> 0;
H[1] = H[1] + b >>> 0;
H[2] = H[2] + c >>> 0;
H[3] = H[3] + d >>> 0;
H[4] = H[4] + e >>> 0;
}
return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
}
v35('v5', 0x50, sha1);
var __accessCheck = (obj, member, msg) => {
if (!member.has(obj))
throw TypeError("Cannot " + msg);
};
var __privateGet = (obj, member, getter) => {
__accessCheck(obj, member, "read from private field");
return getter ? getter.call(obj) : member.get(obj);
};
var __privateAdd = (obj, member, value) => {
if (member.has(obj))
throw TypeError("Cannot add the same private member more than once");
member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
};
var __privateSet = (obj, member, value, setter) => {
__accessCheck(obj, member, "write to private field");
setter ? setter.call(obj, value) : member.set(obj, value);
return value;
};
var _wssUrl, _socketQueue, _hasConnected, _wss, _setWss, _connectNodeSocket, _connectBrowserSocket, _handleConnection;
const _WssUtils = class {
constructor(wssUrl) {
__privateAdd(this, _wssUrl, void 0);
__privateAdd(this, _socketQueue, []);
__privateAdd(this, _hasConnected, false);
__privateAdd(this, _wss, void 0);
__privateAdd(this, _setWss, (socket) => {
__privateSet(this, _wss, socket);
__privateGet(this, _socketQueue).forEach((fn) => fn(socket));
__privateSet(this, _socketQueue, []);
});
this.connect = async (params) => {
if (this.wss || __privateGet(this, _hasConnected))
return this.wss;
console.log("Connecting to WS...");
const { server } = params || {};
try {
if (_WssUtils.isBrowser)
await __privateGet(this, _connectBrowserSocket).call(this);
else
server && await __privateGet(this, _connectNodeSocket).call(this, server);
__privateSet(this, _hasConnected, true);
return this.wss;
} catch (error) {
console.error("Error connecting to WS", error);
throw error;
}
};
__privateAdd(this, _connectNodeSocket, async (server) => {
if (_WssUtils.isBrowser || this.wss)
return;
const { Server } = await import('socket.io');
const serverSocket = new Server(server, {
cors: {
origin: "*"
}
});
serverSocket.on("connection", (socket) => {
__privateGet(this, _setWss).call(this, socket);
__privateGet(this, _handleConnection).call(this);
});
});
__privateAdd(this, _connectBrowserSocket, async () => {
if (!_WssUtils.isBrowser || this.wss)
return;
const { io } = await import('socket.io-client');
const socket = io(this.wsUrl);
__privateGet(this, _setWss).call(this, socket);
});
__privateAdd(this, _handleConnection, async () => {
console.log("Connected to Socket server");
});
this.on = (eventName, callback) => {
if (!this.wss) {
__privateGet(this, _socketQueue).push((socket) => {
socket.on(eventName, callback);
});
return;
}
this.wss.on(eventName, callback);
};
this.emit = (eventName, message) => {
if (!this.wss) {
__privateGet(this, _socketQueue).push((socket) => {
socket.emit(eventName, message);
});
return;
}
this.wss.emit(eventName, message);
};
this.off = (eventName, callback) => {
if (!this.wss) {
__privateGet(this, _socketQueue).push((socket) => {
socket.off(eventName, callback);
});
return;
}
this.wss.off(eventName, callback);
};
this.emitAndWaitForRes = async (eventName, message) => {
return new Promise((resolve, reject) => {
let destroyFn;
const timeout = setTimeout(() => {
destroyFn?.();
reject(new Error(`WS timeout, actionName: ${eventName}`));
}, 1e4);
const __id__ = v4();
this.emit(eventName, { ...message, __id__ });
const handler = (message2) => {
if (message2.__id__ !== __id__)
return;
destroyFn?.();
resolve(message2);
};
this.on(eventName, handler);
destroyFn = () => {
clearTimeout(timeout);
this.off(eventName, handler);
};
});
};
__privateSet(this, _wssUrl, urlRemoveLocalhost(wssUrl ?? _WssUtils.defaultWssUrl));
}
static get instance() {
if (!this._instance)
this._instance = new _WssUtils();
return this._instance;
}
static get isBrowser() {
return typeof window !== "undefined";
}
static isNodeServerSocket(socket) {
return typeof window === "undefined" && Boolean(socket);
}
static isBrowserSocket(socket) {
return _WssUtils.isBrowser && Boolean(socket);
}
get wsUrl() {
return __privateGet(this, _wssUrl);
}
get wss() {
return __privateGet(this, _wss);
}
};
let WssUtils = _WssUtils;
_wssUrl = new WeakMap();
_socketQueue = new WeakMap();
_hasConnected = new WeakMap();
_wss = new WeakMap();
_setWss = new WeakMap();
_connectNodeSocket = new WeakMap();
_connectBrowserSocket = new WeakMap();
_handleConnection = new WeakMap();
WssUtils.defaultWssUrl = `http://${new URL(EnvConfig.get("GPTR_BASE_SERVER_URL")).host}`;
function verifyZod(schema, value) {
const result = schema.safeParse(value);
if (!result.success) {
const errorTextArr = [];
result.error.issues.forEach((issue) => {
const { path: fields } = issue;
return fields.forEach((field) => {
const prefix = errorTextArr.length === 0 ? "Error: " : ".\n";
const errorText = `${prefix}${field} field is ${issue.message?.toLowerCase()}`;
errorTextArr.push(errorText);
});
});
throw new Error(errorTextArr.join("\n"));
}
return result.data;
}
const ChatModelTypeSchema = zod.z.nativeEnum(ChatModelType);
const ChatRoleSchema = zod.z.nativeEnum(ChatRole);
const ChatMessageStatusSchema = zod.z.nativeEnum(ChatMessageStatus);
const ClientEventNameSchema = zod.z.nativeEnum(ClientEventName);
const GptFileTreeItemTypeSchema = zod.z.nativeEnum(GptFileTreeItemType);
const ServerStorageNameSchema = zod.z.nativeEnum(ServerStorageName);
const LocaleLangSchema = zod.z.nativeEnum(LocaleLang);
const BaseSecretsSchema = zod.z.object({
basePath: zod.z.string().optional().describe("The base API url")
});
const BaseModelConfigSchema = zod.z.object({
type: ChatModelTypeSchema.optional().describe("The type of the model"),
modelName: zod.z.string().optional().describe("The name of the model"),
secrets: zod.z.any().optional().describe("The API secrets config")
});
const AnthropicSecretsSchema = BaseSecretsSchema.extend({
apiKey: zod.z.string().optional().describe("The Anthropic API key"),
basePath: zod.z.string().optional().default(DEFAULT_API_BASE_PATH[ChatModelType.Anthropic]).describe("The Anthropic base API url")
});
const AnthropicModelConfigSchema = BaseModelConfigSchema.extend({
type: zod.z.literal(ChatModelType.Anthropic).describe("Use Anthropic model"),
secrets: AnthropicSecretsSchema.optional().describe("The Anthropic API secrets config"),
temperature: zod.z.number().optional().describe("The temperature for the Anthropic model"),
maxTokens: zod.z.number().optional().describe("The maximum number of tokens for the Anthropic model"),
topP: zod.z.number().optional().describe("The top P value for the Anthropic model"),
topK: zod.z.number().optional().describe("The top K value for the Anthropic model")
});
const HuggingFaceSecretsSchema = BaseSecretsSchema.extend({
apiKey: zod.z.string().optional().describe("The HuggingFace API key")
});
const HuggingFaceModelConfigSchema = BaseModelConfigSchema.extend({
type: zod.z.literal(ChatModelType.HuggingFace).describe("Use Open AI model"),
secrets: HuggingFaceSecretsSchema.optional().describe("The HuggingFace API secrets config"),
temperature: zod.z.number().optional().describe("The temperature for the HuggingFace model"),
maxTokens: zod.z.number().optional().describe("The maximum number of tokens for the HuggingFace model"),
topP: zod.z.number().optional().describe("The top P value for the HuggingFace model"),
topK: zod.z.number().optional().describe("The top K value for the HuggingFace model"),
frequencyPenalty: zod.z.number().optional().describe("The frequency penalty for the HuggingFace model")
});
const OpenaiSecretsSchema = BaseSecretsSchema.extend({
apiKey: zod.z.string().optional().describe("The OpenAI API key"),
organization: zod.z.string().optional().describe("The OpenAI organization"),
accessToken: zod.z.string().optional().describe("The OpenAI access token"),
basePath: zod.z.string().optional().default(DEFAULT_API_BASE_PATH[ChatModelType.Openai]).describe("The OpenAI base API path")
});
const OpenaiModelConfigSchema = BaseModelConfigSchema.extend({
type: zod.z.literal(ChatModelType.Openai).describe("Use OpenAI model"),
secrets: OpenaiSecretsSchema.optional().describe("The OpenAI API secrets config"),
temperature: zod.z.number().optional().describe("The temperature for the OpenAI model"),
maxTokens: zod.z.number().optional().describe("The maximum number of tokens for the OpenAI model"),
topP: zod.z.number().optional().describe("The top P value for the OpenAI model"),
frequencyPenalty: zod.z.number().optional().describe("The frequency penalty for the OpenAI model"),
presencePenalty: zod.z.number().optional().describe("The presence penalty for the OpenAI model")
});
const FilterPatternSchema = zod.z.union([
zod.z.array(zod.z.union([zod.z.string(), zod.z.instanceof(RegExp)])),
zod.z.string(),
zod.z.instanceof(RegExp),
zod.z.function(zod.z.tuple([zod.z.string()]), zod.z.boolean()).optional(),
zod.z.null(),
zod.z.undefined()
]);
const ChatModelSchema = zod.z.union([
AnthropicModelConfigSchema,
HuggingFaceModelConfigSchema,
OpenaiModelConfigSchema
]);
const PartialChatModelTypeMapSchema = zod.z.object({
[ChatModelType.Anthropic]: AnthropicModelConfigSchema.optional(),
[ChatModelType.HuggingFace]: HuggingFaceModelConfigSchema.optional(),
[ChatModelType.Openai]: OpenaiModelConfigSchema.optional()
});
const UserConfigSchema = zod.z.object({
model: ChatModelSchema.optional().describe("The LLM model configuration"),
rootPath: zod.z.string().optional().describe("The root path of the project"),
exts: zod.z.array(zod.z.string()).optional().default([".gpt.md"]).describe("The file extensions to be used"),
includes: FilterPatternSchema.optional().default(null).describe("The include patterns for filtering files"),
excludes: FilterPatternSchema.optional().default(null).describe("The exclude patterns for filtering files"),
respectGitIgnore: zod.z.boolean().optional().default(true).describe("Whether to respect .gitignore rules"),
urlConfig: zod.z.record(zod.z.object({
modelNames: zod.z.array(zod.z.string()).optional().describe("The model name that will be displayed in the model selector"),
httpRequestHeader: zod.z.record(zod.z.string()).optional().describe("Additional request headers are required")
})).optional().default({}).describe("Custom http request headers and models names for specific urls")
});
const UserConfigForUserSchema = UserConfigSchema.omit({
rootPath: true,
exts: true
});
const SingleChatMessageSchema = zod.z.object({
name: ChatRoleSchema,
text: zod.z.string()
});
const FormOptionSchema = zod.z.object({
label: zod.z.string().optional(),
value: zod.z.string()
});
const FormFieldBaseConfigSchema = zod.z.object({
type: zod.z.string(),
defaultValue: zod.z.any().optional(),
description: zod.z.string().optional()
});
const FormInputConfigSchema = FormFieldBaseConfigSchema.extend({
type: zod.z.literal("input")
});
const FormTextareaConfigSchema = FormFieldBaseConfigSchema.extend({
type: zod.z.literal("textarea"),
row: zod.z.number().optional()
});
const FormSelectConfigSchema = FormFieldBaseConfigSchema.extend({
type: zod.z.literal("select"),
options: zod.z.array(FormOptionSchema)
});
const FormCheckboxGroupConfigSchema = FormFieldBaseConfigSchema.extend({
type: zod.z.literal("checkbox-group"),
options: zod.z.array(FormOptionSchema)
}).refine((config) => Array.isArray(config.defaultValue), {
message: "defaultValue must be an array of strings for checkbox-group",
path: ["defaultValue"]
});
const FormRadioGroupConfigSchema = FormFieldBaseConfigSchema.extend({
type: zod.z.literal("radio-group"),
options: zod.z.array(FormOptionSchema)
});
const FormItemConfigSchema = zod.z.union([
FormInputConfigSchema,
FormTextareaConfigSchema,
FormSelectConfigSchema,
FormCheckboxGroupConfigSchema,
FormRadioGroupConfigSchema
]);
const SingleFileConfigSchema = zod.z.object({
model: UserConfigSchema.shape.model,
title: zod.z.string().optional(),
userPrompt: zod.z.string().optional(),
systemPrompt: zod.z.string().optional(),
messages: zod.z.array(SingleChatMessageSchema).optional(),
forms: zod.z.record(FormItemConfigSchema).optional()
});
const ChatStreamReqParamsSchema = zod.z.object({
messages: zod.z.array(SingleChatMessageSchema),
prompt: zod.z.string(),
systemPrompt: zod.z.string().optional(),
appendSystemPrompt: zod.z.string().optional(),
systemPromptAsUserPrompt: zod.z.boolean().optional(),
singleFilePath: zod.z.string().optional(),
singleFileConfig: SingleFileConfigSchema.optional(),
overrideModelType: ChatModelTypeSchema.optional(),
overrideModelsConfig: PartialChatModelTypeMapSchema.optional(),
modelTypeVendorNameMap: zod.z.record(zod.z.string()).optional(),
contextFilePaths: zod.z.array(zod.z.string()).optional(),
editingFilePath: zod.z.string().optional(),
rootPath: zod.z.string().optional()
});
const GetModelNamesForChooseReqParamsSchema = zod.z.object({
rootPath: zod.z.string(),
modelType: ChatModelTypeSchema,
modelTypeVendorNameMap: zod.z.record(zod.z.string()).optional()
});
const GetGptFilesReqParamsSchema = zod.z.object({
rootPath: zod.z.string()
});
const GetGptFileInfoReqParamsSchema = zod.z.object({
rootPath: zod.z.string(),
filePath: zod.z.string()
});
const InitGptFilesReqParamsSchema = zod.z.object({
rootPath: zod.z.string(),
gptFilesNames: zod.z.array(zod.z.string())
});
const GetUserConfigReqParamsSchema = zod.z.object({
rootPath: zod.z.string()
});
const StorageGetItemReqParamsSchema = zod.z.object({
storageName: ServerStorageNameSchema,
key: zod.z.string()
});
const StorageSetItemReqParamsSchema = zod.z.object({
storageName: ServerStorageNameSchema,
key: zod.z.string(),
value: zod.z.record(zod.z.any()).nullable().optional()
});
const StorageRemoveItemReqParamsSchema = zod.z.object({
storageName: ServerStorageNameSchema,
key: zod.z.string()
});
const StorageClearReqParamsSchema = zod.z.object({
storageName: ServerStorageNameSchema
});
const GetCommonFilesReqParamsSchema = zod.z.object({
rootPath: zod.z.string(),
excludeExts: zod.z.array(zod.z.string()).optional()
});
const OpenEditorReqParamsSchema = zod.z.object({
rootPath: zod.z.string().optional(),
path: zod.z.string(),
matchContent: zod.z.string().optional()
});
const CreateFilePathReqParamsSchema = zod.z.object({
fileFullPath: zod.z.string(),
isDir: zod.z.boolean()
});
const RenameFilePathReqParamsSchema = zod.z.object({
oldFileFullPath: zod.z.string(),
newFileFullPath: zod.z.string()
});
const DeleteFilePathReqParamsSchema = zod.z.object({
fileFullPath: zod.z.string()
});
const GetFileInfoReqParamsSchema = zod.z.object({
fileFullPath: zod.z.string()
});
const SaveFileContentReqParamsSchema = zod.z.object({
fileFullPath: zod.z.string(),
content: zod.z.string()
});
const GetAppConfigReqParamsSchema = zod.z.object({
langId: LocaleLangSchema.optional()
});
const MarkAsVisitedAppConfigReqParamsSchema = zod.z.object({
types: zod.z.array(zod.z.union([
zod.z.literal("notificationDate"),
zod.z.literal("releaseDate")
]))
});
const userConfigJsonSchema = zodToJsonSchema.zodToJsonSchema(UserConfigForUserSchema);
const singleFileJsonSchema = zodToJsonSchema.zodToJsonSchema(SingleFileConfigSchema);
exports.AnthropicModelConfigSchema = AnthropicModelConfigSchema;
exports.AnthropicSecretsSchema = AnthropicSecretsSchema;
exports.BaseModelConfigSchema = BaseModelConfigSchema;
exports.BaseSecretsSchema = BaseSecretsSchema;
exports.ChatMessageStatus = ChatMessageStatus;
exports.ChatMessageStatusSchema = ChatMessageStatusSchema;
exports.ChatModelSchema = ChatModelSchema;
exports.ChatModelType = ChatModelType;
exports.ChatModelTypeSchema = ChatModelTypeSchema;
exports.ChatRole = ChatRole;
exports.ChatRoleSchema = ChatRoleSchema;
exports.ChatStreamReqParamsSchema = ChatStreamReqParamsSchema;
exports.ClientEventName = ClientEventName;
exports.ClientEventNameSchema = ClientEventNameSchema;
exports.CreateFilePathReqParamsSchema = CreateFilePathReqParamsSchema;
exports.DEFAULT_API_BASE_PATH = DEFAULT_API_BASE_PATH;
exports.DEFAULT_EXCLUDE_FILES = DEFAULT_EXCLUDE_FILES;
exports.DEFAULT_EXCLUDE_FILE_EXTS = DEFAULT_EXCLUDE_FILE_EXTS;
exports.DEFAULT_MODEL_NAMES_FOR_CHOOSE = DEFAULT_MODEL_NAMES_FOR_CHOOSE;
exports.Debug = Debug;
exports.DeleteFilePathReqParamsSchema = DeleteFilePathReqParamsSchema;
exports.EnvConfig = EnvConfig;
exports.FilterPatternSchema = FilterPatternSchema;
exports.FormCheckboxGroupConfigSchema = FormCheckboxGroupConfigSchema;
exports.FormFieldBaseConfigSchema = FormFieldBaseConfigSchema;
exports.FormInputConfigSchema = FormInputConfigSchema;
exports.FormItemConfigSchema = FormItemConfigSchema;
exports.FormOptionSchema = FormOptionSchema;
exports.FormRadioGroupConfigSchema = FormRadioGroupConfigSchema;
exports.FormSelectConfigSchema = FormSelectConfigSchema;
exports.FormTextareaConfigSchema = FormTextareaConfigSchema;
exports.GPT_RUNNER_OFFICIAL_FOLDER = GPT_RUNNER_OFFICIAL_FOLDER;
exports.GetAppConfigReqParamsSchema = GetAppConfigReqParamsSchema;
exports.GetCommonFilesReqParamsSchema = GetCommonFilesReqParamsSchema;
exports.GetFileInfoReqParamsSchema = GetFileInfoReqParamsSchema;
exports.GetGptFileInfoReqParamsSchema = GetGptFileInfoReqParamsSchema;
exports.GetGptFilesReqParamsSchema = GetGptFilesReqParamsSchema;
exports.GetModelNamesForChooseReqParamsSchema = GetModelNamesForChooseReqParamsSchema;
exports.GetUserConfigReqParamsSchema = GetUserConfigReqParamsSchema;
exports.GptFileTreeItemType = GptFileTreeItemType;
exports.GptFileTreeItemTypeSchema = GptFileTreeItemTypeSchema;
exports.HuggingFaceModelConfigSchema = HuggingFaceModelConfigSchema;
exports.HuggingFaceSecretsSchema = HuggingFaceSecretsSchema;
exports.InitGptFilesReqParamsSchema = InitGptFilesReqParamsSchema;
exports.LocaleLang = LocaleLang;
exports.LocaleLangSchema = LocaleLangSchema;
exports.MIN_NODE_VERSION = MIN_NODE_VERSION;
exports.MarkAsVisitedAppConfigReqParamsSchema = MarkAsVisitedAppConfigReqParamsSchema;
exports.OpenEditorReqParamsSchema = OpenEditorReqParamsSchema;
exports.OpenaiModelConfigSchema = OpenaiModelConfigSchema;
exports.OpenaiSecretsSchema = OpenaiSecretsSchema;
exports.PartialChatModelTypeMapSchema = PartialChatModelTypeMapSchema;
exports.RenameFilePathReqParamsSchema = RenameFilePathReqParamsSchema;
exports.SECRET_KEY_PLACEHOLDER = SECRET_KEY_PLACEHOLDER;
exports.STREAM_DONE_FLAG = STREAM_DONE_FLAG;
exports.SaveFileContentReqParamsSchema = SaveFileContentReqParamsSchema;
exports.SecretStorageKey = SecretStorageKey;
exports.ServerStorageName = ServerStorageName;
exports.ServerStorageNameSchema = ServerStorageNameSchema;
exports.SingleChatMessageSchema = SingleChatMessageSchema;
exports.SingleFileConfigSchema = SingleFileConfigSchema;
exports.StorageClearReqParamsSchema = StorageClearReqParamsSchema;
exports.StorageGetItemReqParamsSchema = StorageGetItemReqParamsSchema;
exports.StorageRemoveItemReqParamsSchema = StorageRemoveItemReqParamsSchema;
exports.StorageSetItemReqParamsSchema = StorageSetItemReqParamsSchema;
exports.UserConfigForUserSchema = UserConfigForUserSchema;
exports.UserConfigSchema = UserConfigSchema;
exports.VendorTag = VendorTag;
exports.WssActionName = WssActionName;
exports.WssUtils = WssUtils;
exports.buildFailResponse = buildFailResponse;
exports.buildSuccessResponse = buildSuccessResponse;
exports.createFilterByPattern = createFilterByPattern;
exports.debounce = debounce;
exports.formatSourceValue = formatSourceValue;
exports.getErrorMsg = getErrorMsg;
exports.getProcessCwd = getProcessCwd;
exports.hasOwn = hasOwn;
exports.isChineseCharacter = isChineseCharacter;
exports.objectToQueryString = objectToQueryString;
exports.runOnceByKey = runOnceByKey;
exports.singleFileJsonSchema = singleFileJsonSchema;
exports.sleep = sleep;
exports.toUnixPath = toUnixPath;
exports.travelTree = travelTree;
exports.travelTreeDeepFirst = travelTreeDeepFirst;
exports.tryParseJson = tryParseJson;
exports.tryStringifyJson = tryStringifyJson;
exports.urlRemoveLocalhost = urlRemoveLocalhost;
exports.userConfigJsonSchema = userConfigJsonSchema;
exports.verifyZod = verifyZod;
exports.waitForCondition = waitForCondition;
Reference in New Issue View Git Blame Copy Permalink