agent-chat-sdk-core 0.1.0

package/dist/cjs/client.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentChatClient = void 0;
+const parser_js_1 = require("./parser.js");
+const normalizer_js_1 = require("./normalizer.js");
+const DEFAULT_BUILD_BODY = (query, config) => ({
+    id: config.appId,
+    query,
+});
+const DEFAULT_BUILD_HEADERS = (config) => {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+    };
+    if (config.appKey) {
+        headers.Authorization = `Bearer ${config.appKey}`;
+    }
+    return headers;
+};
+/**
+ * 智能体流式对话客户端
+ *
+ * @example
+ * ```ts
+ * const client = new AgentChatClient({
+ *   url: 'https://your-host/appforge/openapi/v1/InvokeApp/app-xxx',
+ *   appId: 'app-xxx',
+ *   appKey: 'your-key',
+ * });
+ *
+ * await client.chatStream(
+ *   { query: '你好', dataMode: 'normalized' },
+ *   {
+ *     onEvent: (event) => {
+ *       if (event.type === 'answer_delta') {
+ *         console.log(event.content);
+ *       }
+ *     },
+ *   },
+ * );
+ * ```
+ */
+class AgentChatClient {
+    constructor(config) {
+        this.abortController = null;
+        this.config = config;
+    }
+    /** 更新配置 */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    /** 中止当前流式请求 */
+    abort() {
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+    /** 当前配置的请求 URL */
+    getUrl() {
+        return this.config.url;
+    }
+    /**
+     * 发起流式对话
+     */
+    async chatStream(options, handlers = {}) {
+        const { query, signal, dataMode = 'normalized', extraBody = {}, extraHeaders = {}, } = options;
+        this.abort();
+        const controller = new AbortController();
+        this.abortController = controller;
+        const combinedSignal = signal
+            ? combineAbortSignals(signal, controller.signal)
+            : controller.signal;
+        const emit = (event) => handlers.onEvent?.(event);
+        const emitRaw = (chunk) => handlers.onRawChunk?.(chunk);
+        const shouldEmitNormalized = dataMode === 'normalized' || dataMode === 'both';
+        const shouldEmitRaw = dataMode === 'raw' || dataMode === 'both';
+        if (shouldEmitNormalized) {
+            emit({ type: 'stream_start', timestamp: Date.now(), query });
+        }
+        const normCtx = (0, normalizer_js_1.createNormalizeContext)();
+        try {
+            const fetchImpl = this.config.fetch ?? globalThis.fetch;
+            const url = this.config.url;
+            const buildBody = this.config.buildRequestBody ?? DEFAULT_BUILD_BODY;
+            const buildHeaders = this.config.buildHeaders ?? DEFAULT_BUILD_HEADERS;
+            const response = await fetchImpl(url, {
+                method: 'POST',
+                headers: { ...buildHeaders(this.config), ...extraHeaders },
+                body: JSON.stringify({ ...buildBody(query, this.config), ...extraBody }),
+                signal: combinedSignal,
+                cache: 'no-store',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText || response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is empty');
+            }
+            await (0, parser_js_1.readSSEStream)(response.body, (rawChunk) => {
+                if (shouldEmitRaw)
+                    emitRaw(rawChunk);
+                if (shouldEmitNormalized) {
+                    const events = (0, normalizer_js_1.normalizeRawChunk)(rawChunk, normCtx);
+                    events.forEach(emit);
+                }
+            }, combinedSignal);
+            if (shouldEmitNormalized) {
+                (0, normalizer_js_1.finalizeNormalizeContext)(normCtx).forEach(emit);
+                emit({ type: 'stream_end', timestamp: Date.now() });
+            }
+            handlers.onComplete?.();
+        }
+        catch (error) {
+            if (combinedSignal.aborted)
+                return;
+            const err = error instanceof Error ? error : new Error(String(error));
+            handlers.onError?.(err);
+            if (shouldEmitNormalized) {
+                emit({
+                    type: 'error',
+                    timestamp: Date.now(),
+                    message: err.message,
+                });
+                emit({ type: 'stream_end', timestamp: Date.now() });
+            }
+            throw err;
+        }
+        finally {
+            if (this.abortController === controller) {
+                this.abortController = null;
+            }
+        }
+    }
+    /**
+     * 以 AsyncIterable 消费流式事件（便于 for-await）
+     */
+    async *streamEvents(options) {
+        const queue = [];
+        let resolveWait = null;
+        let done = false;
+        let streamError = null;
+        const notify = () => {
+            resolveWait?.();
+            resolveWait = null;
+        };
+        const runPromise = this.chatStream({ ...options, dataMode: options.dataMode ?? 'normalized' }, {
+            onEvent: (event) => {
+                queue.push(event);
+                notify();
+            },
+            onError: (err) => {
+                streamError = err;
+                done = true;
+                notify();
+            },
+            onComplete: () => {
+                done = true;
+                notify();
+            },
+        }).catch((err) => {
+            streamError = err;
+            done = true;
+            notify();
+        });
+        try {
+            while (true) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                    continue;
+                }
+                if (done)
+                    break;
+                await new Promise((resolve) => {
+                    resolveWait = resolve;
+                });
+            }
+            if (streamError)
+                throw streamError;
+        }
+        finally {
+            await runPromise.catch(() => undefined);
+        }
+    }
+}
+exports.AgentChatClient = AgentChatClient;
+function combineAbortSignals(...signals) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    signals.forEach((s) => {
+        if (s.aborted)
+            controller.abort();
+        else
+            s.addEventListener('abort', onAbort, { once: true });
+    });
+    return controller.signal;
+}

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripKnowledgeSupLabels = exports.parseKnowledgeSupLabels = exports.REACT_SSE_TYPE_MAP = exports.applyEventToSession = exports.createSessionState = exports.finalizeNormalizeContext = exports.createNormalizeContext = exports.normalizeRawChunk = exports.isStreamEndSignal = exports.readSSEStream = exports.parseSSELine = exports.AgentChatClient = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "AgentChatClient", { enumerable: true, get: function () { return client_js_1.AgentChatClient; } });
+var parser_js_1 = require("./parser.js");
+Object.defineProperty(exports, "parseSSELine", { enumerable: true, get: function () { return parser_js_1.parseSSELine; } });
+Object.defineProperty(exports, "readSSEStream", { enumerable: true, get: function () { return parser_js_1.readSSEStream; } });
+Object.defineProperty(exports, "isStreamEndSignal", { enumerable: true, get: function () { return parser_js_1.isStreamEndSignal; } });
+var normalizer_js_1 = require("./normalizer.js");
+Object.defineProperty(exports, "normalizeRawChunk", { enumerable: true, get: function () { return normalizer_js_1.normalizeRawChunk; } });
+Object.defineProperty(exports, "createNormalizeContext", { enumerable: true, get: function () { return normalizer_js_1.createNormalizeContext; } });
+Object.defineProperty(exports, "finalizeNormalizeContext", { enumerable: true, get: function () { return normalizer_js_1.finalizeNormalizeContext; } });
+var session_js_1 = require("./session.js");
+Object.defineProperty(exports, "createSessionState", { enumerable: true, get: function () { return session_js_1.createSessionState; } });
+Object.defineProperty(exports, "applyEventToSession", { enumerable: true, get: function () { return session_js_1.applyEventToSession; } });
+var react_flow_js_1 = require("./react-flow.js");
+Object.defineProperty(exports, "REACT_SSE_TYPE_MAP", { enumerable: true, get: function () { return react_flow_js_1.REACT_SSE_TYPE_MAP; } });
+var knowledge_label_js_1 = require("./knowledge-label.js");
+Object.defineProperty(exports, "parseKnowledgeSupLabels", { enumerable: true, get: function () { return knowledge_label_js_1.parseKnowledgeSupLabels; } });
+Object.defineProperty(exports, "stripKnowledgeSupLabels", { enumerable: true, get: function () { return knowledge_label_js_1.stripKnowledgeSupLabels; } });

