qqsl-agent 0.0.1

package/esm2020/chat/services/http.service.mjs

@@ -0,0 +1,68 @@
+import { HttpHeaders, HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { filter, map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../store/store.service";
+export class HttpService {
+    constructor(http, storeService) {
+        this.http = http;
+        this.storeService = storeService;
+    }
+    get(url, paramObj) {
+        if (paramObj) {
+            return this.http
+                .get(url, {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    Authorization: this.storeService.getToken(),
+                }),
+                observe: 'response',
+                params: paramObj,
+                responseType: 'json',
+                withCredentials: false,
+            })
+                .pipe(filter((r) => r instanceof HttpResponse), map((r) => {
+                return r.body;
+            }));
+        }
+        return this.http
+            .get(url, {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+                Authorization: this.storeService.getToken(),
+            }),
+            observe: 'response',
+            responseType: 'json',
+            withCredentials: false,
+        })
+            .pipe(filter((r) => r instanceof HttpResponse), map((r) => {
+            return r.body;
+        }));
+    }
+    post(url, body, options) {
+        // 默认配置
+        const defaultOptions = {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+                Authorization: this.storeService.getToken(),
+            }),
+            observe: 'response',
+            responseType: 'json',
+            withCredentials: false,
+        };
+        // 如果提供了自定义选项，则合并配置
+        const httpOptions = options ? { ...defaultOptions, ...options } : defaultOptions;
+        // 发送 POST 请求
+        return this.http.post(url, body, httpOptions);
+    }
+}
+HttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i2.StoreService }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.StoreService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/chat/services/http2.service.mjs

@@ -0,0 +1,101 @@
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { StoreService } from '../store/store.service';
+import * as i0 from "@angular/core";
+export class HttpService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.storeService = inject(StoreService);
+        this.BASE_URL = '/api'; // 或者完整域名
+    }
+    /**
+     * 统一获取 Headers
+     */
+    getHeaders() {
+        return new HttpHeaders({
+            'Content-Type': 'application/json',
+            Authorization: `${this.storeService.getToken()}`,
+        });
+    }
+    /**
+     * GET 请求
+     */
+    get(url, params) {
+        return this.http.get(this.formatUrl(url), {
+            headers: this.getHeaders(),
+            params: this.resolveParams(params),
+        });
+    }
+    /**
+     * POST 请求
+     */
+    post(url, body) {
+        return this.http.post(this.formatUrl(url), body, {
+            headers: this.getHeaders(),
+        });
+    }
+    /**
+     * PUT 请求
+     */
+    put(url, body) {
+        return this.http.put(this.formatUrl(url), body, {
+            headers: this.getHeaders(),
+        });
+    }
+    /**
+     * DELETE 请求
+     * 兼容支持：既支持 URL 参数，也支持 Body
+     */
+    delete(url, params, body) {
+        return this.http.request('DELETE', this.formatUrl(url), {
+            headers: this.getHeaders(),
+            params: this.resolveParams(params),
+            body: body, // HttpClient 的 delete() 方法默认不支持 body，需用 request() 通用方法
+        });
+    }
+    // ================= 私有辅助方法 =================
+    /**
+     * 统一处理 URL
+     * 比如自动拼接 BaseUrl，或者处理斜杠
+     */
+    formatUrl(url) {
+        if (url.startsWith('http'))
+            return url;
+        // 确保拼接顺滑
+        const baseUrl = this.storeService.getBaseUrl();
+        const cleanBase = baseUrl.replace(/\/$/, '');
+        const cleanUrl = url.startsWith('/') ? url : `/${url}`;
+        return `${cleanBase}${cleanUrl}`;
+    }
+    /**
+     * 统一清洗参数
+     * 过滤掉 null 和 undefined，防止传给后端 "null" 字符串
+     */
+    resolveParams(params) {
+        let httpParams = new HttpParams();
+        if (params) {
+            Object.keys(params).forEach(key => {
+                const value = params[key];
+                if (value !== null && value !== undefined) {
+                    if (Array.isArray(value)) {
+                        // 支持数组参数 ids: [1, 2] => ids=1&ids=2
+                        value.forEach(val => (httpParams = httpParams.append(key, val)));
+                    }
+                    else {
+                        httpParams = httpParams.set(key, value);
+                    }
+                }
+            });
+        }
+        return httpParams;
+    }
+}
+HttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+HttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/chat/services/markdown-stream.service.mjs

