vite-plugin-opencode-assistant 1.0.27 → 1.0.29

package/es/client/App.vue.js

@@ -38,10 +38,11 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 import { defineComponent as _defineComponent } from "vue";
-import { ref, computed, onMounted } from "vue";
+import { ref, computed, onMounted, watch } from "vue";
 import { OpenCodeWidget } from "@vite-plugin-opencode-assistant/components";
 import { useHotkey } from "./composables/useHotkey";
-import { useSSE } from "./composables/useSSE";
+import { useServerSSE } from "./composables/useServerSSE";
+import { useOpencodeSessionSSE } from "./composables/useOpencodeSessionSSE";
 import { useSessions } from "./composables/useSessions";
 import { useTheme } from "./composables/useTheme";
 import { useSelectedElements } from "./composables/useSelectedElements";
@@ -66,9 +67,14 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
     const {
       theme: initialTheme = "auto",
       open: autoOpen = false,
-      hotkey = "ctrl+k"
+      hotkey = "ctrl+k",
+      proxyPort = 4098,
+      proxyHost = "localhost"
     } = props.config;
     const widgetTheme = initialTheme;
+    const proxyBaseUrl = computed(() => {
+      return `http://${proxyHost}:${proxyPort}`;
+    });
     const showNotification = (msg, options) => {
       var _a, _b;
       (_b = (_a = widgetRef.value) == null ? void 0 : _a.showNotification) == null ? void 0 : _b.call(_a, msg, options);
@@ -78,11 +84,9 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
       chromeMcpFailed,
       chromeMcpErrorType,
       chromeMcpErrorMessage,
-      thinking,
       loadingText,
       updateStatusFromTask,
-      setStarting,
-      setThinking
+      setStarting
     } = useServiceStatus();
     const {
       selectedElements,
@@ -102,13 +106,50 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
       loadSessions,
       createSession,
       deleteSession,
-      selectSession
-    } = useSessions(showNotification);
+      selectSession,
+      updateSessionInfo
+    } = useSessions({ showNotification });
     const { updateContext } = useContext(serviceStatus, selectedElements);
+    const serverSSE = useServerSSE({
+      onStatusSync: (data) => {
+        if (data.isStarted !== void 0 && data.isStarted && serviceStatus.value === "idle") {
+          setStarting();
+        }
+        if (data.task) {
+          updateStatusFromTask(data.task, data.errorType, data.errorMessage);
+        }
+        if (serviceStatus.value !== "idle") {
+          loadSessions();
+        }
+      },
+      onTaskUpdate: (data) => {
+        updateStatusFromTask(data.task, data.errorType, data.errorMessage);
+      },
+      onClearElements: () => clearElements(),
+      onConnected: () => updateContext(true)
+    });
+    const opencodeSSE = useOpencodeSessionSSE({
+      proxyBaseUrl: proxyBaseUrl.value,
+      currentSessionId,
+      onConnected: () => {
+        console.log("[OpenCode] Session SSE connected");
+      },
+      onSessionUpdate: (session) => {
+        updateSessionInfo(session);
+      }
+    });
+    const thinking = opencodeSSE.hasAnyThinking;
+    const sessionStates = opencodeSSE.sessionStates;
     const showSessionListSkeleton = computed(() => serviceStatus.value === "starting");
     const computedLoading = computed(() => {
       return serviceStatus.value === "starting" || iframeLoading.value;
     });
+    const displayLoadingText = computed(() => {
+      if (serviceStatus.value === "starting") {
+        return loadingText.value;
+      }
+      return "\u52A0\u8F7D\u4F1A\u8BDD...";
+    });
     const retryWarmup = () => __async(null, null, function* () {
       retryingWarmup.value = true;
       try {
@@ -136,24 +177,6 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
         retryingWarmup.value = false;
       }
     });