package/dist/cjs/knowledge-label.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * 知识库引用标注（answer 正文中的 <sup> 标签）解析
+ *
+ * @example
+ * `<sup score="0.2" fileid="doc_001" filename="FAQ.txt" chunkid="4191..." dsid="docstore_xxx">2</sup>`
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKnowledgeSupLabels = parseKnowledgeSupLabels;
+exports.stripKnowledgeSupLabels = stripKnowledgeSupLabels;
+// \s* 兼容无属性写法 <sup>1</sup>
+const SUP_TAG_REGEX = /<sup\s*([^>]*)>([\s\S]*?)<\/sup>/gi;
+const ATTR_REGEX = /([\w-]+)\s*=\s*"([^"]*)"/g;
+function parseSupAttributes(attrString) {
+    const attributes = {};
+    let match;
+    ATTR_REGEX.lastIndex = 0;
+    while ((match = ATTR_REGEX.exec(attrString)) !== null) {
+        attributes[match[1].toLowerCase()] = match[2];
+    }
+    return attributes;
+}
+function toCitationLabel(raw, attrString, inner) {
+    const attributes = parseSupAttributes(attrString);
+    return {
+        raw,
+        index: inner.trim(),
+        score: attributes.score,
+        fileId: attributes.fileid,
+        filename: attributes.filename,
+        chunkId: attributes.chunkid,
+        datasetId: attributes.dsid,
+        attributes,
+    };
+}
+/**
+ * 解析正文中的知识库 <sup> 引用标签
+ *
+ * @param content - 含 sup 标签的回复正文
+ * @returns 剥离标签后的正文与标注列表
+ */
+function parseKnowledgeSupLabels(content) {
+    const labels = [];
+    const text = content.replace(SUP_TAG_REGEX, (match, attrPart, inner) => {
+        labels.push(toCitationLabel(match, attrPart, inner));
+        return '';
+    });
+    return { text, labels };
+}
+/**
+ * 去掉正文中的知识库 sup 标签（便于暂不渲染引用角标）
+ *
+ * @param content - 原始正文
+ * @param options.stripIncomplete - 是否去掉末尾未闭合的 `<sup`（流式场景建议 true）
+ */
+function stripKnowledgeSupLabels(content, options) {
+    const { text } = parseKnowledgeSupLabels(content);
+    if (options?.stripIncomplete === false)
+        return text;
+    return stripIncompleteSupTail(text);
+}
+/** 去掉末尾未闭合的 sup 片段，避免流式过程中露出半截标签 */
+function stripIncompleteSupTail(text) {
+    const openIdx = text.lastIndexOf('<sup');
+    if (openIdx === -1)
+        return text;
+    const tail = text.slice(openIdx);
+    if (/<\/sup>/i.test(tail))
+        return text;
+    return text.slice(0, openIdx);
+}

