@chat-lab/ui 0.1.0-beta.48 → 0.1.0-beta.49

package/dist/packages/core/dist/index.cjs

@@ -10,426 +10,125 @@ var throttle = require('../../../node_modules/.pnpm/lodash-es@4.17.21/node_modul
 var compact = require('../../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/compact.cjs');
 var findLastIndex = require('../../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/findLastIndex.cjs');
 
-// src/protocols/Adk.ts
-
-// src/protocols/BaseProtocols.ts
-var BaseProtocol = class {
-  constructor(options) {
-    this.protocol = options.protocol;
-    this.protocolName = options.protocolName || options.protocol;
-  }
-  getProtocolName() {
-    return this.protocolName;
-  }
-  onStartSend() {
-  }
-  onEndSend() {
-  }
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var BaseProtocols_default = BaseProtocol;
-
-// src/protocols/constants.ts
-var ProtocolEnum = {
-  AG_UI: "AG_UI",
-  ADK: "ADK",
-  OPEN_AI: "OPEN_AI",
-  ARK: "ARK",
-  A2A: "A2A",
-  // 以上直接提供支持
-  CUSTOM: "CUSTOM"
+var defaultThreadManagerState = {
+  currentThreadId: null,
+  threadMap: {}
 };
-
-// src/types/Message.ts
-var MessageStatus = /* @__PURE__ */ ((MessageStatus2) => {
-  MessageStatus2["SENDING"] = "sending";
-  MessageStatus2["PENDING"] = "pending";
-  MessageStatus2["SUCCESS"] = "success";
-  MessageStatus2["ERROR"] = "error";
-  MessageStatus2["PAUSED"] = "paused";
-  MessageStatus2["ABORTED"] = "aborted";
-  return MessageStatus2;
-})(MessageStatus || {});
-
-// src/utils/Message.ts
-function generateModelMessage(message) {
-  return {
-    id: v4(),
-    role: "assistant",
-    status: "sending" /* SENDING */,
-    content: [],
-    createdAt: Date.now(),
+var createThreadManagerState = () => {
+  return vanilla.proxy({
+    currentThreadId: null,
+    threadMap: {}
+  });
+};
+var createThreadManagerStateWithDefault = () => {
+  const id = v4();
+  return vanilla.proxy({
+    currentThreadId: id,
+    threadMap: {
+      [id]: {
+        id,
+        name: id,
+        metadata: {},
+        sending: false,
+        messages: [],
+        createdAt: dayjs_min.default().unix()
+      }
+    }
+  });
+};
+var threadManagerState = vanilla.proxy(defaultThreadManagerState);
+async function initThreadManagerStore(state) {
+  try {
+    threadManagerState.currentThreadId = state?.currentThreadId || null;
+    threadManagerState.threadMap = state?.threadMap || {};
+  } catch (error) {
+    console.error("initThreadManagerStore error", error);
+  }
+}
+var generateThread = () => {
+  const threadId = v4();
+  const thread = {
+    id: threadId,
+    name: "\u9ED8\u8BA4\u5BF9\u8BDD",
     metadata: {},
-    ...message
+    sending: false,
+    messages: [],
+    createdAt: dayjs_min.default().unix()
   };
-}
-var isTextMessage2 = (message) => message.type === "text";
-var isReasoningMessage2 = (message) => message.type === "reasoning";
-
-// src/utils/getDataType.ts
-var supportTypes = ["image", "video"];
-var supportMimeTypes = ["application/pdf"];
-var getDataType = (mimeType) => {
-  const type = mimeType.split("/")[0];
-  if (supportTypes.includes(type)) {
-    return type;
+  return { currentThreadId: threadId, threadMap: { [threadId]: thread } };
+};
+initThreadManagerStore(generateThread());
+var ThreadMessageManager = class {
+  constructor(state) {
+    this.state = state;
   }
-  if (supportMimeTypes.includes(mimeType)) {
-    return "pdf";
+  // Thread APIs
+  createThread({
+    name = "",
+    metadata = {},
+    switchToNewThread = true
+  }) {
+    const id = v4();
+    const thread = {
+      id,
+      name: name || `\u9ED8\u8BA4\u5BF9\u8BDD${id.slice(0, 4)}`,
+      metadata,
+      createdAt: dayjs_min.default().unix(),
+      updatedAt: dayjs_min.default().unix(),
+      messages: [],
+      sending: false
+    };
+    this.addThread(thread);
+    if (switchToNewThread) {
+      this.setCurrentThread(thread.id);
+    }
   }
-  return "unknown";
-};
-
-// src/protocols/Adk.ts
-var isTextPart = (part) => {
-  return "text" in part && !("thought" in part);
-};
-var isReasoningPart = (part) => {
-  return "text" in part && !!part.thought;
-};
-var isFunctionCallPart = (part) => {
-  return "functionCall" in part;
-};
-var isFunctionResponsePart = (part) => {
-  return "functionResponse" in part;
-};
-var isInlineResponsePart = (part) => {
-  return "inlineData" in part;
-};
-var isFileDataResponsePart = (part) => {
-  return "fileData" in part;
-};
-var formatInlinePart = (part) => {
-  const dataType = getDataType(part.inlineData?.mimeType || "");
-  if (dataType === "unknown") {
-    console.log(
-      `[chatkit:error]: encount unknow mime type ${part.inlineData.mimeType}`
-    );
-    return;
+  addThread(thread) {
+    if (this.checkThreadExist(thread.id, false)) {
+      return;
+    }
+    this.state.threadMap[thread.id] = thread;
   }
-  if (dataType === "image") {
-    return {
-      type: dataType,
-      imageUrl: {
-        url: `data:${part.inlineData?.mimeType};base64,${part.inlineData.data}`
-      }
+  getThread(threadId, throwError = true) {
+    const thread = this.checkThreadExist(threadId, throwError);
+    if (!thread) {
+      return null;
+    }
+    return this.state.threadMap[threadId];
+  }
+  setCurrentThread(threadId) {
+    if (!this.checkThreadExist(threadId, false)) {
+      console.warn(`Thread set current: thread not exist`, threadId);
+      return;
+    }
+    this.state.currentThreadId = threadId;
+    return threadId;
+  }
+  updateThread(threadId, thread) {
+    this.checkThreadExist(threadId);
+    this.state.threadMap[threadId] = {
+      ...this.state.threadMap[threadId],
+      ...thread,
+      updatedAt: dayjs_min.default().unix()
     };
   }
-  const id = v4();
-  return {
-    type: "file",
-    fileId: id,
-    mimeType: part.inlineData.mimeType,
-    fileData: part.inlineData.data,
-    // 无 data 前缀
-    name: `${part.inlineData.mimeType.split("/")[1]}-${id}`
-  };
-};
-var formatFilePart = (part) => {
-  const id = v4();
-  return {
-    type: "file",
-    fileId: id,
-    mimeType: part.fileData.mimeType,
-    fileUrl: part.fileData.fileUri,
-    name: part.fileData.displayName
-  };
-};
-var AdkProtocol = class extends BaseProtocols_default {
-  constructor(options) {
-    super(options);
-    this.protocol = ProtocolEnum.ADK;
-    this.authors = [];
-    this.omitCompleteText = options.omitCompleteText == true;
-    this.protocolName = options.protocolName || options.protocol;
+  deleteThread(threadId) {
+    this.checkThreadExist(threadId);
+    delete this.state.threadMap[threadId];
   }
-  onStartSend() {
-    this.authors = [];
-    this.lastAuthor = void 0;
+  setSending(threadId, sending) {
+    this.checkThreadExist(threadId);
+    this.updateThread(threadId, { sending });
   }
-  // 修改parseChunk方法，使其符合父类抽象方法的定义
-  parseChunk(chunk) {
-    let { message, response } = chunk;
-    let parsedJson = response;
-    const author = parsedJson.author;
-    if (parsedJson.error) {
-      return {
-        ...message,
-        error: parsedJson.error,
-        metadata: {
-          ...message.metadata || {},
-          invocationId: parsedJson.invocationId
-        }
-      };
-    }
-    const parts = parsedJson?.content?.parts || [];
-    if (parsedJson.partial) {
-      for (const part of parts) {
-        const lastMessageContent = last(
-          message.content.filter((_content) => _content.author === author)
-        );
-        const lastReasoningContent = last(
-          message.content.filter(
-            (_content) => _content.author === author && isReasoningMessage2(_content)
-          )
-        );
-        if (lastMessageContent && isTextMessage2(lastMessageContent) && isTextPart(part)) {
-          lastMessageContent.text += part.text;
-        } else if (isTextPart(part)) {
-          message = {
-            ...message,
-            content: [
-              ...message.content,
-              {
-                text: part.text,
-                type: "text",
-                author
-              }
-            ]
-          };
-        } else if (isReasoningPart(part) && lastReasoningContent) {
-          lastReasoningContent.text += part.text;
-        } else if (isReasoningPart(part)) {
-          message = {
-            ...message,
-            content: [
-              ...message.content,
-              { text: part.text, type: "reasoning", author }
-            ]
-          };
-        }
-      }
-      return {
-        ...message,
-        metadata: {
-          ...message.metadata || {},
-          invocationId: parsedJson.invocationId
-        }
-      };
-    }
-    for (const part of parts) {
-      if (isFunctionCallPart(part)) {
-        message = {
-          ...message,
-          content: [
-            ...message.content,
-            {
-              content: null,
-              toolCallId: part.functionCall.id,
-              toolCallArgs: part.functionCall.args,
-              toolCallName: part.functionCall.name,
-              type: "tool_call",
-              author
-            }
-          ]
-        };
-      } else if (isFunctionResponsePart(part)) {
-        message = {
-          ...message,
-          content: message.content.map((item) => {
-            if (item.type === "tool_call" && item.toolCallId === part.functionResponse.id) {
-              return {
-                ...item,
-                content: part.functionResponse.response
-              };
-            }
-            return item;
-          })
-        };
-      } else if (isInlineResponsePart(part)) {
-        message = {
-          ...message,
-          content: compact([...message.content, formatInlinePart(part)])
-        };
-      } else if (isFileDataResponsePart(part)) {
-        message = {
-          ...message,
-          content: compact([...message.content, formatFilePart(part)])
-        };
-      } else if ("text" in part) {
-        if (!this.omitCompleteText || parsedJson.content.role === "user") {
-          if (isReasoningPart(part)) {
-            message = {
-              ...message,
-              content: [
-                ...message.content,
-                { text: part.text, type: "reasoning", author }
-              ]
-            };
-          } else if (isTextPart(part)) {
-            message = {
-              ...message,
-              content: [
-                ...message.content,
-                { text: part.text, type: "text", author }
-              ]
-            };
-          }
-        }
-      }
-    }
-    return {
-      ...message,
-      metadata: {
-        ...message.metadata || {},
-        invocationId: parsedJson.invocationId
-      }
-    };
-  }
-  // 修改generateRequestBody方法，使其符合父类抽象方法的定义
-  generateRequestBody(request) {
-    const { userMessage, defaultParams, dynamicParams } = request;
-    const attachParts = userMessage.attaches?.map((item) => {
-      if (item.url.startsWith("https://") || item.url.startsWith("http://")) {
-        return {
-          fileData: {
-            displayName: item.attachId,
-            fileUri: item.url,
-            mimeType: item.mimeType
-          }
-        };
-      }
-      const base64Data = item.url.startsWith("data:") ? item.url.split(",")[1] : item.url;
-      return {
-        inlineData: {
-          mimeType: item.mimeType,
-          data: base64Data
-        }
-      };
-    }) || [];
-    return {
-      ...defaultParams || {},
-      ...dynamicParams || {},
-      newMessage: {
-        role: "user",
-        parts: compact([
-          ...userMessage.content?.map((item) => {
-            if (item.type === "text") {
-              return {
-                text: item.text
-              };
-            }
-          }) || [],
-          ...attachParts
-        ])
-      }
-    };
-  }
-};
-var Adk_default = AdkProtocol;
-var defaultThreadManagerState = {
-  currentThreadId: null,
-  threadMap: {}
-};
-var createThreadManagerState = () => {
-  return vanilla.proxy({
-    currentThreadId: null,
-    threadMap: {}
-  });
-};
-var createThreadManagerStateWithDefault = () => {
-  const id = v4();
-  return vanilla.proxy({
-    currentThreadId: id,
-    threadMap: {
-      [id]: {
-        id,
-        name: id,
-        metadata: {},
-        sending: false,
-        messages: [],
-        createdAt: dayjs_min.default().unix()
-      }
-    }
-  });
-};
-var threadManagerState = vanilla.proxy(defaultThreadManagerState);
-async function initThreadManagerStore(state) {
-  try {
-    threadManagerState.currentThreadId = state?.currentThreadId || null;
-    threadManagerState.threadMap = state?.threadMap || {};
-  } catch (error) {
-    console.error("initThreadManagerStore error", error);
-  }
-}
-var generateThread = () => {
-  const threadId = v4();
-  const thread = {
-    id: threadId,
-    name: "\u9ED8\u8BA4\u5BF9\u8BDD",
-    metadata: {},
-    sending: false,
-    messages: [],
-    createdAt: dayjs_min.default().unix()
-  };
-  return { currentThreadId: threadId, threadMap: { [threadId]: thread } };
-};
-initThreadManagerStore(generateThread());
-var ThreadMessageManager = class {
-  constructor(state) {
-    this.state = state;
-  }
-  // Thread APIs
-  createThread({
-    name = "",
-    metadata = {},
-    switchToNewThread = true
-  }) {
-    const id = v4();
-    const thread = {
-      id,
-      name: name || `\u9ED8\u8BA4\u5BF9\u8BDD${id.slice(0, 4)}`,
-      metadata,
-      createdAt: dayjs_min.default().unix(),
-      updatedAt: dayjs_min.default().unix(),
-      messages: [],
-      sending: false
-    };
-    this.addThread(thread);
-    if (switchToNewThread) {
-      this.setCurrentThread(thread.id);
-    }
-  }
-  addThread(thread) {
-    if (this.checkThreadExist(thread.id, false)) {
-      return;
-    }
-    this.state.threadMap[thread.id] = thread;
-  }
-  getThread(threadId, throwError = true) {
-    const thread = this.checkThreadExist(threadId, throwError);
-    if (!thread) {
-      return null;
-    }
-    return this.state.threadMap[threadId];
-  }
-  setCurrentThread(threadId) {
-    if (!this.checkThreadExist(threadId, false)) {
-      console.warn(`Thread set current: thread not exist`, threadId);
-      return;
-    }
-    this.state.currentThreadId = threadId;
-    return threadId;
-  }
-  updateThread(threadId, thread) {
-    this.checkThreadExist(threadId);
-    this.state.threadMap[threadId] = {
-      ...this.state.threadMap[threadId],
-      ...thread,
-      updatedAt: dayjs_min.default().unix()
-    };
-  }
-  deleteThread(threadId) {
-    this.checkThreadExist(threadId);
-    delete this.state.threadMap[threadId];
-  }
-  setSending(threadId, sending) {
-    this.checkThreadExist(threadId);
-    this.updateThread(threadId, { sending });
-  }
-  setLoading(threadId, loading, throwError = true) {
-    const thread = this.checkThreadExist(threadId, throwError);
-    if (!thread) {
-      return;
+  setLoading(threadId, loading, throwError = true) {
+    const thread = this.checkThreadExist(threadId, throwError);
+    if (!thread) {
+      return;
     }
     this.updateThread(threadId, { loading });
   }
@@ -732,164 +431,461 @@ var BetterEventSource = class {
     if (!reader) {
       return;
     }
-    const jsonStreamParser = new JsonStreamParser(
-      (json) => {
-        this.emit("message", json);
-      },
-      () => this.isNormalFinished = true
-    );
-    const decoder = new TextDecoder();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          this.emit("end");
-          const remaining = jsonStreamParser.checkFinishedWithSafeJson();
-          if (remaining) {
-            this.emit(
-              "error",
-              new SSEError(
-                "ResponseStreamError" /* ResponseStreamError */,
-                "Response Stream Error: response is not complete with remaining data: " + remaining
-              )
-            );
-          }
-          if (this.isNormalFinished) {
-          } else {
-            this.emit(
-              "error",
-              new SSEError(
-                "InterruptError" /* InterruptError */,
-                "Request abnormal termination"
-              )
-            );
+    const jsonStreamParser = new JsonStreamParser(
+      (json) => {
+        this.emit("message", json);
+      },
+      () => this.isNormalFinished = true
+    );
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.emit("end");
+          const remaining = jsonStreamParser.checkFinishedWithSafeJson();
+          if (remaining) {
+            this.emit(
+              "error",
+              new SSEError(
+                "ResponseStreamError" /* ResponseStreamError */,
+                "Response Stream Error: response is not complete with remaining data: " + remaining
+              )
+            );
+          }
+          if (this.isNormalFinished) {
+          } else {
+            this.emit(
+              "error",
+              new SSEError(
+                "InterruptError" /* InterruptError */,
+                "Request abnormal termination"
+              )
+            );
+          }
+          break;
+        }
+        const text = decoder.decode(value, { stream: true });
+        let response = null;
+        if (text.startsWith("data:")) {
+          response = text.slice(5);
+        } else {
+          response = text;
+        }
+        jsonStreamParser.receiveChunk(response);
+      }
+    } catch (error) {
+      this.emit(
+        "error",
+        new SSEError(
+          error?.name || "ReadableStreamError" /* ReadableStreamError */,
+          error?.message || "Failed to read stream"
+        )
+      );
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch (e) {
+        console.warn(
+          "Failed to release reader lock, might be already released:",
+          e
+        );
+      }
+    }
+  }
+  addEventListener(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, []);
+    }
+    this.eventListeners.get(event)?.push(listener);
+    if (event === "message" && this.eventListeners.get(event)?.length === 1) {
+      this.fetchStream();
+    }
+  }
+  removeEventListener(event, listener) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+  }
+  emit(event, data) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.forEach((listener) => listener(data));
+    }
+  }
+  getHeader(name) {
+    return this.headersReceived?.get(name) || null;
+  }
+};
+
+// src/completions/baseCompletion.ts
+var completion = async (params) => {
+  const {
+    requestOptions: { api, headers = {}, data },
+    abortController,
+    onChunk
+  } = params;
+  try {
+    const eventSource = new BetterEventSource(api, {
+      body: JSON.stringify(data),
+      headers,
+      abortSignal: abortController?.signal
+    });
+    return new Promise((resolve, reject) => {
+      eventSource.addEventListener("error", (error) => {
+        if (error.code === "AbortError") {
+          console.log(error);
+          return;
+        }
+        reject(error);
+      });
+      eventSource.addEventListener("message", (data2) => {
+        onChunk({ response: data2, stop: () => {
+        } });
+      });
+      eventSource.addEventListener("end", () => {
+        resolve();
+      });
+    }).catch((err) => {
+      if (err.code === "AbortError") {
+        return;
+      } else {
+        throw err;
+      }
+    });
+  } catch (error) {
+    console.error("\u8BF7\u6C42\u5931\u8D25:", error.message);
+    throw error;
+  }
+};
+
+// src/completions/adkCompletion.ts
+function getHostUrl(fullUrl) {
+  if (!fullUrl) return "";
+  try {
+    const urlObj = new URL(fullUrl);
+    return urlObj.origin;
+  } catch (error) {
+    console.error(`\u89E3\u6790URL\u5931\u8D25\uFF0C\u65E0\u6548\u7684URL\u683C\u5F0F\uFF1A${fullUrl}`, error);
+    return "";
+  }
+}
+var AdkCompletion = async (params) => {
+  try {
+    await completion(params);
+  } catch (error) {
+    if (error instanceof SSEError && error.message === '{"detail":"Session not found"}') {
+      await fetch(
+        `${getHostUrl(params.requestOptions.api)}/apps/${params.requestOptions.data?.appName}/users/${params.requestOptions.data?.userId}/sessions/${params.requestOptions.data?.sessionId}`,
+        { method: "post", headers: params.requestOptions.headers }
+      );
+      await completion(params);
+      return;
+    }
+    throw error;
+  }
+};
+
+// src/protocols/BaseProtocols.ts
+var BaseProtocols_exports = {};
+__export(BaseProtocols_exports, {
+  default: () => BaseProtocols_default
+});
+var BaseProtocol = class {
+  constructor(options) {
+    this.protocol = options.protocol;
+    this.protocolName = options.protocolName || options.protocol;
+  }
+  getProtocolName() {
+    return this.protocolName;
+  }
+  onStartSend() {
+  }
+  onEndSend() {
+  }
+};
+var BaseProtocols_default = BaseProtocol;
+
+// src/protocols/constants.ts
+var ProtocolEnum = {
+  AG_UI: "AG_UI",
+  ADK: "ADK",
+  OPEN_AI: "OPEN_AI",
+  ARK: "ARK",
+  A2A: "A2A",
+  // 以上直接提供支持
+  CUSTOM: "CUSTOM"
+};
+
+// src/types/Message.ts
+var MessageStatus = /* @__PURE__ */ ((MessageStatus2) => {
+  MessageStatus2["SENDING"] = "sending";
+  MessageStatus2["PENDING"] = "pending";
+  MessageStatus2["SUCCESS"] = "success";
+  MessageStatus2["ERROR"] = "error";
+  MessageStatus2["PAUSED"] = "paused";
+  MessageStatus2["ABORTED"] = "aborted";
+  return MessageStatus2;
+})(MessageStatus || {});
+
+// src/utils/Message.ts
+function generateModelMessage(message) {
+  return {
+    id: v4(),
+    role: "assistant",
+    status: "sending" /* SENDING */,
+    content: [],
+    createdAt: Date.now(),
+    metadata: {},
+    ...message
+  };
+}
+var isTextMessage2 = (message) => message.type === "text";
+var isReasoningMessage2 = (message) => message.type === "reasoning";
+
+// src/utils/getDataType.ts
+var supportTypes = ["image", "video"];
+var supportMimeTypes = ["application/pdf"];
+var getDataType = (mimeType) => {
+  const type = mimeType.split("/")[0];
+  if (supportTypes.includes(type)) {
+    return type;
+  }
+  if (supportMimeTypes.includes(mimeType)) {
+    return "pdf";
+  }
+  return "unknown";
+};
+
+// src/protocols/Adk.ts
+var isTextPart = (part) => {
+  return "text" in part && !("thought" in part);
+};
+var isReasoningPart = (part) => {
+  return "text" in part && !!part.thought;
+};
+var isFunctionCallPart = (part) => {
+  return "functionCall" in part;
+};
+var isFunctionResponsePart = (part) => {
+  return "functionResponse" in part;
+};
+var isInlineResponsePart = (part) => {
+  return "inlineData" in part;
+};
+var isFileDataResponsePart = (part) => {
+  return "fileData" in part;
+};
+var formatInlinePart = (part) => {
+  const dataType = getDataType(part.inlineData?.mimeType || "");
+  if (dataType === "unknown") {
+    console.log(
+      `[chatkit:error]: encount unknow mime type ${part.inlineData.mimeType}`
+    );
+    return;
+  }
+  if (dataType === "image") {
+    return {
+      type: dataType,
+      imageUrl: {
+        url: `data:${part.inlineData?.mimeType};base64,${part.inlineData.data}`
+      }
+    };
+  }
+  const id = v4();
+  return {
+    type: "file",
+    fileId: id,
+    mimeType: part.inlineData.mimeType,
+    fileData: part.inlineData.data,
+    // 无 data 前缀
+    name: `${part.inlineData.mimeType.split("/")[1]}-${id}`
+  };
+};
+var formatFilePart = (part) => {
+  const id = v4();
+  return {
+    type: "file",
+    fileId: id,
+    mimeType: part.fileData.mimeType,
+    fileUrl: part.fileData.fileUri,
+    name: part.fileData.displayName
+  };
+};
+var AdkProtocol = class extends BaseProtocols_default {
+  constructor(options) {
+    super(options);
+    this.protocol = ProtocolEnum.ADK;
+    this.authors = [];
+    this.omitCompleteText = options.omitCompleteText == true;
+    this.protocolName = options.protocolName || options.protocol;
+  }
+  onStartSend() {
+    this.authors = [];
+    this.lastAuthor = void 0;
+  }
+  // 修改parseChunk方法，使其符合父类抽象方法的定义
+  parseChunk(chunk) {
+    let { message, response } = chunk;
+    let parsedJson = response;
+    const author = parsedJson.author;
+    if (parsedJson.error) {
+      return {
+        ...message,
+        error: parsedJson.error
+      };
+    }
+    const parts = parsedJson?.content?.parts || [];
+    if (parsedJson.partial) {
+      for (const part of parts) {
+        const lastMessageContent = last(
+          message.content.filter((_content) => _content.author === author)
+        );
+        const lastReasoningContent = last(
+          message.content.filter(
+            (_content) => _content.author === author && isReasoningMessage2(_content)
+          )
+        );
+        if (lastMessageContent && isTextMessage2(lastMessageContent) && isTextPart(part)) {
+          lastMessageContent.text += part.text;
+        } else if (isTextPart(part)) {
+          message = {
+            ...message,
+            content: [
+              ...message.content,
+              {
+                text: part.text,
+                type: "text",
+                author
+              }
+            ]
+          };
+        } else if (isReasoningPart(part) && lastReasoningContent) {
+          lastReasoningContent.text += part.text;
+        } else if (isReasoningPart(part)) {
+          message = {
+            ...message,
+            content: [
+              ...message.content,
+              { text: part.text, type: "reasoning", author }
+            ]
+          };
+        }
+      }
+      return {
+        ...message
+      };
+    }
+    for (const part of parts) {
+      if (isFunctionCallPart(part)) {
+        message = {
+          ...message,
+          content: [
+            ...message.content,
+            {
+              content: null,
+              toolCallId: part.functionCall.id,
+              toolCallArgs: part.functionCall.args,
+              toolCallName: part.functionCall.name,
+              type: "tool_call",
+              author
+            }
+          ]
+        };
+      } else if (isFunctionResponsePart(part)) {
+        message = {
+          ...message,
+          content: message.content.map((item) => {
+            if (item.type === "tool_call" && item.toolCallId === part.functionResponse.id) {
+              return {
+                ...item,
+                content: part.functionResponse.response
+              };
+            }
+            return item;
+          })
+        };
+      } else if (isInlineResponsePart(part)) {
+        message = {
+          ...message,
+          content: compact([...message.content, formatInlinePart(part)])
+        };
+      } else if (isFileDataResponsePart(part)) {
+        message = {
+          ...message,
+          content: compact([...message.content, formatFilePart(part)])
+        };
+      } else if ("text" in part) {
+        if (!this.omitCompleteText || parsedJson.content.role === "user") {
+          if (isReasoningPart(part)) {
+            message = {
+              ...message,
+              content: [
+                ...message.content,
+                { text: part.text, type: "reasoning", author }
+              ]
+            };
+          } else if (isTextPart(part)) {
+            message = {
+              ...message,
+              content: [
+                ...message.content,
+                { text: part.text, type: "text", author }
+              ]
+            };
           }
-          break;
-        }
-        const text = decoder.decode(value, { stream: true });
-        let response = null;
-        if (text.startsWith("data:")) {
-          response = text.slice(5);
-        } else {
-          response = text;
         }
-        jsonStreamParser.receiveChunk(response);
-      }
-    } catch (error) {
-      this.emit(
-        "error",
-        new SSEError(
-          error?.name || "ReadableStreamError" /* ReadableStreamError */,
-          error?.message || "Failed to read stream"
-        )
-      );
-    } finally {
-      try {
-        reader.releaseLock();
-      } catch (e) {
-        console.warn(
-          "Failed to release reader lock, might be already released:",
-          e
-        );
       }
     }
+    return {
+      ...message
+    };
   }
-  addEventListener(event, listener) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, []);
-    }
-    this.eventListeners.get(event)?.push(listener);
-    if (event === "message" && this.eventListeners.get(event)?.length === 1) {
-      this.fetchStream();
-    }
-  }
-  removeEventListener(event, listener) {
-    const listeners = this.eventListeners.get(event);
-    if (listeners) {
-      const index = listeners.indexOf(listener);
-      if (index !== -1) {
-        listeners.splice(index, 1);
+  // 修改generateRequestBody方法，使其符合父类抽象方法的定义
+  generateRequestBody(request) {
+    const { userMessage, defaultParams, dynamicParams } = request;
+    const attachParts = userMessage.attaches?.map((item) => {
+      if (item.url.startsWith("https://") || item.url.startsWith("http://")) {
+        return {
+          fileData: {
+            displayName: item.attachId,
+            fileUri: item.url,
+            mimeType: item.mimeType
+          }
+        };
       }
-    }
-  }
-  emit(event, data) {
-    const listeners = this.eventListeners.get(event);
-    if (listeners) {
-      listeners.forEach((listener) => listener(data));
-    }
-  }
-  getHeader(name) {
-    return this.headersReceived?.get(name) || null;
-  }
-};
-
-// src/completions/baseCompletion.ts
-var completion = async (params) => {
-  const {
-    requestOptions: { api, headers = {}, data },
-    abortController,
-    onChunk
-  } = params;
-  try {
-    const eventSource = new BetterEventSource(api, {
-      body: JSON.stringify(data),
-      headers,
-      abortSignal: abortController?.signal
-    });
-    return new Promise((resolve, reject) => {
-      eventSource.addEventListener("error", (error) => {
-        if (error.code === "AbortError") {
-          console.log(error);
-          return;
+      const base64Data = item.url.startsWith("data:") ? item.url.split(",")[1] : item.url;
+      return {
+        inlineData: {
+          mimeType: item.mimeType,
+          data: base64Data
         }
-        reject(error);
-      });
-      eventSource.addEventListener("message", (data2) => {
-        onChunk({ response: data2, stop: () => {
-        } });
-      });
-      eventSource.addEventListener("end", () => {
-        resolve();
-      });
-    }).catch((err) => {
-      if (err.code === "AbortError") {
-        return;
-      } else {
-        throw err;
+      };
+    }) || [];
+    return {
+      ...defaultParams || {},
+      ...dynamicParams || {},
+      newMessage: {
+        role: "user",
+        parts: compact([
+          ...userMessage.content?.map((item) => {
+            if (item.type === "text") {
+              return {
+                text: item.text
+              };
+            }
+          }) || [],
+          ...attachParts
+        ])
       }
-    });
-  } catch (error) {
-    console.error("\u8BF7\u6C42\u5931\u8D25:", error.message);
-    throw error;
-  }
-};
-
-// src/completions/adkCompletion.ts
-function getHostUrl(fullUrl) {
-  if (!fullUrl) return "";
-  try {
-    const urlObj = new URL(fullUrl);
-    return urlObj.origin;
-  } catch (error) {
-    console.error(`\u89E3\u6790URL\u5931\u8D25\uFF0C\u65E0\u6548\u7684URL\u683C\u5F0F\uFF1A${fullUrl}`, error);
-    return "";
-  }
-}
-var AdkCompletion = async (params) => {
-  try {
-    await completion(params);
-  } catch (error) {
-    if (error instanceof SSEError && error.message === '{"detail":"Session not found"}') {
-      await fetch(
-        `${getHostUrl(params.requestOptions.api)}/apps/${params.requestOptions.data?.appName}/users/${params.requestOptions.data?.userId}/sessions/${params.requestOptions.data?.sessionId}`,
-        { method: "post", headers: params.requestOptions.headers }
-      );
-      await completion(params);
-      return;
-    }
-    throw error;
+    };
   }
 };
+var Adk_default = AdkProtocol;
 var A2AProtocol = class extends BaseProtocols_default {
   constructor(options) {
     super(options);
@@ -1425,9 +1421,6 @@ var AdkPlugin = class extends ChatkitPlugin {
       }
       this.chatController?.setCurrentThread(threadID);
     };
-    this.setAppName = (appName) => {
-      this.options.appName = appName;
-    };
     this.options = options;
     this.adkProtocol = new Adk_default({
       omitCompleteText: false,
@@ -1815,7 +1808,7 @@ var ChatController = class {
       return;
     }
     const userMessage = {
-      id: msg.id || v4(),
+      id: v4(),
       role: "user",
       threadId: currentThread.id,
       metadata: {},
@@ -1928,7 +1921,6 @@ var ChatController = class {
       status: "sending" /* SENDING */
     };
     this.sendMessage({
-      id: userMessage.id,
       content: userMessage.content,
       attaches: userMessage.attaches
     });
@@ -2035,14 +2027,11 @@ var ChatController = class {
   }
 };
 
-exports.snapshot = vanilla.snapshot;
-exports.subscribe = vanilla.subscribe;
 exports.A2ACompletion = A2ACompletion;
 exports.AdkCompletion = AdkCompletion;
 exports.AdkPlugin = AdkPlugin;
-exports.AdkProtocol = Adk_default;
 exports.AsyncSeriesWaterfallHook = AsyncSeriesWaterfallHook;
-exports.BaseProtocol = BaseProtocols_default;
+exports.BaseProtocol = BaseProtocols_exports;
 exports.ChatController = ChatController;
 exports.ChatkitPlugin = ChatkitPlugin;
 exports.ChatkitPluginManager = ChatkitPluginManager;