@yushaw/sanqian-chat 0.1.1

package/dist/main/index.d.ts

@@ -0,0 +1,58 @@
+import { BrowserWindow } from 'electron';
+import { SanqianSDK } from '@yushaw/sanqian-sdk';
+
+/**
+ * @yushaw/sanqian-chat Core Types
+ *
+ * Re-exports SDK types + chat-specific types
+ */
+
+type WindowPosition = 'center' | 'cursor' | 'remember' | {
+    x: number;
+    y: number;
+};
+interface FloatingWindowConfig {
+    shortcut?: string;
+    position?: WindowPosition;
+    width?: number;
+    height?: number;
+    alwaysOnTop?: boolean;
+    showInTaskbar?: boolean;
+    theme?: 'light' | 'dark' | 'system';
+}
+
+/**
+ * FloatingWindow - Main process module for floating chat window
+ */
+
+interface FloatingWindowOptions extends FloatingWindowConfig {
+    /** SDK instance getter */
+    getSdk: () => SanqianSDK | null;
+    /** Agent ID getter */
+    getAgentId: () => string | null;
+    /** Path to preload script */
+    preloadPath: string;
+    /** Path to renderer HTML or URL */
+    rendererPath: string;
+    /** Dev mode - load from URL instead of file */
+    devMode?: boolean;
+}
+declare class FloatingWindow {
+    private window;
+    private options;
+    private savedPosition;
+    private activeStreams;
+    constructor(options: FloatingWindowOptions);
+    private createWindow;
+    private getInitialPosition;
+    private registerShortcut;
+    private setupIpcHandlers;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    isVisible(): boolean;
+    destroy(): void;
+    getWindow(): BrowserWindow | null;
+}
+
+export { FloatingWindow, type FloatingWindowConfig, type FloatingWindowOptions, type WindowPosition };

package/dist/main/index.js

