filecat 5.32.0 → 5.32.2

package/build/server/main/domain/ai_agent/ai_agent.service.js

@@ -0,0 +1,715 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ai_agentService = exports.Ai_agentService = void 0;
+const ai_agent_constant_1 = require("./ai_agent.constant");
+const stream_1 = require("stream");
+const os_1 = __importDefault(require("os"));
+const ai_agent_tools_1 = require("./ai_agent.tools");
+const setting_service_1 = require("../setting/setting.service");
+const path_1 = __importDefault(require("path"));
+const user_service_1 = require("../user/user.service");
+const pty_shell_1 = require("pty-shell");
+const shell_service_1 = require("../shell/shell.service");
+const user_req_1 = require("../../../common/req/user.req");
+const setting_req_1 = require("../../../common/req/setting.req");
+const Env_1 = require("../../../common/node/Env");
+const FileUtil_1 = require("../file/FileUtil");
+const StringUtil_1 = require("../../../common/StringUtil");
+const ValueUtil_1 = require("../../../common/ValueUtil");
+const ListUtil_1 = require("../../../common/ListUtil");
+const ws_server_1 = require("../../../common/frame/ws.server");
+const WsData_1 = require("../../../common/frame/WsData");
+const path_util_1 = require("../../../common/path_util");
+const common_util_1 = require("../../../common/common.util");
+const threads_filecat_1 = require("../../threads/filecat/threads.filecat");
+const threads_type_1 = require("../../threads/threads.type");
+const DataUtil_1 = require("../data/DataUtil");
+const data_type_1 = require("../data/data_type");
+const pinyin_pro_1 = require("pinyin-pro");
+const value_util_1 = require("../../../common/node/value.util");
+const config_1 = require("../../other/config");
+const { cut, cut_all, cut_for_search, tokenize, add_word, } = require("jieba-wasm");
+let API_KEY = process.env.AI_API_KEY;
+let BASE_URL = "https://ark.cn-beijing.volces.com/api/v3/chat/completions";
+let MODEL = "doubao-seed-1-6";
+let config;
+let config_env = new setting_req_1.ai_agent_item_dotenv();
+let config_search_doc = new setting_req_1.ai_docs_setting_param();
+function isChinese(str) {
+    return /[\u4e00-\u9fa5]/.test(str);
+}
+class Ai_agentService {
+    constructor() {
+        this.docs_data_map = new Map();
+        this.docs_info = new setting_req_1.ai_docs_load_info();
+        this.all_wss_set = new Set;
+        this.running_num = 1;
+        this.sys_ai_is_open = false;
+    }
+    async search_docs({ keywords }) {
+        const scoreMap = new Map();
+        const new_keywords = {};
+        for (const k of keywords) {
+            if (!k)
+                continue;
+            new_keywords[k] = 1;
+            if (isChinese(k)) {
+                for (const k2 of cut_for_search(k, true)) {
+                    if (k2)
+                        new_keywords[k2] = 1;
+                }
+                const pyFull = (0, pinyin_pro_1.pinyin)(k, { toneType: "none" });
+                if (pyFull) {
+                    new_keywords[pyFull.replace(/\s+/g, "")] = 1;
+                }
+            }
+            else {
+            }
+        }
+        let keys = [...new Set(Object.keys(new_keywords)
+                .map(k => k.toLowerCase().trim())
+                .filter(Boolean))];
+        keys = [keys.join(" ")];
+        const r_list = await Promise.all(keys.map(k => threads_filecat_1.ThreadsFilecat.post(threads_type_1.threads_msg_type.docs_search, { key: k }, 60000)));
+        for (let i = 0; i < r_list.length; i++) {
+            const { ids, names_ids } = r_list[i];
+            let extra_weight = 0;
+            for (let i = 0; i < ids.length; i++) {
+                const id = ids[i];
+                const weight = 1 / (i + 1) + extra_weight;
+                scoreMap.set(id, (scoreMap.get(id) || 0) + weight);
+            }
+            for (let i = 0; i < names_ids.length; i++) {
+                const id = names_ids[i];
+                const weight = 1 / (i + 1) + extra_weight + 0.5;
+                scoreMap.set(id, (scoreMap.get(id) || 0) + weight);
+            }
+        }
+        const sorted = [...scoreMap.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([id]) => id);
+        const results = [];
+        let total_char_num = 0;
+        for (const id of sorted) {
+            if (total_char_num >= config_search_doc.docs_max_char_num) {
+                break;
+            }
+            const content = (await FileUtil_1.FileUtil.readFileSync(id)).toString();
+            results.push({
+                file_name: id,
+                content
+            });
+            total_char_num += content.length;
+        }
+        return `知识库搜索结果 ${JSON.stringify({
+            results
+        })}`;
+    }
+    init_search_docs_param() {
+        if (!this.sys_ai_is_open)
+            return;
+        const setting = setting_service_1.settingService.ai_docs_setting();
+        Env_1.Env.load(setting.param, config_search_doc);
+    }
+    async load_one_file(token, param_path) {
+        if (!this.sys_ai_is_open)
+            return;
+        const root_path = setting_service_1.settingService.getFileRootPath(token);
+        let sysPath = decodeURIComponent(param_path);
+        if ((0, path_util_1.isAbsolutePath)(sysPath)) {
+        }
+        else {
+            sysPath = path_1.default.join(root_path, sysPath);
+        }
+        user_service_1.userService.check_user_path(token, sysPath);
+        await this.init_search_docs([{
+                auto_load: true,
+                dir: sysPath
+            }]);
+    }
+    async add_content(file_path) {
+        return threads_filecat_1.ThreadsFilecat.post(threads_type_1.threads_msg_type.docs_add, {
+            use_zh_segmentation: config_search_doc.use_zh_segmentation,
+            file_path,
+            mtime: this.docs_data_map.get((0, value_util_1.hash_str_to_number)(file_path))?.time_stamp
+        }, 60 * 1000);
+    }
+    async remove_content(file_path) {
+        await threads_filecat_1.ThreadsFilecat.post(threads_type_1.threads_msg_type.docs_del, {
+            file_path
+        }, 60 * 1000);
+        this.docs_data_map.delete((0, value_util_1.hash_str_to_number)(file_path));
+    }
+    async close_index() {
+        this.running_num++;
+        if (threads_filecat_1.ThreadsFilecat.is_running)
+            await threads_filecat_1.ThreadsFilecat.post(threads_type_1.threads_msg_type.docs_close, {}, 60 * 1000);
+        exports.ai_agentService.docs_data_map.clear();
+        this.docs_info.init(0);
+    }
+    push_wss(now) {
+        this.docs_info.consume_time_ms_len = Date.now() - now;
+        this.docs_info.total_num = this.docs_data_map.size;
+        ws_server_1.Wss.sendToAllClient(WsData_1.CmdType.ai_load_info, this.docs_info, this.all_wss_set);
+    }
+    async init() {
+        this.load_key();
+        if (!this.sys_ai_is_open)
+            return;
+        (0, threads_filecat_1.start_worker_threads)();
+        const body = { index_storage_type: config_search_doc.index_storage_type };
+        if (config_search_doc.index_storage_type === 'sqlite') {
+            body['db_path'] = DataUtil_1.DataUtil.get_file_path(data_type_1.data_dir_tem_name.sys_database_dir, data_type_1.file_key.fts5_rag_db);
+        }
+        await threads_filecat_1.ThreadsFilecat.post(threads_type_1.threads_msg_type.docs_init, body, 60 * 1000);
+    }
+    async init_search_docs(target_list) {
+        if (!this.sys_ai_is_open)
+            return;
+        const now = Date.now();
+        await this.init();
+        this.docs_info.init(0);
+        this.push_wss(now);
+        const dir_recursion_depth = config_search_doc.dir_recursion_depth;
+        const list = target_list || setting_service_1.settingService.ai_docs_setting().list;
+        if (!list?.length) {
+            return;
+        }
+        let running_num = this.running_num;
+        let ignore_list = [];
+        let allow_list = [];
+        if (config_search_doc.ignore_dir) {
+            if (typeof config_search_doc.ignore_dir === 'string') {
+                ignore_list.push(config_search_doc.ignore_dir);
+            }
+            else {
+                if (Array.isArray(config_search_doc.ignore_dir)) {
+                    ignore_list = config_search_doc.ignore_dir;
+                }
+            }
+        }
+        if (config_search_doc.allow_file_path) {
+            if (typeof config_search_doc.allow_file_path === 'string') {
+                allow_list.push(config_search_doc.allow_file_path);
+            }
+            else {
+                if (Array.isArray(config_search_doc.allow_file_path)) {
+                    allow_list = config_search_doc.allow_file_path;
+                }
+            }
+        }
+        const files_set = new Set();
+        let update_file_num = 0;
+        let await_file_total = config_search_doc.await_file_num ?? 0;
+        const add_file_path_list = [];
+        const update_file_path_list = [];
+        const handleFile = async (file_path, file_name) => {
+            if (files_set.size >= config_search_doc.max_file_num) {
+                return;
+            }
+            if (running_num != this.running_num)
+                return;
+            if (config_search_doc.allow_file_path) {
+                let ok = false;
+                for (const allow of allow_list) {
+                    if ((0, StringUtil_1.matchGitignore)(file_path, allow)) {
+                        ok = true;
+                        break;
+                    }
+                }
+                if (!ok)
+                    return;
+            }
+            if (await_file_total <= 0) {
+                await_file_total = config_search_doc.await_file_num ?? 0;
+                if (config_search_doc.await_time_ms_len) {
+                    await common_util_1.CommonUtil.sleep(config_search_doc.await_time_ms_len);
+                }
+            }
+            else {
+                await_file_total--;
+            }
+            const file_stats = await FileUtil_1.FileUtil.statSync(file_path);
+            if (!file_stats.isFile())
+                return;
+            if (file_stats.size > config_search_doc.max_file_byte_size) {
+                return;
+            }
+            this.docs_info.size += file_stats.size;
+            const hash_id = (0, value_util_1.hash_str_to_number)(file_path);
+            if (this.docs_data_map.has(hash_id)) {
+                const it = this.docs_data_map.get(hash_id);
+                const mtime = file_stats.mtime.getTime();
+                if (it.time_stamp === mtime) {
+                }
+                else {
+                    it.time_stamp = mtime;
+                    update_file_path_list.push(file_path);
+                    update_file_num++;
+                }
+            }
+            else {
+                add_file_path_list.push(file_path);
+                this.docs_data_map.set(hash_id, {
+                    time_stamp: file_stats.mtime.getTime(),
+                });
+                update_file_num++;
+            }
+            this.docs_info.num++;
+            files_set.add(hash_id);
+        };
+        const async_poll = new ListUtil_1.AsyncPool(config_search_doc.max_file_concurrency);
+        const walkDir = async (dir, depth) => {
+            if (depth > dir_recursion_depth) {
+                return;
+            }
+            if (running_num != this.running_num)
+                return;
+            const stat = await FileUtil_1.FileUtil.statSync(dir);
+            if (stat.isFile()) {
+                await async_poll.run(() => handleFile(dir, path_1.default.basename(dir)));
+                return;
+            }
+            const entries = await FileUtil_1.FileUtil.readdirSync(dir);
+            for (const entry of entries) {
+                if (files_set.size >= config_search_doc.max_file_num) {
+                    return;
+                }
+                const fullPath = path_1.default.join(dir, entry);
+                let ok = false;
+                for (const ignore of ignore_list) {
+                    if ((0, StringUtil_1.matchGitignore)(entry, ignore)) {
+                        ok = true;
+                        break;
+                    }
+                }
+                if (ok)
+                    continue;
+                const stat = await FileUtil_1.FileUtil.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (depth < dir_recursion_depth) {
+                        await walkDir(fullPath, depth + 1);
+                    }
+                }
+                else if (stat.isFile()) {
+                    await async_poll.run(() => handleFile(fullPath, entry));
+                }
+            }
+            this.push_wss(now);
+        };
+        const total = list.length;
+        for (let i = 0; i < list.length; i++) {
+            const it = list[i];
+            if (it.auto_load) {
+                await walkDir(it.dir, 0);
+            }
+        }
+        const totalFiles = add_file_path_list.length + update_file_path_list.length;
+        let processed = 0;
+        for (const file_path of add_file_path_list) {
+            this.docs_info.char_num += (await this.add_content(file_path))?.char_num ?? 0;
+            processed++;
+            this.docs_info.progress = ((processed / totalFiles) * 100).toFixed(2);
+            this.push_wss(now);
+        }
+        for (const file_path of update_file_path_list) {
+            await this.remove_content(file_path);
+            this.docs_info.char_num += (await this.add_content(file_path))?.char_num ?? 0;
+            processed++;
+            this.docs_info.progress = ((processed / totalFiles) * 100).toFixed(2);
+            this.push_wss(now);
+        }
+        this.docs_info.progress = 100;
+        this.push_wss(now);
+        console.log(`共扫描了 ${files_set.size} 个知识库文件`);
+        console.log(`共更新了 ${update_file_num} 个知识库文件`);
+        console.log(`知识库总字符数量 ${this.docs_info.char_num} `);
+        console.log(`知识库总文件大小 ${(0, ValueUtil_1.formatFileSize)(this.docs_info.size)} `);
+        console.log(`加载总耗时 ${(0, ValueUtil_1.formatDuration)(this.docs_info.consume_time_ms_len)}`);
+    }
+    async delete_index_with_progress(targetPath) {
+        this.docs_info.init(0);
+        const filesToDelete = [];
+        const now = Date.now();
+        const collectFiles = async (p) => {
+            const stat = await FileUtil_1.FileUtil.statSync(p);
+            if (!stat)
+                return;
+            if (stat.isFile()) {
+                if (this.docs_data_map.has((0, value_util_1.hash_str_to_number)(p))) {
+                    filesToDelete.push(p);
+                    this.docs_info.size += stat.size;
+                    this.docs_info.num++;
+                }
+            }
+            else if (stat.isDirectory()) {
+                const entries = await FileUtil_1.FileUtil.readdirSync(p);
+                for (const entry of entries) {
+                    await collectFiles(path_1.default.join(p, entry));
+                }
+            }
+        };
+        await collectFiles(targetPath);
+        const totalFiles = filesToDelete.length;
+        let processed = 0;
+        for (const filePath of filesToDelete) {
+            await this.remove_content(filePath);
+            processed++;
+            this.docs_info.progress = ((processed / totalFiles) * 100).toFixed(2);
+            this.push_wss(now);
+        }
+        this.docs_info.progress = 100;
+        this.push_wss(now);
+    }
+    get_env() {
+        return config_env;
+    }
+    load_key() {
+        config_env = new setting_req_1.ai_agent_item_dotenv();
+        this.sys_ai_is_open = false;
+        const r = setting_service_1.settingService.ai_agent_setting();
+        for (const it of r.models) {
+            if (it.open) {
+                MODEL = it.model;
+                BASE_URL = it.url;
+                API_KEY = it.token;
+                config = it;
+                if (it.dotenv) {
+                    Env_1.Env.load(it.dotenv, config_env);
+                }
+                this.sys_ai_is_open = true;
+                return;
+            }
+        }
+        config = undefined;
+        API_KEY = undefined;
+        BASE_URL = undefined;
+        MODEL = undefined;
+    }
+    trimMessages(messages, maxChars = 12000) {
+        let total = 0;
+        const result = [];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            const size = JSON.stringify(msg).length;
+            if (total + size > maxChars)
+                break;
+            total += size;
+            result.unshift(msg);
+        }
+        return result;
+    }
+    ;
+    async permission_test(token, user, toolName, args) {
+        switch (toolName) {
+            case "exec_cmd": {
+                const cmd = args.cmd?.trim();
+                if (!cmd)
+                    throw new Error("cmd 不能为空");
+                const argv = cmd.split(" ");
+                const code = await shell_service_1.shellServiceImpl.check_exe_cmd({
+                    user_id: user.id,
+                    cwd: process.cwd()
+                })(argv, argv.slice(1));
+                if (code === pty_shell_1.exec_type.not) {
+                    throw new Error(`没有权限执行命令：${cmd}`);
+                }
+                break;
+            }
+            case "list_files":
+            case "read_file":
+                user_service_1.userService.check_user_path(token, args.path);
+                break;
+            case "edit_file":
+                user_service_1.userService.check_user_path(token, args.path);
+                user_service_1.userService.check_user_auth(token, user_req_1.UserAuth.filecat_file_delete_cut_rename);
+                break;
+        }
+    }
+    is_use_local_data() {
+        return this.docs_data_map.size > 0;
+    }
+    async chat(originMessages, res, token) {
+        if (!API_KEY) {
+            throw new Error("api 没有设置，请设置诸如豆包、openai 的 model api");
+        }
+        const user = user_service_1.userService.get_user_info_by_token(token);
+        const rootPath = setting_service_1.settingService.getFileRootPath(token);
+        const workMessages = [
+            {
+                role: "system",
+                content: `
+1. 你是一个服务器机器人，当前操作系统是 ${os_1.default.platform()}，
+   当前目录是 ${rootPath}，
+   当前系统登陆用户是 ${user.username}，用户的id为 ${user.user_id}，${user.note}。
+2. 使用 markdown格式回答用户。
+3. 你是开源项目filecat的一部分，项目地址 https://github.com/xiaobaidadada/filecat。
+${this.is_use_local_data() ? `4. 当你不了解某些知识的时候，直接使用search_docs工具函数来搜素本地知识库搜索相关资料，如果用到了知识库,需要给用户引用的知识库文件路径。` : ''}
+
+${config.sys_prompt ?? ''}
+`
+            },
+            ...this.trimMessages(originMessages, config_env.char_max)
+        ];
+        if (config_search_doc.force_use_local_data) {
+            const t_ = await this.search_docs({ keywords: [workMessages[workMessages.length - 1].content] });
+            workMessages[workMessages.length - 1].content = `本地知识库搜到 ${t_} 
+            ${workMessages[workMessages.length - 1].content}`;
+        }
+        const env = {
+            toolLoop: config_env.tool_call_max,
+            tool_error_max: config_env.tool_error_max
+        };
+        const controller = new AbortController();
+        if (res) {
+            res.on("close", () => {
+                controller.abort();
+            });
+        }
+        while (env.toolLoop-- > 0) {
+            let assistantMessage = {
+                role: "assistant",
+                content: "",
+                tool_calls: []
+            };
+            const toolCallMap = new Map();
+            await this.callLLSync(workMessages, (chunk) => {
+                if (!chunk)
+                    return;
+                if (chunk.content) {
+                    assistantMessage.content += chunk.content;
+                    this.write_to_res(res, chunk.content);
+                }
+                if (chunk.tool_calls) {
+                    for (const tc of chunk.tool_calls) {
+                        const idx = tc.index;
+                        if (!toolCallMap.has(idx)) {
+                            toolCallMap.set(idx, {
+                                id: tc.id,
+                                type: "function",
+                                function: {
+                                    name: tc.function?.name ?? "",
+                                    arguments: ""
+                                }
+                            });
+                        }
+                        const call = toolCallMap.get(idx);
+                        if (tc.id) {
+                            call.id = tc.id;
+                        }
+                        if (tc.function?.name) {
+                            call.function.name = tc.function.name;
+                        }
+                        if (tc.function?.arguments) {
+                            call.function.arguments += tc.function.arguments;
+                        }
+                    }
+                }
+            }, (e) => {
+                throw e;
+            }, controller);
+            assistantMessage.tool_calls = Array.from(toolCallMap.values());
+            if (assistantMessage.tool_calls.length > 0) {
+                assistantMessage.content = null;
+            }
+            workMessages.push(assistantMessage);
+            if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
+                this.end_to_res(res);
+                return res;
+            }
+            for (const call of assistantMessage.tool_calls) {
+                let args = {};
+                try {
+                    args = JSON.parse(call.function.arguments || "{}");
+                }
+                catch (e) {
+                    throw new Error(`工具参数 JSON 解析失败: ${call.function.arguments}`);
+                }
+                const toolName = call.function.name;
+                await this.permission_test(token, user, toolName, args);
+                try {
+                    let result = await ai_agent_tools_1.Ai_agentTools[toolName](args);
+                    let resultStr = String(result);
+                    if (resultStr.length > 5000) {
+                        resultStr = resultStr.slice(0, 4000) + "\n...（内容过长已截断）";
+                    }
+                    workMessages.push({
+                        role: "tool",
+                        tool_call_id: call.id,
+                        content: resultStr
+                    });
+                }
+                catch (e) {
+                    if (env.tool_error_max-- <= 0)
+                        throw e;
+                    workMessages.push({
+                        role: "tool",
+                        tool_call_id: call.id,
+                        content: String(e)
+                    });
+                }
+            }
+        }
+        this.write_to_res(res, "超出最大理解语义次数");
+        this.end_to_res(res);
+        return res;
+    }
+    write_to_res(res, text) {
+        res.write(`event: message\ndata: ${JSON.stringify(text)}\n\n`);
+    }
+    end_to_res(res) {
+        res.write(`data: [DONE]\n\n`);
+        res.end();
+    }
+    async flow_call(res, work_messages) {
+        const finalMessages = this.trimMessages(work_messages);
+        finalMessages.push({
+            role: 'system',
+            content: '现在基于以上结果对用户进行简洁的回答，并使用markdown的格式。'
+        });
+        let json_body = {
+            model: MODEL,
+            messages: finalMessages,
+            stream: true,
+            temperature: 0.7
+        };
+        try {
+            if (config.json_params) {
+                const obj = JSON.parse(config.json_params);
+                for (const key of Object.keys(obj)) {
+                    json_body[key] = obj[key];
+                }
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+        const aiResponse = await fetch(BASE_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${API_KEY}`
+            },
+            body: JSON.stringify(json_body)
+        });
+        if (!aiResponse.ok || !aiResponse.body) {
+            res.write(`event: error\ndata: ${aiResponse.status === 413
+                ? "请求内容过大（413）"
+                : "AI 请求失败"}\n\n`);
+            res.end();
+            return res;
+        }
+        if (!json_body.stream) {
+            const r = await aiResponse.json();
+            const msg = r.choices[0].message;
+            this.write_to_res(res, msg.content);
+            res.end();
+            return res;
+        }
+        const nodeStream = stream_1.Readable.fromWeb(aiResponse.body);
+        res.on("close", () => {
+            nodeStream.destroy();
+        });
+        nodeStream.pipe(res);
+        return nodeStream;
+    }
+    async callLLSync(messages, call_data, error_call, controller) {
+        const tools = [...ai_agent_constant_1.ai_tools];
+        if (this.is_use_local_data()) {
+            tools.push(ai_agent_constant_1.ai_tools_search_docs);
+        }
+        const json_body = {
+            messages,
+            tools: tools,
+            temperature: 0.2,
+            model: MODEL,
+        };
+        try {
+            if (config.json_params) {
+                const obj = JSON.parse(config.json_params);
+                for (const key of Object.keys(obj)) {
+                    json_body[key] = obj[key];
+                }
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+        json_body.tools = tools;
+        json_body.messages = messages;
+        const res = await fetch(BASE_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${API_KEY}`
+            },
+            body: JSON.stringify(json_body),
+            signal: controller.signal
+        });
+        const contentType = res.headers.get("content-type") || "";
+        const isSSE = contentType.includes("text/event-stream");
+        if (isSSE) {
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buf = '';
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let parts = buf.split(/\r?\n\r?\n/);
+                buf = parts.pop();
+                for (const part of parts) {
+                    if (!part.trim())
+                        continue;
+                    const lines = part.split('\n');
+                    let dataLines = [];
+                    for (const line of lines) {
+                        if (line.startsWith('data:')) {
+                            dataLines.push(line.replace(/^data:\s*/, ''));
+                        }
+                    }
+                    const dataStr = dataLines.join('\n');
+                    if (dataStr.trim() === '[DONE]') {
+                        return;
+                    }
+                    try {
+                        const json = JSON.parse(dataStr);
+                        const message = json.choices?.[0]?.delta ?? json.choices?.[0]?.message;
+                        if (message)
+                            call_data(message);
+                    }
+                    catch (e) {
+                        if (e.name === "AbortError") {
+                            return;
+                        }
+                        error_call(e);
+                        return;
+                    }
+                }
+            }
+            return;
+        }
+        if (!res.ok) {
+            const text = await res.text();
+            try {
+                const json = JSON.parse(text);
+                error_call((json.message || json.error?.message || text));
+            }
+            catch {
+                error_call(text);
+            }
+            return;
+        }
+        call_data((await res.json()).choices[0].message);
+    }
+}
+exports.Ai_agentService = Ai_agentService;
+exports.ai_agentService = new Ai_agentService();
+config_1.ServerEvent.on("start", (data) => {
+    exports.ai_agentService.init().catch(console.error);
+});
+//# sourceMappingURL=ai_agent.service.js.map