@tdesign-react/chat 1.0.2-alpha.8 → 1.1.0-alpha.1

package/es/chat-engine/core/index.js

@@ -0,0 +1,754 @@
+/**
+ * tdesign v1.0.2-alpha.15
+ * (c) 2026 tdesign
+ * @license MIT
+ */
+
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { AGUIAdapter } from './adapters/agui/index.js';
+export { AGUIAdapter } from './adapters/agui/index.js';
+import './event-bus/index.js';
+import { MessageStore } from './store/message.js';
+import MessageProcessor from './processor/index.js';
+import './server/index.js';
+import { isAIMessage } from './utils/index.js';
+export { applyJsonPatch, findTargetElement, getMessageContentForCopy, isAIMessage, isActivityContent, isAttachmentContent, isImageContent, isMarkdownContent, isReasoningContent, isSearchContent, isSuggestionContent, isTextContent, isThinkingContent, isToolCallContent, isUserMessage, safeParseJSON } from './utils/index.js';
+export { StateManagerImpl, stateManager } from './adapters/agui/state-manager.js';
+export { activityManager } from './adapters/agui/activity-manager.js';
+import { ChatEventBus } from './event-bus/ChatEventBus.js';
+export { ChatEventBus, createEventBus } from './event-bus/ChatEventBus.js';
+import { ChatEngineEventType } from './event-bus/types.js';
+export { ChatEngineEventType } from './event-bus/types.js';
+import { LLMService } from './server/llm-service.js';
+export { AGUIEventType, ActivityDeltaEventSchema, ActivitySnapshotEventSchema, CustomEventSchema, EventSchemas, MessagesSnapshotEventSchema, RawEventSchema, RunErrorEventSchema, RunFinishedEventSchema, RunStartedEventSchema, StateDeltaEventSchema, StateSnapshotEventSchema, StepFinishedEventSchema, StepStartedEventSchema, TextMessageChunkEventSchema, TextMessageContentEventSchema, TextMessageEndEventSchema, TextMessageStartEventSchema, ThinkingEndEventSchema, ThinkingStartEventSchema, ThinkingTextMessageContentEventSchema, ThinkingTextMessageEndEventSchema, ThinkingTextMessageStartEventSchema, ToolCallArgsEventSchema, ToolCallChunkEventSchema, ToolCallEndEventSchema, ToolCallResultEventSchema, ToolCallStartEventSchema, isActivityEvent, isStateEvent, isTextMessageEvent, isThinkingEvent, isToolCallEvent } from './adapters/agui/events.js';
+import '@babel/runtime/helpers/toConsumableArray';
+import './adapters/agui/event-mapper.js';
+import './adapters/agui/utils.js';
+import '@babel/runtime/helpers/typeof';
+import 'zod';
+import './adapters/agui/types.js';
+import '@babel/runtime/helpers/possibleConstructorReturn';
+import '@babel/runtime/helpers/getPrototypeOf';
+import '@babel/runtime/helpers/inherits';
+import '@babel/runtime/helpers/wrapNativeSuper';
+import '@babel/runtime/helpers/slicedToArray';
+import '@babel/runtime/helpers/get';
+import './store/reactiveState.js';
+import './server/types.js';
+import './server/errors.js';
+import './server/connection-manager.js';
+import './utils/logger.js';
+import './server/sse-client.js';
+import './utils/eventEmitter.js';
+import './server/sse-parser.js';
+import './server/batch-client.js';
+
+var _excluded = ["prompt", "attachments"];
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var ChatEngine = /*#__PURE__*/function () {
+  function ChatEngine(eventBusOptions) {
+    _classCallCheck(this, ChatEngine);
+    _defineProperty(this, "stopReceive", false);
+    _defineProperty(this, "aguiAdapter", null);
+    this.messageProcessor = new MessageProcessor();
+    this.messageStore = new MessageStore();
+    this.eventBus = new ChatEventBus(eventBusOptions);
+  }
+  return _createClass(ChatEngine, [{
+    key: "messages",
+    get: function get() {
+      return this.messageStore.messages;
+    }
+  }, {
+    key: "status",
+    get: function get() {
+      var _this$messages$at;
+      return ((_this$messages$at = this.messages.at(-1)) === null || _this$messages$at === void 0 ? void 0 : _this$messages$at.status) || "idle";
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.eventBus.emit(ChatEngineEventType.ENGINE_DESTROY, {
+        timestamp: Date.now()
+      });
+      this.abortChat();
+      this.messageStore.clearHistory();
+      this.aguiAdapter = null;
+      this.eventBus.destroy();
+    }
+  }, {
+    key: "init",
+    value: function init(configSetter, initialMessages) {
+      this.messageStore.initialize(this.convertMessages(initialMessages));
+      this.config = typeof configSetter === "function" ? configSetter() : configSetter || {};
+      this.llmService = new LLMService();
+      if (this.config.protocol === "agui") {
+        this.aguiAdapter = new AGUIAdapter();
+      }
+      this.eventBus.emit(ChatEngineEventType.ENGINE_INIT, {
+        timestamp: Date.now()
+      });
+    }
+  }, {
+    key: "sendUserMessage",
+    value: function () {
+      var _sendUserMessage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(requestParams) {
+        var sendRequest,
+          prompt,
+          attachments,
+          customParams,
+          hasValidPrompt,
+          hasValidAttachments,
+          userMessage,
+          aiMessage,
+          params,
+          _args = arguments;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              sendRequest = _args.length > 1 && _args[1] !== undefined ? _args[1] : true;
+              prompt = requestParams.prompt, attachments = requestParams.attachments, customParams = _objectWithoutProperties(requestParams, _excluded);
+              hasValidPrompt = prompt && prompt.trim() !== "";
+              hasValidAttachments = Array.isArray(attachments) && attachments.length > 0;
+              if (!(!hasValidPrompt && !hasValidAttachments)) {
+                _context.next = 1;
+                break;
+              }
+              console.warn("[ChatEngine] sendUserMessage: \u5FC5\u987B\u63D0\u4F9B\u6709\u6548\u7684prompt\u6216attachments");
+              return _context.abrupt("return");
+            case 1:
+              userMessage = this.messageProcessor.createUserMessage(prompt, attachments);
+              aiMessage = this.messageProcessor.createAssistantMessage();
+              this.messageStore.createMultiMessages([userMessage, aiMessage]);
+              this.eventBus.emit(ChatEngineEventType.MESSAGE_CREATE, {
+                message: userMessage,
+                messages: this.messages
+              });
+              if (sendRequest) {
+                params = _objectSpread(_objectSpread({}, requestParams), {}, {
+                  messageID: aiMessage.id
+                }, customParams);
+                this.sendRequest(params);
+              }
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function sendUserMessage(_x) {
+        return _sendUserMessage.apply(this, arguments);
+      }
+      return sendUserMessage;
+    }()
+  }, {
+    key: "sendSystemMessage",
+    value: function () {
+      var _sendSystemMessage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(msg) {
+        var systemMessage;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              systemMessage = {
+                role: "system",
+                content: [{
+                  type: "text",
+                  data: msg
+                }]
+              };
+              this.messageStore.createMessage(systemMessage);
+              this.eventBus.emit(ChatEngineEventType.MESSAGE_CREATE, {
+                message: systemMessage,
+                messages: this.messages
+              });
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function sendSystemMessage(_x2) {
+        return _sendSystemMessage.apply(this, arguments);
+      }
+      return sendSystemMessage;
+    }()
+  }, {
+    key: "sendAIMessage",
+    value: function () {
+      var _sendAIMessage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var options,
+          _options$params,
+          params,
+          content,
+          _options$sendRequest,
+          sendRequest,
+          newAIMessage,
+          _args3 = arguments;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              options = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {};
+              _options$params = options.params, params = _options$params === void 0 ? {} : _options$params, content = options.content, _options$sendRequest = options.sendRequest, sendRequest = _options$sendRequest === void 0 ? true : _options$sendRequest;
+              newAIMessage = this.messageProcessor.createAssistantMessage({
+                content: content,
+                status: sendRequest ? "pending" : "complete"
+              });
+              this.messageStore.createMessage(newAIMessage);
+              this.eventBus.emit(ChatEngineEventType.MESSAGE_CREATE, {
+                message: newAIMessage,
+                messages: this.messages
+              });
+              if (!sendRequest) {
+                _context3.next = 1;
+                break;
+              }
+              params.messageID = newAIMessage.id;
+              _context3.next = 1;
+              return this.sendRequest(params);
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function sendAIMessage() {
+        return _sendAIMessage.apply(this, arguments);
+      }
+      return sendAIMessage;
+    }()
+  }, {
+    key: "abortChat",
+    value: function () {
+      var _abortChat = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        var _this$config;
+        var _this$messageStore$la, messageId;
+        return _regeneratorRuntime.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              this.stopReceive = true;
+              if (!((_this$config = this.config) !== null && _this$config !== void 0 && _this$config.onAbort)) {
+                _context4.next = 1;
+                break;
+              }
+              _context4.next = 1;
+              return this.config.onAbort();
+            case 1:
+              try {
+                this.llmService.closeConnect();
+                if (!this.config.stream) {
+                  if ((_this$messageStore$la = this.messageStore.lastAIMessage) !== null && _this$messageStore$la !== void 0 && _this$messageStore$la.id) {
+                    messageId = this.messageStore.lastAIMessage.id;
+                    this.messageStore.removeMessage(messageId);
+                    this.eventBus.emit(ChatEngineEventType.MESSAGE_DELETE, {
+                      messageId: messageId,
+                      messages: this.messages
+                    });
+                  }
+                }
+              } catch (error) {
+                console.warn("Error during service cleanup:", error);
+              }
+            case 2:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function abortChat() {
+        return _abortChat.apply(this, arguments);
+      }
+      return abortChat;
+    }()
+  }, {
+    key: "registerMergeStrategy",
+    value: function registerMergeStrategy(type, handler) {
+      this.messageProcessor.registerHandler(type, handler);
+    }
+  }, {
+    key: "setMessages",
+    value: function setMessages(messages) {
+      var mode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "replace";
+      this.messageStore.setMessages(messages, mode);
+    }
+  }, {
+    key: "clearMessages",
+    value: function clearMessages() {
+      this.messageStore.clearHistory();
+      this.eventBus.emit(ChatEngineEventType.MESSAGE_CLEAR, {
+        timestamp: Date.now()
+      });
+    }
+  }, {
+    key: "regenerateAIMessage",
+    value: function () {
+      var _regenerateAIMessage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+        var _this$lastRequestPara, _this$lastRequestPara2;
+        var keepVersion,
+          lastAIMessage,
+          newAIMessage,
+          params,
+          _args5 = arguments;
+        return _regeneratorRuntime.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              keepVersion = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : false;
+              lastAIMessage = this.messageStore.lastAIMessage;
+              if (lastAIMessage) {
+                _context5.next = 1;
+                break;
+              }
+              return _context5.abrupt("return");
+            case 1:
+              if (!keepVersion) {
+                this.messageStore.removeMessage(lastAIMessage.id);
+              } else {
+                this.messageStore.createMessageBranch(lastAIMessage.id);
+              }
+              newAIMessage = this.messageProcessor.createAssistantMessage();
+              this.messageStore.createMessage(newAIMessage);
+              params = _objectSpread(_objectSpread({}, this.lastRequestParams || {}), {}, {
+                messageID: newAIMessage.id,
+                prompt: (_this$lastRequestPara = (_this$lastRequestPara2 = this.lastRequestParams) === null || _this$lastRequestPara2 === void 0 ? void 0 : _this$lastRequestPara2.prompt) !== null && _this$lastRequestPara !== void 0 ? _this$lastRequestPara : ""
+              });
+              _context5.next = 2;
+              return this.sendRequest(params);
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function regenerateAIMessage() {
+        return _regenerateAIMessage.apply(this, arguments);
+      }
+      return regenerateAIMessage;
+    }()
+  }, {
+    key: "sendRequest",
+    value: function () {
+      var _sendRequest = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(params) {
+        var id, _t;
+        return _regeneratorRuntime.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              id = params.messageID;
+              this.eventBus.emit(ChatEngineEventType.REQUEST_START, {
+                params: params,
+                messageId: id
+              });
+              _context6.prev = 1;
+              if (!this.config.stream) {
+                _context6.next = 3;
+                break;
+              }
+              this.stopReceive = false;
+              _context6.next = 2;
+              return this.handleStreamRequest(params);
+            case 2:
+              _context6.next = 4;
+              break;
+            case 3:
+              _context6.next = 4;
+              return this.handleBatchRequest(params);
+            case 4:
+              this.lastRequestParams = params;
+              _context6.next = 6;
+              break;
+            case 5:
+              _context6.prev = 5;
+              _t = _context6["catch"](1);
+              this.setMessageStatus(id, "error");
+              this.eventBus.emit(ChatEngineEventType.REQUEST_ERROR, {
+                messageId: id,
+                error: _t,
+                params: params
+              });
+              throw _t;
+            case 6:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[1, 5]]);
+      }));
+      function sendRequest(_x3) {
+        return _sendRequest.apply(this, arguments);
+      }
+      return sendRequest;
+    }()
+  }, {
+    key: "getToolcallByName",
+    value: function getToolcallByName(name) {
+      var _this$aguiAdapter;
+      return (_this$aguiAdapter = this.aguiAdapter) === null || _this$aguiAdapter === void 0 ? void 0 : _this$aguiAdapter.getToolcallByName(name);
+    }
+  }, {
+    key: "handleBatchRequest",
+    value: function () {
+      var _handleBatchRequest = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(params) {
+        var id, result, message;
+        return _regeneratorRuntime.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              id = params.messageID;
+              if (id) {
+                _context7.next = 1;
+                break;
+              }
+              return _context7.abrupt("return");
+            case 1:
+              this.setMessageStatus(id, "pending");
+              _context7.next = 2;
+              return this.llmService.handleBatchRequest(params, this.config);
+            case 2:
+              result = _context7.sent;
+              if (result) {
+                this.processMessageResult(id, result);
+                this.setMessageStatus(id, "complete");
+                message = this.messageStore.getMessageByID(id);
+                if (message) {
+                  this.eventBus.emit(ChatEngineEventType.REQUEST_COMPLETE, {
+                    messageId: id,
+                    params: params,
+                    message: message
+                  });
+                }
+              } else {
+                this.setMessageStatus(id, "error");
+                this.eventBus.emit(ChatEngineEventType.REQUEST_ERROR, {
+                  messageId: id,
+                  error: new Error("Batch request returned empty result"),
+                  params: params
+                });
+              }
+            case 3:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function handleBatchRequest(_x4) {
+        return _handleBatchRequest.apply(this, arguments);
+      }
+      return handleBatchRequest;
+    }()
+  }, {
+    key: "handleError",
+    value: function handleError(id, error) {
+      var _this$config$onError, _this$config2;
+      this.setMessageStatus(id, "error");
+      (_this$config$onError = (_this$config2 = this.config).onError) === null || _this$config$onError === void 0 || _this$config$onError.call(_this$config2, error);
+      this.eventBus.emit(ChatEngineEventType.REQUEST_ERROR, {
+        messageId: id,
+        error: error
+      });
+    }
+  }, {
+    key: "handleComplete",
+    value: function handleComplete(id, isAborted, params, chunk) {
+      var _this$config$onComple, _this$config3;
+      var customResult = (_this$config$onComple = (_this$config3 = this.config).onComplete) === null || _this$config$onComple === void 0 ? void 0 : _this$config$onComple.call(_this$config3, isAborted, params, chunk);
+      if (Array.isArray(customResult) || customResult && "status" in customResult) {
+        this.processMessageResult(id, customResult);
+      } else {
+        var allContentFailed = this.messageStore.messages.find(function (content) {
+          return content.status === "error";
+        });
+        this.setMessageStatus(id, isAborted ? "stop" : allContentFailed ? "error" : "complete");
+      }
+      var message = this.messageStore.getMessageByID(id);
+      if (message) {
+        if (isAborted) {
+          this.eventBus.emit(ChatEngineEventType.REQUEST_ABORT, {
+            messageId: id,
+            params: params
+          });
+        } else {
+          this.eventBus.emit(ChatEngineEventType.REQUEST_COMPLETE, {
+            messageId: id,
+            params: params,
+            message: message
+          });
+        }
+      }
+    }
+  }, {
+    key: "handleStreamRequest",
+    value: function () {
+      var _handleStreamRequest = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(params) {
+        var id, isAGUI;
+        return _regeneratorRuntime.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              id = params.messageID;
+              isAGUI = this.config.protocol === "agui";
+              if (id) {
+                this.setMessageStatus(id, "streaming");
+              }
+              if (!(isAGUI && this.aguiAdapter)) {
+                _context8.next = 2;
+                break;
+              }
+              _context8.next = 1;
+              return this.handleAGUIStreamRequest(params, id);
+            case 1:
+              _context8.next = 3;
+              break;
+            case 2:
+              _context8.next = 3;
+              return this.handleDefaultStreamRequest(params, id);
+            case 3:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function handleStreamRequest(_x5) {
+        return _handleStreamRequest.apply(this, arguments);
+      }
+      return handleStreamRequest;
+    }()
+  }, {
+    key: "handleAGUIStreamRequest",
+    value: function () {
+      var _handleAGUIStreamRequest = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9(params, messageId) {
+        var _this = this;
+        return _regeneratorRuntime.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.next = 1;
+              return this.llmService.handleStreamRequest(params, _objectSpread(_objectSpread({}, this.config), {}, {
+                onMessage: function onMessage(chunk) {
+                  if (_this.stopReceive || !messageId) return null;
+                  var result = null;
+                  if (_this.aguiAdapter) {
+                    result = _this.aguiAdapter.handleAGUIEvent(chunk, {
+                      onRunStart: function onRunStart(event) {
+                        var _this$aguiAdapter2, _this$config$onStart, _this$config4;
+                        (_this$aguiAdapter2 = _this.aguiAdapter) === null || _this$aguiAdapter2 === void 0 || _this$aguiAdapter2.reset();
+                        (_this$config$onStart = (_this$config4 = _this.config).onStart) === null || _this$config$onStart === void 0 || _this$config$onStart.call(_this$config4, JSON.stringify(event));
+                        _this.eventBus.emit(ChatEngineEventType.AGUI_RUN_START, {
+                          runId: event.runId || "",
+                          threadId: event.threadId,
+                          timestamp: Date.now()
+                        });
+                      },
+                      onRunComplete: function onRunComplete(isAborted, requestParams, event) {
+                        _this.handleComplete(messageId, isAborted, requestParams, event);
+                        if (!isAborted) {
+                          _this.eventBus.emit(ChatEngineEventType.AGUI_RUN_COMPLETE, {
+                            runId: (event === null || event === void 0 ? void 0 : event.runId) || "",
+                            threadId: event === null || event === void 0 ? void 0 : event.threadId,
+                            timestamp: Date.now()
+                          });
+                        }
+                      },
+                      onRunError: function onRunError(error) {
+                        _this.handleError(messageId, error);
+                        _this.eventBus.emit(ChatEngineEventType.AGUI_RUN_ERROR, {
+                          error: error
+                        });
+                      }
+                    });
+                  }
+                  if (_this.config.onMessage) {
+                    var userResult = _this.config.onMessage(chunk, _this.messageStore.getMessageByID(messageId), result);
+                    if (userResult) {
+                      result = userResult;
+                    }
+                  }
+                  _this.eventBus.emit(ChatEngineEventType.REQUEST_STREAM, {
+                    messageId: messageId,
+                    chunk: chunk,
+                    content: result
+                  });
+                  _this.processMessageResult(messageId, result);
+                  return result;
+                },
+                onError: function onError(error) {
+                  if (messageId) _this.handleError(messageId, error);
+                },
+                onComplete: function onComplete(isAborted) {
+                  if (isAborted && messageId) {
+                    _this.handleComplete(messageId, isAborted, params);
+                  }
+                }
+              }));
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function handleAGUIStreamRequest(_x6, _x7) {
+        return _handleAGUIStreamRequest.apply(this, arguments);
+      }
+      return handleAGUIStreamRequest;
+    }()
+  }, {
+    key: "handleDefaultStreamRequest",
+    value: function () {
+      var _handleDefaultStreamRequest = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0(params, messageId) {
+        var _this2 = this;
+        return _regeneratorRuntime.wrap(function (_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              _context0.next = 1;
+              return this.llmService.handleStreamRequest(params, _objectSpread(_objectSpread({}, this.config), {}, {
+                onStart: function onStart(chunk) {
+                  var _this2$config$onStart, _this2$config;
+                  (_this2$config$onStart = (_this2$config = _this2.config).onStart) === null || _this2$config$onStart === void 0 || _this2$config$onStart.call(_this2$config, chunk);
+                },
+                onMessage: function onMessage(chunk) {
+                  if (_this2.stopReceive || !messageId) return null;
+                  var result = null;
+                  if (_this2.config.onMessage) {
+                    result = _this2.config.onMessage(chunk, _this2.messageStore.getMessageByID(messageId));
+                  }
+                  _this2.eventBus.emit(ChatEngineEventType.REQUEST_STREAM, {
+                    messageId: messageId,
+                    chunk: chunk,
+                    content: result
+                  });
+                  _this2.processMessageResult(messageId, result);
+                  return result;
+                },
+                onError: function onError(error) {
+                  if (messageId) _this2.handleError(messageId, error);
+                },
+                onComplete: function onComplete(isAborted) {
+                  if (messageId) {
+                    _this2.handleComplete(messageId, isAborted, params);
+                  }
+                }
+              }));
+            case 1:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee0, this);
+      }));
+      function handleDefaultStreamRequest(_x8, _x9) {
+        return _handleDefaultStreamRequest.apply(this, arguments);
+      }
+      return handleDefaultStreamRequest;
+    }()
+  }, {
+    key: "processMessageResult",
+    value: function processMessageResult(messageId, result) {
+      if (!result) return;
+      if (Array.isArray(result)) {
+        this.messageStore.updateMultipleContents(messageId, result);
+      } else {
+        this.processContentUpdate(messageId, result);
+      }
+      var message = this.messageStore.getMessageByID(messageId);
+      if (message) {
+        this.eventBus.emit(ChatEngineEventType.MESSAGE_UPDATE, {
+          messageId: messageId,
+          content: result,
+          message: message
+        });
+        if (this.aguiAdapter) {
+          this.emitAGUIDetailEvents(messageId, result);
+        }
+      }
+    }
+  }, {
+    key: "emitAGUIDetailEvents",
+    value: function emitAGUIDetailEvents(messageId, result) {
+      var contents = Array.isArray(result) ? result : [result];
+      var _iterator = _createForOfIteratorHelper(contents),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _content$data2;
+          var content = _step.value;
+          if (content.data.activityType) {
+            var _content$data;
+            this.eventBus.emit(ChatEngineEventType.AGUI_ACTIVITY, {
+              activityType: content.data.activityType,
+              messageId: messageId,
+              content: content === null || content === void 0 || (_content$data = content.data) === null || _content$data === void 0 ? void 0 : _content$data.content
+            });
+          }
+          if (content !== null && content !== void 0 && (_content$data2 = content.data) !== null && _content$data2 !== void 0 && (_content$data2 = _content$data2.eventType) !== null && _content$data2 !== void 0 && _content$data2.startsWith("TOOL_CALL")) {
+            this.eventBus.emit(ChatEngineEventType.AGUI_TOOLCALL, {
+              toolCall: content.data,
+              eventType: content.data.eventType
+            });
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "convertMessages",
+    value: function convertMessages(messages) {
+      if (!messages) return {
+        messageIds: [],
+        messages: []
+      };
+      return {
+        messageIds: messages.map(function (msg) {
+          return msg.id;
+        }),
+        messages: messages
+      };
+    }
+  }, {
+    key: "setMessageStatus",
+    value: function setMessageStatus(messageId, status) {
+      var _this$messageStore$ge;
+      var previousStatus = (_this$messageStore$ge = this.messageStore.getMessageByID(messageId)) === null || _this$messageStore$ge === void 0 ? void 0 : _this$messageStore$ge.status;
+      this.messageStore.setMessageStatus(messageId, status);
+      if (status) {
+        this.eventBus.emit(ChatEngineEventType.MESSAGE_STATUS_CHANGE, {
+          messageId: messageId,
+          status: status,
+          previousStatus: previousStatus
+        });
+      }
+    }
+  }, {
+    key: "processContentUpdate",
+    value: function processContentUpdate(messageId, rawChunk) {
+      var message = this.messageStore.messages.find(function (m) {
+        return m.id === messageId;
+      });
+      if (!message || !isAIMessage(message) || !message.content) return;
+      var targetIndex;
+      if ((rawChunk === null || rawChunk === void 0 ? void 0 : rawChunk.strategy) === "append") {
+        targetIndex = -1;
+      } else {
+        targetIndex = message.content.findIndex(function (content) {
+          return content.type === rawChunk.type;
+        });
+        if (targetIndex !== -1) {
+          for (var i = message.content.length - 1; i >= 0; i--) {
+            if (message.content[i].type === rawChunk.type) {
+              targetIndex = i;
+              break;
+            }
+          }
+        }
+      }
+      var processed = this.messageProcessor.processContentUpdate(targetIndex !== -1 ? message.content[targetIndex] : void 0, rawChunk);
+      this.messageStore.appendContent(messageId, processed, targetIndex);
+    }
+  }]);
+}();
+
+export { ChatEngine as default };
+//# sourceMappingURL=index.js.map