@@ -0,0 +1,299 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main/index.ts
+var main_exports = {};
+__export(main_exports, {
+  FloatingWindow: () => FloatingWindow
+});
+module.exports = __toCommonJS(main_exports);
+
+// src/main/FloatingWindow.ts
+var import_electron = require("electron");
+var ipcHandlersRegistered = false;
+var activeInstance = null;
+var FloatingWindow = class {
+  constructor(options) {
+    this.window = null;
+    this.savedPosition = null;
+    this.activeStreams = /* @__PURE__ */ new Map();
+    if (activeInstance) {
+      console.warn("[FloatingWindow] Only one instance supported. Destroying previous.");
+      activeInstance.destroy();
+    }
+    activeInstance = this;
+    this.options = {
+      width: 400,
+      height: 500,
+      alwaysOnTop: true,
+      showInTaskbar: false,
+      position: "center",
+      ...options
+    };
+    this.setupIpcHandlers();
+    if (this.options.shortcut) {
+      import_electron.app.whenReady().then(() => this.registerShortcut());
+    }
+  }
+  createWindow() {
+    const { width, height, alwaysOnTop, showInTaskbar, preloadPath } = this.options;
+    const win = new import_electron.BrowserWindow({
+      width,
+      height,
+      show: false,
+      frame: false,
+      transparent: true,
+      resizable: true,
+      alwaysOnTop,
+      skipTaskbar: !showInTaskbar,
+      webPreferences: {
+        preload: preloadPath,
+        contextIsolation: true,
+        nodeIntegration: false
+      }
+    });
+    if (this.options.devMode) {
+      win.loadURL(this.options.rendererPath);
+    } else {
+      win.loadFile(this.options.rendererPath);
+    }
+    win.on("blur", () => {
+    });
+    win.on("closed", () => {
+      this.window = null;
+    });
+    return win;
+  }
+  getInitialPosition() {
+    const { position, width = 400, height = 500 } = 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);
+      const x = Math.min(cursorPos.x, display.bounds.x + display.bounds.width - width);
+      const y = Math.min(cursorPos.y, display.bounds.y + display.bounds.height - height);
+      return { x, y };
+    }
+    const primaryDisplay = import_electron.screen.getPrimaryDisplay();
+    const { width: screenWidth, height: screenHeight } = primaryDisplay.workAreaSize;
+    return {
+      x: Math.round((screenWidth - width) / 2),
+      y: Math.round((screenHeight - height) / 2)
+    };
+  }
+  registerShortcut() {
+    const { shortcut } = this.options;
+    if (!shortcut) return;
+    try {
+      const success = import_electron.globalShortcut.register(shortcut, () => this.toggle());
+      if (!success) {
+        console.warn(`[FloatingWindow] Failed to register shortcut: ${shortcut}`);
+      }
+    } catch (e) {
+      console.error(`[FloatingWindow] Shortcut registration error:`, e);
+    }
+  }
+  setupIpcHandlers() {
+    if (ipcHandlersRegistered) return;
+    ipcHandlersRegistered = true;
+    import_electron.ipcMain.handle("sanqian-chat:connect", async () => {
+      try {
+        const sdk = activeInstance?.options.getSdk();
+        if (!sdk) throw new Error("SDK not available");
+        await sdk.ensureReady();
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Connection failed" };
+      }
+    });
+    import_electron.ipcMain.handle("sanqian-chat:isConnected", () => {
+      const sdk = activeInstance?.options.getSdk();
+      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();
+      if (!sdk || !agentId) {
+        webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: "SDK or agent not ready" } });
+        return;
+      }
+      const streamState = { cancelled: false };
+      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 });
+        for await (const evt of stream) {
+          if (streamState.cancelled) break;
+          switch (evt.type) {
+            case "text":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "text", content: evt.content } });
+              break;
+            case "thinking":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "thinking", content: evt.content } });
+              break;
+            case "tool_call":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "tool_call", tool_call: evt.tool_call } });
+              break;
+            case "tool_result":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "tool_result", tool_call_id: evt.tool_call_id, result: evt.result } });
+              break;
+            case "done":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "done", conversationId: evt.conversationId, title: evt.title } });
+              break;
+            case "error":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: evt.error } });
+              break;
+            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) {
+        if (!streamState.cancelled) {
+          webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: e instanceof Error ? e.message : "Stream error" } });
+        }
+      } finally {
+        activeInstance?.activeStreams.delete(streamId);
+      }
+    });
+    import_electron.ipcMain.handle("sanqian-chat:cancelStream", (_, params) => {
+      const stream = activeInstance?.activeStreams.get(params.streamId);
+      if (stream) {
+        stream.cancelled = true;
+        activeInstance?.activeStreams.delete(params.streamId);
+      }
+      return { success: true };
+    });
+    import_electron.ipcMain.handle("sanqian-chat:hitlResponse", (_, params) => {
+      const sdk = activeInstance?.options.getSdk();
+      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" };
+      try {
+        const result = await sdk.listConversations({ agentId, ...params });
+        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();
+      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 };
+      } 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();
+      if (!sdk) return { success: false, error: "SDK not ready" };
+      try {
+        await sdk.deleteConversation(params.conversationId);
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to delete" };
+      }
+    });
+    import_electron.ipcMain.handle("sanqian-chat:hide", () => {
+      activeInstance?.hide();
+      return { success: true };
+    });
+  }
+  // Public API
+  show() {
+    if (!this.window) {
+      this.window = this.createWindow();
+    }
+    const pos = this.getInitialPosition();
+    this.window.setPosition(pos.x, pos.y);
+    this.window.show();
+    this.window.focus();
+  }
+  hide() {
+    if (this.window) {
+      if (this.options.position === "remember") {
+        const [x, y] = this.window.getPosition();
+        this.savedPosition = { x, y };
+      }
+      this.window.hide();
+    }
+  }
+  toggle() {
+    if (this.window?.isVisible()) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  isVisible() {
+    return this.window?.isVisible() ?? false;
+  }
+  destroy() {
+    if (this.options.shortcut) {
+      import_electron.globalShortcut.unregister(this.options.shortcut);
+    }
+    this.window?.destroy();
+    this.window = null;
+    this.activeStreams.forEach((stream) => {
+      stream.cancelled = true;
+    });
+    this.activeStreams.clear();
+    if (activeInstance === this) {
+      activeInstance = null;
+      if (ipcHandlersRegistered) {
+        import_electron.ipcMain.removeHandler("sanqian-chat:connect");
+        import_electron.ipcMain.removeHandler("sanqian-chat:isConnected");
+        import_electron.ipcMain.removeHandler("sanqian-chat:stream");
+        import_electron.ipcMain.removeHandler("sanqian-chat:cancelStream");
+        import_electron.ipcMain.removeHandler("sanqian-chat:hitlResponse");
+        import_electron.ipcMain.removeHandler("sanqian-chat:listConversations");
+        import_electron.ipcMain.removeHandler("sanqian-chat:getConversation");
+        import_electron.ipcMain.removeHandler("sanqian-chat:deleteConversation");
+        import_electron.ipcMain.removeHandler("sanqian-chat:hide");
+        ipcHandlersRegistered = false;
+      }
+    }
+  }
+  getWindow() {
+    return this.window;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingWindow
+});

package/dist/main/index.mjs