package/dist/cjs/normalizer.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNormalizeContext = createNormalizeContext;
+exports.normalizeRawChunk = normalizeRawChunk;
+exports.finalizeNormalizeContext = finalizeNormalizeContext;
+const ANSWER_TYPES = new Set(['answer', 'text', 'message']);
+const STREAM_END_TYPES = new Set(['done', 'end', 'finish', 'completed', 'stop']);
+const TOOL_TYPES = new Set(['tool', 'knowledge', 'plugin', 'mcp', 'memory_var_update', 'workflow']);
+let toolIdSeq = 0;
+function nextToolId() {
+    toolIdSeq += 1;
+    return `tool_${toolIdSeq}_${Date.now()}`;
+}
+function createNormalizeContext() {
+    return {
+        thinkingContent: '',
+        answerContent: '',
+        isThinking: false,
+        thinkingRound: 0,
+    };
+}
+function isToolType(type) {
+    return TOOL_TYPES.has(type);
+}
+function resolveCallKind(type) {
+    if (type === 'knowledge')
+        return 'knowledge';
+    if (type === 'plugin')
+        return 'plugin';
+    if (type === 'mcp')
+        return 'mcp';
+    if (type === 'memory_var_update')
+        return 'memory';
+    if (type === 'workflow')
+        return 'workflow';
+    return 'tool';
+}
+/** 规范化耗时（去掉末尾 s） */
+function normalizeRunningTime(value) {
+    if (!value)
+        return undefined;
+    return String(value).replace(/s$/i, '').trim();
+}
+/**
+ * 拼接回答正文：兼容增量 delta 与服务端推送的累积全文
+ */
+function appendAnswerContent(ctx, incoming) {
+    if (!incoming)
+        return;
+    if (!ctx.answerContent) {
+        ctx.answerContent = incoming;
+        return;
+    }
+    if (incoming.startsWith(ctx.answerContent)) {
+        ctx.answerContent = incoming;
+        return;
+    }
+    if (ctx.answerContent.endsWith(incoming))
+        return;
+    ctx.answerContent += incoming;
+}
+function resolveCallTitle(kind, raw) {
+    if (kind === 'knowledge')
+        return '知识库调用';
+    if (kind === 'plugin')
+        return '插件调用';
+    if (kind === 'mcp')
+        return 'MCP调用';
+    if (kind === 'memory') {
+        const name = raw?.name;
+        if (typeof name === 'string' && name)
+            return `记忆变量 ${name}`;
+        return '记忆变量更新';
+    }
+    if (kind === 'workflow') {
+        if (typeof raw?.tool_name === 'string' && raw.tool_name)
+            return String(raw.tool_name);
+        return '工作流调用';
+    }
+    if (typeof raw?.tool_name === 'string' && raw.tool_name)
+        return String(raw.tool_name);
+    return '工具调用';
+}
+function resolveToolId(chunk) {
+    if (chunk.type === 'workflow' && chunk.raw) {
+        if (typeof chunk.raw.tool_call_id === 'string')
+            return chunk.raw.tool_call_id;
+        if (typeof chunk.raw.workflow_id === 'string')
+            return chunk.raw.workflow_id;
+        if (typeof chunk.raw.tool_id === 'string')
+            return chunk.raw.tool_id;
+    }
+    if (chunk.type === 'memory_var_update' && chunk.raw) {
+        const name = typeof chunk.raw.name === 'string' ? chunk.raw.name : 'var';
+        const conv = typeof chunk.raw.conversation_id === 'string' ? chunk.raw.conversation_id : '';
+        return `memory_${name}_${conv}`.slice(0, 120);
+    }
+    if (typeof chunk.raw?.tool_call_id === 'string')
+        return chunk.raw.tool_call_id;
+    if (typeof chunk.raw?.chunk_id === 'string')
+        return chunk.raw.chunk_id;
+    return undefined;
+}
+/** 结束当前思考阶段，进入 ReAct 下一步（工具调用或回答） */
+function endThinkingPhase(ctx, events, timestamp) {
+    if (!ctx.isThinking)
+        return;
+    const content = ctx.thinkingContent.trim();
+    ctx.isThinking = false;
+    if (content) {
+        events.push({
+            type: 'thinking_end',
+            timestamp,
+            content,
+            runningTime: normalizeRunningTime(ctx.thinkingRunningTime),
+            round: ctx.thinkingRound,
+        });
+    }
+    ctx.thinkingContent = '';
+    ctx.thinkingRunningTime = undefined;
+}
+/** 开始新一轮思考（支持 ReAct 多轮：思考 → 工具 → 再思考） */
+function startThinkingPhase(ctx, events, timestamp) {
+    if (ctx.isThinking)
+        return;
+    ctx.thinkingRound += 1;
+    ctx.isThinking = true;
+    ctx.thinkingContent = '';
+    ctx.thinkingRunningTime = undefined;
+    events.push({
+        type: 'thinking_start',
+        timestamp,
+        round: ctx.thinkingRound,
+    });
+}
+function emitToolStart(ctx, events, timestamp, callKind, title, toolId) {
+    const id = toolId ?? nextToolId();
+    ctx.activeToolId = id;
+    events.push({
+        type: callKind === 'knowledge' ? 'knowledge_call_start' : 'tool_call_start',
+        timestamp,
+        toolId: id,
+        title,
+        callKind,
+    });
+}
+function emitToolEnd(ctx, events, timestamp, callKind, title, content, runningTime, toolId) {
+    const id = toolId ?? ctx.activeToolId ?? nextToolId();
+    events.push({
+        type: callKind === 'knowledge' ? 'knowledge_call_end' : 'tool_call_end',
+        timestamp,
+        toolId: id,
+        title,
+        content,
+        runningTime: normalizeRunningTime(runningTime),
+        callKind,
+    });
+    if (ctx.activeToolId === id)
+        ctx.activeToolId = undefined;
+}
+/**
+ * ReAct 流式事件归一化
+ *
+ * 交互时序：
+ * 1. thinking_start → thinking_delta* → thinking_end（进入工具/MCP/工作流，或开始输出 answer 时收尾）
+ * 2. tool_call_start → tool_call_end（工具调用中 → 完成）
+ * 3. 可重复 1-2 多轮
+ * 4. answer_delta* 流式输出最终结果（不触发 thinking_end，避免 answer-toolsnode 空包多计一轮）
+ */
+function normalizeRawChunk(chunk, ctx) {
+    const timestamp = Date.now();
+    const events = [];
+    if (chunk.type === 'error') {
+        endThinkingPhase(ctx, events, timestamp);
+        events.push({
+            type: 'error',
+            timestamp,
+            message: chunk.error || chunk.content || '执行出错，请稍后重试',
+            detail: chunk.error_detail,
+        });
+        return events;
+    }
+    if (chunk.type === 'thinking') {
+        if (chunk.running_time) {
+            ctx.thinkingRunningTime = normalizeRunningTime(chunk.running_time);
+        }
+        startThinkingPhase(ctx, events, timestamp);
+        ctx.thinkingContent += chunk.content;
+        events.push({
+            type: 'thinking_delta',
+            timestamp,
+            delta: chunk.content,
+            content: ctx.thinkingContent,
+            round: ctx.thinkingRound,
+        });
+        return events;
+    }
+    if (isToolType(chunk.type)) {
+        endThinkingPhase(ctx, events, timestamp);
+        const callKind = resolveCallKind(chunk.type);
+        const title = resolveCallTitle(callKind, chunk.raw);
+        const rawId = resolveToolId(chunk);
+        if (chunk.running_time) {
+            if (!ctx.activeToolId) {
+                emitToolStart(ctx, events, timestamp, callKind, title, rawId);
+            }
+            emitToolEnd(ctx, events, timestamp, callKind, title, chunk.content, chunk.running_time, rawId);
+        }
+        else if (chunk.content) {
+            emitToolEnd(ctx, events, timestamp, callKind, title, chunk.content, undefined, rawId);
+        }
+        else {
+            emitToolStart(ctx, events, timestamp, callKind, title, rawId);
+        }
+        return events;
+    }
+    if (ANSWER_TYPES.has(chunk.type)) {
+        // 思考阶段结束、开始输出最终回答时立即 thinking_end，避免 loading 持续到流结束
+        endThinkingPhase(ctx, events, timestamp);
+        const delta = chunk.content;
+        appendAnswerContent(ctx, delta);
+        events.push({
+            type: 'answer_delta',
+            timestamp,
+            delta,
+            content: ctx.answerContent,
+        });
+        return events;
+    }
+    if (STREAM_END_TYPES.has(chunk.type)) {
+        endThinkingPhase(ctx, events, timestamp);
+        events.push({ type: 'stream_end', timestamp });
+        return events;
+    }
+    if (chunk.content &&
+        chunk.type !== 'thinking' &&
+        !isToolType(chunk.type) &&
+        chunk.type !== 'error') {
+        endThinkingPhase(ctx, events, timestamp);
+        const delta = chunk.content;
+        appendAnswerContent(ctx, delta);
+        events.push({
+            type: 'answer_delta',
+            timestamp,
+            delta,
+            content: ctx.answerContent,
+        });
+        return events;
+    }
+    events.push({ type: 'raw', timestamp, chunk });
+    return events;
+}
+function finalizeNormalizeContext(ctx) {
+    const events = [];
+    endThinkingPhase(ctx, events, Date.now());
+    return events;
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}