@yushaw/sanqian-chat 0.1.1 → 0.2.0

package/dist/main/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,51 +17,260 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/main/index.ts
 var main_exports = {};
 __export(main_exports, {
-  FloatingWindow: () => FloatingWindow
+  FloatingWindow: () => FloatingWindow,
+  SanqianAppClient: () => SanqianAppClient
 });
 module.exports = __toCommonJS(main_exports);
 
+// src/main/client.ts
+var import_sanqian_sdk = require("@yushaw/sanqian-sdk");
+var SanqianAppClient = class {
+  constructor(config) {
+    const tools = (config.tools || []).map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+      handler: t.handler
+    }));
+    const sdkConfig = {
+      appName: config.appName,
+      appVersion: config.appVersion,
+      displayName: config.displayName,
+      launchCommand: config.launchCommand,
+      debug: config.debug,
+      tools
+    };
+    this.sdk = new import_sanqian_sdk.SanqianSDK(sdkConfig);
+  }
+  // ============================================================
+  // Connection Management
+  // ============================================================
+  /**
+   * Connect to Sanqian and register this application
+   */
+  async connect() {
+    await this.sdk.connect();
+  }
+  /**
+   * Disconnect from Sanqian
+   */
+  async disconnect() {
+    await this.sdk.disconnect();
+  }
+  /**
+   * Check if connected to Sanqian
+   */
+  isConnected() {
+    return this.sdk.isConnected();
+  }
+  /**
+   * Ensure SDK is ready (connects if needed, waits for registration)
+   */
+  async ensureReady() {
+    await this.sdk.ensureReady();
+  }
+  // ============================================================
+  // Reconnection Control (for Chat UI)
+  // ============================================================
+  /**
+   * Request persistent connection (enables auto-reconnect)
+   * Call when a component needs the connection to stay alive
+   */
+  acquireReconnect() {
+    this.sdk.acquireReconnect();
+  }
+  /**
+   * Release persistent connection request
+   * Call when a component no longer needs the connection
+   */
+  releaseReconnect() {
+    this.sdk.releaseReconnect();
+  }
+  // ============================================================
+  // Agent Management
+  // ============================================================
+  /**
+   * Create or update a private agent
+   * @returns The full agent ID (app_name:agent_id)
+   */
+  async createAgent(config) {
+    const sdkConfig = {
+      agent_id: config.agentId,
+      name: config.name,
+      description: config.description,
+      system_prompt: config.systemPrompt,
+      tools: config.tools
+    };
+    const result = await this.sdk.createAgent(sdkConfig);
+    return { agentId: result.agent_id };
+  }
+  // ============================================================
+  // Embedding
+  // ============================================================
+  /**
+   * Get embedding configuration from Sanqian
+   * @returns Embedding config or null if not available
+   */
+  async getEmbeddingConfig() {
+    try {
+      const config = await this.sdk.getEmbeddingConfig();
+      return {
+        available: config.available,
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        modelName: config.modelName,
+        dimensions: config.dimensions
+      };
+    } catch {
+      return null;
+    }
+  }
+  // ============================================================
+  // Events
+  // ============================================================
+  /**
+   * Subscribe to client events
+   */
+  on(event, handler) {
+    this.sdk.on(event, handler);
+    return this;
+  }
+  /**
+   * Remove all event listeners
+   */
+  removeAllListeners() {
+    this.sdk.removeAllListeners();
+  }
+  // ============================================================
+  // Chat API
+  // ============================================================
+  /**
+   * Stream chat messages
+   */
+  chatStream(agentId, messages, options) {
+    return this.sdk.chatStream(agentId, messages, options);
+  }
+  /**
+   * Send HITL (Human-in-the-Loop) response
+   */
+  sendHitlResponse(runId, response) {
+    this.sdk.sendHitlResponse(runId, response);
+  }
+  // ============================================================
+  // Conversation Management
+  // ============================================================
+  /**
+   * List conversations for an agent
+   */
+  async listConversations(options) {
+    return this.sdk.listConversations(options);
+  }
+  /**
+   * Get conversation details
+   */
+  async getConversation(conversationId, options) {
+    return this.sdk.getConversation(conversationId, options);
+  }
+  /**
+   * Delete a conversation
+   */
+  async deleteConversation(conversationId) {
+    return this.sdk.deleteConversation(conversationId);
+  }
+  // ============================================================
+  // Internal Access (for FloatingWindow and other internal components)
+  // ============================================================
+  /**
+   * Get the underlying SDK instance
+   * @internal This is for internal use by other sanqian-chat components
+   */
+  _getSdk() {
+    return this.sdk;
+  }
+};
+
 // src/main/FloatingWindow.ts
 var import_electron = require("electron");
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
 var ipcHandlersRegistered = false;
 var activeInstance = null;