@@ -0,0 +1,137 @@
+// markdown-stream.service.ts
+import { Injectable } from '@angular/core';
+import { Marked } from 'marked';
+import { markedHighlight } from 'marked-highlight';
+import hljs from 'highlight.js';
+import DOMPurify from 'dompurify'; // 防 XSS
+import * as i0 from "@angular/core";
+export class MarkdownStreamService {
+    constructor() {
+        this.marked = new Marked(
+        // 高亮代码
+        markedHighlight({
+            emptyLangClass: 'hljs',
+            langPrefix: 'hljs language-',
+            highlight(code, lang, info) {
+                const language = hljs.getLanguage(lang) ? lang : 'plaintext';
+                return hljs.highlight(code, { language }).value;
+            },
+        }));
+        // 支持 $$...$$ 和 $...$ 数学公式
+        // this.marked.use({
+        //     // 包含从 markdown 创建标记的函数的对象
+        //     tokenizer: {
+        //         inlineMath(src: string) {
+        //             const cap = /^\$([^\$]+)\$/.exec(src);
+        //             if (cap) {
+        //                 return { type: 'inlineMath', raw: cap[0], text: cap[1] };
+        //             }
+        //         },
+        //         codespan(src: string) {
+        //             const math = this.inlineMath(src);
+        //             if (math) return math;
+        //             return false;
+        //         }
+        //     }
+        // });
+        // marked 17+ 必须使用 extensions 方式注册
+        this.marked.use({
+            extensions: [
+                {
+                    name: 'inlineMath',
+                    level: 'inline',
+                    start(src) {
+                        return src.indexOf('$'); // 告诉 marked 从哪里开始尝试匹配
+                    },
+                    tokenizer(src) {
+                        // 匹配 $...$，但不能包含换行，且不允许 $$ 开头（留给块级公式）
+                        const match = src.match(/^\$(?!\$)([^\n$]+?)\$/);
+                        if (match) {
+                            return {
+                                type: 'inlineMath',
+                                raw: match[0],
+                                text: match[1].trim(), // 公式内容
+                            };
+                        }
+                        return undefined;
+                    },
+                    renderer(token) {
+                        // 这里直接返回原始文本，后面你可以用 KaTeX / MathJax 渲染
+                        return `$${token.text}$`;
+                        // 或者如果你已经全局接管了渲染，可以 return false
+                    },
+                },
+                // 可选：同时支持 $$...$$ 块级公式
+                {
+                    name: 'displayMath',
+                    level: 'block',
+                    start(src) {
+                        return src.indexOf('$$');
+                    },
+                    tokenizer(src) {
+                        const match = src.match(/^\$\$([\s\S]+?)\$\$/);
+                        if (match) {
+                            return {
+                                type: 'displayMath',
+                                raw: match[0],
+                                text: match[1].trim(),
+                            };
+                        }
+                        return undefined;
+                    },
+                    renderer(token) {
+                        return `$$${token.text}$$`;
+                    },
+                },
+            ],
+        });
+    }
+    // 关键：增量渲染（流式专用！）
+    renderIncremental(markdown) {
+        // 防止渲染一半的代码块崩溃
+        const safeMarkdown = this.completeCodeBlocks(markdown);
+        try {
+            let html = this.marked.parse(safeMarkdown);
+            html = DOMPurify.sanitize(html); // 安全
+            return html;
+        }
+        catch (e) {
+            return this.escapeHtml(safeMarkdown);
+        }
+    }
+    // 智能补全未闭合的代码块（流式必备！）
+    completeCodeBlocks(text) {
+        const lines = text.split('\n');
+        let inCode = false;
+        let fence = '';
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim().match(/^```/)) {
+                if (!inCode) {
+                    fence = line.trim();
+                    inCode = true;
+                }
+                else if (line.trim() === '```' || line.trim().startsWith('```')) {
+                    inCode = false;
+                    fence = '';
+                }
+            }
+        }
+        if (inCode) {
+            text += '\n```';
+        }
+        return text;
+    }
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+}
+MarkdownStreamService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MarkdownStreamService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MarkdownStreamService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MarkdownStreamService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MarkdownStreamService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown-stream.service.js","sourceRoot":"","sources":["../../../../../projects/agent/chat/services/markdown-stream.service.ts"],"names":[],"mappings":"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","sourcesContent":["// markdown-stream.service.ts\nimport { Injectable } from '@angular/core';\nimport { Marked } from 'marked';\nimport { markedHighlight } from 'marked-highlight';\nimport hljs from 'highlight.js';\nimport * as katex from 'katex';\nimport DOMPurify from 'dompurify'; // 防 XSS\n\n@Injectable({ providedIn: 'root' })\nexport class MarkdownStreamService {\n  private marked: Marked;\n\n  constructor() {\n    this.marked = new Marked(\n      // 高亮代码\n      markedHighlight({\n        emptyLangClass: 'hljs',\n        langPrefix: 'hljs language-',\n        highlight(code, lang, info) {\n          const language = hljs.getLanguage(lang) ? lang : 'plaintext';\n          return hljs.highlight(code, { language }).value;\n        },\n      }),\n      // {\n      //     gfm: true,\n      //     breaks: true,\n      //     // 自定义 renderer 支持 KaTeX\n      //     renderer: {\n      //         code(code: string, lang: string | undefined) {\n      //             if (lang === 'math' || lang === 'katex') {\n      //                 return `<div class=\"math-block\">${katex.renderToString(code, { throwOnError: false, displayMode: true })}</div>`;\n      //             }\n      //             return false; // 交给 highlight 处理\n      //         },\n      //         inlineMath(math: string) {\n      //             return katex.renderToString(math, { throwOnError: false });\n      //         }\n      //     }\n      // }\n    );\n\n    // 支持 $$...$$ 和 $...$ 数学公式\n    // this.marked.use({\n    //     // 包含从 markdown 创建标记的函数的对象\n    //     tokenizer: {\n    //         inlineMath(src: string) {\n    //             const cap = /^\\$([^\\$]+)\\$/.exec(src);\n    //             if (cap) {\n    //                 return { type: 'inlineMath', raw: cap[0], text: cap[1] };\n    //             }\n    //         },\n    //         codespan(src: string) {\n    //             const math = this.inlineMath(src);\n    //             if (math) return math;\n    //             return false;\n    //         }\n    //     }\n    // });\n\n    // marked 17+ 必须使用 extensions 方式注册\n    this.marked.use({\n      extensions: [\n        {\n          name: 'inlineMath',\n          level: 'inline', // 必须是 inline\n          start(src: string) {\n            return src.indexOf('$'); // 告诉 marked 从哪里开始尝试匹配\n          },\n          tokenizer(src: string) {\n            // 匹配 $...$，但不能包含换行，且不允许 $$ 开头（留给块级公式）\n            const match = src.match(/^\\$(?!\\$)([^\\n$]+?)\\$/);\n            if (match) {\n              return {\n                type: 'inlineMath',\n                raw: match[0], // 原始文本：$xxx$\n                text: match[1].trim(), // 公式内容\n              };\n            }\n            return undefined;\n          },\n          renderer(token: any) {\n            // 这里直接返回原始文本，后面你可以用 KaTeX / MathJax 渲染\n            return `$${token.text}$`;\n            // 或者如果你已经全局接管了渲染，可以 return false\n          },\n        },\n\n        // 可选：同时支持 $$...$$ 块级公式\n        {\n          name: 'displayMath',\n          level: 'block',\n          start(src: string) {\n            return src.indexOf('$$');\n          },\n          tokenizer(src: string) {\n            const match = src.match(/^\\$\\$([\\s\\S]+?)\\$\\$/);\n            if (match) {\n              return {\n                type: 'displayMath',\n                raw: match[0],\n                text: match[1].trim(),\n              };\n            }\n            return undefined;\n          },\n          renderer(token: any) {\n            return `$$${token.text}$$`;\n          },\n        },\n      ],\n    });\n  }\n\n  // 关键：增量渲染（流式专用！）\n  renderIncremental(markdown: string): string {\n    // 防止渲染一半的代码块崩溃\n    const safeMarkdown = this.completeCodeBlocks(markdown);\n    try {\n      let html = this.marked.parse(safeMarkdown) as string;\n      html = DOMPurify.sanitize(html); // 安全\n      return html;\n    } catch (e) {\n      return this.escapeHtml(safeMarkdown);\n    }\n  }\n\n  // 智能补全未闭合的代码块（流式必备！）\n  private completeCodeBlocks(text: string): string {\n    const lines = text.split('\\n');\n    let inCode = false;\n    let fence = '';\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i];\n      if (line.trim().match(/^```/)) {\n        if (!inCode) {\n          fence = line.trim();\n          inCode = true;\n        } else if (line.trim() === '```' || line.trim().startsWith('```')) {\n          inCode = false;\n          fence = '';\n        }\n      }\n    }\n    if (inCode) {\n      text += '\\n```';\n    }\n    return text;\n  }\n\n  private escapeHtml(text: string): string {\n    const div = document.createElement('div');\n    div.textContent = text;\n    return div.innerHTML;\n  }\n}\n"]}

