@cloudbase/agent-ui-miniprogram 0.0.12 → 1.0.1-alpha.7

package/dist/index.cjs.js

@@ -1,1450 +0,0 @@
-'use strict';
-
-/**
- * AG-UI WeChat Miniprogram SDK Types
- */
-// ============================================================================
-// AG-UI Protocol Types (Local Copy)
-// ============================================================================
-//
-// These types are copied from @ag-ui/core to avoid bundling Zod.
-//
-// COMPATIBILITY:
-//   - Based on: @ag-ui/core v0.0.42
-//   - Source files:
-//       - ag-ui/sdks/typescript/packages/core/src/events.ts
-//       - ag-ui/sdks/typescript/packages/core/src/types.ts
-//
-// MAINTENANCE:
-//   When updating to a new version of @ag-ui/core, compare the source files
-//   above and update these types accordingly. Key things to check:
-//   - New EventType values
-//   - New event interfaces
-//   - Changes to Message, Tool, ToolCall, Context, RunAgentInput
-//
-// ============================================================================
-/**
- * Event types for AG-UI protocol
- * @see @ag-ui/core EventType
- */
-exports.EventType = void 0;
-(function (EventType) {
-  EventType["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
-  EventType["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
-  EventType["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
-  EventType["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
-  EventType["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
-  EventType["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
-  EventType["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
-  EventType["TOOL_CALL_START"] = "TOOL_CALL_START";
-  EventType["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
-  EventType["TOOL_CALL_END"] = "TOOL_CALL_END";
-  EventType["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
-  EventType["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
-  EventType["THINKING_START"] = "THINKING_START";
-  EventType["THINKING_END"] = "THINKING_END";
-  EventType["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
-  EventType["STATE_DELTA"] = "STATE_DELTA";
-  EventType["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
-  EventType["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
-  EventType["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
-  EventType["RAW"] = "RAW";
-  EventType["CUSTOM"] = "CUSTOM";
-  EventType["RUN_STARTED"] = "RUN_STARTED";
-  EventType["RUN_FINISHED"] = "RUN_FINISHED";
-  EventType["RUN_ERROR"] = "RUN_ERROR";
-  EventType["STEP_STARTED"] = "STEP_STARTED";
-  EventType["STEP_FINISHED"] = "STEP_FINISHED";
-})(exports.EventType || (exports.EventType = {}));
-
-/**
- * AG-UI Event Handler
- * Processes AG-UI events and updates state accordingly
- */
-/**
- * Create initial processing state
- */
-function createProcessingState() {
-  return {
-    activeMessages: new Map(),
-    pendingToolCalls: new Map(),
-    rawToUiMessageMap: new Map()
-  };
-}
-/**
- * Find the index of the last TextPart in a parts array
- */
-function findLastTextPartIndex(parts) {
-  for (let i = parts.length - 1; i >= 0; i--) {
-    if (parts[i].type === "text") {
-      return i;
-    }
-  }
-  return -1;
-}
-/**
- * Find the index of a ToolPart by toolCallId in a parts array
- */
-function findToolPartIndex(parts, toolCallId) {
-  return parts.findIndex(p => p.type === "tool" && p.toolCallId === toolCallId);
-}
-/**
- * Rebuild UI-optimized messages from raw AG-UI messages.
- *
- * This utility function transforms the raw message array into a format
- * optimized for UI rendering:
- * - Filters out tool role messages (they appear as parts in assistant messages)
- * - Merges consecutive assistant messages into a single UIMessage with multiple parts
- * - Converts text content and tool calls into a unified parts-based structure
- *
- * @param messages - Raw AG-UI message array
- * @returns Array of UIMessage objects optimized for rendering
- *
- * @example
- * ```typescript
- * const messages: Message[] = [
- *   { id: 'm1', role: 'user', content: 'Hello' },
- *   { id: 'm2', role: 'assistant', content: 'Hi there!' },
- *   { id: 'm3', role: 'assistant', content: 'How can I help?' },
- * ];
- *
- * const uiMessages = rebuildUiMessages(messages);
- * // Result: [
- * //   { id: 'm1', role: 'user', parts: [{ type: 'text', text: 'Hello' }] },
- * //   { id: 'm2', role: 'assistant', parts: [
- * //     { type: 'text', text: 'Hi there!' },
- * //     { type: 'text', text: 'How can I help?' },
- * //   ] },
- * // ]
- * ```
- */
-function rebuildUiMessages(messages) {
-  const uiMessages = [];
-  for (const msg of messages) {
-    // Skip tool messages
-    if (msg.role === "tool") {
-      continue;
-    }
-    const lastUiMsg = uiMessages[uiMessages.length - 1];
-    const isAssistant = msg.role === "assistant";
-    const shouldMerge = isAssistant && (lastUiMsg === null || lastUiMsg === void 0 ? void 0 : lastUiMsg.role) === "assistant";
-    // Build parts for this message
-    const parts = [];
-    // Add text part if content exists and is a string (ignore binary/structured content for now)
-    if (msg.content && typeof msg.content === "string") {
-      parts.push({
-        id: msg.id,
-        type: "text",
-        text: msg.content,
-        state: "done"
-      });
-    }
-    // Add tool parts from toolCalls
-    const toolCalls = msg.toolCalls;
-    if (toolCalls) {
-      for (const tc of toolCalls) {
-        let args = {};
-        try {
-          args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
-        } catch (_a) {
-          // Keep empty args
-        }
-        parts.push({
-          type: "tool",
-          id: `tool_call_${tc.id}`,
-          toolCallId: tc.id,
-          name: tc.function.name,
-          argsString: tc.function.arguments || "",
-          args,
-          status: "completed" // Assume completed in snapshot
-        });
-      }
-    }
-    if (shouldMerge) {
-      // Merge into existing assistant uiMessage
-      lastUiMsg.parts.push(...parts);
-    } else if (parts.length > 0 || msg.role !== "assistant") {
-      // Create new uiMessage (always create for non-assistant, only if has parts for assistant)
-      uiMessages.push({
-        id: msg.id,
-        role: msg.role,
-        parts
-      });
-    }
-  }
-  return uiMessages;
-}
-/**
- * Process a single AG-UI event and update state
- */
-function processEvent(event, ctx, processingState) {
-  var _a, _b;
-  // Fire raw event callback if provided
-  (_a = ctx.onRawEvent) === null || _a === void 0 ? void 0 : _a.call(ctx, event);
-  const state = ctx.getState();
-  switch (event.type) {
-    // ========== Run Lifecycle ==========
-    case exports.EventType.RUN_STARTED:
-      {
-        const runStartedEvent = event;
-        // Validate: server's threadId should match client's
-        if (runStartedEvent.threadId && state.threadId && runStartedEvent.threadId !== state.threadId) {
-          console.warn(`[AGUI] threadId mismatch: client="${state.threadId}", server="${runStartedEvent.threadId}". Using client's.`);
-        }
-        ctx.setData({
-          "agui.isRunning": true,
-          "agui.runId": runStartedEvent.runId,
-          "agui.error": null
-        });
-        break;
-      }
-    case exports.EventType.RUN_FINISHED:
-      {
-        ctx.setData({
-          "agui.isRunning": false,
-          "agui.runId": null,
-          "agui.activeToolCalls": []
-        });
-        // Clear processing state
-        processingState.activeMessages.clear();
-        processingState.pendingToolCalls.clear();
-        processingState.rawToUiMessageMap.clear();
-        break;
-      }
-    case exports.EventType.RUN_ERROR:
-      {
-        const runErrorEvent = event;
-        const error = {
-          code: "RUNTIME_ERROR",
-          message: runErrorEvent.message,
-          recoverable: false,
-          details: {
-            code: runErrorEvent.code
-          }
-        };
-        ctx.setData({
-          "agui.isRunning": false,
-          "agui.runId": null,
-          "agui.error": error
-        });
-        break;
-      }
-    // ========== Text Messages ==========
-    case exports.EventType.TEXT_MESSAGE_START:
-      {
-        const textMessageStartEvent = event;
-        processingState.activeMessages.set(textMessageStartEvent.messageId, {
-          id: textMessageStartEvent.messageId,
-          role: textMessageStartEvent.role,
-          content: ""
-        });
-        // Add new message to state
-        const newMsg = {
-          id: textMessageStartEvent.messageId,
-          role: textMessageStartEvent.role,
-          content: ""
-        };
-        const newIndex = state.messages.length;
-        ctx.setData({
-          [`agui.messages[${newIndex}]`]: newMsg
-        });
-        // === uiMessages: merge consecutive assistant messages ===
-        const lastUiMsg = state.uiMessages[state.uiMessages.length - 1];
-        const isAssistant = textMessageStartEvent.role === "assistant";
-        const shouldMerge = isAssistant && (lastUiMsg === null || lastUiMsg === void 0 ? void 0 : lastUiMsg.role) === "assistant";
-        if (shouldMerge) {
-          // Merge into existing assistant uiMessage - add new TextPart
-          processingState.rawToUiMessageMap.set(textMessageStartEvent.messageId, lastUiMsg.id);
-          const newTextPart = {
-            id: textMessageStartEvent.messageId,
-            type: "text",
-            text: "",
-            state: "streaming"
-          };
-          const uiMsgIndex = state.uiMessages.length - 1;
-          const partIndex = lastUiMsg.parts.length;
-          ctx.setData({
-            [`agui.uiMessages[${uiMsgIndex}].parts[${partIndex}]`]: newTextPart
-          });
-        } else {
-          // Create new uiMessage
-          processingState.rawToUiMessageMap.set(textMessageStartEvent.messageId, textMessageStartEvent.messageId);
-          const newTextPart = {
-            id: textMessageStartEvent.messageId,
-            type: "text",
-            text: "",
-            state: "streaming"
-          };
-          const newUiMsg = {
-            id: textMessageStartEvent.messageId,
-            role: textMessageStartEvent.role,
-            parts: [newTextPart]
-          };
-          const uiMsgIndex = state.uiMessages.length;
-          ctx.setData({
-            [`agui.uiMessages[${uiMsgIndex}]`]: newUiMsg
-          });
-        }
-        break;
-      }
-    case exports.EventType.TEXT_MESSAGE_CONTENT:
-      {
-        const textMessageContentEvent = event;
-        const activeMsg = processingState.activeMessages.get(textMessageContentEvent.messageId);
-        if (activeMsg) {
-          activeMsg.content += textMessageContentEvent.delta;
-          // Efficient path-based update for messages
-          const index = state.messages.findIndex(m => m.id === textMessageContentEvent.messageId);
-          if (index >= 0) {
-            ctx.setData({
-              [`agui.messages[${index}].content`]: activeMsg.content
-            });
-          }
-          // === uiMessages: update the corresponding TextPart ===
-          const uiMsgId = processingState.rawToUiMessageMap.get(textMessageContentEvent.messageId);
-          if (uiMsgId) {
-            const uiMsgIndex = state.uiMessages.findIndex(m => m.id === uiMsgId);
-            if (uiMsgIndex >= 0) {
-              const uiMsg = state.uiMessages[uiMsgIndex];
-              // Find the last TextPart (the one being streamed)
-              const partIndex = findLastTextPartIndex(uiMsg.parts);
-              if (partIndex >= 0) {
-                const textPart = uiMsg.parts[partIndex];
-                ctx.setData({
-                  [`agui.uiMessages[${uiMsgIndex}].parts[${partIndex}].text`]: textPart.text + textMessageContentEvent.delta
-                });
-              }
-            }
-          }
-        }
-        break;
-      }
-    case exports.EventType.TEXT_MESSAGE_END:
-      {
-        const textMessageEndEvent = event;
-        // === uiMessages: mark TextPart as done ===
-        const uiMsgId = processingState.rawToUiMessageMap.get(textMessageEndEvent.messageId);
-        if (uiMsgId) {
-          const uiMsgIndex = state.uiMessages.findIndex(m => m.id === uiMsgId);
-          if (uiMsgIndex >= 0) {
-            const uiMsg = state.uiMessages[uiMsgIndex];
-            const partIndex = findLastTextPartIndex(uiMsg.parts);
-            if (partIndex >= 0) {
-              ctx.setData({
-                [`agui.uiMessages[${uiMsgIndex}].parts[${partIndex}].state`]: "done"
-              });
-            }
-          }
-        }
-        processingState.activeMessages.delete(textMessageEndEvent.messageId);
-        break;
-      }
-    // ========== Tool Calls ==========
-    case exports.EventType.TOOL_CALL_START:
-      {
-        const toolCallStartEvent = event;
-        // Find parent message: use provided parentMessageId or fallback to nearest assistant message
-        let parentMsgId = toolCallStartEvent.parentMessageId;
-        let parentMsgIndex = -1;
-        if (parentMsgId) {
-          parentMsgIndex = state.messages.findIndex(m => m.id === parentMsgId);
-        }
-        if (parentMsgIndex < 0) {
-          // Fallback: find the most recent assistant message
-          for (let i = state.messages.length - 1; i >= 0; i--) {
-            if (state.messages[i].role === "assistant") {
-              parentMsgIndex = i;
-              parentMsgId = state.messages[i].id;
-              break;
-            }
-          }
-        }
-        // Error: no parent assistant message found
-        if (parentMsgIndex < 0 || !parentMsgId) {
-          const error = {
-            code: "INVALID_EVENT",
-            message: `TOOL_CALL_START for "${toolCallStartEvent.toolCallId}" has no parent assistant message. ` + `Either provide parentMessageId or ensure an assistant message exists.`,
-            recoverable: false,
-            details: {
-              toolCallId: toolCallStartEvent.toolCallId,
-              toolCallName: toolCallStartEvent.toolCallName
-            }
-          };
-          console.error(`[AGUI] ${error.message}`);
-          ctx.setData({
-            "agui.error": error
-          });
-          break;
-        }
-        processingState.pendingToolCalls.set(toolCallStartEvent.toolCallId, {
-          id: toolCallStartEvent.toolCallId,
-          name: toolCallStartEvent.toolCallName,
-          argsString: "",
-          parentMessageId: parentMsgId
-        });
-        // Add to active tool calls
-        const toolCallState = {
-          toolCallId: toolCallStartEvent.toolCallId,
-          name: toolCallStartEvent.toolCallName,
-          argsString: "",
-          args: {},
-          status: "pending"
-        };
-        const toolIndex = state.activeToolCalls.length;
-        ctx.setData({
-          [`agui.activeToolCalls[${toolIndex}]`]: toolCallState
-        });
-        // Attach tool call to parent assistant message
-        if (parentMsgIndex >= 0) {
-          const msg = state.messages[parentMsgIndex];
-          const existingToolCalls = msg.toolCalls || [];
-          const newToolCall = {
-            id: toolCallStartEvent.toolCallId,
-            type: "function",
-            function: {
-              name: toolCallStartEvent.toolCallName,
-              arguments: ""
-            }
-          };
-          ctx.setData({
-            [`agui.messages[${parentMsgIndex}].toolCalls`]: [...existingToolCalls, newToolCall]
-          });
-        }
-        // === uiMessages: add ToolPart to the parent assistant uiMessage ===
-        // Find or create parent assistant uiMessage
-        let parentUiMsgIndex = -1;
-        const lastUiMsg = state.uiMessages[state.uiMessages.length - 1];
-        if ((lastUiMsg === null || lastUiMsg === void 0 ? void 0 : lastUiMsg.role) === "assistant") {
-          parentUiMsgIndex = state.uiMessages.length - 1;
-        } else {
-          // Create a new assistant uiMessage for the tool call
-          const newUiMsg = {
-            id: parentMsgId,
-            role: "assistant",
-            parts: []
-          };
-          parentUiMsgIndex = state.uiMessages.length;
-          ctx.setData({
-            [`agui.uiMessages[${parentUiMsgIndex}]`]: newUiMsg
-          });
-        }
-        // Add ToolPart
-        const toolPart = {
-          type: "tool",
-          id: `tool_call_${toolCallStartEvent.toolCallId}`,
-          toolCallId: toolCallStartEvent.toolCallId,
-          name: toolCallStartEvent.toolCallName,
-          argsString: "",
-          args: {},
-          status: "pending"
-        };
-        const parentUiMsg = state.uiMessages[parentUiMsgIndex] || {
-          parts: []
-        };
-        const toolPartIndex = parentUiMsg.parts.length;
-        ctx.setData({
-          [`agui.uiMessages[${parentUiMsgIndex}].parts[${toolPartIndex}]`]: toolPart
-        });
-        break;
-      }
-    case exports.EventType.TOOL_CALL_ARGS:
-      {
-        const toolCallArgsEvent = event;
-        const pending = processingState.pendingToolCalls.get(toolCallArgsEvent.toolCallId);
-        if (pending) {
-          pending.argsString += toolCallArgsEvent.delta;
-          // Update UI with streaming progress
-          const index = state.activeToolCalls.findIndex(tc => tc.toolCallId === toolCallArgsEvent.toolCallId);
-          if (index >= 0) {
-            ctx.setData({
-              [`agui.activeToolCalls[${index}].argsString`]: pending.argsString
-            });
-          }
-          // Update arguments in parent message's toolCalls
-          if (pending.parentMessageId) {
-            const msgIndex = state.messages.findIndex(m => m.id === pending.parentMessageId);
-            if (msgIndex >= 0) {
-              const msg = state.messages[msgIndex];
-              const tcIndex = (_b = msg.toolCalls) === null || _b === void 0 ? void 0 : _b.findIndex(tc => tc.id === toolCallArgsEvent.toolCallId);
-              if (tcIndex !== undefined && tcIndex >= 0) {
-                ctx.setData({
-                  [`agui.messages[${msgIndex}].toolCalls[${tcIndex}].function.arguments`]: pending.argsString
-                });
-              }
-            }
-          }
-          // === uiMessages: update ToolPart argsString ===
-          const lastUiMsg = state.uiMessages[state.uiMessages.length - 1];
-          if ((lastUiMsg === null || lastUiMsg === void 0 ? void 0 : lastUiMsg.role) === "assistant") {
-            const uiMsgIndex = state.uiMessages.length - 1;
-            const toolPartIndex = findToolPartIndex(lastUiMsg.parts, toolCallArgsEvent.toolCallId);
-            if (toolPartIndex >= 0) {
-              ctx.setData({
-                [`agui.uiMessages[${uiMsgIndex}].parts[${toolPartIndex}].argsString`]: pending.argsString
-              });
-            }
-          }
-        }
-        break;
-      }
-    case exports.EventType.TOOL_CALL_END:
-      {
-        const toolCallEndEvent = event;
-        const pending = processingState.pendingToolCalls.get(toolCallEndEvent.toolCallId);
-        // Mark as ready - args complete, waiting for execution
-        const index = state.activeToolCalls.findIndex(tc => tc.toolCallId === toolCallEndEvent.toolCallId);
-        if (index >= 0) {
-          // Parse args
-          let args = {};
-          if (pending === null || pending === void 0 ? void 0 : pending.argsString) {
-            try {
-              args = JSON.parse(pending.argsString);
-            } catch (_c) {
-              // Keep empty args on parse failure
-            }
-          }
-          ctx.setData({
-            [`agui.activeToolCalls[${index}].status`]: "ready",
-            [`agui.activeToolCalls[${index}].args`]: args
-          });
-        }
-        // === uiMessages: update ToolPart status and parse args ===
-        const lastUiMsg = state.uiMessages[state.uiMessages.length - 1];
-        if ((lastUiMsg === null || lastUiMsg === void 0 ? void 0 : lastUiMsg.role) === "assistant") {
-          const uiMsgIndex = state.uiMessages.length - 1;
-          const toolPartIndex = findToolPartIndex(lastUiMsg.parts, toolCallEndEvent.toolCallId);
-          if (toolPartIndex >= 0) {
-            let args = {};
-            if (pending === null || pending === void 0 ? void 0 : pending.argsString) {
-              try {
-                args = JSON.parse(pending.argsString);
-              } catch (_d) {
-                // Keep empty args on parse failure
-              }
-            }
-            ctx.setData({
-              [`agui.uiMessages[${uiMsgIndex}].parts[${toolPartIndex}].status`]: "ready",
-              [`agui.uiMessages[${uiMsgIndex}].parts[${toolPartIndex}].args`]: args
-            });
-          }
-        }
-        break;
-      }
-    // ========== Messages Snapshot ==========
-    case exports.EventType.MESSAGES_SNAPSHOT:
-      {
-        const messagesSnapshotEvent = event;
-        ctx.setData({
-          "agui.messages": messagesSnapshotEvent.messages,
-          "agui.uiMessages": rebuildUiMessages(messagesSnapshotEvent.messages)
-        });
-        break;
-      }
-  }
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-}
-function __values(o) {
-  var s = typeof Symbol === "function" && Symbol.iterator,
-    m = s && o[s],
-    i = 0;
-  if (m) return m.call(o);
-  if (o && typeof o.length === "number") return {
-    next: function () {
-      if (o && i >= o.length) o = void 0;
-      return {
-        value: o && o[i++],
-        done: !o
-      };
-    }
-  };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-function __await(v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-function __asyncGenerator(thisArg, _arguments, generator) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var g = generator.apply(thisArg, _arguments || []),
-    i,
-    q = [];
-  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () {
-    return this;
-  }, i;
-  function awaitReturn(f) {
-    return function (v) {
-      return Promise.resolve(v).then(f, reject);
-    };
-  }
-  function verb(n, f) {
-    if (g[n]) {
-      i[n] = function (v) {
-        return new Promise(function (a, b) {
-          q.push([n, v, a, b]) > 1 || resume(n, v);
-        });
-      };
-      if (f) i[n] = f(i[n]);
-    }
-  }
-  function resume(n, v) {
-    try {
-      step(g[n](v));
-    } catch (e) {
-      settle(q[0][3], e);
-    }
-  }
-  function step(r) {
-    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-  }
-  function fulfill(value) {
-    resume("next", value);
-  }
-  function reject(value) {
-    resume("throw", value);
-  }
-  function settle(f, v) {
-    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
-  }
-}
-function __asyncValues(o) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var m = o[Symbol.asyncIterator],
-    i;
-  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
-    return this;
-  }, i);
-  function verb(n) {
-    i[n] = o[n] && function (v) {
-      return new Promise(function (resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
-      });
-    };
-  }
-  function settle(resolve, reject, d, v) {
-    Promise.resolve(v).then(function (v) {
-      resolve({
-        value: v,
-        done: d
-      });
-    }, reject);
-  }
-}
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-/**
- * AG-UI Behavior for WeChat Miniprogram
- * Main entry point - provides the Behavior mixin pattern
- */
-/**
- * Create initial state from options
- */
-function createInitialState(options) {
-  var _a, _b, _c, _d, _e;
-  const messages = (_a = options.messages) !== null && _a !== void 0 ? _a : [];
-  return {
-    messages,
-    uiMessages: rebuildUiMessages(messages),
-    isRunning: false,
-    runId: null,
-    activeToolCalls: [],
-    error: null,
-    threadId: (_b = options.threadId) !== null && _b !== void 0 ? _b : generateId(),
-    tools: (_d = (_c = options.tools) === null || _c === void 0 ? void 0 : _c.map(t => ({
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters
-    }))) !== null && _d !== void 0 ? _d : [],
-    contexts: (_e = options.contexts) !== null && _e !== void 0 ? _e : []
-  };
-}
-/**
- * Creates an AG-UI Behavior mixin for WeChat Mini Program components.
- *
- * This factory function returns a Behavior definition that provides AG-UI
- * protocol support via the `agui` namespace on component data.
- *
- * @param options - Configuration options for the behavior
- * @param options.transport - Transport instance for communicating with the agent backend
- * @param options.messages - Initial message history to populate the conversation
- * @param options.tools - Client tools that the agent can invoke
- * @param options.threadId - Custom thread ID (auto-generated if not provided)
- * @param options.contexts - Additional context objects to pass to the agent
- * @param options.onRawEvent - Callback invoked for each raw AG-UI event received
- * @returns A Behavior definition to be mixed into a Component
- *
- * @example
- * ```typescript
- * // Basic usage with transport
- * const transport = new CloudbaseTransport({ botId: 'your-bot-id' });
- * Component({
- *   behaviors: [createAGUIBehavior({ transport })],
- * });
- *
- * // With initial messages and tools
- * Component({
- *   behaviors: [createAGUIBehavior({
- *     transport,
- *     messages: [{ id: 'm1', role: 'user', content: 'Hello' }],
- *     tools: [{
- *       name: 'get_weather',
- *       description: 'Get current weather',
- *       parameters: { type: 'object', properties: { city: { type: 'string' } } },
- *       handler: async ({ args }) => ({ temp: 72, city: args.city }),
- *     }],
- *   })],
- * });
- * ```
- */
-function createAGUIBehavior(options = {}) {
-  var _a, _b;
-  // Build toolHandlers map from options (for internal use)
-  const toolHandlers = new Map((_b = (_a = options.tools) === null || _a === void 0 ? void 0 : _a.map(t => [t.name, t])) !== null && _b !== void 0 ? _b : []);
-  return Behavior({
-    data: {
-      agui: createInitialState(options)
-    },
-    lifetimes: {
-      attached() {
-        // Initialize internal state (non-serializable)
-        const instance = {
-          transport: options.transport || null,
-          toolHandlers,
-          processingState: createProcessingState(),
-          options
-        };
-        // Store instance on component
-        this.__agui = instance;
-        // Create agui namespace with bound methods and state getters
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const self = this;
-        self.agui = {
-          // Methods
-          init: self._aguiInit.bind(self),
-          setThreadId: self._aguiSetThreadId.bind(self),
-          sendMessage: self._aguiSendMessage.bind(self),
-          appendMessage: self._aguiAppendMessage.bind(self),
-          setMessages: self._aguiSetMessages.bind(self),
-          reset: self._aguiReset.bind(self),
-          addTool: self._aguiAddTool.bind(self),
-          removeTool: self._aguiRemoveTool.bind(self),
-          updateTool: self._aguiUpdateTool.bind(self),
-          clearTools: self._aguiClearTools.bind(self),
-          // State getters - proxy to this.data.agui for convenience
-          get messages() {
-            return self.data.agui.messages;
-          },
-          get uiMessages() {
-            return self.data.agui.uiMessages;
-          },
-          get isRunning() {
-            return self.data.agui.isRunning;
-          },
-          get runId() {
-            return self.data.agui.runId;
-          },
-          get activeToolCalls() {
-            return self.data.agui.activeToolCalls;
-          },
-          get error() {
-            return self.data.agui.error;
-          },
-          get threadId() {
-            return self.data.agui.threadId;
-          },
-          get tools() {
-            return self.data.agui.tools;
-          },
-          get contexts() {
-            return self.data.agui.contexts;
-          },
-          // Config getter - exposes current configuration options
-          get config() {
-            return getInstance(self).options;
-          }
-        };
-      },
-      detached() {
-        const instance = getInstance(this);
-        if (instance) {
-          instance.toolHandlers.clear();
-          instance.processingState.activeMessages.clear();
-          instance.processingState.pendingToolCalls.clear();
-        }
-      }
-    },
-    methods: {
-      // ========== Lifecycle Methods ==========
-      /**
-       * Initialize the AG-UI behavior with runtime configuration.
-       * Call this in the component's `attached` lifecycle if transport
-       * was not provided in `createAGUIBehavior` options.
-       *
-       * @param config - Runtime configuration object
-       * @param config.transport - Transport instance for agent communication
-       * @param config.threadId - Optional thread ID to override the generated one
-       *
-       * @example
-       * ```typescript
-       * Component({
-       *   behaviors: [aguiBehavior],
-       *   lifetimes: {
-       *     attached() {
-       *       this.agui.init({
-       *         transport: new CloudbaseTransport({ botId: 'my-bot' }),
-       *       });
-       *     },
-       *   },
-       * });
-       * ```
-       */
-      _aguiInit(config) {
-        const instance = getInstance(this);
-        instance.transport = config.transport;
-        if (config.threadId) {
-          this.setData({
-            "agui.threadId": config.threadId
-          });
-        }
-      },
-      // ========== Dynamic Config Setters ==========
-      /**
-       * Update the thread ID for subsequent agent runs.
-       *
-       * @param threadId - New thread ID to use
-       */
-      _aguiSetThreadId(threadId) {
-        this.setData({
-          "agui.threadId": threadId
-        });
-      },
-      // ========== Message Methods ==========
-      /**
-       * Send a message to the agent and process the streaming response.
-       *
-       * This is the primary method for initiating a conversation turn.
-       * It appends the message(s) to the conversation history and starts
-       * an agent run. The response will be streamed and state updated reactively.
-       *
-       * @param input - Either a string (converted to user message) or an array of Message objects
-       * @returns Promise that resolves when the agent run completes
-       *
-       * @example
-       * ```typescript
-       * // Send a simple text message
-       * await this.agui.sendMessage('What is the weather like?');
-       *
-       * // Send a pre-constructed message
-       * await this.agui.sendMessage([
-       *   { id: 'msg-1', role: 'user', content: 'Hello' },
-       * ]);
-       * ```
-       */
-      _aguiSendMessage(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-          const instance = getInstance(this);
-          if (!instance.transport) {
-            const error = {
-              code: "INIT_ERROR",
-              message: "Transport not initialized. Call agui.init() first or provide transport in createAGUIBehavior options.",
-              recoverable: true
-            };
-            this.setData({
-              "agui.error": error
-            });
-            return;
-          }
-          // Convert text to delta messages array
-          const deltaMessages = typeof input === "string" ? [{
-            id: generateId(),
-            role: "user",
-            content: input
-          }] : input;
-          // Add delta messages to both messages and uiMessages
-          const currentMessages = this.data.agui.messages;
-          const newMessages = [...currentMessages, ...deltaMessages];
-          this.setData({
-            "agui.messages": newMessages,
-            // Rebuild uiMessages from full messages to handle merging correctly
-            "agui.uiMessages": rebuildUiMessages(newMessages),
-            "agui.error": null,
-            "agui.isRunning": true
-          });
-          // Run the agent with delta messages
-          yield this.__aguiRunAgent(instance, deltaMessages);
-        });
-      },
-      /**
-       * Append a single message to the conversation history without triggering an agent run.
-       * Useful for adding system messages or programmatically inserting messages.
-       *
-       * @param message - The message to append
-       */
-      _aguiAppendMessage(message) {
-        const currentMessages = this.data.agui.messages;
-        const newMessages = [...currentMessages, message];
-        this.setData({
-          "agui.messages": newMessages,
-          "agui.uiMessages": rebuildUiMessages(newMessages)
-        });
-      },
-      /**
-       * Replace the entire message history.
-       * Useful for loading a saved conversation or resetting to a specific state.
-       *
-       * @param messages - The new message array to set
-       */
-      _aguiSetMessages(messages) {
-        this.setData({
-          "agui.messages": messages,
-          "agui.uiMessages": rebuildUiMessages(messages)
-        });
-      },
-      /**
-       * Reset the AG-UI state to the initial configuration.
-       * Clears all messages, tool calls, and errors. Restores tools to initial set.
-       */
-      _aguiReset() {
-        var _a;
-        const instance = getInstance(this);
-        const opts = instance.options;
-        // Clear internal state
-        instance.processingState.activeMessages.clear();
-        instance.processingState.pendingToolCalls.clear();
-        // Restore toolHandlers from options
-        instance.toolHandlers.clear();
-        for (const tool of (_a = opts.tools) !== null && _a !== void 0 ? _a : []) {
-          instance.toolHandlers.set(tool.name, tool);
-        }
-        // Restore to original options state
-        this.setData({
-          agui: createInitialState(opts)
-        });
-      },
-      // ========== Tool Methods ==========
-      /**
-       * Register a client tool that the agent can invoke.
-       * The tool's handler function will be called when the agent requests this tool.
-       *
-       * @param tool - The tool definition including name, description, parameters schema, and handler
-       *
-       * @example
-       * ```typescript
-       * this.agui.addTool({
-       *   name: 'get_weather',
-       *   description: 'Get current weather for a city',
-       *   parameters: {
-       *     type: 'object',
-       *     properties: { city: { type: 'string' } },
-       *     required: ['city'],
-       *   },
-       *   handler: async ({ args }) => {
-       *     const weather = await fetchWeather(args.city);
-       *     return { temperature: weather.temp, conditions: weather.conditions };
-       *   },
-       * });
-       * ```
-       */
-      _aguiAddTool(tool) {
-        const instance = getInstance(this);
-        const state = this.data.agui;
-        // Store handler internally
-        instance.toolHandlers.set(tool.name, tool);
-        // Expose definition to UI (without handler)
-        const toolDef = {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
-        };
-        this.setData({
-          "agui.tools": [...state.tools, toolDef]
-        });
-      },
-      /**
-       * Remove a registered tool by name.
-       *
-       * @param name - The name of the tool to remove
-       */
-      _aguiRemoveTool(name) {
-        const instance = getInstance(this);
-        const state = this.data.agui;
-        instance.toolHandlers.delete(name);
-        this.setData({
-          "agui.tools": state.tools.filter(t => t.name !== name)
-        });
-      },
-      /**
-       * Update an existing tool's properties.
-       * Merges the updates with the existing tool definition.
-       *
-       * @param name - The name of the tool to update
-       * @param updates - Partial tool definition with properties to update
-       */
-      _aguiUpdateTool(name, updates) {
-        const instance = getInstance(this);
-        const state = this.data.agui;
-        const existing = instance.toolHandlers.get(name);
-        if (existing) {
-          const updated = Object.assign(Object.assign({}, existing), updates);
-          instance.toolHandlers.set(name, updated);
-          // Update UI-visible definition
-          this.setData({
-            "agui.tools": state.tools.map(t => t.name === name ? {
-              name: updated.name,
-              description: updated.description,
-              parameters: updated.parameters
-            } : t)
-          });
-        }
-      },
-      /**
-       * Remove all registered tools.
-       */
-      _aguiClearTools() {
-        const instance = getInstance(this);
-        instance.toolHandlers.clear();
-        this.setData({
-          "agui.tools": []
-        });
-      },
-      // ========== Internal Methods (not exposed via namespace) ==========
-      __aguiRunAgent(instance, deltaMessages) {
-        return __awaiter(this, void 0, void 0, function* () {
-          var _a, e_1, _b, _c;
-          const state = this.data.agui;
-          // Build request with delta messages only
-          const input = {
-            threadId: state.threadId,
-            runId: generateId(),
-            messages: deltaMessages,
-            tools: state.tools,
-            context: state.contexts,
-            state: {},
-            forwardedProps: {}
-          };
-          // Create event handler context
-          const handlerCtx = {
-            getState: () => this.data.agui,
-            setData: updates => this.setData(updates),
-            onRawEvent: instance.options.onRawEvent
-          };
-          try {
-            try {
-              // Process events from transport
-              for (var _d = true, _e = __asyncValues(instance.transport.run(input)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const event = _c;
-                // Cast BaseEvent to AGUIEvent for proper type narrowing
-                const typedEvent = event;
-                processEvent(typedEvent, handlerCtx, instance.processingState);
-                // Handle tool call execution
-                if (typedEvent.type === exports.EventType.TOOL_CALL_END) {
-                  const toolCallEndEvent = typedEvent;
-                  yield this.__aguiExecuteToolCall(instance, toolCallEndEvent.toolCallId);
-                }
-              }
-            } catch (e_1_1) {
-              e_1 = {
-                error: e_1_1
-              };
-            } finally {
-              try {
-                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-              } finally {
-                if (e_1) throw e_1.error;
-              }
-            }
-          } catch (err) {
-            console.error("[AGUI] Transport error:", err);
-            const error = {
-              code: "TRANSPORT_ERROR",
-              message: err instanceof Error ? err.message : "Unknown transport error",
-              recoverable: true,
-              originalError: err instanceof Error ? err : undefined
-            };
-            this.setData({
-              "agui.error": error,
-              "agui.isRunning": false
-            });
-          }
-        });
-      },
-      __aguiExecuteToolCall(instance, toolCallId) {
-        return __awaiter(this, void 0, void 0, function* () {
-          const pending = instance.processingState.pendingToolCalls.get(toolCallId);
-          if (!pending) return;
-          const tool = instance.toolHandlers.get(pending.name);
-          // Update status to executing (both activeToolCalls and uiMessages)
-          this.__aguiUpdateToolCallStatus(toolCallId, "executing");
-          // Parse arguments
-          let args = {};
-          try {
-            args = pending.argsString ? JSON.parse(pending.argsString) : {};
-          } catch (err) {
-            console.error("[AGUI] Failed to parse tool arguments:", pending.argsString, err);
-            const error = {
-              code: "PARSE_ERROR",
-              message: `Failed to parse tool arguments for ${pending.name}`,
-              recoverable: false
-            };
-            this.__aguiUpdateToolCallStatus(toolCallId, "failed", undefined, error);
-            // Add error result and continue conversation
-            const toolResultMessage = this.__aguiAddToolResultMessage(toolCallId, JSON.stringify({
-              error: error.message
-            }));
-            yield this.__aguiRunAgent(instance, [toolResultMessage]);
-            return;
-          }
-          // Update parsed args
-          const updatedToolCalls = this.data.agui.activeToolCalls.map(tc => tc.toolCallId === toolCallId ? Object.assign(Object.assign({}, tc), {
-            args
-          }) : tc);
-          this.setData({
-            "agui.activeToolCalls": updatedToolCalls
-          });
-          if (!tool) {
-            const error = {
-              code: "TOOL_NOT_FOUND",
-              message: `Tool "${pending.name}" not found`,
-              recoverable: false
-            };
-            this.__aguiUpdateToolCallStatus(toolCallId, "failed", undefined, error);
-            // Add error result and continue conversation
-            const toolResultMessage = this.__aguiAddToolResultMessage(toolCallId, JSON.stringify({
-              error: error.message
-            }));
-            yield this.__aguiRunAgent(instance, [toolResultMessage]);
-            return;
-          }
-          // Execute tool
-          try {
-            const result = yield Promise.resolve(tool.handler({
-              name: tool.name,
-              description: tool.description,
-              toolCallId,
-              args
-            }));
-            this.__aguiUpdateToolCallStatus(toolCallId, "completed", result);
-            // Add tool result message
-            const toolResultMessage = this.__aguiAddToolResultMessage(toolCallId, result);
-            // Clean up
-            instance.processingState.pendingToolCalls.delete(toolCallId);
-            // Continue conversation with tool result as delta
-            yield this.__aguiRunAgent(instance, [toolResultMessage]);
-          } catch (err) {
-            console.error("[AGUI] Tool execution error:", pending.name, err);
-            const error = {
-              code: "TOOL_EXECUTION_ERROR",
-              message: err instanceof Error ? err.message : "Tool execution failed",
-              recoverable: false,
-              originalError: err instanceof Error ? err : undefined
-            };
-            this.__aguiUpdateToolCallStatus(toolCallId, "failed", undefined, error);
-            // Add tool result with error and continue conversation
-            // (same as success path - let LLM handle the error)
-            const toolResultMessage = this.__aguiAddToolResultMessage(toolCallId, JSON.stringify({
-              error: error.message
-            }));
-            yield this.__aguiRunAgent(instance, [toolResultMessage]);
-          }
-        });
-      },
-      __aguiUpdateToolCallStatus(toolCallId, status, result, error) {
-        const state = this.data.agui;
-        // Update activeToolCalls
-        const activeToolCalls = state.activeToolCalls.map(tc => tc.toolCallId === toolCallId ? Object.assign(Object.assign({}, tc), {
-          status,
-          result,
-          error
-        }) : tc);
-        // Update uiMessages - find the ToolPart and update it
-        const uiMessages = state.uiMessages.map(uiMsg => {
-          if (uiMsg.role !== "assistant") return uiMsg;
-          const hasToolPart = uiMsg.parts.some(p => p.type === "tool" && p.toolCallId === toolCallId);
-          if (!hasToolPart) return uiMsg;
-          return Object.assign(Object.assign({}, uiMsg), {
-            parts: uiMsg.parts.map(p => p.type === "tool" && p.toolCallId === toolCallId ? Object.assign(Object.assign({}, p), {
-              status,
-              result,
-              error
-            }) : p)
-          });
-        });
-        this.setData({
-          "agui.activeToolCalls": activeToolCalls,
-          "agui.uiMessages": uiMessages
-        });
-      },
-      __aguiAddToolResultMessage(toolCallId, content) {
-        const state = this.data.agui;
-        const toolMessage = {
-          id: generateId(),
-          role: "tool",
-          toolCallId,
-          content
-        };
-        this.setData({
-          "agui.messages": [...state.messages, toolMessage]
-        });
-        return toolMessage;
-      }
-    }
-  });
-}
-function generateId() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, c => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 0x3 | 0x8;
-    return v.toString(16);
-  });
-}
-/**
- * Get the internal AGUI instance from a component
- */
-function getInstance(component) {
-  return component.__agui;
-}
-/**
- * Default AG-UI behavior instance with no static configuration.
- *
- * Use this for a purely imperative usage pattern where all configuration
- * is done at runtime via `agui.init()`.
- *
- * @example
- * ```typescript
- * Component({
- *   behaviors: [aguiBehavior],
- *   lifetimes: {
- *     attached() {
- *       this.agui.init({
- *         transport: new CloudbaseTransport({ botId: 'my-bot' }),
- *       });
- *     },
- *   },
- * });
- * ```
- */
-const aguiBehavior = createAGUIBehavior();
-
-/**
- * AG-UI Transport Implementations
- */
-/**
- * Mock transport implementation for testing and development.
- *
- * Simulates an AG-UI agent backend by emitting a configurable sequence
- * of events. Useful for unit tests, prototyping, and demo applications.
- *
- * @example
- * ```typescript
- * // Create with predefined events
- * const transport = new MockTransport({
- *   events: MockTransport.createTextResponse('Hello, world!'),
- *   delayMs: 100, // Simulate network latency
- * });
- *
- * // Or set events dynamically
- * transport.setEvents(MockTransport.createToolCallResponse('get_weather', { city: 'NYC' }));
- * ```
- */
-class MockTransport {
-  constructor(options = {}) {
-    var _a;
-    this.events = options.events || [];
-    this.delayMs = (_a = options.delayMs) !== null && _a !== void 0 ? _a : 50;
-  }
-  /**
-   * Set the events to emit during the next `run()` call.
-   *
-   * @param events - Array of AG-UI events to emit
-   */
-  setEvents(events) {
-    this.events = events;
-  }
-  /**
-   * Create a simple text response event sequence.
-   *
-   * @param text - The text content of the assistant's response
-   * @param messageId - Optional message ID (defaults to "msg-1")
-   * @returns Array of events representing a complete text response
-   */
-  static createTextResponse(text, messageId = "msg-1") {
-    return [{
-      type: exports.EventType.RUN_STARTED,
-      threadId: "thread-1",
-      runId: "run-1"
-    }, {
-      type: exports.EventType.TEXT_MESSAGE_START,
-      messageId,
-      role: "assistant"
-    }, {
-      type: exports.EventType.TEXT_MESSAGE_CONTENT,
-      messageId,
-      delta: text
-    }, {
-      type: exports.EventType.TEXT_MESSAGE_END,
-      messageId
-    }, {
-      type: exports.EventType.RUN_FINISHED,
-      threadId: "thread-1",
-      runId: "run-1"
-    }];
-  }
-  /**
-   * Create a tool call response event sequence.
-   *
-   * @param toolName - Name of the tool being called
-   * @param args - Arguments to pass to the tool (will be JSON stringified)
-   * @param toolCallId - Optional tool call ID (defaults to "tc-1")
-   * @returns Array of events representing a tool call (without RUN_FINISHED)
-   */
-  static createToolCallResponse(toolName, args, toolCallId = "tc-1") {
-    return [{
-      type: exports.EventType.RUN_STARTED,
-      threadId: "thread-1",
-      runId: "run-1"
-    }, {
-      type: exports.EventType.TOOL_CALL_START,
-      toolCallId,
-      toolCallName: toolName
-    }, {
-      type: exports.EventType.TOOL_CALL_ARGS,
-      toolCallId,
-      delta: JSON.stringify(args)
-    }, {
-      type: exports.EventType.TOOL_CALL_END,
-      toolCallId
-    }
-    // Note: RUN_FINISHED will be emitted after tool execution
-    ];
-  }
-  run(_input) {
-    return __asyncGenerator(this, arguments, function* run_1() {
-      for (const event of this.events) {
-        if (this.delayMs > 0) {
-          yield __await(this.delay(this.delayMs));
-        }
-        yield yield __await(event);
-      }
-    });
-  }
-  delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-/**
- * Production transport for WeChat Cloud Development (Cloudbase).
- *
- * Connects to a WeChat AI Bot configured in the Cloud Development console.
- * Requires the `wx.cloud.extend.AI.bot.sendMessage` API to be available.
- *
- * @example
- * ```typescript
- * const transport = new CloudbaseTransport({
- *   botId: 'bot-xxxxxx', // Your bot ID from Cloud Development console
- * });
- *
- * Component({
- *   behaviors: [createAGUIBehavior({ transport })],
- * });
- * ```
- */
-class CloudbaseTransport {
-  /**
-   * Create a new CloudbaseTransport instance.
-   *
-   * @param options - Configuration options
-   * @param options.botId - The bot ID from WeChat Cloud Development console
-   */
-  constructor(options) {
-    this.botId = options.botId;
-  }
-  run(input) {
-    return __asyncGenerator(this, arguments, function* run_2() {
-      var _a, e_1, _b, _c;
-      var _d, _e, _f, _g;
-      // Capture botId before async generator (avoids 'this' context issues after transpilation)
-      const botId = this.botId;
-      // Check if wx.cloud.extend.AI.bot.sendMessage is available
-      if (typeof wx === "undefined" || !((_g = (_f = (_e = (_d = wx.cloud) === null || _d === void 0 ? void 0 : _d.extend) === null || _e === void 0 ? void 0 : _e.AI) === null || _f === void 0 ? void 0 : _f.bot) === null || _g === void 0 ? void 0 : _g.sendMessage)) {
-        throw new Error("CloudbaseTransport requires wx.cloud.extend.AI.bot.sendMessage");
-      }
-      // Start the bot conversation
-      const res = yield __await(wx.cloud.extend.AI.bot.sendMessage({
-        botId,
-        data: input
-      }));
-      try {
-        for (var _h = true, _j = __asyncValues(res.eventStream), _k; _k = yield __await(_j.next()), _a = _k.done, !_a; _h = true) {
-          _c = _k.value;
-          _h = false;
-          const event = _c;
-          if (event.json) {
-            yield yield __await(event.json);
-          }
-        }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
-      } finally {
-        try {
-          if (!_h && !_a && (_b = _j.return)) yield __await(_b.call(_j));
-        } finally {
-          if (e_1) throw e_1.error;
-        }
-      }
-    });
-  }
-}
-
-exports.CloudbaseTransport = CloudbaseTransport;
-exports.MockTransport = MockTransport;
-exports.aguiBehavior = aguiBehavior;
-exports.createAGUIBehavior = createAGUIBehavior;
-exports.rebuildUiMessages = rebuildUiMessages;