@yushaw/sanqian-sdk 0.2.10 → 0.2.11

package/dist/index.browser.mjs

@@ -0,0 +1,1058 @@
+// src/client.browser.ts
+import WebSocket from "isomorphic-ws";
+
+// src/errors.ts
+var SANQIAN_WEBSITE = "https://sanqian.io";
+var SDKErrorCode = /* @__PURE__ */ ((SDKErrorCode2) => {
+  SDKErrorCode2["NOT_INSTALLED"] = "NOT_INSTALLED";
+  SDKErrorCode2["NOT_RUNNING"] = "NOT_RUNNING";
+  SDKErrorCode2["CONNECTION_TIMEOUT"] = "CONNECTION_TIMEOUT";
+  SDKErrorCode2["STARTUP_TIMEOUT"] = "STARTUP_TIMEOUT";
+  SDKErrorCode2["REGISTRATION_FAILED"] = "REGISTRATION_FAILED";
+  SDKErrorCode2["REQUEST_TIMEOUT"] = "REQUEST_TIMEOUT";
+  SDKErrorCode2["REQUEST_FAILED"] = "REQUEST_FAILED";
+  SDKErrorCode2["DISCONNECTED"] = "DISCONNECTED";
+  SDKErrorCode2["WEBSOCKET_ERROR"] = "WEBSOCKET_ERROR";
+  SDKErrorCode2["AGENT_NOT_FOUND"] = "AGENT_NOT_FOUND";
+  SDKErrorCode2["CONVERSATION_NOT_FOUND"] = "CONVERSATION_NOT_FOUND";
+  SDKErrorCode2["TOOL_NOT_FOUND"] = "TOOL_NOT_FOUND";
+  SDKErrorCode2["TOOL_EXECUTION_TIMEOUT"] = "TOOL_EXECUTION_TIMEOUT";
+  return SDKErrorCode2;
+})(SDKErrorCode || {});
+var ErrorMessages = {
+  ["NOT_INSTALLED" /* NOT_INSTALLED */]: {
+    en: `Sanqian is not installed on this computer.`,
+    zh: `Sanqian \u5C1A\u672A\u5B89\u88C5\u5728\u6B64\u7535\u8111\u4E0A\u3002`,
+    hint: {
+      en: `Please download and install Sanqian from ${SANQIAN_WEBSITE}`,
+      zh: `\u8BF7\u8BBF\u95EE ${SANQIAN_WEBSITE} \u4E0B\u8F7D\u5B89\u88C5 Sanqian`
+    }
+  },
+  ["NOT_RUNNING" /* NOT_RUNNING */]: {
+    en: `Sanqian is not running.`,
+    zh: `Sanqian \u672A\u5728\u8FD0\u884C\u3002`,
+    hint: {
+      en: `Please start Sanqian first, or enable autoLaunchSanqian option in SDK config.`,
+      zh: `\u8BF7\u5148\u542F\u52A8 Sanqian\uFF0C\u6216\u5728 SDK \u914D\u7F6E\u4E2D\u542F\u7528 autoLaunchSanqian \u9009\u9879\u3002`
+    }
+  },
+  ["CONNECTION_TIMEOUT" /* CONNECTION_TIMEOUT */]: {
+    en: `Failed to connect to Sanqian (connection timeout).`,
+    zh: `\u8FDE\u63A5 Sanqian \u5931\u8D25\uFF08\u8FDE\u63A5\u8D85\u65F6\uFF09\u3002`,
+    hint: {
+      en: `Please check if Sanqian is running properly. If the problem persists, try restarting Sanqian.`,
+      zh: `\u8BF7\u68C0\u67E5 Sanqian \u662F\u5426\u6B63\u5E38\u8FD0\u884C\u3002\u5982\u95EE\u9898\u6301\u7EED\uFF0C\u8BF7\u5C1D\u8BD5\u91CD\u542F Sanqian\u3002`
+    }
+  },
+  ["STARTUP_TIMEOUT" /* STARTUP_TIMEOUT */]: {
+    en: `Sanqian failed to start within 2 minutes.`,
+    zh: `Sanqian \u5728 2 \u5206\u949F\u5185\u672A\u80FD\u542F\u52A8\u3002`,
+    hint: {
+      en: `Please try starting Sanqian manually. If it fails to start, reinstall from ${SANQIAN_WEBSITE}`,
+      zh: `\u8BF7\u5C1D\u8BD5\u624B\u52A8\u542F\u52A8 Sanqian\u3002\u5982\u4ECD\u65E0\u6CD5\u542F\u52A8\uFF0C\u8BF7\u4ECE ${SANQIAN_WEBSITE} \u91CD\u65B0\u5B89\u88C5\u3002`
+    }
+  },
+  ["REGISTRATION_FAILED" /* REGISTRATION_FAILED */]: {
+    en: `Failed to register with Sanqian.`,
+    zh: `\u5411 Sanqian \u6CE8\u518C\u5931\u8D25\u3002`,
+    hint: {
+      en: `Please check your SDK configuration (appName, tools). If the problem persists, try restarting Sanqian.`,
+      zh: `\u8BF7\u68C0\u67E5 SDK \u914D\u7F6E\uFF08appName\u3001tools\uFF09\u3002\u5982\u95EE\u9898\u6301\u7EED\uFF0C\u8BF7\u5C1D\u8BD5\u91CD\u542F Sanqian\u3002`
+    }
+  },
+  ["REQUEST_TIMEOUT" /* REQUEST_TIMEOUT */]: {
+    en: `Request timed out.`,
+    zh: `\u8BF7\u6C42\u8D85\u65F6\u3002`,
+    hint: {
+      en: `The operation took too long. Please try again.`,
+      zh: `\u64CD\u4F5C\u8017\u65F6\u8FC7\u957F\uFF0C\u8BF7\u91CD\u8BD5\u3002`
+    }
+  },
+  ["REQUEST_FAILED" /* REQUEST_FAILED */]: {
+    en: `Request failed.`,
+    zh: `\u8BF7\u6C42\u5931\u8D25\u3002`,
+    hint: {
+      en: `Please check the error details and try again.`,
+      zh: `\u8BF7\u68C0\u67E5\u9519\u8BEF\u8BE6\u60C5\u540E\u91CD\u8BD5\u3002`
+    }
+  },
+  ["DISCONNECTED" /* DISCONNECTED */]: {
+    en: `Disconnected from Sanqian.`,
+    zh: `\u4E0E Sanqian \u7684\u8FDE\u63A5\u5DF2\u65AD\u5F00\u3002`,
+    hint: {
+      en: `The SDK will automatically reconnect. If problems persist, check if Sanqian is still running.`,
+      zh: `SDK \u4F1A\u81EA\u52A8\u91CD\u8FDE\u3002\u5982\u95EE\u9898\u6301\u7EED\uFF0C\u8BF7\u68C0\u67E5 Sanqian \u662F\u5426\u4ECD\u5728\u8FD0\u884C\u3002`
+    }
+  },
+  ["WEBSOCKET_ERROR" /* WEBSOCKET_ERROR */]: {
+    en: `WebSocket connection error.`,
+    zh: `WebSocket \u8FDE\u63A5\u9519\u8BEF\u3002`,
+    hint: {
+      en: `Please check your network and firewall settings. Sanqian uses local WebSocket on port shown in settings.`,
+      zh: `\u8BF7\u68C0\u67E5\u7F51\u7EDC\u548C\u9632\u706B\u5899\u8BBE\u7F6E\u3002Sanqian \u4F7F\u7528\u672C\u5730 WebSocket\uFF0C\u7AEF\u53E3\u53EF\u5728\u8BBE\u7F6E\u4E2D\u67E5\u770B\u3002`
+    }
+  },
+  ["AGENT_NOT_FOUND" /* AGENT_NOT_FOUND */]: {
+    en: `Agent not found.`,
+    zh: `\u627E\u4E0D\u5230\u8BE5 Agent\u3002`,
+    hint: {
+      en: `Please check the agent ID. Use listAgents() to see available agents.`,
+      zh: `\u8BF7\u68C0\u67E5 Agent ID\u3002\u4F7F\u7528 listAgents() \u67E5\u770B\u53EF\u7528\u7684 Agent\u3002`
+    }
+  },
+  ["CONVERSATION_NOT_FOUND" /* CONVERSATION_NOT_FOUND */]: {
+    en: `Conversation not found.`,
+    zh: `\u627E\u4E0D\u5230\u8BE5\u5BF9\u8BDD\u3002`,
+    hint: {
+      en: `The conversation may have been deleted. Start a new conversation with startConversation().`,
+      zh: `\u8BE5\u5BF9\u8BDD\u53EF\u80FD\u5DF2\u88AB\u5220\u9664\u3002\u4F7F\u7528 startConversation() \u5F00\u59CB\u65B0\u5BF9\u8BDD\u3002`
+    }
+  },
+  ["TOOL_NOT_FOUND" /* TOOL_NOT_FOUND */]: {
+    en: `Tool not found.`,
+    zh: `\u627E\u4E0D\u5230\u8BE5\u5DE5\u5177\u3002`,
+    hint: {
+      en: `Please check that the tool is registered in your SDK config.`,
+      zh: `\u8BF7\u68C0\u67E5\u8BE5\u5DE5\u5177\u662F\u5426\u5DF2\u5728 SDK \u914D\u7F6E\u4E2D\u6CE8\u518C\u3002`
+    }
+  },
+  ["TOOL_EXECUTION_TIMEOUT" /* TOOL_EXECUTION_TIMEOUT */]: {
+    en: `Tool execution timed out.`,
+    zh: `\u5DE5\u5177\u6267\u884C\u8D85\u65F6\u3002`,
+    hint: {
+      en: `The tool took too long to execute. Consider increasing toolExecutionTimeout in SDK config.`,
+      zh: `\u5DE5\u5177\u6267\u884C\u65F6\u95F4\u8FC7\u957F\u3002\u53EF\u5728 SDK \u914D\u7F6E\u4E2D\u589E\u52A0 toolExecutionTimeout\u3002`
+    }
+  }
+};
+var SanqianSDKError = class extends Error {
+  code;
+  messageZh;
+  hint;
+  hintZh;
+  constructor(code, details) {
+    const msg = ErrorMessages[code];
+    const fullMessage = details ? `${msg.en} ${details}` : msg.en;
+    super(fullMessage);
+    this.name = "SanqianSDKError";
+    this.code = code;
+    this.messageZh = details ? `${msg.zh} ${details}` : msg.zh;
+    this.hint = msg.hint?.en;
+    this.hintZh = msg.hint?.zh;
+  }
+  /**
+   * Get full error message with hint (English)
+   */
+  getFullMessage() {
+    return this.hint ? `${this.message}
+${this.hint}` : this.message;
+  }
+  /**
+   * Get full error message with hint (Chinese)
+   */
+  getFullMessageZh() {
+    return this.hintZh ? `${this.messageZh}
+${this.hintZh}` : this.messageZh;
+  }
+  /**
+   * Get bilingual error message
+   */
+  getBilingualMessage() {
+    return `${this.getFullMessage()}
+
+${this.getFullMessageZh()}`;
+  }
+};
+function createSDKError(code, details) {
+  return new SanqianSDKError(code, details);
+}
+
+// src/client.browser.ts
+var SanqianSDK = class _SanqianSDK {
+  config;
+  ws = null;
+  connectionInfo = null;
+  state = {
+    connected: false,
+    registering: false,
+    registered: false,
+    reconnectAttempts: 0
+  };
+  // Tool handlers by name
+  toolHandlers = /* @__PURE__ */ new Map();
+  // Pending request futures
+  pendingRequests = /* @__PURE__ */ new Map();
+  // Timers
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  heartbeatAckPending = false;
+  missedHeartbeats = 0;
+  static MAX_MISSED_HEARTBEATS = 2;
+  // Connection promise for deduplication
+  connectingPromise = null;
+  // Reconnect reference count
+  reconnectRefCount = 0;
+  // Event listeners
+  eventListeners = /* @__PURE__ */ new Map();
+  // ============================================
+  // Debug Logging
+  // ============================================
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SDK]", ...args);
+    }
+  }
+  warn(...args) {
+    if (this.config.debug) {
+      console.warn("[SDK]", ...args);
+    }
+  }
+  constructor(config) {
+    if (!config.connectionInfo) {
+      throw new SanqianSDKError(
+        "NOT_RUNNING" /* NOT_RUNNING */,
+        "Browser build requires connectionInfo in config. Use the Node.js build for auto-discovery, or provide connectionInfo manually."
+      );
+    }
+    this.config = {
+      reconnectInterval: 5e3,
+      heartbeatInterval: 3e4,
+      toolExecutionTimeout: 3e4,
+      debug: false,
+      autoLaunchSanqian: false,
+      // Not supported in browser
+      ...config
+    };
+    for (const tool of config.tools) {
+      this.toolHandlers.set(tool.name, tool.handler);
+    }
+  }
+  /**
+   * Build WebSocket URL from connection info
+   */
+  buildWebSocketUrl(info) {
+    const wsPath = info.ws_path || "/ws/apps";
+    return `ws://127.0.0.1:${info.port}${wsPath}?token=${info.token}`;
+  }
+  // ============================================
+  // Lifecycle
+  // ============================================
+  async connect() {
+    return this.ensureReady();
+  }
+  async connectWithInfo(info) {
+    this.connectionInfo = info;
+    const url = this.buildWebSocketUrl(info);
+    return new Promise((resolve, reject) => {
+      this.log(`Connecting to ${url}`);
+      this.ws = new WebSocket(url);
+      const connectTimeout = setTimeout(() => {
+        reject(createSDKError("CONNECTION_TIMEOUT" /* CONNECTION_TIMEOUT */));
+        this.ws?.close();
+      }, 1e4);
+      this.ws.onopen = async () => {
+        clearTimeout(connectTimeout);
+        this.log("WebSocket connected");
+        this.state.connected = true;
+        this.state.reconnectAttempts = 0;
+        this.emit("connected");
+        try {
+          await this.register();
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      };
+      this.ws.onclose = (event) => {
+        const reasonRaw = event.reason;
+        const reason = typeof reasonRaw === "string" ? reasonRaw : reasonRaw?.toString() || "";
+        this.log(`WebSocket closed: ${event.code} ${reason}`);
+        this.handleDisconnect(reason);
+      };
+      this.ws.onerror = (event) => {
+        const error = event.error || new Error("WebSocket error");
+        console.error("[SDK] WebSocket error:", error);
+        this.state.lastError = error;
+        this.emit("error", error);
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const data = typeof event.data === "string" ? event.data : event.data.toString();
+          const message = JSON.parse(data);
+          this.handleMessage(message);
+        } catch (e) {
+          this.warn("Failed to parse message:", e);
+        }
+      };
+    });
+  }
+  async disconnect() {
+    this.stopHeartbeat();
+    this.stopReconnect();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.state = {
+      connected: false,
+      registering: false,
+      registered: false,
+      reconnectAttempts: 0
+    };
+  }
+  // ============================================
+  // Registration
+  // ============================================
+  async register() {
+    this.state.registering = true;
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "register",
+      app: {
+        name: this.config.appName,
+        version: this.config.appVersion,
+        display_name: this.config.displayName,
+        launch_command: this.config.launchCommand
+      },
+      tools: this.config.tools.map((t) => ({
+        name: `${this.config.appName}:${t.name}`,
+        description: t.description,
+        parameters: t.parameters,
+        searchable: t.searchable ?? true
+      }))
+    };
+    try {
+      const response = await this.sendAndWait(
+        message,
+        msgId,
+        1e4
+      );
+      if (!response.success) {
+        throw createSDKError("REGISTRATION_FAILED" /* REGISTRATION_FAILED */, response.error);
+      }
+      this.state.registering = false;
+      this.state.registered = true;
+      this.startHeartbeat();
+      this.emit("registered");
+      this.log(`Registered as '${this.config.appName}'`);
+    } catch (e) {
+      this.state.registering = false;
+      throw e;
+    }
+  }
+  // ============================================
+  // Message Handling
+  // ============================================
+  handleMessage(message) {
+    const { id, type } = message;
+    if (id && this.pendingRequests.has(id)) {
+      const pending = this.pendingRequests.get(id);
+      this.pendingRequests.delete(id);
+      pending.resolve(message);
+      return;
+    }
+    switch (type) {
+      case "tool_call":
+        this.handleToolCall(message);
+        break;
+      case "heartbeat_ack":
+        this.heartbeatAckPending = false;
+        this.missedHeartbeats = 0;
+        break;
+      case "chat_stream":
+        this.handleChatStream(message);
+        break;
+      default:
+        this.warn(`Unknown message type: ${type}`);
+    }
+  }
+  handleChatStream(message) {
+    const {
+      id,
+      event,
+      content,
+      tool_call,
+      tool_result,
+      conversation_id,
+      title,
+      usage,
+      error
+    } = message;
+    if (!id) return;
+    const handler = this.streamHandlers.get(id);
+    if (!handler) {
+      this.warn(`No stream handler for message ${id}`);
+      return;
+    }
+    switch (event) {
+      case "text":
+        handler.onEvent({ type: "text", content });
+        break;
+      case "tool_call":
+        handler.onEvent({ type: "tool_call", tool_call });
+        break;
+      case "tool_result":
+        if (tool_result) {
+          handler.onEvent({
+            type: "tool_call",
+            tool_call: {
+              id: tool_result.call_id,
+              type: "function",
+              function: {
+                name: "tool_result",
+                arguments: JSON.stringify(tool_result)
+              }
+            }
+          });
+        }
+        break;
+      case "done":
+        handler.onDone({
+          message: message.message || { role: "assistant", content: "" },
+          conversationId: conversation_id || "",
+          title,
+          usage
+        });
+        break;
+      case "error":
+        handler.onError(new Error(error || "Unknown stream error"));
+        break;
+    }
+  }
+  async handleToolCall(message) {
+    this.log(`handleToolCall received:`, JSON.stringify(message));
+    const { id, call_id, name, arguments: args } = message;
+    const msgId = id || call_id;
+    const toolName = name.includes(":") ? name.split(":")[1] : name;
+    this.log(
+      `Looking for handler: '${toolName}', available handlers:`,
+      Array.from(this.toolHandlers.keys())
+    );
+    const handler = this.toolHandlers.get(toolName);
+    this.emit("tool_call", { name: toolName, arguments: args });
+    if (!handler) {
+      await this.sendToolResult(
+        msgId,
+        call_id,
+        false,
+        void 0,
+        `Tool '${toolName}' not found`
+      );
+      return;
+    }
+    try {
+      this.log(`Executing tool '${toolName}' with args:`, args);
+      const result = await Promise.race([
+        handler(args),
+        this.createTimeout(this.config.toolExecutionTimeout)
+      ]);
+      this.log(`Tool '${toolName}' completed successfully`);
+      await this.sendToolResult(msgId, call_id, true, result);
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      const errorStack = e instanceof Error ? e.stack : void 0;
+      this.log(`Tool '${toolName}' failed:`, errorMessage);
+      if (errorStack) {
+        this.log(`Tool error stack:`, errorStack);
+      }
+      await this.sendToolResult(msgId, call_id, false, void 0, errorMessage);
+    }
+  }
+  async sendToolResult(id, callId, success, result, error) {
+    const message = {
+      id,
+      type: "tool_result",
+      call_id: callId,
+      success,
+      result,
+      error
+    };
+    this.log(
+      `Sending tool_result for ${callId}:`,
+      success ? "success" : `error: ${error}`
+    );
+    this.send(message);
+  }
+  // ============================================
+  // Connection Management
+  // ============================================
+  handleDisconnect(reason) {
+    this.stopHeartbeat();
+    this.state.connected = false;
+    this.state.registered = false;
+    this.emit("disconnected", reason);
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(createSDKError("DISCONNECTED" /* DISCONNECTED */));
+    }
+    this.pendingRequests.clear();
+    if (reason === "Client disconnect") {
+      this.log("Client disconnected intentionally, skipping auto-reconnect");
+      return;
+    }
+    if (reason === "Replaced by new connection") {
+      this.log("Connection replaced by newer one, skipping auto-reconnect");
+      return;
+    }
+    if (this.connectingPromise) {
+      this.log(
+        "Connection attempt already in progress, skipping auto-reconnect"
+      );
+      return;
+    }
+    if (!this.shouldAutoReconnect()) {
+      this.log(
+        "No components require reconnection (refCount=0), skipping auto-reconnect"
+      );
+      return;
+    }
+    this.scheduleReconnect();
+  }
+  shouldAutoReconnect() {
+    return this.reconnectRefCount > 0;
+  }
+  acquireReconnect() {
+    this.reconnectRefCount++;
+    this.log(`acquireReconnect: refCount=${this.reconnectRefCount}`);
+  }
+  releaseReconnect() {
+    this.reconnectRefCount = Math.max(0, this.reconnectRefCount - 1);
+    this.log(`releaseReconnect: refCount=${this.reconnectRefCount}`);
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    const baseDelay = Math.min(
+      500 * Math.pow(2, this.state.reconnectAttempts),
+      5e3
+    );
+    const jitter = Math.random() * 500;
+    const delay = baseDelay + jitter;
+    this.log(
+      `Scheduling reconnect in ${Math.round(delay)}ms (attempt ${this.state.reconnectAttempts + 1})`
+    );
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      this.state.reconnectAttempts++;
+      try {
+        await this.ensureReady();
+      } catch (e) {
+        console.error("[SDK] Reconnect failed:", e);
+        if (!this.isConnected()) {
+          this.scheduleReconnect();
+        }
+      }
+    }, delay);
+  }
+  stopReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  // ============================================
+  // Heartbeat
+  // ============================================
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.missedHeartbeats = 0;
+    this.heartbeatAckPending = false;
+    this.heartbeatTimer = setInterval(() => {
+      if (this.heartbeatAckPending) {
+        this.missedHeartbeats++;
+        this.warn(
+          `Missed heartbeat ack (${this.missedHeartbeats}/${_SanqianSDK.MAX_MISSED_HEARTBEATS})`
+        );
+        if (this.missedHeartbeats >= _SanqianSDK.MAX_MISSED_HEARTBEATS) {
+          this.warn("Too many missed heartbeat acks, connection may be dead");
+          this.ws?.close(4e3, "Heartbeat timeout");
+          return;
+        }
+      }
+      const message = {
+        type: "heartbeat",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.heartbeatAckPending = true;
+      try {
+        this.send(message);
+      } catch (e) {
+        console.error("[SDK] Heartbeat send failed:", e);
+        this.ws?.close(4e3, "Heartbeat send failed");
+      }
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ============================================
+  // Communication
+  // ============================================
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      const error = new Error(
+        `WebSocket not open (state: ${this.ws?.readyState ?? "null"}), cannot send message`
+      );
+      console.error(`[SDK] ${error.message}:`, message);
+      throw error;
+    }
+    const data = JSON.stringify(message);
+    this.log(`WebSocket send:`, data.substring(0, 200));
+    this.ws.send(data);
+  }
+  sendAndWait(message, id, timeout) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(createSDKError("REQUEST_TIMEOUT" /* REQUEST_TIMEOUT */));
+      }, timeout);
+      this.pendingRequests.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+      try {
+        this.send(message);
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(id);
+        reject(e);
+      }
+    });
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  getState() {
+    return { ...this.state };
+  }
+  isConnected() {
+    return this.state.connected && this.state.registered;
+  }
+  async ensureReady() {
+    if (this.isConnected()) {
+      return;
+    }
+    if (this.connectingPromise) {
+      this.log("Connection already in progress, waiting...");
+      return this.connectingPromise;
+    }
+    this.connectingPromise = this.doFullConnect();
+    try {
+      await this.connectingPromise;
+    } finally {
+      this.connectingPromise = null;
+    }
+  }
+  async doFullConnect() {
+    this.log("Starting connection (browser mode)...");
+    const info = this.config.connectionInfo;
+    await this.connectWithInfo(info);
+  }
+  async updateTools(tools) {
+    this.toolHandlers.clear();
+    for (const tool of tools) {
+      this.toolHandlers.set(tool.name, tool.handler);
+    }
+    if (this.isConnected()) {
+      const msgId = this.generateId();
+      const message = {
+        id: msgId,
+        type: "tools_update",
+        tools: tools.map((t) => ({
+          name: `${this.config.appName}:${t.name}`,
+          description: t.description,
+          parameters: t.parameters,
+          searchable: t.searchable ?? true
+        }))
+      };
+      await this.sendAndWait(message, msgId, 5e3);
+    }
+  }
+  // ============================================
+  // Private Agent API
+  // ============================================
+  async createAgent(config) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "create_agent",
+      agent: config
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (!response.success) {
+      throw createSDKError("AGENT_NOT_FOUND" /* AGENT_NOT_FOUND */, response.error);
+    }
+    if (response.agent) {
+      return response.agent;
+    }
+    return {
+      agent_id: response.agent_id,
+      name: config.name,
+      description: config.description,
+      tools: config.tools || []
+    };
+  }
+  async listAgents() {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "list_agents"
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (response.error) {
+      throw new Error(response.error);
+    }
+    return response.agents;
+  }
+  async deleteAgent(agentId) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "delete_agent",
+      agent_id: agentId
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (!response.success) {
+      throw createSDKError("AGENT_NOT_FOUND" /* AGENT_NOT_FOUND */, response.error);
+    }
+  }
+  async updateAgent(agentId, updates) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "update_agent",
+      agent_id: agentId,
+      updates
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (!response.success || !response.agent) {
+      throw createSDKError("AGENT_NOT_FOUND" /* AGENT_NOT_FOUND */, response.error);
+    }
+    return response.agent;
+  }
+  // ============================================
+  // Conversation API
+  // ============================================
+  async listConversations(options) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "list_conversations",
+      agent_id: options?.agentId,
+      limit: options?.limit,
+      offset: options?.offset
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (response.error) {
+      throw new Error(response.error);
+    }
+    return {
+      conversations: response.conversations,
+      total: response.total
+    };
+  }
+  async getConversation(conversationId, options) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "get_conversation",
+      conversation_id: conversationId,
+      include_messages: options?.includeMessages ?? true,
+      message_limit: options?.messageLimit,
+      message_offset: options?.messageOffset
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (!response.success || !response.conversation) {
+      throw createSDKError("CONVERSATION_NOT_FOUND" /* CONVERSATION_NOT_FOUND */, response.error);
+    }
+    return response.conversation;
+  }
+  async deleteConversation(conversationId) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "delete_conversation",
+      conversation_id: conversationId
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      1e4
+    );
+    if (!response.success) {
+      throw createSDKError("CONVERSATION_NOT_FOUND" /* CONVERSATION_NOT_FOUND */, response.error);
+    }
+  }
+  // ============================================
+  // Chat API
+  // ============================================
+  streamHandlers = /* @__PURE__ */ new Map();
+  async chat(agentId, messages, options) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "chat",
+      agent_id: agentId,
+      messages,
+      conversation_id: options?.conversationId,
+      stream: false,
+      remote_tools: options?.remoteTools?.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }))
+    };
+    const response = await this.sendAndWait(
+      message,
+      msgId,
+      6e5
+    );
+    if (!response.success) {
+      const errorLower = (response.error || "").toLowerCase();
+      if (errorLower.includes("agent") && errorLower.includes("not found")) {
+        throw createSDKError("AGENT_NOT_FOUND" /* AGENT_NOT_FOUND */, response.error);
+      }
+      throw createSDKError("REQUEST_FAILED" /* REQUEST_FAILED */, response.error);
+    }
+    return {
+      message: response.message,
+      conversationId: response.conversation_id,
+      title: response.title,
+      usage: response.usage
+    };
+  }
+  async *chatStream(agentId, messages, options) {
+    await this.ensureReady();
+    const msgId = this.generateId();
+    const message = {
+      id: msgId,
+      type: "chat",
+      agent_id: agentId,
+      messages,
+      conversation_id: options?.conversationId,
+      stream: true,
+      remote_tools: options?.remoteTools?.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }))
+    };
+    const eventQueue = [];
+    let done = false;
+    let error = null;
+    let resolveNext = null;
+    this.streamHandlers.set(msgId, {
+      onEvent: (event) => {
+        eventQueue.push(event);
+        resolveNext?.();
+      },
+      onDone: (response) => {
+        eventQueue.push({
+          type: "done",
+          conversationId: response.conversationId,
+          title: response.title
+        });
+        done = true;
+        resolveNext?.();
+      },
+      onError: (e) => {
+        error = e;
+        resolveNext?.();
+      }
+    });
+    try {
+      this.send(message);
+      while (!done && !error) {
+        if (eventQueue.length > 0) {
+          yield eventQueue.shift();
+        } else {
+          await new Promise((resolve) => {
+            resolveNext = resolve;
+          });
+          resolveNext = null;
+        }
+      }
+      while (eventQueue.length > 0) {
+        yield eventQueue.shift();
+      }
+      if (error) {
+        throw error;
+      }
+    } finally {
+      this.streamHandlers.delete(msgId);
+    }
+  }
+  startConversation(agentId) {
+    return new Conversation(this, agentId);
+  }
+  // ============================================
+  // Events
+  // ============================================
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.eventListeners.get(event)?.delete(listener);
+    return this;
+  }
+  once(event, listener) {
+    const onceWrapper = ((...args) => {
+      this.off(event, onceWrapper);
+      listener(...args);
+    });
+    return this.on(event, onceWrapper);
+  }
+  /**
+   * Remove all event listeners
+   *
+   * Call this to prevent memory leaks when disposing the SDK instance.
+   * If event is specified, only removes listeners for that event.
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.eventListeners.delete(event);
+    } else {
+      this.eventListeners.clear();
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(...args);
+        } catch (e) {
+          console.error(`[SDK] Event listener error for '${event}':`, e);
+        }
+      }
+    }
+  }
+  // ============================================
+  // Utilities
+  // ============================================
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  createTimeout(ms) {
+    return new Promise((_, reject) => {
+      setTimeout(
+        () => reject(createSDKError("TOOL_EXECUTION_TIMEOUT" /* TOOL_EXECUTION_TIMEOUT */)),
+        ms
+      );
+    });
+  }
+};
+var Conversation = class {
+  sdk;
+  agentId;
+  _conversationId = null;
+  constructor(sdk, agentId, conversationId) {
+    this.sdk = sdk;
+    this.agentId = agentId;
+    this._conversationId = conversationId || null;
+  }
+  get id() {
+    return this._conversationId;
+  }
+  async send(content, options) {
+    const response = await this.sdk.chat(
+      this.agentId,
+      [{ role: "user", content }],
+      {
+        conversationId: this._conversationId || void 0,
+        remoteTools: options?.remoteTools
+      }
+    );
+    if (response.conversationId && !this._conversationId) {
+      this._conversationId = response.conversationId;
+    }
+    return response;
+  }
+  async *sendStream(content, options) {
+    const stream = this.sdk.chatStream(
+      this.agentId,
+      [{ role: "user", content }],
+      {
+        conversationId: this._conversationId || void 0,
+        remoteTools: options?.remoteTools
+      }
+    );
+    for await (const event of stream) {
+      if (event.type === "done" && event.conversationId && !this._conversationId) {
+        this._conversationId = event.conversationId;
+      }
+      yield event;
+    }
+  }
+  async delete() {
+    if (!this._conversationId) {
+      throw new Error("No conversation to delete");
+    }
+    await this.sdk.deleteConversation(this._conversationId);
+    this._conversationId = null;
+  }
+  async getDetails(options) {
+    if (!this._conversationId) {
+      throw new Error("No conversation to get details for");
+    }
+    return this.sdk.getConversation(this._conversationId, {
+      includeMessages: true,
+      messageLimit: options?.messageLimit
+    });
+  }
+};
+export {
+  Conversation,
+  ErrorMessages,
+  SANQIAN_WEBSITE,
+  SDKErrorCode,
+  SanqianSDK,
+  SanqianSDKError,
+  createSDKError
+};
+//# sourceMappingURL=index.browser.mjs.map