package/esm2020/chat/services/sse.service.mjs

@@ -0,0 +1,107 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { StoreService } from '../store/store.service';
+import * as i0 from "@angular/core";
+export class SseService {
+    constructor() {
+        this.storeService = inject(StoreService);
+        this.conversationICodeSource = new BehaviorSubject(null);
+        this.conversationICode$ = this.conversationICodeSource.asObservable();
+        // 思考内容
+        this.thinkingSource = new BehaviorSubject('');
+        this.thinking$ = this.thinkingSource.asObservable();
+        // 实时流式文本
+        this.messageSource = new BehaviorSubject('');
+        this.currentMessage$ = this.messageSource.asObservable();
+        this.deltaSource = new BehaviorSubject('');
+        this.delta$ = this.deltaSource.asObservable();
+        this.loadingSource = new BehaviorSubject(false);
+        this.loading$ = this.loadingSource.asObservable();
+        // 完整消息历史
+        this.fullThinking = '';
+        this.fullMessage = '';
+        // 支持取消（关键！）
+        this.controller = new AbortController();
+    }
+    async streamChat(body) {
+        this.loadingSource.next(true);
+        this.messageSource.next(''); // 清空
+        this.fullMessage = '';
+        try {
+            const response = await fetch(`${this.storeService.getBaseUrl()}/api/ChatModel/generate`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: this.storeService.getToken(),
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok || !response.body) {
+                throw new Error('网络错误');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder('utf-8');
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value, { stream: true });
+                const lines = chunk.split('\n\n');
+                for (const line of lines) {
+                    if (line.startsWith('data:')) {
+                        const jsonStr = line.replaceAll('data:', '');
+                        try {
+                            const data = JSON.parse(jsonStr);
+                            const delta = data.content || '';
+                            if (delta) {
+                                // 对话以及问答编码
+                                if (delta.conversation) {
+                                    this.conversationICodeSource.next(delta);
+                                    continue;
+                                }
+                                // 比如显示“AI 正在思考...”
+                                if (data.think) {
+                                    this.fullThinking += delta;
+                                    this.thinkingSource.next(this.fullThinking);
+                                    continue;
+                                }
+                                this.fullMessage += delta;
+                                this.messageSource.next(this.fullMessage); // 实时推送完整内容
+                                this.deltaSource.next(delta); // 只推本次新增的文字
+                            }
+                            if (data.down) {
+                                // down: true 表示结束
+                                this.loadingSource.next(false);
+                            }
+                        }
+                        catch (e) {
+                            console.log('sse error', e);
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err.name !== 'AbortError') {
+                this.messageSource.next('请求失败：' + err.message);
+            }
+        }
+        finally {
+            this.loadingSource.next(false);
+        }
+    }
+    cancel() {
+        this.controller.abort();
+        this.controller = new AbortController();
+    }
+}
+SseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SseService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse.service.js","sourceRoot":"","sources":["../../../../../projects/agent/chat/services/sse.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject } from 'rxjs';\nimport { ISendMessage } from '../models/send-message.model';\nimport { StoreService } from '../store/store.service';\n\nexport interface ConversationICodeObj {\n  conversation: string;\n  question: string;\n  answer: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SseService {\n  private storeService = inject(StoreService);\n  private conversationICodeSource = new BehaviorSubject<ConversationICodeObj | null>(null);\n  conversationICode$ = this.conversationICodeSource.asObservable();\n\n  // 思考内容\n  private thinkingSource = new BehaviorSubject<string>('');\n  thinking$ = this.thinkingSource.asObservable();\n\n  // 实时流式文本\n  private messageSource = new BehaviorSubject<string>('');\n  currentMessage$ = this.messageSource.asObservable();\n\n  private deltaSource = new BehaviorSubject<string>('');\n  delta$ = this.deltaSource.asObservable();\n\n  loadingSource = new BehaviorSubject<boolean>(false);\n  loading$ = this.loadingSource.asObservable();\n\n  // 完整消息历史\n  private fullThinking = '';\n  private fullMessage = '';\n\n  async streamChat(body: ISendMessage) {\n    this.loadingSource.next(true);\n    this.messageSource.next(''); // 清空\n    this.fullMessage = '';\n\n    try {\n      const response = await fetch(`${this.storeService.getBaseUrl()}/api/ChatModel/generate`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          Authorization: this.storeService.getToken(),\n          Accept: 'text/event-stream',\n        },\n        body: JSON.stringify(body),\n      });\n\n      if (!response.ok || !response.body) {\n        throw new Error('网络错误');\n      }\n\n      const reader = response.body.getReader();\n      const decoder = new TextDecoder('utf-8');\n\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) break;\n\n        const chunk = decoder.decode(value, { stream: true });\n        const lines = chunk.split('\\n\\n');\n\n        for (const line of lines) {\n          if (line.startsWith('data:')) {\n            const jsonStr = line.replaceAll('data:', '');\n            try {\n              const data = JSON.parse(jsonStr);\n              const delta = data.content || '';\n\n              if (delta) {\n                // 对话以及问答编码\n                if (delta.conversation) {\n                  this.conversationICodeSource.next(delta);\n                  continue;\n                }\n                // 比如显示“AI 正在思考...”\n                if (data.think) {\n                  this.fullThinking += delta;\n                  this.thinkingSource.next(this.fullThinking);\n                  continue;\n                }\n                this.fullMessage += delta;\n                this.messageSource.next(this.fullMessage); // 实时推送完整内容\n                this.deltaSource.next(delta); // 只推本次新增的文字\n              }\n              if (data.down) {\n                // down: true 表示结束\n                this.loadingSource.next(false);\n              }\n            } catch (e) {\n              console.log('sse error', e);\n            }\n          }\n        }\n      }\n    } catch (err: any) {\n      if (err.name !== 'AbortError') {\n        this.messageSource.next('请求失败：' + err.message);\n      }\n    } finally {\n      this.loadingSource.next(false);\n    }\n  }\n\n  // 支持取消（关键！）\n  private controller = new AbortController();\n\n  cancel() {\n    this.controller.abort();\n    this.controller = new AbortController();\n  }\n}\n"]}

package/esm2020/chat/store/store.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class StoreService {
+    constructor() {
+        this.token = '';
+        this.baseUrl = '';
+        this.currentConversationSource = new BehaviorSubject(null);
+        this.currentConversation$ = this.currentConversationSource.asObservable();
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    getToken() {
+        return (this.token ||
+            'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.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_lroHluIIiLCJ1c2VyTWFyayI6ZmFsc2UsInBob25lIjoiMTMwODkxMjczNzAiLCJlbnYiOiJyZWxlYXNlIiwidG9wUmVnaW9uQ29kZSI6IjYzMDEwMDAwMDAwMCJ9.Bzlz0LC5rbwItBgw6B-dhSKhXnAATXiaL-rR3EHD4wmJ-BpWWrDakYAjzUCtWL4ExkTqSxXIClCztc412o5pT3b9EN7R6WH5namjpxzwozCVXQyBYvjoCrS5UX1_iUkvVMr6WAqiUUzIanVSrmaRpszxyD8S_fLBge971-Cli44J1FQDBY8QN8TiH3v3c5aDWDBJVYPHqe3_zEAeL3dlERgl8pTLAydx54a2QqCVH2xfX_zSzFXJeK2iamIyI8H4cyP0pQrYl2rjSuR7LsjJSJz_QeSQKZlctG8odrBMV5OoHlWC2isNGqszqyp1POX2HyWb-U4qn8KuKKryjACrow');
+    }
+    setBaseUrl(url) {
+        this.baseUrl = url;
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    setCurrentConversation(conversation) {
+        this.conversationICode = conversation?.iCode;
+        this.currentConversationSource.next(conversation);
+    }
+    getConversationICode() {
+        return this.conversationICode;
+    }
+}
+StoreService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+StoreService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StoreService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StoreService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.service.js","sourceRoot":"","sources":["../../../../../projects/agent/chat/store/store.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;;AAIvC,MAAM,OAAO,YAAY;IADzB;QAEU,UAAK,GAAG,EAAE,CAAC;QACX,YAAO,GAAG,EAAE,CAAC;QAGb,8BAAyB,GAAG,IAAI,eAAe,CAAsB,IAAI,CAAC,CAAC;QACnF,yBAAoB,GAAG,IAAI,CAAC,yBAAyB,CAAC,YAAY,EAAE,CAAC;KA6BtE;IA3BC,QAAQ,CAAC,KAAa;QACpB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,QAAQ;QACN,OAAO,CACL,IAAI,CAAC,KAAK;YACV,83KAA83K,CAC/3K,CAAC;IACJ,CAAC;IAED,UAAU,CAAC,GAAW;QACpB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;IACrB,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,sBAAsB,CAAC,YAAiC;QACtD,IAAI,CAAC,iBAAiB,GAAG,YAAY,EAAE,KAAK,CAAC;QAC7C,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACpD,CAAC;IAED,oBAAoB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;;0GAlCU,YAAY;8GAAZ,YAAY,cADC,MAAM;4FACnB,YAAY;kBADxB,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { Conversation } from '../models/conversation.model';\n\n@Injectable({ providedIn: 'root' })\nexport class StoreService {\n  private token = '';\n  private baseUrl = '';\n  private conversationICode?: string;\n\n  private currentConversationSource = new BehaviorSubject<Conversation | null>(null);\n  currentConversation$ = this.currentConversationSource.asObservable();\n\n  setToken(token: string): void {\n    this.token = token;\n  }\n\n  getToken(): string {\n    return (\n      this.token ||\n      'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.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_lroHluIIiLCJ1c2VyTWFyayI6ZmFsc2UsInBob25lIjoiMTMwODkxMjczNzAiLCJlbnYiOiJyZWxlYXNlIiwidG9wUmVnaW9uQ29kZSI6IjYzMDEwMDAwMDAwMCJ9.Bzlz0LC5rbwItBgw6B-dhSKhXnAATXiaL-rR3EHD4wmJ-BpWWrDakYAjzUCtWL4ExkTqSxXIClCztc412o5pT3b9EN7R6WH5namjpxzwozCVXQyBYvjoCrS5UX1_iUkvVMr6WAqiUUzIanVSrmaRpszxyD8S_fLBge971-Cli44J1FQDBY8QN8TiH3v3c5aDWDBJVYPHqe3_zEAeL3dlERgl8pTLAydx54a2QqCVH2xfX_zSzFXJeK2iamIyI8H4cyP0pQrYl2rjSuR7LsjJSJz_QeSQKZlctG8odrBMV5OoHlWC2isNGqszqyp1POX2HyWb-U4qn8KuKKryjACrow'\n    );\n  }\n\n  setBaseUrl(url: string): void {\n    this.baseUrl = url;\n  }\n\n  getBaseUrl(): string {\n    return this.baseUrl;\n  }\n\n  setCurrentConversation(conversation: Conversation | null): void {\n    this.conversationICode = conversation?.iCode;\n    this.currentConversationSource.next(conversation);\n  }\n\n  getConversationICode(): string | undefined {\n    return this.conversationICode;\n  }\n}\n"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of ai-agent
+ */
+export default void 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FnZW50L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxlQUFlLEtBQUssQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBhaS1hZ2VudFxuICovXG5cbmV4cG9ydCBkZWZhdWx0IHZvaWQgMDsiXX0=

package/esm2020/qqsl-agent.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXFzbC1hZ2VudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FnZW50L3Fxc2wtYWdlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==