@@ -0,0 +1,272 @@
+// src/main/FloatingWindow.ts
+import { BrowserWindow, globalShortcut, screen, ipcMain, app } from "electron";
+var ipcHandlersRegistered = false;
+var activeInstance = null;
+var FloatingWindow = class {
+  constructor(options) {
+    this.window = null;
+    this.savedPosition = null;
+    this.activeStreams = /* @__PURE__ */ new Map();
+    if (activeInstance) {
+      console.warn("[FloatingWindow] Only one instance supported. Destroying previous.");
+      activeInstance.destroy();
+    }
+    activeInstance = this;
+    this.options = {
+      width: 400,
+      height: 500,
+      alwaysOnTop: true,
+      showInTaskbar: false,
+      position: "center",
+      ...options
+    };
+    this.setupIpcHandlers();
+    if (this.options.shortcut) {
+      app.whenReady().then(() => this.registerShortcut());
+    }
+  }
+  createWindow() {
+    const { width, height, alwaysOnTop, showInTaskbar, preloadPath } = this.options;
+    const win = new BrowserWindow({
+      width,
+      height,
+      show: false,
+      frame: false,
+      transparent: true,
+      resizable: true,
+      alwaysOnTop,
+      skipTaskbar: !showInTaskbar,
+      webPreferences: {
+        preload: preloadPath,
+        contextIsolation: true,
+        nodeIntegration: false
+      }
+    });
+    if (this.options.devMode) {
+      win.loadURL(this.options.rendererPath);
+    } else {
+      win.loadFile(this.options.rendererPath);
+    }
+    win.on("blur", () => {
+    });
+    win.on("closed", () => {
+      this.window = null;
+    });
+    return win;
+  }
+  getInitialPosition() {
+    const { position, width = 400, height = 500 } = this.options;
+    if (typeof position === "object" && "x" in position) {
+      return position;
+    }
+    if (position === "remember" && this.savedPosition) {
+      return this.savedPosition;
+    }
+    if (position === "cursor") {
+      const cursorPos = screen.getCursorScreenPoint();
+      const display = screen.getDisplayNearestPoint(cursorPos);
+      const x = Math.min(cursorPos.x, display.bounds.x + display.bounds.width - width);
+      const y = Math.min(cursorPos.y, display.bounds.y + display.bounds.height - height);
+      return { x, y };
+    }
+    const primaryDisplay = screen.getPrimaryDisplay();
+    const { width: screenWidth, height: screenHeight } = primaryDisplay.workAreaSize;
+    return {
+      x: Math.round((screenWidth - width) / 2),
+      y: Math.round((screenHeight - height) / 2)
+    };
+  }
+  registerShortcut() {
+    const { shortcut } = this.options;
+    if (!shortcut) return;
+    try {
+      const success = globalShortcut.register(shortcut, () => this.toggle());
+      if (!success) {
+        console.warn(`[FloatingWindow] Failed to register shortcut: ${shortcut}`);
+      }
+    } catch (e) {
+      console.error(`[FloatingWindow] Shortcut registration error:`, e);
+    }
+  }
+  setupIpcHandlers() {
+    if (ipcHandlersRegistered) return;
+    ipcHandlersRegistered = true;
+    ipcMain.handle("sanqian-chat:connect", async () => {
+      try {
+        const sdk = activeInstance?.options.getSdk();
+        if (!sdk) throw new Error("SDK not available");
+        await sdk.ensureReady();
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Connection failed" };
+      }
+    });
+    ipcMain.handle("sanqian-chat:isConnected", () => {
+      const sdk = activeInstance?.options.getSdk();
+      return sdk?.isConnected() ?? false;
+    });
+    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();
+      if (!sdk || !agentId) {
+        webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: "SDK or agent not ready" } });
+        return;
+      }
+      const streamState = { cancelled: false };
+      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 });
+        for await (const evt of stream) {
+          if (streamState.cancelled) break;
+          switch (evt.type) {
+            case "text":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "text", content: evt.content } });
+              break;
+            case "thinking":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "thinking", content: evt.content } });
+              break;
+            case "tool_call":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "tool_call", tool_call: evt.tool_call } });
+              break;
+            case "tool_result":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "tool_result", tool_call_id: evt.tool_call_id, result: evt.result } });
+              break;
+            case "done":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "done", conversationId: evt.conversationId, title: evt.title } });
+              break;
+            case "error":
+              webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: evt.error } });
+              break;
+            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) {
+        if (!streamState.cancelled) {
+          webContents.send("sanqian-chat:streamEvent", { streamId, event: { type: "error", error: e instanceof Error ? e.message : "Stream error" } });
+        }
+      } finally {
+        activeInstance?.activeStreams.delete(streamId);
+      }
+    });
+    ipcMain.handle("sanqian-chat:cancelStream", (_, params) => {
+      const stream = activeInstance?.activeStreams.get(params.streamId);
+      if (stream) {
+        stream.cancelled = true;
+        activeInstance?.activeStreams.delete(params.streamId);
+      }
+      return { success: true };
+    });
+    ipcMain.handle("sanqian-chat:hitlResponse", (_, params) => {
+      const sdk = activeInstance?.options.getSdk();
+      if (sdk && params.runId) {
+        sdk.sendHitlResponse(params.runId, params.response);
+      }
+      return { success: true };
+    });
+    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" };
+      try {
+        const result = await sdk.listConversations({ agentId, ...params });
+        return { success: true, data: result };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to list" };
+      }
+    });
+    ipcMain.handle("sanqian-chat:getConversation", async (_, params) => {
+      const sdk = activeInstance?.options.getSdk();
+      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 };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to get" };
+      }
+    });
+    ipcMain.handle("sanqian-chat:deleteConversation", async (_, params) => {
+      const sdk = activeInstance?.options.getSdk();
+      if (!sdk) return { success: false, error: "SDK not ready" };
+      try {
+        await sdk.deleteConversation(params.conversationId);
+        return { success: true };
+      } catch (e) {
+        return { success: false, error: e instanceof Error ? e.message : "Failed to delete" };
+      }
+    });
+    ipcMain.handle("sanqian-chat:hide", () => {
+      activeInstance?.hide();
+      return { success: true };
+    });
+  }
+  // Public API
+  show() {
+    if (!this.window) {
+      this.window = this.createWindow();
+    }
+    const pos = this.getInitialPosition();
+    this.window.setPosition(pos.x, pos.y);
+    this.window.show();
+    this.window.focus();
+  }
+  hide() {
+    if (this.window) {
+      if (this.options.position === "remember") {
+        const [x, y] = this.window.getPosition();
+        this.savedPosition = { x, y };
+      }
+      this.window.hide();
+    }
+  }
+  toggle() {
+    if (this.window?.isVisible()) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  isVisible() {
+    return this.window?.isVisible() ?? false;
+  }
+  destroy() {
+    if (this.options.shortcut) {
+      globalShortcut.unregister(this.options.shortcut);
+    }
+    this.window?.destroy();
+    this.window = null;
+    this.activeStreams.forEach((stream) => {
+      stream.cancelled = true;
+    });
+    this.activeStreams.clear();
+    if (activeInstance === this) {
+      activeInstance = null;
+      if (ipcHandlersRegistered) {
+        ipcMain.removeHandler("sanqian-chat:connect");
+        ipcMain.removeHandler("sanqian-chat:isConnected");
+        ipcMain.removeHandler("sanqian-chat:stream");
+        ipcMain.removeHandler("sanqian-chat:cancelStream");
+        ipcMain.removeHandler("sanqian-chat:hitlResponse");
+        ipcMain.removeHandler("sanqian-chat:listConversations");
+        ipcMain.removeHandler("sanqian-chat:getConversation");
+        ipcMain.removeHandler("sanqian-chat:deleteConversation");
+        ipcMain.removeHandler("sanqian-chat:hide");
+        ipcHandlersRegistered = false;
+      }
+    }
+  }
+  getWindow() {
+    return this.window;
+  }
+};
+export {
+  FloatingWindow
+};

package/dist/preload/index.d.ts

@@ -0,0 +1,67 @@
+import { HitlResponse } from '@yushaw/sanqian-sdk';
+
+/**
+ * @yushaw/sanqian-chat Preload
+ *
+ * Exposes IPC methods to renderer via contextBridge
+ */
+
+interface SanqianChatAPI {
+    connect(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    isConnected(): Promise<boolean>;
+    stream(params: {
+        streamId: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        conversationId?: string;
+    }): Promise<void>;
+    cancelStream(params: {
+        streamId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    onStreamEvent(callback: (streamId: string, event: unknown) => void): () => void;
+    sendHitlResponse(params: {
+        response: HitlResponse;
+        runId?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    listConversations(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        success: boolean;
+        data?: unknown;
+        error?: string;
+    }>;
+    getConversation(params: {
+        conversationId: string;
+        messageLimit?: number;
+    }): Promise<{
+        success: boolean;
+        data?: unknown;
+        error?: string;
+    }>;
+    deleteConversation(params: {
+        conversationId: string;
+    }): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    hide(): Promise<{
+        success: boolean;
+    }>;
+}
+declare global {
+    interface Window {
+        sanqianChat: SanqianChatAPI;
+    }
+}
+
+export type { SanqianChatAPI };