@tdesign-react/chat 1.1.0-alpha.11 → 1.1.0-alpha.13

package/es/chat-engine/core/adapters/openclaw/event-mapper.js

@@ -0,0 +1,606 @@
+/**
+ * tdesign v1.1.0-alpha.12
+ * (c) 2026 tdesign
+ * @license MIT
+ */
+
+import _typeof from '@babel/runtime/helpers/typeof';
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { OpenClawEventType, ChatEventState, AgentStreamType, AgentDataType } from './types/events.js';
+import '../shared/index.js';
+import '../shared/activity-manager.js';
+import { createToolCallContent, mergeStringContent, updateToolCall, handleSuggestionToolCall, createActivityContent } from '../agui/utils.js';
+import { activityManager } from '../agui/ActivityManager.js';
+import '../shared/content-factory.js';
+import '../shared/merge-utils.js';
+import '@babel/runtime/helpers/toConsumableArray';
+import '../../utils/index.js';
+import '../../utils/immutable-patch.js';
+import '@babel/runtime/helpers/objectWithoutProperties';
+import '@babel/runtime/helpers/toArray';
+
+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 OpenClawEventMapper = /*#__PURE__*/function () {
+  function OpenClawEventMapper() {
+    _classCallCheck(this, OpenClawEventMapper);
+    _defineProperty(this, "textBuffer", "");
+    _defineProperty(this, "currentRunId", null);
+    _defineProperty(this, "toolCallMap", {});
+    _defineProperty(this, "toolCallEnded", /* @__PURE__ */new Set());
+  }
+  return _createClass(OpenClawEventMapper, [{
+    key: "mapEvent",
+    value: function mapEvent(frame) {
+      var event = frame.event,
+        payload = frame.payload;
+      switch (event) {
+        case OpenClawEventType.CHAT:
+          return this.mapChatEvent(payload);
+        case OpenClawEventType.AGENT:
+          return this.mapAgentEvent(payload);
+        case OpenClawEventType.CONNECT_CHALLENGE:
+          return {
+            content: null,
+            isFinal: false,
+            hasError: false
+          };
+        default:
+          return this.mapGenericEvent(event, payload);
+      }
+    }
+  }, {
+    key: "mapChatEvent",
+    value: function mapChatEvent(payload) {
+      var state = payload.state,
+        message = payload.message,
+        runId = payload.runId,
+        errorMessage = payload.errorMessage;
+      this.currentRunId = runId || this.currentRunId;
+      switch (state) {
+        case ChatEventState.DELTA:
+          return this.handleChatDelta(message);
+        case ChatEventState.FINAL:
+          return this.handleChatFinal(message);
+        case ChatEventState.ERROR:
+          return {
+            content: this.createErrorContent(errorMessage || "Chat error"),
+            isFinal: true,
+            hasError: true,
+            errorMessage: errorMessage,
+            runId: this.currentRunId || void 0
+          };
+        case ChatEventState.ABORTED:
+          return {
+            content: null,
+            isFinal: true,
+            hasError: false,
+            runId: this.currentRunId || void 0
+          };
+        default:
+          return {
+            content: null,
+            isFinal: false,
+            hasError: false
+          };
+      }
+    }
+  }, {
+    key: "handleChatDelta",
+    value: function handleChatDelta(message) {
+      if (!(message !== null && message !== void 0 && message.content)) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var text = this.extractTextFromContent(message.content);
+      if (text === null) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var prevBuffer = this.textBuffer;
+      this.textBuffer = text;
+      var delta = text.startsWith(prevBuffer) ? text.slice(prevBuffer.length) : text;
+      if (!delta) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var textContent = {
+        type: "text",
+        data: delta,
+        status: "streaming"
+      };
+      return {
+        content: textContent,
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleChatFinal",
+    value: function handleChatFinal(_message) {
+      this.textBuffer = "";
+      var textContent = {
+        type: "text",
+        data: "",
+        status: "complete"
+      };
+      return {
+        content: textContent,
+        isFinal: true,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "mapAgentEvent",
+    value: function mapAgentEvent(payload) {
+      var stream = payload.stream,
+        data = payload.data,
+        runId = payload.runId;
+      this.currentRunId = runId || this.currentRunId;
+      switch (stream) {
+        case AgentStreamType.TOOL:
+          return this.handleToolStream(data);
+        case AgentStreamType.ACTIVITY:
+          return this.handleActivityStream(data);
+        case AgentStreamType.ASSISTANT:
+        case void 0:
+        default:
+          return this.handleAssistantStream(payload);
+      }
+    }
+  }, {
+    key: "handleAssistantStream",
+    value: function handleAssistantStream(payload) {
+      var type = payload.type,
+        data = payload.data;
+      if (data && typeof data.text === "string" && typeof data.delta === "string") {
+        return this.handleAgentTextSnapshot(data);
+      }
+      var eventType = type || (data === null || data === void 0 ? void 0 : data.type);
+      switch (eventType) {
+        case AgentDataType.TEXT_SNAPSHOT:
+        case "snapshot":
+          return this.handleAgentTextSnapshot(data);
+        case AgentDataType.TEXT_DELTA:
+        case "delta":
+          return this.handleAgentTextDelta(data);
+        case AgentDataType.DONE:
+        case "done":
+        case "complete":
+        case "final":
+          return this.handleAgentComplete();
+        case AgentDataType.ERROR:
+        case "error":
+          return {
+            content: this.createErrorContent((data === null || data === void 0 ? void 0 : data.text) || "Agent error"),
+            isFinal: true,
+            hasError: true,
+            errorMessage: data === null || data === void 0 ? void 0 : data.text,
+            runId: this.currentRunId || void 0
+          };
+        case AgentDataType.TOOL_CALL:
+          return this.handleToolCall(data);
+        case AgentDataType.TOOL_RESULT:
+          return this.handleToolResult(data);
+        default:
+          return this.handleAgentGenericData(data);
+      }
+    }
+  }, {
+    key: "handleAgentTextSnapshot",
+    value: function handleAgentTextSnapshot(data) {
+      var text = (data === null || data === void 0 ? void 0 : data.text) || "";
+      var delta = data === null || data === void 0 ? void 0 : data.delta;
+      if (!text && !delta) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      this.textBuffer = text;
+      var contentData = typeof delta === "string" ? delta : text;
+      if (!contentData) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var textContent = {
+        type: "text",
+        data: contentData,
+        status: "streaming"
+      };
+      return {
+        content: textContent,
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleAgentTextDelta",
+    value: function handleAgentTextDelta(data) {
+      var delta = (data === null || data === void 0 ? void 0 : data.delta) || (data === null || data === void 0 ? void 0 : data.text) || "";
+      if (!delta) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      this.textBuffer += delta;
+      var textContent = {
+        type: "text",
+        data: delta,
+        status: "streaming"
+      };
+      return {
+        content: textContent,
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleAgentComplete",
+    value: function handleAgentComplete() {
+      var textContent = {
+        type: "text",
+        data: "",
+        status: "complete"
+      };
+      this.textBuffer = "";
+      return {
+        content: textContent,
+        isFinal: true,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleAgentGenericData",
+    value: function handleAgentGenericData(data) {
+      var text = data === null || data === void 0 ? void 0 : data.text;
+      var delta = data === null || data === void 0 ? void 0 : data.delta;
+      if (typeof delta === "string" && delta) {
+        this.textBuffer += delta;
+        return {
+          content: {
+            type: "text",
+            data: delta,
+            status: "streaming"
+          },
+          isFinal: false,
+          hasError: false,
+          runId: this.currentRunId || void 0
+        };
+      }
+      if (typeof text === "string" && text) {
+        var prevBuffer = this.textBuffer;
+        this.textBuffer = text;
+        var contentData = text.startsWith(prevBuffer) ? text.slice(prevBuffer.length) : text;
+        if (!contentData) {
+          return {
+            content: null,
+            isFinal: false,
+            hasError: false
+          };
+        }
+        return {
+          content: {
+            type: "text",
+            data: contentData,
+            status: "streaming"
+          },
+          isFinal: false,
+          hasError: false,
+          runId: this.currentRunId || void 0
+        };
+      }
+      return {
+        content: null,
+        isFinal: false,
+        hasError: false
+      };
+    }
+  }, {
+    key: "handleToolStream",
+    value: function handleToolStream(data) {
+      if (!(data !== null && data !== void 0 && data.toolCallId)) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var toolCallId = data.toolCallId,
+        toolCallName = data.toolCallName,
+        state = data.state;
+      switch (state) {
+        case "start":
+          return this.handleToolCallStart(toolCallId, toolCallName, data);
+        case "args":
+          return this.handleToolCallArgs(toolCallId, data);
+        case "result":
+          return this.handleToolCallResult(toolCallId, data);
+        case "end":
+          return this.handleToolCallEnd(toolCallId);
+        default:
+          return this.handleToolCallGeneric(data);
+      }
+    }
+  }, {
+    key: "handleToolCallStart",
+    value: function handleToolCallStart(toolCallId, toolCallName, data) {
+      this.toolCallMap[toolCallId] = {
+        eventType: "TOOL_CALL_START",
+        toolCallId: toolCallId,
+        toolCallName: toolCallName || "unknown",
+        parentMessageId: (data === null || data === void 0 ? void 0 : data.parentMessageId) || "",
+        args: (data === null || data === void 0 ? void 0 : data.args) || (data === null || data === void 0 ? void 0 : data.delta) || ""
+      };
+      return {
+        content: createToolCallContent(this.toolCallMap[toolCallId], "pending", "append"),
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleToolCallArgs",
+    value: function handleToolCallArgs(toolCallId, data) {
+      if (!this.toolCallMap[toolCallId]) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var currentArgs = this.toolCallMap[toolCallId].args || "";
+      var newArgs = mergeStringContent(currentArgs, (data === null || data === void 0 ? void 0 : data.delta) || "");
+      this.toolCallMap[toolCallId] = updateToolCall(this.toolCallMap[toolCallId], {
+        eventType: "TOOL_CALL_ARGS",
+        args: newArgs
+      });
+      return {
+        content: createToolCallContent(this.toolCallMap[toolCallId], "streaming", "merge"),
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleToolCallResult",
+    value: function handleToolCallResult(toolCallId, data) {
+      if (!this.toolCallMap[toolCallId]) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var currentResult = this.toolCallMap[toolCallId].result || "";
+      var newResult = mergeStringContent(currentResult, (data === null || data === void 0 ? void 0 : data.content) || (data === null || data === void 0 ? void 0 : data.result) || "");
+      this.toolCallMap[toolCallId] = updateToolCall(this.toolCallMap[toolCallId], {
+        eventType: "TOOL_CALL_RESULT",
+        result: newResult
+      });
+      var suggestionContent = handleSuggestionToolCall(this.toolCallMap[toolCallId]);
+      if (suggestionContent) {
+        return {
+          content: suggestionContent,
+          isFinal: false,
+          hasError: false,
+          runId: this.currentRunId || void 0
+        };
+      }
+      return {
+        content: createToolCallContent(this.toolCallMap[toolCallId], "complete", "merge"),
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleToolCallEnd",
+    value: function handleToolCallEnd(toolCallId) {
+      this.toolCallEnded.add(toolCallId);
+      if (this.toolCallMap[toolCallId]) {
+        this.toolCallMap[toolCallId] = _objectSpread(_objectSpread({}, this.toolCallMap[toolCallId]), {}, {
+          eventType: "TOOL_CALL_END"
+        });
+      }
+      return {
+        content: this.toolCallMap[toolCallId] ? createToolCallContent(this.toolCallMap[toolCallId], "complete", "merge") : null,
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "handleToolCallGeneric",
+    value: function handleToolCallGeneric(data) {
+      if (!(data !== null && data !== void 0 && data.toolCallId)) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var toolCallId = data.toolCallId;
+      var toolCallName = data.toolCallName;
+      if (!this.toolCallMap[toolCallId]) {
+        return this.handleToolCallStart(toolCallId, toolCallName, data);
+      }
+      if (data.delta || data.args) {
+        return this.handleToolCallArgs(toolCallId, data);
+      }
+      if (data.content || data.result) {
+        return this.handleToolCallResult(toolCallId, data);
+      }
+      return {
+        content: null,
+        isFinal: false,
+        hasError: false
+      };
+    }
+  }, {
+    key: "handleToolCall",
+    value: function handleToolCall(data) {
+      if (!(data !== null && data !== void 0 && data.toolCallId)) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      return this.handleToolCallStart(data.toolCallId, data.toolCallName || "unknown", data);
+    }
+  }, {
+    key: "handleToolResult",
+    value: function handleToolResult(data) {
+      if (!(data !== null && data !== void 0 && data.toolCallId)) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      return this.handleToolCallResult(data.toolCallId, data);
+    }
+  }, {
+    key: "handleActivityStream",
+    value: function handleActivityStream(data) {
+      if (!(data !== null && data !== void 0 && data.activityType)) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var activityType = data.activityType;
+      var state = data.state;
+      var eventType = state === "snapshot" ? "ACTIVITY_SNAPSHOT" : "ACTIVITY_DELTA";
+      var activityData = activityManager.handleActivityEvent({
+        type: eventType,
+        activityType: activityType,
+        content: data.content,
+        patch: data.patch,
+        messageId: data.messageId
+      });
+      if (!activityData) {
+        return {
+          content: null,
+          isFinal: false,
+          hasError: false
+        };
+      }
+      var isSnapshot = state === "snapshot";
+      var existingActivity = activityManager.getActivity(activityType);
+      var isFirstEvent = isSnapshot || !existingActivity && state === "delta";
+      return {
+        content: createActivityContent(activityType, activityData.content, "streaming", isFirstEvent ? "append" : "merge", activityData.deltaInfo),
+        isFinal: false,
+        hasError: false,
+        runId: this.currentRunId || void 0
+      };
+    }
+  }, {
+    key: "mapGenericEvent",
+    value: function mapGenericEvent(_event, payload) {
+      if (_typeof(payload) === "object" && payload !== null) {
+        var p = payload;
+        var text = p.text || p.content || p.message;
+        if (typeof text === "string") {
+          return {
+            content: {
+              type: "text",
+              data: text,
+              status: "streaming"
+            },
+            isFinal: false,
+            hasError: false
+          };
+        }
+      }
+      return {
+        content: null,
+        isFinal: false,
+        hasError: false
+      };
+    }
+  }, {
+    key: "extractTextFromContent",
+    value: function extractTextFromContent(content) {
+      if (!Array.isArray(content)) {
+        return null;
+      }
+      return content.filter(function (c) {
+        return (c === null || c === void 0 ? void 0 : c.type) === "text" && (c === null || c === void 0 ? void 0 : c.text);
+      }).map(function (c) {
+        return c.text;
+      }).join("");
+    }
+  }, {
+    key: "createErrorContent",
+    value: function createErrorContent(message) {
+      return {
+        type: "text",
+        data: "Error: ".concat(message),
+        status: "error"
+      };
+    }
+  }, {
+    key: "getTextBuffer",
+    value: function getTextBuffer() {
+      return this.textBuffer;
+    }
+  }, {
+    key: "getCurrentRunId",
+    value: function getCurrentRunId() {
+      return this.currentRunId;
+    }
+  }, {
+    key: "getToolCall",
+    value: function getToolCall(toolCallId) {
+      return this.toolCallMap[toolCallId];
+    }
+  }, {
+    key: "getToolCalls",
+    value: function getToolCalls() {
+      return Object.values(this.toolCallMap);
+    }
+  }, {
+    key: "isToolCallEnded",
+    value: function isToolCallEnded(toolCallId) {
+      return this.toolCallEnded.has(toolCallId);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.textBuffer = "";
+      this.currentRunId = null;
+      this.toolCallMap = {};
+      this.toolCallEnded.clear();
+      activityManager.clear();
+    }
+  }]);
+}();
+
+export { OpenClawEventMapper };
+//# sourceMappingURL=event-mapper.js.map