@chat-lab/ui 0.1.0-beta.8 → 0.1.0-beta.81

package/dist/core/dist/index.js

@@ -0,0 +1,2175 @@
+import { last, isNil, throttle, keys, compact, findLastIndex } from 'lodash-es';
+import { v4 } from 'uuid';
+import { proxy } from 'valtio';
+export { snapshot, subscribe, useSnapshot } from 'valtio';
+import dayjs from 'dayjs';
+import { DefaultAgentCardResolver, ClientFactory, ClientFactoryOptions } from '@a2a-js/sdk/client';
+import { proxy as proxy$1 } from 'valtio/vanilla';
+import mitt from 'mitt';
+
+// 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 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.splitText = options.splitText || false;
+    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,
+        metadata: {
+          ...message.metadata || {},
+          invocationId: parsedJson.invocationId
+        }
+      };
+    }
+    let stateDelta = parsedJson?.actions?.stateDelta || {}, hasStateDelta = keys(stateDelta).length > 0;
+    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,
+          hasStateDelta,
+          stateDelta
+        }
+      };
+    }
+    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,
+        hasStateDelta,
+        stateDelta
+      }
+    };
+  }
+  // 修改generateRequestBody方法，使其符合父类抽象方法的定义
+  generateRequestBody(request) {
+    const { userMessage, defaultParams, dynamicParams } = request;
+    const attachParts = userMessage.attaches?.map((item) => {
+      if (item.url.startsWith("https://") || item.url.startsWith("http://") || item.url.startsWith("/")) {
+        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 = {
+  loading: false,
+  disabled: false,
+  currentThreadId: null,
+  threadMap: {}
+};
+var createThreadManagerState = () => {
+  return proxy({
+    loading: false,
+    disabled: false,
+    currentThreadId: null,
+    threadMap: {}
+  });
+};
+var createThreadManagerStateWithDefault = () => {
+  const id = v4();
+  return proxy({
+    loading: false,
+    disabled: false,
+    currentThreadId: id,
+    threadMap: {
+      [id]: {
+        id,
+        name: id,
+        metadata: {},
+        sending: false,
+        messages: [],
+        createdAt: dayjs().unix()
+      }
+    }
+  });
+};
+var threadManagerState = 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().unix()
+  };
+  return { loading: false, disabled: false, 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().unix(),
+      updatedAt: dayjs().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().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;
+    }
+    this.updateThread(threadId, { loading });
+  }
+  getCurrentThread() {
+    const threadId = this.state.currentThreadId;
+    if (!threadId) {
+      return null;
+    }
+    return this.state.threadMap[threadId];
+  }
+  checkThreadExist(threadId, throwError = true) {
+    const thread = this.state.threadMap[threadId];
+    if (!thread) {
+      if (throwError) {
+        throw new Error(`Thread ${threadId} not found`);
+      }
+      return null;
+    }
+    return thread;
+  }
+  // Message APIs
+  getMessage(threadId, messageId) {
+    return this.checkMessageExist(threadId, messageId);
+  }
+  addMessage(threadId, message) {
+    const isExist = this.checkThreadExist(threadId, false);
+    if (!isExist) {
+      return;
+    }
+    this.state.threadMap[threadId].messages.push(message);
+  }
+  updateMessage(threadId, messageId, updateOptions) {
+    const message = this.checkMessageExist(threadId, messageId);
+    if (!message) {
+      return;
+    }
+    const messageIndex = this.state.threadMap[threadId].messages.findIndex(
+      (msg) => msg.id === messageId
+    );
+    const { updatedMessage, partial } = updateOptions;
+    if (partial) {
+      Object.assign(
+        this.state.threadMap[threadId].messages[messageIndex],
+        updatedMessage
+      );
+    } else {
+      this.state.threadMap[threadId].messages[messageIndex] = {
+        ...updatedMessage,
+        id: messageId
+      };
+    }
+  }
+  updateMessages(threadId, messages) {
+    this.checkThreadExist(threadId);
+    this.state.threadMap[threadId].messages = messages;
+  }
+  removeMessage(threadId, messageId) {
+    this.checkMessageExist(threadId, messageId);
+    this.state.threadMap[threadId].messages = this.state.threadMap[threadId].messages.filter((msg) => msg.id !== messageId);
+  }
+  checkMessageExist(threadId, messageId) {
+    const thread = this.checkThreadExist(threadId);
+    if (!thread) {
+      return null;
+    }
+    const message = thread.messages.find(
+      (msg) => msg.id === messageId
+    );
+    if (!message) {
+      return null;
+    }
+    return message;
+  }
+};
+var storeActions = new ThreadMessageManager(threadManagerState);
+function rewriteAgentCardUrl(original, serviceUrl) {
+  const base = new URL(serviceUrl);
+  const rewriteSingleUrl = (oldUrl) => {
+    const u = new URL(oldUrl, base);
+    u.protocol = base.protocol;
+    u.hostname = base.hostname;
+    u.port = base.port;
+    return u.toString();
+  };
+  return {
+    ...original,
+    url: rewriteSingleUrl(original.url),
+    additionalInterfaces: original.additionalInterfaces?.map((i) => ({
+      ...i,
+      url: rewriteSingleUrl(i.url)
+    }))
+  };
+}
+var A2ACompletion = async ({
+  onChunk,
+  requestOptions,
+  abortController,
+  thread,
+  onUpdateThread
+}) => {
+  const cardResolver = new DefaultAgentCardResolver({
+    fetchImpl: (input, init) => {
+      return fetch(input, {
+        ...init,
+        headers: {
+          ...init?.headers || {},
+          ...requestOptions.headers
+        }
+      });
+    }
+  });
+  const rawCard = await cardResolver.resolve(requestOptions.api);
+  const serviceUrl = requestOptions.api;
+  const rewrittenCard = rewriteAgentCardUrl(rawCard, serviceUrl);
+  const factory = new ClientFactory(
+    ClientFactoryOptions.createFrom(ClientFactoryOptions.default, {
+      cardResolver
+    })
+  );
+  const client = await factory.createFromAgentCard(rewrittenCard);
+  const contextId = thread?.metadata?.contextId || v4();
+  onUpdateThread?.({
+    metadata: {
+      ...thread?.metadata,
+      contextId
+    }
+  });
+  try {
+    const stream = await client.sendMessageStream(
+      {
+        ...requestOptions.data,
+        message: {
+          ...requestOptions?.data?.message || {},
+          contextId
+        }
+      },
+      {
+        signal: abortController?.signal,
+        serviceParameters: requestOptions.headers
+      }
+    );
+    for await (const event of stream) {
+      onChunk({
+        response: event,
+        stop: () => {
+        }
+      });
+    }
+  } catch (e) {
+    console.error("Error:", e);
+  }
+};
+
+// src/sse/SseError.ts
+var SSEError = class {
+  constructor(code, message, logid) {
+    this.code = code;
+    this.logid = logid;
+    this.message = message;
+  }
+};
+
+// src/utils/errorParse.ts
+function errorParse(str) {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    try {
+      return JSON.parse(str);
+    } catch (e2) {
+      const match = str.match(/^\s*\{\s*"error"\s*:\s*"(.*)"\s*\}\s*$/s);
+      if (match) {
+        return { error: match[1] };
+      }
+      throw e;
+    }
+  }
+}
+
+// src/sse/JsonParser.ts
+var removePrefix = (text) => {
+  if (text.startsWith("data:")) {
+    return text.slice(5);
+  }
+  return text;
+};
+var JsonStreamParser = class {
+  constructor(jsonParseCallback, finishCallback) {
+    this.buffer = "";
+    /**
+     * Event Stream 的换行格式包括三种：CRLF（回车加换行）、LF（换行）和 CR（回车）
+     * 默认支持 CRLF 换行格式
+     * https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+     */
+    this.endOfLine = "\r\n\r\n";
+    this.jsonParseCallback = jsonParseCallback;
+    this.finishCallback = finishCallback;
+  }
+  receiveChunk(chunk) {
+    this.buffer += chunk;
+    this.findEndOfLine();
+    let jsonBoundary = this.findJsonBoundary();
+    while (jsonBoundary !== -1) {
+      const rawJson = removePrefix(this.buffer.substring(0, jsonBoundary));
+      this.buffer = this.buffer.substring(jsonBoundary + this.endOfLine.length);
+      if (rawJson.trim() === "[DONE]") {
+        this.finishCallback();
+        return;
+      }
+      try {
+        const json = JSON.parse(rawJson);
+        this.jsonParseCallback(json);
+      } catch (error) {
+        try {
+          const safeJson = errorParse(rawJson);
+          if (safeJson) {
+            this.jsonParseCallback(safeJson);
+          } else {
+            console.error("[JsonStreamParser] Failed to parse JSON", error);
+          }
+        } catch (e) {
+          console.error("[JsonStreamParser] Failed to parse JSON", error);
+        }
+      }
+      jsonBoundary = this.findJsonBoundary();
+    }
+  }
+  checkFinishedWithSafeJson() {
+    return this.buffer.length == 0 ? true : this.buffer;
+  }
+  findEndOfLine() {
+    if (this.buffer.indexOf("\r\n\r\n") !== -1) {
+      this.endOfLine = "\r\n\r\n";
+    } else if (this.buffer.indexOf("\n\n") !== -1) {
+      this.endOfLine = "\n\n";
+    }
+  }
+  findJsonBoundary() {
+    return this.buffer.indexOf(this.endOfLine);
+  }
+};
+
+// src/sse/BetterEventSource.ts
+var BetterEventSource = class {
+  constructor(url, options) {
+    this.headersReceived = null;
+    this.isNormalFinished = false;
+    this.url = url;
+    this.options = options || {};
+    this.eventListeners = /* @__PURE__ */ new Map();
+  }
+  fetchStream() {
+    fetch(this.url, {
+      method: "POST",
+      headers: {
+        ...this.options.headers,
+        "content-type": "application/json"
+      },
+      body: this.options.body,
+      credentials: "include",
+      signal: this.options.abortSignal
+    }).then(async (response) => {
+      try {
+        if (!response.ok) {
+          const text = await response.text();
+          this.emit("error", new SSEError("ConnectionError" /* ConnectionError */, text));
+          return;
+        }
+      } catch (error) {
+        try {
+          response.json().then((resp) => {
+            this.emit(
+              "error",
+              new SSEError("ConnectionError" /* ConnectionError */, "Fail to connect")
+            );
+          });
+        } catch (err) {
+          this.emit(
+            "error",
+            new SSEError("ConnectionError" /* ConnectionError */, "Fail to connect")
+          );
+        }
+        return;
+      }
+      this.headersReceived = response.headers;
+      this.emit("headerReceived", this.headersReceived);
+      const reader = response.body?.getReader();
+      return this.readStream(reader);
+    }).catch((error) => {
+      this.emit(
+        "error",
+        new SSEError(
+          error?.name || "Error" /* Error */,
+          error?.message || "Failed to response"
+        )
+      );
+    });
+  }
+  async readStream(reader) {
+    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"
+              )
+            );
+          }
+          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;
+  }
+};
+var createMetaData = (metaData) => {
+  const meta = proxy$1(metaData || {});
+  return meta;
+};
+var A2AProtocol = class extends BaseProtocols_default {
+  constructor(options) {
+    super(options);
+    this.protocol = ProtocolEnum.A2A;
+    this.protocolName = options.protocolName || options.protocol;
+  }
+  // 修改parseChunk方法，使其符合父类抽象方法的定义
+  parseChunk(chunk) {
+    let { message, response } = chunk;
+    const event = response;
+    switch (event.kind) {
+      // case 'task':
+      //   const parts =
+      //     event.history?.reverse().find(prev => prev.role === 'agent')?.parts ||
+      //     [];
+      //   const contents = [];
+      //   for (const part of parts) {
+      //     if (part.kind === 'text') {
+      //       contents.push({
+      //         type: 'text' as const,
+      //         text: part.text,
+      //       });
+      //     }
+      //   }
+      //   return { ...message, content: contents };
+      // }
+      case "artifact-update":
+        const parts = event.artifact.parts || [];
+        const contents = [...message.content];
+        for (const part of parts) {
+          if (part.kind === "text") {
+            contents.push({
+              type: "text",
+              text: part.text
+            });
+          }
+        }
+        return { ...message, content: contents };
+      case "status-update": {
+        const msg = event.status?.message;
+        if (msg && msg.role === "agent") {
+          const contents2 = [...message.content];
+          for (const part of msg.parts) {
+            if (part.kind === "text") ; else if (part.kind === "data") {
+              const dataPart = part;
+              const adkType = part.metadata?.adk_type;
+              if (adkType === "function_call" || adkType === "function_response") {
+                const existingIdx = contents2.findIndex(
+                  (c) => c.type === "tool_call" && c.toolCallId === dataPart.data.id
+                );
+                if (existingIdx !== -1) {
+                  const existing = contents2[existingIdx];
+                  if (adkType === "function_call") {
+                    existing.toolCallArgs = dataPart.data.args;
+                    existing.toolCallName = dataPart.data.name;
+                  } else {
+                    existing.content = dataPart.data.response;
+                  }
+                  contents2[existingIdx] = existing;
+                } else {
+                  if (adkType === "function_call") {
+                    contents2.push({
+                      type: "tool_call",
+                      toolCallId: dataPart.data.id,
+                      toolCallName: dataPart.data.name,
+                      toolCallArgs: dataPart.data.args,
+                      content: null
+                    });
+                  } else {
+                    contents2.push({
+                      type: "tool_call",
+                      toolCallId: dataPart.data.id,
+                      toolCallName: dataPart.data.name,
+                      toolCallArgs: {},
+                      content: dataPart.data.response
+                    });
+                  }
+                }
+              }
+            }
+          }
+          return { ...message, content: contents2 };
+        }
+        break;
+      }
+    }
+    return message;
+  }
+  // 修改generateRequestBody方法，使其符合父类抽象方法的定义
+  generateRequestBody(request) {
+    const { userMessage, defaultParams, dynamicParams } = request;
+    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 || {}),
+      message: {
+        messageId: v4(),
+        role: "user",
+        parts: [
+          {
+            kind: "text",
+            text: userMessage.content.filter((item) => item.type === "text").map((item) => item.text).join("")
+          }
+        ],
+        kind: "message"
+      }
+    };
+  }
+};
+var a2a_default = A2AProtocol;
+var ArkProtocol = class extends BaseProtocols_default {
+  // stream: boolean;
+  constructor(options) {
+    super(options);
+    this.protocol = ProtocolEnum.ARK;
+    this.protocolName = options.protocolName || options.protocol;
+  }
+  // 修改parseChunk方法的签名，使其符合BaseProtocol接口定义
+  parseChunk(chunk) {
+    const arkResponse = chunk.response;
+    const text = arkResponse.choices?.[0]?.message?.content || "";
+    const reasoningText = arkResponse?.choices?.[0]?.message?.reasoningContent || "";
+    const newContent = [...chunk.message.content];
+    if (reasoningText) {
+      const lastReasoningIndex = findLastIndex(
+        newContent,
+        (c) => c.type === "reasoning"
+      );
+      if (lastReasoningIndex !== -1) {
+        const prev = newContent[lastReasoningIndex];
+        newContent[lastReasoningIndex] = {
+          ...prev,
+          text: prev.text + reasoningText
+        };
+      } else {
+        newContent.push({
+          type: "reasoning",
+          text: reasoningText
+        });
+      }
+    }
+    if (text) {
+      const lastTextIndex = findLastIndex(newContent, (c) => c.type === "text");
+      if (lastTextIndex !== -1) {
+        const prev = newContent[lastTextIndex];
+        newContent[lastTextIndex] = {
+          ...prev,
+          text: prev.text + text
+        };
+      } else {
+        newContent.push({
+          type: "text",
+          text
+        });
+      }
+    }
+    return {
+      ...chunk.message,
+      content: newContent
+    };
+  }
+  // 修改generateRequestBody方法，确保包含defaultParams参数
+  generateRequestBody(request) {
+    const { userMessage, contextMessages } = request;
+    return {
+      model: "doubao-seed-1-6-251015",
+      max_completion_tokens: 65535,
+      messages: [
+        ...contextMessages.map((item) => ({
+          role: item.role,
+          content: item.content.map((content) => ({
+            text: content.text,
+            type: "text"
+          }))
+        })),
+        {
+          content: [
+            {
+              text: userMessage.content[0].text,
+              type: "text"
+            }
+          ],
+          role: "user"
+        }
+      ],
+      reasoning_effort: "medium"
+    };
+  }
+};
+var ark_default = ArkProtocol;
+
+// src/protocols/getProtocol.ts
+var getSupportProtocolAdaptor = (protocol) => {
+  switch (protocol) {
+    case ProtocolEnum.ARK:
+      return new ark_default({
+        protocolName: "ark stream",
+        protocol: ProtocolEnum.ARK
+      });
+    case ProtocolEnum.ADK:
+      return new Adk_default({
+        protocolName: "adk stream",
+        protocol: ProtocolEnum.ADK,
+        omitCompleteText: true
+      });
+    case ProtocolEnum.A2A:
+      return new a2a_default({
+        protocolName: "a2a stream",
+        protocol: ProtocolEnum.A2A
+      });
+    default:
+      return new ark_default({
+        protocolName: "ark stream",
+        protocol: ProtocolEnum.ARK
+      });
+  }
+};
+var getProtocolAdaptor = (protocolOptions) => {
+  if (protocolOptions.protocol === ProtocolEnum.CUSTOM) {
+    return protocolOptions.protocolAdaptor;
+  }
+  return getSupportProtocolAdaptor(protocolOptions.protocol);
+};
+var SyncWaterfallHook = class {
+  constructor() {
+    this.taps = [];
+  }
+  tap(name, fn) {
+    this.taps.push({ name, fn });
+  }
+  untap(name) {
+    this.taps = this.taps.filter((t) => t.name !== name);
+  }
+  call(initialData) {
+    let currentData = initialData;
+    const taps = [...this.taps];
+    for (const tap of taps) {
+      try {
+        const result = tap.fn(currentData);
+        if (result !== void 0) {
+          currentData = result;
+        }
+      } catch (e) {
+        console.error(`Error in plugin hook ${tap.name}:`, e);
+      }
+    }
+    return currentData;
+  }
+  isEmpty() {
+    return this.taps.length === 0;
+  }
+};
+var AsyncSeriesWaterfallHook = class {
+  constructor() {
+    this.taps = [];
+  }
+  tap(name, fn) {
+    this.taps.push({ name, fn });
+  }
+  tapAsync(name, fn) {
+    this.tap(name, (data) => fn(data));
+  }
+  untap(name) {
+    this.taps = this.taps.filter((t) => t.name !== name);
+  }
+  async callAsync(initialData) {
+    let currentData = initialData;
+    const taps = [...this.taps];
+    for (const tap of taps) {
+      try {
+        const result = await tap.fn(currentData);
+        if (result !== void 0) {
+          currentData = result;
+        }
+      } catch (e) {
+        console.error(`Error in plugin hook ${tap.name}:`, e);
+      }
+    }
+    return currentData;
+  }
+  isEmpty() {
+    return this.taps.length === 0;
+  }
+};
+var SyncHook = class {
+  constructor() {
+    this.taps = [];
+  }
+  tap(name, fn) {
+    this.taps.push({ name, fn });
+  }
+  untap(name) {
+    this.taps = this.taps.filter((t) => t.name !== name);
+  }
+  call(data) {
+    const taps = [...this.taps];
+    for (const tap of taps) {
+      try {
+        tap.fn(data);
+      } catch (e) {
+        console.error(`Error in plugin hook ${tap.name}:`, e);
+      }
+    }
+  }
+  isEmpty() {
+    return this.taps.length === 0;
+  }
+};
+var SyncBailHook = class {
+  constructor() {
+    this.taps = [];
+  }
+  tap(name, fn) {
+    this.taps.push({ name, fn });
+  }
+  untap(name) {
+    this.taps = this.taps.filter((t) => t.name !== name);
+  }
+  call(initialData) {
+    for (const tap of this.taps) {
+      try {
+        const result = tap.fn(initialData);
+        if (result !== void 0) {
+          return result;
+        }
+      } catch (e) {
+        console.error(`Error in plugin hook ${tap.name}:`, e);
+      }
+    }
+    return void 0;
+  }
+  isEmpty() {
+    return this.taps.length === 0;
+  }
+};
+var ChatkitPlugin = class {
+  constructor({ pluginName: pluginName2 }) {
+    this.chatController = null;
+    this.pluginName = pluginName2;
+    this.emitter = mitt();
+  }
+  getName() {
+    return this.pluginName;
+  }
+  apply(compiler) {
+    throw new Error("[chatkit:plugin] function apply need to be implement!");
+  }
+  setChatController(chatController) {
+    this.chatController = chatController;
+  }
+  // Lifecycle hooks
+  onInit() {
+  }
+  onDestroy() {
+  }
+};
+var Compiler = class {
+  constructor() {
+    this.hooks = {
+      lifecycle: {
+        inited: new AsyncSeriesWaterfallHook(),
+        beforeInitStore: new AsyncSeriesWaterfallHook(),
+        beforeDestroy: new AsyncSeriesWaterfallHook()
+      },
+      message: {
+        received: new SyncHook(),
+        beforeSend: new AsyncSeriesWaterfallHook(),
+        error: new SyncWaterfallHook(),
+        end: new AsyncSeriesWaterfallHook(),
+        finallyEnd: new SyncWaterfallHook(),
+        abort: new SyncWaterfallHook()
+      },
+      attachment: {
+        added: new AsyncSeriesWaterfallHook(),
+        removed: new AsyncSeriesWaterfallHook()
+      },
+      thread: {
+        beforeCreate: new AsyncSeriesWaterfallHook(),
+        created: new AsyncSeriesWaterfallHook(),
+        updated: new AsyncSeriesWaterfallHook(),
+        deleted: new AsyncSeriesWaterfallHook(),
+        beforeSwitch: new AsyncSeriesWaterfallHook(),
+        afterSwitch: new AsyncSeriesWaterfallHook()
+      },
+      error: {
+        occurred: new SyncHook()
+      },
+      ui: {
+        renderSlot: new SyncWaterfallHook()
+      }
+    };
+  }
+  offByName(name) {
+    Object.values(this.hooks).forEach((group) => {
+      Object.values(group).forEach((hook) => {
+        if (hook instanceof AsyncSeriesWaterfallHook || hook instanceof SyncWaterfallHook || hook instanceof SyncHook || hook instanceof SyncBailHook) {
+          hook.untap(name);
+        }
+      });
+    });
+  }
+};
+var ChatkitPluginManager = class {
+  constructor({
+    plugins,
+    chatController
+  }) {
+    this.plugins = [];
+    this.plugins = [];
+    this.compiler = new Compiler();
+    this.chatController = chatController;
+    plugins.forEach((plugin) => {
+      this.addPlugin(plugin);
+    });
+  }
+  async addPlugin(plugin) {
+    if (this.plugins.includes(plugin)) return;
+    this.plugins.push(plugin);
+    plugin.apply(this.compiler);
+    plugin.setChatController(this.chatController);
+    if (plugin.onInit) {
+      try {
+        await plugin.onInit();
+      } catch (e) {
+        console.error(`Error initializing plugin ${plugin.getName()}:`, e);
+      }
+    }
+  }
+  async removePlugin(plugin) {
+    const index = this.plugins.indexOf(plugin);
+    if (index === -1) return;
+    this.plugins = this.plugins.filter((p) => p !== plugin);
+    this.compiler.offByName(plugin.getName());
+    if (plugin.onDestroy) {
+      try {
+        await plugin.onDestroy();
+      } catch (e) {
+        console.error(`Error destroying plugin ${plugin.getName()}:`, e);
+      }
+    }
+  }
+  getPlugins() {
+    return this.plugins;
+  }
+  // Accessor for the compiler to allow external triggering of hooks
+  get hooks() {
+    return this.compiler.hooks;
+  }
+  reportError(error) {
+    return this.compiler.hooks.error.occurred.call(error);
+  }
+  getPluginByName(name) {
+    return this.plugins.find((plugin) => plugin.getName() === name);
+  }
+};
+
+// src/utils/LocalStorage.ts
+var LocalStorage = class {
+  constructor(namespace) {
+    this.namespace = namespace;
+  }
+  getKey(key) {
+    return `${this.namespace}:${key}`;
+  }
+  async getItem(key) {
+    const value = localStorage.getItem(this.getKey(key));
+    try {
+      return value ? JSON.parse(value) : null;
+    } catch (e) {
+      return value;
+    }
+  }
+  async setItem(key, value) {
+    localStorage.setItem(this.getKey(key), JSON.stringify(value));
+  }
+  async removeItem(key) {
+    localStorage.removeItem(this.getKey(key));
+  }
+  async removeByValue(value) {
+    const targetValue = JSON.stringify(value);
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && key.startsWith(`${this.namespace}:`)) {
+        const itemValue = localStorage.getItem(key);
+        if (itemValue === targetValue) {
+          keysToRemove.push(key);
+        }
+      }
+    }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
+  }
+};
+var pluginName = "ADKPlugin";
+function buildSessionUrl(api, appName, userId, sessionId) {
+  const apiUrlObj = new URL(api);
+  const baseUrl = `${apiUrlObj.origin}/apps/${appName}/users/${userId}/sessions/${sessionId}`;
+  const queryString = apiUrlObj.search;
+  return queryString ? `${baseUrl}${queryString}` : baseUrl;
+}
+function buildRunSseUrl(api) {
+  const apiUrlObj = new URL(api);
+  const baseApiUrl = `${apiUrlObj.origin}`;
+  const queryString = apiUrlObj.search;
+  return queryString ? `${baseApiUrl}/run_sse${queryString}` : `${baseApiUrl}/run_sse`;
+}
+var AdkPlugin = class extends ChatkitPlugin {
+  constructor(options) {
+    super({ pluginName });
+    this.runtimeMap = new LocalStorage("runtime");
+    this.switchRuntime = async (runtime, appName) => {
+      this.options.appName = appName;
+      const threadID = await this.runtimeMap.getItem(runtime);
+      if (!threadID || !this.chatController?.getThread(threadID)) {
+        const id = threadID || v4();
+        this.chatController?.addThread({
+          id,
+          name: id,
+          metadata: {},
+          sending: false,
+          messages: [],
+          createdAt: dayjs().unix()
+        }).then((res) => {
+          this.runtimeMap.setItem(runtime, res.id);
+          this.chatController?.setCurrentThread(res.id);
+        });
+        return;
+      }
+      this.chatController?.setCurrentThread(threadID);
+    };
+    this.setAppName = (appName) => {
+      this.options.appName = appName;
+    };
+    this.updateOptions = (options) => {
+      this.options = options;
+    };
+    this.options = options;
+    this.adkProtocol = new Adk_default({
+      omitCompleteText: false,
+      protocol: "ADK"
+    });
+  }
+  apply(compiler) {
+    compiler.hooks.message.beforeSend.tap(pluginName, async (ctx) => {
+      const requestOptions = ctx.requestOptions || {};
+      const headers = requestOptions.headers || {};
+      const thread = ctx.thread;
+      if (!requestOptions.api || !headers.Authorization) {
+        this.chatController?.onError?.(
+          new Error("ADK\u914D\u7F6E\u7F3A\u5931\uFF1Aapi \u6216 Authorization \u4E3A\u7A7A")
+        );
+        ctx.shouldSend = false;
+        return ctx;
+      }
+      const hasInitSession = !!thread.metadata?.["sessionInited"];
+      const isInitingSession = !!thread.metadata?.["isInitingSession"];
+      if (!hasInitSession && !isInitingSession) {
+        ctx.thread.metadata = {
+          ...ctx.thread.metadata,
+          ["isInitingSession"]: true
+        };
+        let res;
+        try {
+          const url = buildSessionUrl(
+            requestOptions.api,
+            this.options.appName,
+            this.options.userId,
+            thread.id
+          );
+          res = await fetch(url, {
+            method: "POST",
+            headers: {
+              Authorization: headers.Authorization
+            }
+          });
+          if (!res.ok) {
+            const text = await res.text();
+            this.chatController?.onError?.(
+              new Error(
+                `ADK \u63D2\u4EF6\u521D\u59CB\u5316\u4F1A\u8BDD\u5931\u8D25\uFF0C\u72B6\u6001\u7801\uFF1A${res.status}\uFF0C\u9519\u8BEF\u4FE1\u606F\uFF1A${text}`
+              )
+            );
+            ctx.shouldSend = false;
+            return ctx;
+          }
+        } catch (error) {
+          console.error("Error initializing ADK session:", error);
+          this.chatController?.onError?.(
+            new Error(`ADK \u63D2\u4EF6\u521D\u59CB\u5316\u4F1A\u8BDD\u5931\u8D25\uFF0C\u9519\u8BEF\u4FE1\u606F\uFF1A${error.message}`)
+          );
+          ctx.shouldSend = false;
+          return ctx;
+        }
+        const xSessionId = res.headers.get("x-session-id");
+        const data = await res.json();
+        const runSseUrl = buildRunSseUrl(requestOptions.api);
+        this.chatController?.updateThread(ctx.thread.id, {
+          metadata: {
+            ...ctx.thread.metadata,
+            ["sessionInited"]: true,
+            ["isInitingSession"]: false,
+            sessionId: data.id,
+            ["x-session-id"]: xSessionId
+          }
+        });
+        ctx.dynamicParams = {
+          ...ctx.dynamicParams,
+          sessionId: data.id,
+          userId: this.options.userId,
+          appName: this.options.appName
+        };
+        ctx.extraRequestOptions = {
+          ...ctx.extraRequestOptions,
+          headers: {
+            ...requestOptions.headers,
+            ["x-session-id"]: xSessionId
+          },
+          api: runSseUrl
+        };
+        return ctx;
+      }
+      ctx.dynamicParams = {
+        ...ctx.dynamicParams,
+        sessionId: thread.metadata?.["sessionId"],
+        userId: this.options.userId,
+        appName: this.options.appName
+      };
+      ctx.extraRequestOptions = {
+        ...ctx.extraRequestOptions,
+        headers: {
+          ...requestOptions.headers,
+          ["x-session-id"]: thread.metadata?.["x-session-id"]
+        },
+        api: buildRunSseUrl(requestOptions.api)
+      };
+      return ctx;
+    });
+    compiler.hooks.thread.created.tap(pluginName, async (thread) => {
+      if (this.chatController === null) {
+        return thread;
+      }
+      const threadId = thread.id;
+      const requestOptions = this.chatController?.getRequestOptions();
+      if (!requestOptions || !requestOptions.api || !requestOptions.headers) {
+        this.chatController?.onError?.(
+          new Error("ADK\u914D\u7F6E\u7F3A\u5931\uFF1Aapi \u6216 Authorization \u4E3A\u7A7A")
+        );
+        return thread;
+      }
+      const url = buildSessionUrl(
+        requestOptions.api,
+        this.options.appName,
+        this.options.userId,
+        thread.id
+      );
+      const getFetchResponse = await fetch(url, {
+        method: "get",
+        headers: requestOptions.headers
+      });
+      if (getFetchResponse.ok) {
+        const data = await getFetchResponse.json();
+        const xSessionId = getFetchResponse.headers.get("x-session-id");
+        this.options.onStateChange?.(data.state);
+        this.chatController?.updateThread(threadId, {
+          metadata: {
+            ...thread.metadata,
+            ["sessionInited"]: true,
+            sessionId: data.id,
+            ["isInitingSession"]: false,
+            ["x-session-id"]: xSessionId,
+            state: data.state
+          },
+          //     id: string;
+          //     author: string;
+          //     content: { parts: any[] };
+          //   }) =>
+          //     this.adkProtocol.parseChunk({
+          //       message: {
+          //         id: chunk.id,
+          //         status: MessageStatus.SUCCESS,
+          //         role: chunk.author === 'user' ? 'user' : 'assistant',
+          //         threadId: threadId,
+          //         metadata: {},
+          //         content: [],
+          //       },
+          //       response: chunk,
+          //     }),
+          // ),
+          messages: data?.events?.reduce((prev, cur) => {
+            if (prev.length === 0 || cur.author === "user" || last(prev)?.role !== (cur.author === "user" ? "user" : "assistant")) {
+              prev.push(
+                this.adkProtocol.parseChunk({
+                  message: {
+                    id: cur.id,
+                    status: "success" /* SUCCESS */,
+                    role: cur.author === "user" ? "user" : "assistant",
+                    threadId,
+                    metadata: {},
+                    content: []
+                  },
+                  response: cur
+                })
+              );
+            } else {
+              prev[prev.length - 1] = this.adkProtocol.parseChunk({
+                message: last(prev),
+                response: cur
+              });
+            }
+            return prev;
+          }, [])
+        });
+        return thread;
+      }
+      const postFetchResponse = await fetch(url, {
+        method: "POST",
+        headers: requestOptions.headers
+      });
+      if (postFetchResponse.ok) {
+        const data = await postFetchResponse.json();
+        const xSessionId = postFetchResponse.headers.get("x-session-id");
+        this.chatController?.updateThread(threadId, {
+          metadata: {
+            ...thread.metadata,
+            ["sessionInited"]: true,
+            ["x-session-id"]: xSessionId,
+            sessionId: data.id,
+            ["isInitingSession"]: false
+          },
+          messages: []
+        });
+      } else {
+        this.chatController?.onError?.(
+          new Error(
+            `ADK \u63D2\u4EF6\u521D\u59CB\u5316\u4F1A\u8BDD\u5931\u8D25\uFF0C\u72B6\u6001\u7801\uFF1A${postFetchResponse.status}`
+          )
+        );
+        console.warn(
+          `ADK \u63D2\u4EF6\u521D\u59CB\u5316\u4F1A\u8BDD\u5931\u8D25\uFF0C\u72B6\u6001\u7801\uFF1A${postFetchResponse.status}`
+        );
+      }
+      return thread;
+    });
+    compiler.hooks.thread.afterSwitch.tap(
+      pluginName,
+      async (thread) => {
+        if (this.chatController === null) {
+          return thread;
+        }
+        const threadId = thread.id;
+        const requestOptions = this.chatController?.getRequestOptions();
+        const url = buildSessionUrl(
+          requestOptions.api,
+          this.options.appName,
+          this.options.userId,
+          thread.id
+        );
+        const res = await fetch(url, {
+          method: "POST",
+          headers: requestOptions.headers
+        });
+        if (res.ok) {
+          const data = await res.json();
+          this.chatController?.updateThread(threadId, {
+            metadata: {
+              ...thread.metadata,
+              ["sessionInited"]: true,
+              sessionId: data.id,
+              ["isInitingSession"]: false,
+              ["x-session-id"]: res.headers.get("x-session-id")
+            }
+            // messages: data.events.map((chunk:{id:string}) =>
+            //   this.adkProtocol.parseChunk({
+            //     message: {
+            //       id: chunk.id,
+            //       status: MessageStatusEnum.SUCCESS,
+            //       role: chunk.message.role,
+            //       threadId: chunk.message.threadId,
+            //       metadata: chunk.message.metadata,
+            //       content: [],
+            //     },
+            //     response: chunk,
+            //   }),
+            // ),
+          });
+        }
+        return thread;
+      }
+    );
+    compiler.hooks.thread.deleted.tap(pluginName, (thread) => {
+      this.runtimeMap.removeByValue(thread.id);
+      return thread;
+    });
+    compiler.hooks.error.occurred.tap(pluginName, (error) => {
+      this.chatController?.onError?.(error);
+    });
+  }
+};
+async function fetchChatCompletion({
+  message,
+  requestOptions,
+  abortController,
+  pluginManager,
+  completions,
+  protocolAdaptor,
+  onResponse,
+  onReceivedMessage,
+  storeManager,
+  thread
+}) {
+  try {
+    let currentMessage = storeManager.getMessage(
+      message.threadId,
+      message.id
+    ) || message;
+    const throttledOnResponse = throttle(
+      (msg) => onResponse(msg),
+      500,
+      { leading: true, trailing: true }
+    );
+    const onChunk = ({
+      response
+    }) => {
+      const updatedMessage = protocolAdaptor.parseChunk({
+        message: currentMessage,
+        response
+      });
+      currentMessage = updatedMessage;
+      onReceivedMessage?.(currentMessage);
+      if (updatedMessage.status === "error" /* ERROR */) {
+        throttledOnResponse.cancel();
+        onResponse(() => ({ ...currentMessage, status: "error" /* ERROR */ }));
+        return;
+      }
+      throttledOnResponse(() => ({
+        status: "pending" /* PENDING */,
+        ...currentMessage
+      }));
+    };
+    try {
+      if (abortController?.signal) {
+        abortController.signal.addEventListener("abort", () => {
+          currentMessage = {
+            ...currentMessage,
+            sending: false,
+            status: "aborted" /* ABORTED */,
+            endedAt: dayjs().unix()
+          };
+          onResponse(currentMessage);
+        });
+      }
+      await completions({
+        abortController,
+        requestOptions,
+        onChunk,
+        thread,
+        onUpdateThread: (updates) => {
+          storeManager.updateThread(message.threadId, updates);
+        }
+      });
+    } catch (error) {
+      throttledOnResponse.cancel();
+      console.log(error);
+      currentMessage = {
+        ...currentMessage,
+        status: "error" /* ERROR */,
+        sending: false,
+        endedAt: Date.now(),
+        error: {
+          message: error.message || "\u672A\u77E5\u9519\u8BEF",
+          extra: error.stack
+        }
+      };
+      onResponse(currentMessage);
+      return;
+    }
+    throttledOnResponse.cancel();
+    onResponse({
+      ...currentMessage,
+      id: currentMessage.id,
+      threadId: currentMessage.threadId,
+      status: currentMessage.status !== "error" /* ERROR */ ? "success" /* SUCCESS */ : "error" /* ERROR */,
+      endedAt: Date.now()
+    });
+  } catch (error) {
+    console.log(error);
+    const _message = storeManager.getMessage(
+      message.threadId,
+      message.id
+    );
+    _message.status = "error" /* ERROR */;
+    _message.sending = false;
+    _message.endedAt = Date.now();
+    _message.error = {
+      message: error.message || "\u672A\u77E5\u9519\u8BEF",
+      extra: error.stack
+    };
+    onResponse(_message);
+  } finally {
+    pluginManager.hooks.message.end.callAsync(
+      storeManager.getThread(message.threadId)
+    );
+  }
+}
+
+// src/utils/ToRaw.ts
+var toRaw = (obj) => {
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (err) {
+    return obj;
+  }
+};
+
+// src/ChatController.ts
+var ChatController = class {
+  constructor(options) {
+    this.abortControllers = /* @__PURE__ */ new Map();
+    this.pluginManager = new ChatkitPluginManager({
+      plugins: options.plugins || [],
+      chatController: this
+    });
+    this.requestOptions = options.requestOptions;
+    this.protocolOptions = options.protocolOptions;
+    this.store = options.storeManager || storeActions;
+    this.onError = options.onError;
+    this.metaData = options.metaData || createMetaData();
+  }
+  setStore(store) {
+    this.store = store;
+  }
+  setRequestOptions(requestOptions) {
+    let pending;
+    if (typeof requestOptions === "function") {
+      pending = requestOptions(this.requestOptions);
+    } else {
+      pending = requestOptions;
+    }
+    this.requestOptions = pending;
+  }
+  getRequestOptions() {
+    return this.requestOptions;
+  }
+  setProtocolOptions(protocolOptions) {
+    this.protocolOptions = protocolOptions;
+  }
+  getProtocolOptions() {
+    return this.protocolOptions;
+  }
+  async sendMessage(msg, extraRequestOptions) {
+    const currentThread = this.store.getCurrentThread();
+    if (!currentThread) {
+      return;
+    }
+    const userMessage = {
+      id: msg.id || v4(),
+      role: "user",
+      threadId: currentThread.id,
+      metadata: {},
+      attaches: msg.attaches,
+      status: "sending" /* SENDING */,
+      content: msg.content,
+      createdAt: dayjs().unix(),
+      updatedAt: dayjs().unix()
+    };
+    const controller = new AbortController();
+    this.abortControllers.set(
+      msg.abortControllerId || currentThread.id,
+      controller
+    );
+    await this.sendMessageCore({
+      extraRequestOptions,
+      userMessage,
+      threadId: currentThread.id,
+      allMessages: currentThread?.messages || [],
+      abortController: controller
+    });
+    this.abortControllers.delete(msg.abortControllerId || currentThread.id);
+    return controller;
+  }
+  async triggerCompletion({
+    abortControllerId,
+    assistantMessage,
+    extraRequestOptions
+  }) {
+    const currentThread = this.store.getCurrentThread();
+    if (!currentThread) {
+      return;
+    }
+    const controller = new AbortController();
+    this.abortControllers.set(
+      abortControllerId || currentThread.id,
+      controller
+    );
+    await this.sendMessageCore({
+      assistantMessage,
+      extraRequestOptions,
+      threadId: currentThread.id,
+      allMessages: currentThread?.messages || [],
+      abortController: controller
+    });
+    this.abortControllers.delete(abortControllerId || currentThread.id);
+    return controller;
+  }
+  abortMessage(threadId) {
+    const { preventDefault } = this.pluginManager.hooks.message.abort.call({
+      preventDefault: false
+    });
+    if (preventDefault) {
+      return;
+    }
+    const id = threadId || this.store.getCurrentThread()?.id;
+    if (!id) {
+      return;
+    }
+    const controller = this.abortControllers.get(id);
+    controller?.abort();
+    this.abortControllers.delete(id);
+    this.store.setSending(id, false);
+    this.store.setLoading(id, false);
+  }
+  getCurrentThread() {
+    const thread = this.store.getCurrentThread();
+    if (isNil(thread)) {
+      return null;
+    }
+    return toRaw(thread);
+  }
+  async setCurrentThread(threadId) {
+    this.store.setCurrentThread(threadId);
+  }
+  async addThread(thread) {
+    const context = await this.pluginManager.hooks.thread.beforeCreate.callAsync(
+      thread
+    );
+    this.store.addThread(context);
+    this.pluginManager.hooks.thread.created.callAsync(context);
+    return context;
+  }
+  getThread(threadId, throwError = false) {
+    return this.store.getThread(threadId, throwError);
+  }
+  updateThread(threadId, thread) {
+    this.store.updateThread(threadId, thread);
+  }
+  setThreadName(threadId, name) {
+    this.store.updateThread(threadId, { name });
+  }
+  deleteThread(threadId) {
+    const thread = this.store.getThread(threadId);
+    if (!thread) {
+      console.warn("Thread deleted: thread not exist", threadId);
+      return;
+    }
+    this.store.deleteThread(threadId);
+    this.pluginManager.hooks.thread.deleted.callAsync(thread);
+  }
+  clearCurrentThread() {
+    const currentThread = this.store.getCurrentThread();
+    if (currentThread?.id) {
+      if (currentThread.sending) {
+        throw new Error("\u6B63\u5728\u53D1\u9001\u6D88\u606F\uFF0C\u8BF7\u5148\u505C\u6B62\u53D1\u9001\u518D\u6E05\u7A7A\u4F1A\u8BDD");
+      }
+      this.updateThread(currentThread?.id, {
+        sending: false,
+        messages: [],
+        createdAt: dayjs().unix()
+      });
+    }
+  }
+  setSending(threadId, sending) {
+    this.store.setSending(threadId, sending);
+  }
+  setLoading(threadId, loading) {
+    this.store.setLoading(threadId, loading);
+  }
+  addMessage(threadId, message) {
+    this.store.addMessage(threadId, message);
+  }
+  updateMessage(threadId, messageId, updateOptions) {
+    this.store.updateMessage(threadId, messageId, updateOptions);
+  }
+  updateMessages(threadId, messages) {
+    this.store.updateMessages(threadId, messages);
+  }
+  reloadMessage({
+    threadId,
+    messageId
+  }) {
+    const thread = this.store.getThread(threadId);
+    if (!thread) {
+      return;
+    }
+    const message = thread.messages.find((item) => messageId.includes(item.id));
+    if (!message) {
+      return;
+    }
+    const userMessage = {
+      ...message,
+      id: v4(),
+      status: "sending" /* SENDING */
+    };
+    this.sendMessage({
+      id: userMessage.id,
+      content: userMessage.content,
+      attaches: userMessage.attaches
+    });
+  }
+  getMessage(threadId, messageId) {
+    return this.store.getMessage(threadId, messageId);
+  }
+  removeMessage(threadId, messageId) {
+    this.store.removeMessage(threadId, messageId);
+  }
+  async sendMessageCore({
+    extraRequestOptions,
+    userMessage,
+    assistantMessage: assistantMessageFromProps,
+    threadId,
+    allMessages = [],
+    abortController,
+    // completions,
+    onError: onErrorFromProps,
+    override = false
+  }) {
+    const thread = this.store.getThread(threadId);
+    if (!thread) {
+      onErrorFromProps?.(new Error(`\u5BF9\u8BDD ${threadId} \u4E0D\u5B58\u5728`));
+      return;
+    }
+    let assistantMessage;
+    this.store.setLoading(threadId, true);
+    const onError = (error) => {
+      this.store.setLoading(threadId, false);
+      onErrorFromProps?.(error);
+    };
+    let hookContext = {
+      requestOptions: this.requestOptions,
+      userMessage,
+      contextMessages: allMessages,
+      thread,
+      onError,
+      dynamicParams: {},
+      extraRequestOptions: {},
+      shouldSend: true
+    };
+    try {
+      hookContext = await this.pluginManager.hooks.message.beforeSend.callAsync(
+        hookContext
+      );
+    } catch (e) {
+    }
+    const storeManager = this.store;
+    if (hookContext.shouldSend === false) {
+      if (hookContext.shouldAddUserMessage) {
+        storeManager.addMessage(threadId, hookContext.userMessage);
+      }
+      if (hookContext.resetStatus) {
+        storeManager.setLoading(
+          threadId,
+          hookContext.resetStatus.loading,
+          false
+        );
+        storeManager.setSending(threadId, hookContext.resetStatus.sending);
+      } else {
+        storeManager.setSending(threadId, false);
+        storeManager.setLoading(
+          threadId,
+          hookContext.resetStatus.loading,
+          false
+        );
+      }
+      return;
+    }
+    const shouldSend = {
+      dynamicParams: hookContext.dynamicParams,
+      requestOptions: hookContext.extraRequestOptions,
+      userMessage: hookContext.userMessage
+    };
+    try {
+      const protocolAdaptor = getProtocolAdaptor(this.protocolOptions);
+      const requestBody = protocolAdaptor.generateRequestBody({
+        dynamicParams: shouldSend.dynamicParams,
+        defaultParams: this.requestOptions.defaultParams || {},
+        userMessage: shouldSend.userMessage || {
+          role: "user",
+          content: [],
+          attaches: []
+        },
+        thread,
+        contextMessages: allMessages
+      });
+      if (userMessage) storeManager.addMessage(threadId, userMessage);
+      assistantMessage = assistantMessageFromProps || generateModelMessage({
+        threadId
+      });
+      if (!assistantMessageFromProps) {
+        if (override) {
+          this.store.updateMessages(threadId, [
+            ...allMessages,
+            assistantMessage
+          ]);
+        } else this.store.addMessage(threadId, assistantMessage);
+      }
+      this.store.setSending(threadId, true);
+      await fetchChatCompletion({
+        abortController,
+        message: assistantMessage,
+        requestOptions: {
+          ...this.requestOptions || {},
+          ...shouldSend?.requestOptions || {},
+          ...extraRequestOptions || {},
+          data: requestBody
+        },
+        pluginManager: this.pluginManager,
+        completions: this.requestOptions.completions || AdkCompletion,
+        protocolAdaptor,
+        storeManager,
+        thread,
+        onReceivedMessage: async (message) => {
+          this.pluginManager.hooks.message.received.call(message);
+        },
+        onResponse: async (updatedMessageOrFactory) => {
+          let updatedMessage;
+          if (typeof updatedMessageOrFactory === "function") {
+            updatedMessage = updatedMessageOrFactory();
+          } else {
+            updatedMessage = updatedMessageOrFactory;
+          }
+          if (updatedMessage.status === "pending" /* PENDING */ && !updatedMessage.createdAt) {
+            updatedMessage.createdAt = Date.now();
+          }
+          storeManager.updateMessage(threadId, updatedMessage.id, {
+            updatedMessage,
+            partial: true
+          });
+        }
+      });
+    } catch (error) {
+      onErrorFromProps?.(error);
+    } finally {
+      const { loading, sending } = await this.pluginManager.hooks.message.finallyEnd.call({
+        loading: false,
+        sending: false
+      });
+      storeManager.setSending(threadId, sending);
+      storeManager.setLoading(threadId, loading);
+    }
+  }
+};
+
+export { A2ACompletion, AdkCompletion, AdkPlugin, Adk_default as AdkProtocol, AsyncSeriesWaterfallHook, BaseProtocols_default as BaseProtocol, ChatController, ChatkitPlugin, ChatkitPluginManager, Compiler, MessageStatus, ProtocolEnum, SyncBailHook, SyncHook, SyncWaterfallHook, ThreadMessageManager, completion, createMetaData, createThreadManagerState, createThreadManagerStateWithDefault, getProtocolAdaptor, storeActions, threadManagerState };
+//# sourceMappingURL=index.js.map