-    const { setupSSE } = useSSE(
-      (data) => {
-        if (data.isStarted !== void 0 && data.isStarted && serviceStatus.value === "idle") {
-          setStarting();
-        }
-        if (data.task) {
-          updateStatusFromTask(data.task, data.errorType, data.errorMessage);
-        }
-        if (serviceStatus.value !== "idle") {
-          loadSessions();
-        }
-      },
-      (data) => {
-        updateStatusFromTask(data.task, data.errorType, data.errorMessage);
-      },
-      () => clearElements(),
-      () => updateContext(true)
-    );
     const ensureServicesStarted = () => __async(null, null, function* () {
       if (serviceStatus.value !== "idle") return true;
       try {
@@ -161,7 +184,7 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
         const data = yield res.json();
         if (data.success) {
           setStarting();
-          setupSSE();
+          serverSSE.connect();
           return true;
         }
       } catch (e) {
@@ -181,10 +204,17 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
         showNotification("Vue Inspector \u672A\u52A0\u8F7D\uFF0C\u65E0\u6CD5\u4F7F\u7528\u5143\u7D20\u9009\u62E9\u529F\u80FD");
       }
     });
+    watch(serviceStatus, (status, oldStatus) => {
+      if (status !== "idle" && oldStatus === "idle") {
+        serverSSE.connect();
+        opencodeSSE.connect();
+      }
+    });
     onMounted(() => {
       if (serviceStatus.value !== "idle") {
         loadSessions();
-        setupSSE();
+        serverSSE.connect();
+        opencodeSSE.connect();
         updateContext(true);
       }
       if (autoOpen && serviceStatus.value !== "idle") {
@@ -193,11 +223,8 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
         }, 1e3);
       }
       const handleIframeMessage = (event) => {
-        var _a, _b;
-        if (((_a = event.data) == null ? void 0 : _a.type) === "OPENCODE_THINKING_STATE") {
-          setThinking(event.data.thinking);
-        }
-        if (((_b = event.data) == null ? void 0 : _b.type) === "OPENCODE_READY") {
+        var _a;
+        if (((_a = event.data) == null ? void 0 : _a.type) === "OPENCODE_READY") {
           sendThemeToIframe();
         }
       };
@@ -252,7 +279,7 @@ const __vue_sfc__ = /* @__PURE__ */ _defineComponent({
     const handleFrameLoaded = () => {
       iframeLoading.value = false;
     };
-    const __returned__ = { props, open, selectMode, sessionListCollapsed, loading, widgetRef, retryingWarmup, initialTheme, autoOpen, hotkey, widgetTheme, showNotification, serviceStatus, chromeMcpFailed, chromeMcpErrorType, chromeMcpErrorMessage, thinking, loadingText, updateStatusFromTask, setStarting, setThinking, selectedElements, removeElement, clearElements, theme, sendThemeToIframe, sessions, loadingSessionList, currentSessionId, iframeSrc, iframeLoading, loadSessions, createSession, deleteSession, selectSession, updateContext, showSessionListSkeleton, computedLoading, retryWarmup, setupSSE, ensureServicesStarted, handleToggle, handleSelectNode, handleClearSelected, handleSelectModeChange, handleSessionListCollapsedChange, handleThemeChange, handleRemoveSelectedNode, handleFrameLoaded, get OpenCodeWidget() {
+    const __returned__ = { props, open, selectMode, sessionListCollapsed, loading, widgetRef, retryingWarmup, initialTheme, autoOpen, hotkey, proxyPort, proxyHost, widgetTheme, proxyBaseUrl, showNotification, serviceStatus, chromeMcpFailed, chromeMcpErrorType, chromeMcpErrorMessage, loadingText, updateStatusFromTask, setStarting, selectedElements, removeElement, clearElements, theme, sendThemeToIframe, sessions, loadingSessionList, currentSessionId, iframeSrc, iframeLoading, loadSessions, createSession, deleteSession, selectSession, updateSessionInfo, updateContext, serverSSE, opencodeSSE, thinking, sessionStates, showSessionListSkeleton, computedLoading, displayLoadingText, retryWarmup, ensureServicesStarted, handleToggle, handleSelectNode, handleClearSelected, handleSelectModeChange, handleSessionListCollapsedChange, handleThemeChange, handleRemoveSelectedNode, handleFrameLoaded, get OpenCodeWidget() {
       return OpenCodeWidget;
     }, LoadingContent, ChromeWarmupError };
     Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
@@ -274,6 +301,7 @@ function __vue_render__(_ctx, _cache, $props, $setup, $data, $options) {
     "iframe-src": $setup.iframeSrc,
     "current-session-id": $setup.currentSessionId,
     sessions: $setup.sessions,
+    "session-states": $setup.sessionStates,
     "session-key": "id",
     "hotkey-label": $setup.hotkey,
     thinking: $setup.thinking,
@@ -292,7 +320,7 @@ function __vue_render__(_ctx, _cache, $props, $setup, $data, $options) {
     onFrameLoaded: $setup.handleFrameLoaded
   }, {
     loading: _withCtx(() => [
-      _createVNode($setup["LoadingContent"], { "loading-text": $setup.loadingText }, null, 8, ["loading-text"])
+      _createVNode($setup["LoadingContent"], { "loading-text": $setup.displayLoadingText }, null, 8, ["loading-text"])
     ]),
     error: _withCtx(() => [
       $setup.chromeMcpFailed ? (_openBlock(), _createBlock($setup["ChromeWarmupError"], {
@@ -305,7 +333,7 @@ function __vue_render__(_ctx, _cache, $props, $setup, $data, $options) {
     ]),
     _: 1
     /* STABLE */
-  }, 8, ["theme", "open", "select-mode", "session-list-collapsed", "frame-loading", "loading-session-list", "show-session-list-skeleton", "show-error", "iframe-src", "current-session-id", "sessions", "hotkey-label", "thinking", "onCreateSession", "onDeleteSession", "onSelectSession", "onEmptyAction"]);
+  }, 8, ["theme", "open", "select-mode", "session-list-collapsed", "frame-loading", "loading-session-list", "show-session-list-skeleton", "show-error", "iframe-src", "current-session-id", "sessions", "session-states", "hotkey-label", "thinking", "onCreateSession", "onDeleteSession", "onSelectSession", "onEmptyAction"]);
 }
 __vue_sfc__.render = __vue_render__;
 var App_vue_default = __vue_sfc__;

package/es/client/composables/index.d.ts

@@ -0,0 +1,10 @@
+export { useSSE } from "./useSSE";
+export { useServerSSE } from "./useServerSSE";
+export { useOpencodeSSE } from "./useOpencodeSSE";
+export { useOpencodeSessionSSE } from "./useOpencodeSessionSSE";
+export { useHotkey } from "./useHotkey";
+export { useSessions } from "./useSessions";
+export { useTheme } from "./useTheme";
+export { useSelectedElements } from "./useSelectedElements";
+export { useServiceStatus } from "./useServiceStatus";
+export { useContext } from "./useContext";

package/es/client/composables/index.js

@@ -0,0 +1,22 @@
+import { useSSE } from "./useSSE";
+import { useServerSSE } from "./useServerSSE";
+import { useOpencodeSSE } from "./useOpencodeSSE";
+import { useOpencodeSessionSSE } from "./useOpencodeSessionSSE";
+import { useHotkey } from "./useHotkey";
+import { useSessions } from "./useSessions";
+import { useTheme } from "./useTheme";
+import { useSelectedElements } from "./useSelectedElements";
+import { useServiceStatus } from "./useServiceStatus";
+import { useContext } from "./useContext";
+export {
+  useContext,
+  useHotkey,
+  useOpencodeSSE,
+  useOpencodeSessionSSE,
+  useSSE,
+  useSelectedElements,
+  useServerSSE,
+  useServiceStatus,
+  useSessions,
+  useTheme
+};

package/es/client/composables/useOpencodeSSE.d.ts

@@ -0,0 +1,64 @@
+import { type Ref } from "vue";
+/**
+ * OpenCode SSE 事件 payload
+ */
+export interface OpencodeSSEPayload {
+    type: string;
+    properties: {
+        sessionID?: string;
+        status?: {
+            type: string;
+        };
+        info?: {
+            sessionID?: string;
+            role?: string;
+            time?: {
+                completed?: number;
+                created?: number;
+                updated?: number;
+                archived?: number;
+                compacting?: number;
+            };
+            title?: string;
+            id?: string;
+            summary?: {
+                additions?: number;
+                deletions?: number;
+                files?: number;
+            };
+        };
+        [key: string]: unknown;
+    };
+}
+/**
+ * OpenCode SSE 消息结构
+ */
+export interface OpencodeSSEMessage {
+    payload: OpencodeSSEPayload;
+}
+/**
+ * OpenCode SSE 配置选项
+ */
+export interface OpencodeSSEOptions {
+    /** OpenCode proxy 基础 URL (例如: http://localhost:4098/xxx) */
+    proxyBaseUrl: string;
+    /** 是否启用 */
+    enabled?: Ref<boolean>;
+    /** 事件处理器 */
+    onEvent?: (payload: OpencodeSSEPayload) => void;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** 连接错误回调 */
+    onError?: (error: Error) => void;
+}
+/**
+ * 监听 OpenCode SSE 事件
+ * 端点: /global/event (通过 proxy server)
+ * 只负责连接管理和消息分发，不包含业务逻辑
+ */
+export declare function useOpencodeSSE(options: OpencodeSSEOptions): {
+    status: Ref<import("./useSSE").SSEConnectionStatus, import("./useSSE").SSEConnectionStatus>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+};

package/es/client/composables/useOpencodeSSE.js

@@ -0,0 +1,29 @@
+import { useSSE } from "./useSSE";
+function useOpencodeSSE(options) {
+  const { proxyBaseUrl, enabled, onEvent, onConnected, onError } = options;
+  const endpoint = `${proxyBaseUrl}/global/event`;
+  const { status, isConnected, connect, disconnect } = useSSE({
+    endpoint,
+    autoConnect: false,
+    enabled,
+    onMessage: (data) => {
+      const message = data;
+      const payload = message.payload;
+      if (!payload) return;
+      onEvent == null ? void 0 : onEvent(payload);
+    },
+    onConnected,
+    onError
+  });
+  return {
+    // 状态
+    status,
+    isConnected,
+    // 方法
+    connect,
+    disconnect
+  };
+}
+export {
+  useOpencodeSSE
+};

package/es/client/composables/useOpencodeSessionSSE.d.ts

@@ -0,0 +1,66 @@
+import { type Ref, type ComputedRef } from "vue";
+/**
+ * Session 状态类型
+ */
+export type OpencodeSessionStatusType = "idle" | "running" | "streaming" | "completed";
+/**
+ * Session 思考状态
+ */
+export interface OpencodeSessionThinkingState {
+    thinking: boolean;
+    statusType: OpencodeSessionStatusType;
+    hasPending: boolean;
+}
+/**
+ * Session 更新事件数据
+ */
+export interface OpencodeSessionUpdateData {
+    id: string;
+    title?: string;
+    time?: {
+        created?: number;
+        updated?: number;
+        archived?: number;
+        compacting?: number;
+    };
+    summary?: {
+        additions?: number;
+        deletions?: number;
+        files?: number;
+    };
+}
+/**
+ * OpenCode Session SSE 配置选项
+ */
+export interface OpencodeSessionSSEOptions {
+    /** OpenCode proxy 基础 URL */
+    proxyBaseUrl: string;
+    /** 当前 session ID (响应式) */
+    currentSessionId: Ref<string | null>;
+    /** 是否启用 */
+    enabled?: Ref<boolean>;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** Session 更新回调 (包括标题变化) */
+    onSessionUpdate?: (session: OpencodeSessionUpdateData) => void;
+}
+/**
+ * 监听 OpenCode Session SSE 事件
+ * 专注于 session thinking 状态管理和标题更新
+ */
+export declare function useOpencodeSessionSSE(options: OpencodeSessionSSEOptions): {
+    status: Ref<import("./useSSE").SSEConnectionStatus, import("./useSSE").SSEConnectionStatus>;
+    isConnected: ComputedRef<boolean>;
+    sessionStates: Ref<Record<string, OpencodeSessionThinkingState>, Record<string, OpencodeSessionThinkingState>>;
+    currentThinking: ComputedRef<boolean>;
+    currentSessionState: ComputedRef<OpencodeSessionThinkingState | null>;
+    hasAnyThinking: ComputedRef<boolean>;
+    thinkingSessionCount: ComputedRef<number>;
+    connect: () => void;
+    disconnect: () => void;
+    clearSessionState: (sessionID: string) => void;
+    clearAllSessionStates: () => void;
+    getSessionState: (sessionID: string) => OpencodeSessionThinkingState | undefined;
+    isSessionThinking: (sessionID: string) => boolean;
+    getSessionsThinking: (sessionIds: string[]) => Record<string, boolean>;
+};

package/es/client/composables/useOpencodeSessionSSE.js

@@ -0,0 +1,168 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { ref, computed } from "vue";
+import {
+  useOpencodeSSE
+} from "./useOpencodeSSE";
+function useOpencodeSessionSSE(options) {
+  const { proxyBaseUrl, currentSessionId, enabled, onConnected, onSessionUpdate } = options;
+  const sessionStates = ref({});
+  function isPendingMessage(info) {
+    var _a;
+    return (info == null ? void 0 : info.role) === "assistant" && typeof ((_a = info == null ? void 0 : info.time) == null ? void 0 : _a.completed) !== "number";
+  }
+  function updateThinkingState(sessionID) {
+    const state = sessionStates.value[sessionID];
+    const isThinking = (state == null ? void 0 : state.hasPending) || (state == null ? void 0 : state.statusType) !== "idle";
+    sessionStates.value[sessionID] = {
+      thinking: isThinking,
+      statusType: (state == null ? void 0 : state.statusType) || "idle",
+      hasPending: (state == null ? void 0 : state.hasPending) || false
+    };
+  }
+  function handleEvent(payload) {
+    var _a;
+    const type = payload.type;
+    const props = payload.properties;
+    switch (type) {
+      case "session.updated": {
+        const info = props.info;
+        if (!(info == null ? void 0 : info.id)) return;
+        onSessionUpdate == null ? void 0 : onSessionUpdate({
+          id: info.id,
+          title: info.title,
+          time: info.time,
+          summary: info.summary
+        });
+        break;
+      }
+      case "session.status": {
+        const sessionID = props.sessionID;
+        if (!sessionID) return;
+        const statusType = ((_a = props.status) == null ? void 0 : _a.type) || "idle";
+        sessionStates.value[sessionID] = {
+          thinking: statusType !== "idle",
+          statusType,
+          hasPending: false
+        };
+        updateThinkingState(sessionID);
+        break;
+      }
+      case "message.updated": {
+        const info = props.info;
+        if (!(info == null ? void 0 : info.sessionID)) return;
+        const sessionID = info.sessionID;
+        if (info.role === "assistant") {
+          const hasPending = isPendingMessage(info);
+          const current = sessionStates.value[sessionID] || {
+            thinking: false,
+            statusType: "idle",
+            hasPending: false
+          };
+          sessionStates.value[sessionID] = __spreadProps(__spreadValues({}, current), {
+            hasPending
+          });
+          updateThinkingState(sessionID);
+        }
+        break;
+      }
+      case "message.part.delta": {
+        const sessionID = props.sessionID;
+        if (!sessionID) return;
+        const current = sessionStates.value[sessionID];
+        if (!(current == null ? void 0 : current.hasPending)) {
+          sessionStates.value[sessionID] = {
+            thinking: true,
+            statusType: (current == null ? void 0 : current.statusType) || "idle",
+            hasPending: true
+          };
+        }
+        break;
+      }
+    }
+  }
+  const sse = useOpencodeSSE({
+    proxyBaseUrl,
+    enabled,
+    onEvent: handleEvent,
+    onConnected
+  });
+  const currentThinking = computed(() => {
+    var _a, _b;
+    const id = currentSessionId.value;
+    if (!id) return false;
+    return (_b = (_a = sessionStates.value[id]) == null ? void 0 : _a.thinking) != null ? _b : false;
+  });
+  const currentSessionState = computed(() => {
+    const id = currentSessionId.value;
+    if (!id) return null;
+    return sessionStates.value[id] || null;
+  });
+  const hasAnyThinking = computed(() => {
+    return Object.values(sessionStates.value).some((state) => state.thinking);
+  });
+  const thinkingSessionCount = computed(() => {
+    return Object.values(sessionStates.value).filter((state) => state.thinking).length;
+  });
+  function clearSessionState(sessionID) {
+    delete sessionStates.value[sessionID];
+  }
+  function clearAllSessionStates() {
+    sessionStates.value = {};
+  }
+  function getSessionState(sessionID) {
+    return sessionStates.value[sessionID];
+  }
+  function isSessionThinking(sessionID) {
+    var _a, _b;
+    return (_b = (_a = sessionStates.value[sessionID]) == null ? void 0 : _a.thinking) != null ? _b : false;
+  }
+  function getSessionsThinking(sessionIds) {
+    return sessionIds.reduce(
+      (acc, id) => {
+        acc[id] = isSessionThinking(id);
+        return acc;
+      },
+      {}
+    );
+  }
+  return {
+    // SSE 基础状态
+    status: sse.status,
+    isConnected: sse.isConnected,
+    // session 状态
+    sessionStates,
+    currentThinking,
+    currentSessionState,
+    hasAnyThinking,
+    thinkingSessionCount,
+    // 方法
+    connect: sse.connect,
+    disconnect: sse.disconnect,
+    clearSessionState,
+    clearAllSessionStates,
+    getSessionState,
+    isSessionThinking,
+    getSessionsThinking
+  };
+}
+export {
+  useOpencodeSessionSSE
+};

package/es/client/composables/useSSE.d.ts

@@ -1,20 +1,87 @@
-import { ServiceStartupTask } from "@vite-plugin-opencode-assistant/shared";
-interface SSEStatusSyncData {
-    type: "STATUS_SYNC";
-    isStarted?: boolean;
-    task: ServiceStartupTask;
-    errorType?: string;
-    errorMessage?: string;
+import { type Ref } from "vue";
+/**
+ * SSE 连接状态
+ */
+export type SSEConnectionStatus = "idle" | "connecting" | "connected" | "disconnected" | "error";
+/**
+ * SSE 配置选项
+ */
+export interface SSEOptions {
+    /** SSE 端点 URL */
+    endpoint: string;
+    /** 是否自动连接 */
+    autoConnect?: boolean;
+    /** 是否启用 (响应式) */
+    enabled?: Ref<boolean>;
+    /** 最大重试次数 */
+    maxRetries?: number;
+    /** 重试延迟基数 (ms) */
+    retryDelay?: number;
+    /** 连接成功回调 */
+    onConnected?: () => void;
+    /** 连接断开回调 */
+    onDisconnected?: () => void;
+    /** 连接错误回调 */
+    onError?: (error: Error) => void;
+    /** 消息处理回调 */
+    onMessage?: (data: unknown) => void;
 }
-interface SSETaskUpdateData {
-    type: "TASK_UPDATE";
-    task: ServiceStartupTask;
-    errorType?: string;
-    errorMessage?: string;
-}
-export declare function useSSE(onStatusSync: (data: SSEStatusSyncData) => void, onTaskUpdate: (data: SSETaskUpdateData) => void, onClearElements: () => void, onConnected: () => void): {
-    setupSSE: () => void;
-    closeSSE: () => void;
-    sseRetryCount: import("vue").Ref<number, number>;
+/**
+ * 通用 SSE 连接管理
+ * 提供基础的连接、重连、状态管理功能
+ */
+export declare function useSSE(options: SSEOptions): {
+    connection: Ref<{
+        onerror: ((this: EventSource, ev: Event) => any) | null;
+        onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
+        onopen: ((this: EventSource, ev: Event) => any) | null;
+        readonly readyState: number;
+        readonly url: string;
+        readonly withCredentials: boolean;
+        close: () => void;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSED: 2;
+        addEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null, EventSource | {
+        onerror: ((this: EventSource, ev: Event) => any) | null;
+        onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
+        onopen: ((this: EventSource, ev: Event) => any) | null;
+        readonly readyState: number;
+        readonly url: string;
+        readonly withCredentials: boolean;
+        close: () => void;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSED: 2;
+        addEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof EventSourceEventMap>(type: K, listener: (this: EventSource, ev: EventSourceEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: (this: EventSource, event: MessageEvent) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null>;
+    status: Ref<SSEConnectionStatus, SSEConnectionStatus>;
+    retryCount: Ref<number, number>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    isConnecting: import("vue").ComputedRef<boolean>;
+    connect: () => void;
+    disconnect: () => void;
+    reconnect: () => void;
+    resetRetryCount: () => void;
 };
-export {};