-var FloatingWindow = class {
+var setActiveInstance = (instance) => {
+  activeInstance = instance;
+};
+var FloatingWindow = class _FloatingWindow {
   constructor(options) {
     this.window = null;
-    this.savedPosition = null;
+    this.savedState = null;
+    this.stateSaveTimer = null;
     this.activeStreams = /* @__PURE__ */ new Map();
+    this.reconnectAcquired = false;
     if (activeInstance) {
       console.warn("[FloatingWindow] Only one instance supported. Destroying previous.");
       activeInstance.destroy();
     }
-    activeInstance = this;
+    setActiveInstance(this);
     this.options = {
       width: 400,
       height: 500,
       alwaysOnTop: true,
       showInTaskbar: false,
-      position: "center",
+      // position 默认不设置，让 rememberWindowState 优先读取已保存状态
+      // 若无保存状态则 fallback 到居中
+      rememberWindowState: true,
       ...options
     };
+    this.loadWindowState();
     this.setupIpcHandlers();
     if (this.options.shortcut) {
       import_electron.app.whenReady().then(() => this.registerShortcut());
     }
   }
+  /**
+   * Get SDK instance from either getClient or getSdk
+   */
+  static getSdkFromOptions(options) {
+    if (options.getClient) {
+      const client = options.getClient();
+      return client?._getSdk() ?? null;
+    }
+    if (options.getSdk) {
+      return options.getSdk();
+    }
+    return null;
+  }
   createWindow() {
-    const { width, height, alwaysOnTop, showInTaskbar, preloadPath } = this.options;
+    const { alwaysOnTop, showInTaskbar, preloadPath } = this.options;
+    const initialBounds = this.getInitialBounds();
+    const { minWidth, minHeight } = this.getMinSize();
     const win = new import_electron.BrowserWindow({
-      width,
-      height,
+      width: initialBounds.width,
+      height: initialBounds.height,
+      x: initialBounds.x,
+      y: initialBounds.y,
       show: false,
       frame: false,
       transparent: true,
+      hasShadow: false,
+      // Disable system shadow to avoid white border on macOS
       resizable: true,
+      backgroundColor: "#00000000",
+      minWidth,
+      minHeight,
       alwaysOnTop,
       skipTaskbar: !showInTaskbar,
       webPreferences: {
@@ -75,19 +286,37 @@ var FloatingWindow = class {
     }
     win.on("blur", () => {
     });
+    win.on("move", () => {
+      this.scheduleSaveWindowState();
+    });
+    win.on("resize", () => {
+      this.scheduleSaveWindowState();
+    });
+    win.on("close", () => {
+      this.saveWindowState();
+    });
     win.on("closed", () => {
       this.window = null;
     });
     return win;
   }
-  getInitialPosition() {
-    const { position, width = 400, height = 500 } = this.options;
+  getInitialBounds() {
+    const { width = 400, height = 500 } = this.options;
+    const { minWidth, minHeight } = this.getMinSize();
+    const resolvedWidth = Math.max(width, minWidth);
+    const resolvedHeight = Math.max(height, minHeight);
+    const savedBounds = this.shouldUseSavedState() ? this.getSavedBounds() : null;
+    if (savedBounds) {
+      return savedBounds;
+    }
+    const pos = this.getInitialPosition(resolvedWidth, resolvedHeight);
+    return { ...pos, width: resolvedWidth, height: resolvedHeight };
+  }
+  getInitialPosition(width, height) {
+    const { position } = this.options;
     if (typeof position === "object" && "x" in position) {
       return position;
     }
-    if (position === "remember" && this.savedPosition) {
-      return this.savedPosition;
-    }
     if (position === "cursor") {
       const cursorPos = import_electron.screen.getCursorScreenPoint();
       const display = import_electron.screen.getDisplayNearestPoint(cursorPos);
@@ -96,10 +325,118 @@ var FloatingWindow = class {
       return { x, y };
     }
     const primaryDisplay = import_electron.screen.getPrimaryDisplay();
-    const { width: screenWidth, height: screenHeight } = primaryDisplay.workAreaSize;
+    const workArea = primaryDisplay.workArea;
+    return {
+      x: workArea.x + Math.round((workArea.width - width) / 2),
+      y: workArea.y + Math.round((workArea.height - height) / 2)
+    };
+  }
+  shouldPersistWindowState() {
+    return Boolean(this.options.rememberWindowState || this.options.position === "remember");
+  }
+  shouldUseSavedState() {
+    const { position } = this.options;
+    if (position && position !== "remember") return false;
+    return this.shouldPersistWindowState();
+  }
+  getMinSize() {
+    return {
+      minWidth: this.options.minWidth ?? 320,
+      minHeight: this.options.minHeight ?? 420
+    };
+  }
+  getWindowStatePath() {
+    if (!this.shouldPersistWindowState()) return null;
+    if (this.options.windowStatePath) return this.options.windowStatePath;
+    const stateDir = import_path.default.join(import_os.default.homedir(), ".sanqian-chat");
+    const key = this.options.windowStateKey || import_electron.app.getName() || "sanqian-chat";
+    const safeKey = key.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return import_path.default.join(stateDir, `${safeKey}-window.json`);
+  }
+  getResolvedUiConfig() {
+    const uiConfig = this.options.uiConfig ?? {};
+    const resolved = { ...uiConfig };
+    if (!resolved.theme && this.options.theme) {
+      resolved.theme = this.options.theme === "system" ? "auto" : this.options.theme;
+    }
+    if (typeof resolved.alwaysOnTop !== "boolean" && typeof this.options.alwaysOnTop === "boolean") {
+      resolved.alwaysOnTop = this.options.alwaysOnTop;
+    }
+    if (Object.keys(resolved).length === 0) {
+      return null;
+    }
+    return resolved;
+  }
+  loadWindowState() {
+    const statePath = this.getWindowStatePath();
+    if (!statePath) return;
+    try {
+      const raw = import_fs.default.readFileSync(statePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.displayId === "number" && parsed.bounds && parsed.percent && typeof parsed.percent.x === "number" && typeof parsed.percent.y === "number" && typeof parsed.percent.width === "number" && typeof parsed.percent.height === "number") {
+        this.savedState = parsed;
+      }
+    } catch {
+    }
+  }
+  scheduleSaveWindowState() {
+    if (!this.shouldPersistWindowState()) return;
+    if (this.stateSaveTimer) clearTimeout(this.stateSaveTimer);
+    this.stateSaveTimer = setTimeout(() => {
+      this.stateSaveTimer = null;
+      this.saveWindowState();
+    }, 200);
+  }
+  saveWindowState() {
+    if (!this.window || !this.shouldPersistWindowState()) return;
+    const statePath = this.getWindowStatePath();
+    if (!statePath) return;
+    try {
+      const bounds = this.window.getBounds();
+      const display = import_electron.screen.getDisplayMatching(bounds);
+      const percent = this.getPercentFromBounds(bounds, display);
+      const state = {
+        displayId: display.id,
+        bounds: { ...bounds },
+        percent,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      import_fs.default.mkdirSync(import_path.default.dirname(statePath), { recursive: true });
+      import_fs.default.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf8");
+      this.savedState = state;
+    } catch (e) {
+      console.warn("[FloatingWindow] Failed to save window state:", e);
+    }
+  }
+  getPercentFromBounds(bounds, display) {
+    const workArea = display.workArea;
+    const clamp = (value) => Math.min(1, Math.max(0, value));
+    return {
+      x: clamp((bounds.x - workArea.x) / workArea.width),
+      y: clamp((bounds.y - workArea.y) / workArea.height),
+      width: clamp(bounds.width / workArea.width),
+      height: clamp(bounds.height / workArea.height)
+    };
+  }
+  getSavedBounds() {
+    if (!this.shouldPersistWindowState() || !this.savedState) return null;
+    const displays = import_electron.screen.getAllDisplays();
+    const display = displays.find((d) => d.id === this.savedState?.displayId) ?? import_electron.screen.getPrimaryDisplay();
+    const workArea = display.workArea;
+    const { minWidth, minHeight } = this.getMinSize();
+    const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+    const percent = this.savedState.percent;
+    const width = clamp(Math.round(percent.width * workArea.width), minWidth, workArea.width);
+    const height = clamp(Math.round(percent.height * workArea.height), minHeight, workArea.height);
+    const x = Math.round(workArea.x + percent.x * workArea.width);
+    const y = Math.round(workArea.y + percent.y * workArea.height);
+    const maxX = workArea.x + workArea.width - width;
+    const maxY = workArea.y + workArea.height - height;
     return {
-      x: Math.round((screenWidth - width) / 2),
-      y: Math.round((screenHeight - height) / 2)
+      x: clamp(x, workArea.x, maxX),
+      y: clamp(y, workArea.y, maxY),
+      width,
+      height
     };
   }
   registerShortcut() {
@@ -119,7 +456,7 @@ var FloatingWindow = class {
     ipcHandlersRegistered = true;
     import_electron.ipcMain.handle("sanqian-chat:connect", async () => {
       try {
-        const sdk = activeInstance?.options.getSdk();
+        const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
         if (!sdk) throw new Error("SDK not available");
         await sdk.ensureReady();
         return { success: true };
@@ -128,27 +465,42 @@ var FloatingWindow = class {
       }
     });
     import_electron.ipcMain.handle("sanqian-chat:isConnected", () => {
-      const sdk = activeInstance?.options.getSdk();
+      const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
       return sdk?.isConnected() ?? false;
     });
     import_electron.ipcMain.handle("sanqian-chat:stream", async (event, params) => {
       const webContents = event.sender;
-      const { streamId, messages, conversationId } = params;
-      const sdk = activeInstance?.options.getSdk();
-      const agentId = activeInstance?.options.getAgentId();
+      const { streamId, messages, conversationId, agentId: requestedAgentId } = params;
+      const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
+      const agentId = requestedAgentId ?? activeInstance?.options.getAgentId();
       if (!sdk || !agentId) {
         webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: "SDK or agent not ready" } });
         return;
       }
-      const streamState = { cancelled: false };
+      const streamState = { cancelled: false, runId: null };
       activeInstance?.activeStreams.set(streamId, streamState);
       try {
         await sdk.ensureReady();
         const sdkMessages = messages.map((m) => ({ role: m.role, content: m.content }));
-        const stream = sdk.chatStream(agentId, sdkMessages, { conversationId });
+        const stream = sdk.chatStream(
+          agentId,
+          sdkMessages,
+          { conversationId, persistHistory: true }
+        );
         for await (const evt of stream) {
           if (streamState.cancelled) break;
+          if (activeInstance?.options.devMode) {
+            console.log("[FloatingWindow] SDK event:", evt.type, JSON.stringify(evt).slice(0, 200));
+          }
           switch (evt.type) {
+            case "start": {
+              const startEvt = evt;
+              if (startEvt.run_id) {
+                streamState.runId = startEvt.run_id;
+              }
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "start", run_id: startEvt.run_id } });
+              break;
+            }
             case "text":
               webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "text", content: evt.content } });
               break;
@@ -167,12 +519,13 @@ var FloatingWindow = class {
             case "error":
               webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: evt.error } });
               break;
-            default:
+            default: {
               const anyEvt = evt;
               if (anyEvt.type === "interrupt") {
                 webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "interrupt", interrupt_type: anyEvt.interrupt_type, interrupt_payload: anyEvt.interrupt_payload, run_id: anyEvt.run_id } });
               }
               break;
+            }
           }
         }
       } catch (e) {
@@ -187,40 +540,64 @@ var FloatingWindow = class {
       const stream = activeInstance?.activeStreams.get(params.streamId);
       if (stream) {
         stream.cancelled = true;
+        if (stream.runId) {
+          const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
+          if (sdk) {
+            try {
+              sdk.cancelRun(stream.runId);
+            } catch (e) {
+              console.warn("[FloatingWindow] Failed to cancel run:", e);
+            }
+          }
+        }
         activeInstance?.activeStreams.delete(params.streamId);
       }
       return { success: true };
     });
     import_electron.ipcMain.handle("sanqian-chat:hitlResponse", (_, params) => {
-      const sdk = activeInstance?.options.getSdk();
+      const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
       if (sdk && params.runId) {
         sdk.sendHitlResponse(params.runId, params.response);
       }
       return { success: true };
     });
     import_electron.ipcMain.handle("sanqian-chat:listConversations", async (_, params) => {
-      const sdk = activeInstance?.options.getSdk();
-      const agentId = activeInstance?.options.getAgentId();
-      if (!sdk || !agentId) return { success: false, error: "SDK not ready" };
+      const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
+      if (!sdk) return { success: false, error: "SDK not ready" };
       try {
-        const result = await sdk.listConversations({ agentId, ...params });
+        const result = await sdk.listConversations({
+          limit: params?.limit,
+          offset: params?.offset
+        });
         return { success: true, data: result };
       } catch (e) {
         return { success: false, error: e instanceof Error ? e.message : "Failed to list" };
       }
     });
     import_electron.ipcMain.handle("sanqian-chat:getConversation", async (_, params) => {
-      const sdk = activeInstance?.options.getSdk();
+      const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
       if (!sdk) return { success: false, error: "SDK not ready" };
       try {
         const result = await sdk.getConversation(params.conversationId, { messageLimit: params.messageLimit });
-        return { success: true, data: result };
+        let messages = result?.messages;
+        const sdkWithHistory = sdk;
+        if (typeof sdkWithHistory.getMessages === "function") {
+          try {
+            const history = await sdkWithHistory.getMessages(params.conversationId, { limit: params.messageLimit });
+            if (history?.messages && history.messages.length > 0) {
+              messages = history.messages;
+            }
+          } catch (e) {
+            console.warn("[sanqian-chat][main] getMessages failed, fallback to getConversation:", e);
+          }
+        }
+        return { success: true, data: { ...result, messages } };
       } catch (e) {
         return { success: false, error: e instanceof Error ? e.message : "Failed to get" };
       }
     });
     import_electron.ipcMain.handle("sanqian-chat:deleteConversation", async (_, params) => {
-      const sdk = activeInstance?.options.getSdk();
+      const sdk = activeInstance ? _FloatingWindow.getSdkFromOptions(activeInstance.options) : null;
       if (!sdk) return { success: false, error: "SDK not ready" };
       try {
         await sdk.deleteConversation(params.conversationId);
@@ -233,26 +610,63 @@ var FloatingWindow = class {
       activeInstance?.hide();
       return { success: true };
     });
+    import_electron.ipcMain.handle("sanqian-chat:setAlwaysOnTop", (_event, params) => {
+      if (!activeInstance) return { success: false, error: "Window not available" };
+      activeInstance.setAlwaysOnTop(params.alwaysOnTop);
+      return { success: true };
+    });
+    import_electron.ipcMain.handle("sanqian-chat:getAlwaysOnTop", () => {
+      if (!activeInstance) return { success: false, error: "Window not available" };
+      return { success: true, data: activeInstance.isAlwaysOnTop() };
+    });
+    import_electron.ipcMain.handle("sanqian-chat:getUiConfig", () => {
+      if (!activeInstance) return { success: false, error: "Window not available" };
+      return { success: true, data: activeInstance.getResolvedUiConfig() };
+    });
   }
   // Public API
   show() {
     if (!this.window) {
       this.window = this.createWindow();
     }
-    const pos = this.getInitialPosition();
-    this.window.setPosition(pos.x, pos.y);
+    if (this.shouldPersistWindowState()) {
+      const bounds = this.getInitialBounds();
+      this.window.setBounds(bounds);
+    } else {
+      const pos = this.getInitialPosition(this.options.width ?? 400, this.options.height ?? 500);
+      this.window.setPosition(pos.x, pos.y);
+    }
     this.window.show();
     this.window.focus();
+    if (!this.reconnectAcquired) {
+      const sdk = _FloatingWindow.getSdkFromOptions(this.options);
+      sdk?.acquireReconnect();
+      this.reconnectAcquired = true;
+    }
   }
   hide() {
     if (this.window) {
-      if (this.options.position === "remember") {
-        const [x, y] = this.window.getPosition();
-        this.savedPosition = { x, y };
-      }
+      this.saveWindowState();
       this.window.hide();
+      if (this.reconnectAcquired) {
+        const sdk = _FloatingWindow.getSdkFromOptions(this.options);
+        sdk?.releaseReconnect();
+        this.reconnectAcquired = false;
+      }
+    }
+  }
+  setAlwaysOnTop(alwaysOnTop) {
+    this.options.alwaysOnTop = alwaysOnTop;
+    if (this.window) {
+      this.window.setAlwaysOnTop(alwaysOnTop);
     }
   }
+  isAlwaysOnTop() {
+    if (this.window) {
+      return this.window.isAlwaysOnTop();
+    }
+    return Boolean(this.options.alwaysOnTop);
+  }
   toggle() {
     if (this.window?.isVisible()) {
       this.hide();
@@ -267,6 +681,15 @@ var FloatingWindow = class {
     if (this.options.shortcut) {
       import_electron.globalShortcut.unregister(this.options.shortcut);
     }
+    if (this.stateSaveTimer) {
+      clearTimeout(this.stateSaveTimer);
+      this.stateSaveTimer = null;
+    }
+    if (this.reconnectAcquired) {
+      const sdk = _FloatingWindow.getSdkFromOptions(this.options);
+      sdk?.releaseReconnect();
+      this.reconnectAcquired = false;
+    }
     this.window?.destroy();
     this.window = null;
     this.activeStreams.forEach((stream) => {
@@ -285,6 +708,9 @@ var FloatingWindow = class {
         import_electron.ipcMain.removeHandler("sanqian-chat:getConversation");
         import_electron.ipcMain.removeHandler("sanqian-chat:deleteConversation");
         import_electron.ipcMain.removeHandler("sanqian-chat:hide");
+        import_electron.ipcMain.removeHandler("sanqian-chat:setAlwaysOnTop");
+        import_electron.ipcMain.removeHandler("sanqian-chat:getAlwaysOnTop");
+        import_electron.ipcMain.removeHandler("sanqian-chat:getUiConfig");
         ipcHandlersRegistered = false;
       }
     }
@@ -295,5 +721,6 @@ var FloatingWindow = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FloatingWindow
+  FloatingWindow,
+  SanqianAppClient
 });