@yourgpt/copilot-sdk 0.1.1 → 1.0.1

package/dist/{chunk-R452HH3J.cjs → chunk-BN75ZW24.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkIH7WXWX4_cjs = require('./chunk-IH7WXWX4.cjs');
+var chunk42YQ4ATO_cjs = require('./chunk-42YQ4ATO.cjs');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var z = require('zod');
@@ -1742,6 +1742,9 @@ function CopilotProvider({
   const clearMessages = react.useCallback(() => {
     chatRef.current?.clearMessages();
   }, []);
+  const setMessages = react.useCallback((messages2) => {
+    chatRef.current?.setMessages(messages2);
+  }, []);
   const regenerate = react.useCallback(async (messageId) => {
     await chatRef.current?.regenerate(messageId);
   }, []);
@@ -1783,6 +1786,7 @@ function CopilotProvider({
       sendMessage,
       stop,
       clearMessages,
+      setMessages,
       regenerate,
       // Tool execution
       registerTool,
@@ -1812,6 +1816,7 @@ function CopilotProvider({
       sendMessage,
       stop,
       clearMessages,
+      setMessages,
       regenerate,
       registerTool,
       unregisterTool,
@@ -1925,17 +1930,17 @@ function useAITools(options = {}) {
   const rememberedConsentRef = react.useRef(/* @__PURE__ */ new Set());
   react.useEffect(() => {
     if (!autoStart || !isEnabled) return;
-    if (consoleCapture && !chunkIH7WXWX4_cjs.isConsoleCaptureActive()) {
-      chunkIH7WXWX4_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunk42YQ4ATO_cjs.isConsoleCaptureActive()) {
+      chunk42YQ4ATO_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunkIH7WXWX4_cjs.isNetworkCaptureActive()) {
-      chunkIH7WXWX4_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunk42YQ4ATO_cjs.isNetworkCaptureActive()) {
+      chunk42YQ4ATO_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
     return () => {
-      chunkIH7WXWX4_cjs.stopConsoleCapture();
-      chunkIH7WXWX4_cjs.stopNetworkCapture();
+      chunk42YQ4ATO_cjs.stopConsoleCapture();
+      chunk42YQ4ATO_cjs.stopNetworkCapture();
     };
   }, [
     autoStart,
@@ -1950,12 +1955,12 @@ function useAITools(options = {}) {
       if (!screenshot) {
         throw new Error("Screenshot capture is not enabled");
       }
-      if (!chunkIH7WXWX4_cjs.isScreenshotSupported()) {
+      if (!chunk42YQ4ATO_cjs.isScreenshotSupported()) {
         throw new Error(
           "Screenshot capture is not supported in this environment"
         );
       }
-      return chunkIH7WXWX4_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
+      return chunk42YQ4ATO_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
     },
     [screenshot, screenshotOptions]
   );
@@ -1964,7 +1969,7 @@ function useAITools(options = {}) {
       if (!consoleCapture) {
         return { logs: [], totalCaptured: 0 };
       }
-      return chunkIH7WXWX4_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
+      return chunk42YQ4ATO_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
     },
     [consoleCapture, consoleOptions]
   );
@@ -1973,7 +1978,7 @@ function useAITools(options = {}) {
       if (!network) {
         return { requests: [], totalCaptured: 0 };
       }
-      return chunkIH7WXWX4_cjs.getNetworkRequests({ ...networkOptions, ...opts });
+      return chunk42YQ4ATO_cjs.getNetworkRequests({ ...networkOptions, ...opts });
     },
     [network, networkOptions]
   );
@@ -2066,23 +2071,23 @@ function useAITools(options = {}) {
     ]
   );
   const startCapturing = react.useCallback(() => {
-    if (consoleCapture && !chunkIH7WXWX4_cjs.isConsoleCaptureActive()) {
-      chunkIH7WXWX4_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunk42YQ4ATO_cjs.isConsoleCaptureActive()) {
+      chunk42YQ4ATO_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunkIH7WXWX4_cjs.isNetworkCaptureActive()) {
-      chunkIH7WXWX4_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunk42YQ4ATO_cjs.isNetworkCaptureActive()) {
+      chunk42YQ4ATO_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
   }, [consoleCapture, network, consoleOptions, networkOptions]);
   const stopCapturing = react.useCallback(() => {
-    chunkIH7WXWX4_cjs.stopConsoleCapture();
-    chunkIH7WXWX4_cjs.stopNetworkCapture();
+    chunk42YQ4ATO_cjs.stopConsoleCapture();
+    chunk42YQ4ATO_cjs.stopNetworkCapture();
     setActiveCaptures({ console: false, network: false });
   }, []);
   const clearCaptured = react.useCallback(() => {
-    chunkIH7WXWX4_cjs.clearConsoleLogs();
-    chunkIH7WXWX4_cjs.clearNetworkRequests();
+    chunk42YQ4ATO_cjs.clearConsoleLogs();
+    chunk42YQ4ATO_cjs.clearNetworkRequests();
   }, []);
   const formatForAI = react.useCallback((context) => {
     const parts = [];
@@ -2092,16 +2097,16 @@ function useAITools(options = {}) {
       );
     }
     if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
-      parts.push(chunkIH7WXWX4_cjs.formatLogsForAI(context.consoleLogs.logs));
+      parts.push(chunk42YQ4ATO_cjs.formatLogsForAI(context.consoleLogs.logs));
     }
     if (context.networkRequests && context.networkRequests.requests.length > 0) {
-      parts.push(chunkIH7WXWX4_cjs.formatRequestsForAI(context.networkRequests.requests));
+      parts.push(chunk42YQ4ATO_cjs.formatRequestsForAI(context.networkRequests.requests));
     }
     return parts.length > 0 ? parts.join("\n\n---\n\n") : "No context captured.";
   }, []);
   const detectIntentFn = react.useCallback(
     (message) => {
-      const result = chunkIH7WXWX4_cjs.detectIntent(message);
+      const result = chunk42YQ4ATO_cjs.detectIntent(message);
       result.suggestedTools = result.suggestedTools.filter((tool) => {
         if (tool === "screenshot") return screenshot;
         if (tool === "console") return consoleCapture;
@@ -2225,7 +2230,7 @@ function convertZodSchema(schema, _toolName) {
     }
   } catch {
   }
-  return chunkIH7WXWX4_cjs.zodObjectToInputSchema(schema);
+  return chunk42YQ4ATO_cjs.zodObjectToInputSchema(schema);
 }
 function useToolWithSchema(config, dependencies = []) {
   const { registerTool, unregisterTool } = useCopilotContext();
@@ -2523,7 +2528,7 @@ function useAgent(options) {
         if (!response.ok) {
           throw new Error(`Agent error: ${response.status}`);
         }
-        for await (const event of chunkIH7WXWX4_cjs.streamSSE(response)) {
+        for await (const event of chunk42YQ4ATO_cjs.streamSSE(response)) {
           handleAgentEvent(event);
         }
       } catch (err) {
@@ -2876,6 +2881,425 @@ function useDevLogger() {
   ]);
 }
 
+// src/react/internal/ReactThreadManagerState.ts
+var ReactThreadManagerState = class {
+  constructor(initialThreads) {
+    this._threads = [];
+    this._currentThreadId = null;
+    this._currentThread = null;
+    this._loadStatus = "idle";
+    this._error = void 0;
+    // Callbacks for React subscriptions (useSyncExternalStore)
+    this.subscribers = /* @__PURE__ */ new Set();
+    // ============================================
+    // Subscription (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const threads = useSyncExternalStore(
+     *   state.subscribe,
+     *   () => state.threads
+     * );
+     * ```
+     */
+    this.subscribe = (callback) => {
+      this.subscribers.add(callback);
+      return () => {
+        this.subscribers.delete(callback);
+      };
+    };
+    if (initialThreads) {
+      this._threads = initialThreads;
+    }
+  }
+  // ============================================
+  // Getters
+  // ============================================
+  get threads() {
+    return this._threads;
+  }
+  get currentThreadId() {
+    return this._currentThreadId;
+  }
+  get currentThread() {
+    return this._currentThread;
+  }
+  get loadStatus() {
+    return this._loadStatus;
+  }
+  get error() {
+    return this._error;
+  }
+  // ============================================
+  // Setters (trigger reactivity)
+  // ============================================
+  set threads(value) {
+    this._threads = value;
+    this.notify();
+  }
+  // ============================================
+  // Mutations
+  // ============================================
+  setThreads(threads) {
+    this._threads = threads;
+    this.notify();
+  }
+  setCurrentThread(thread) {
+    this._currentThread = thread;
+    this._currentThreadId = thread?.id ?? null;
+    this.notify();
+  }
+  setCurrentThreadId(id) {
+    this._currentThreadId = id;
+    this.notify();
+  }
+  addThread(thread) {
+    this._threads = [thread, ...this._threads];
+    this.notify();
+  }
+  updateThread(id, updates) {
+    this._threads = this._threads.map(
+      (t) => t.id === id ? { ...t, ...updates } : t
+    );
+    if (updates.updatedAt) {
+      this._threads = [...this._threads].sort(
+        (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
+      );
+    }
+    if (this._currentThread?.id === id) {
+      this._currentThread = { ...this._currentThread, ...updates };
+    }
+    this.notify();
+  }
+  removeThread(id) {
+    this._threads = this._threads.filter((t) => t.id !== id);
+    if (this._currentThreadId === id) {
+      this._currentThreadId = null;
+      this._currentThread = null;
+    }
+    this.notify();
+  }
+  setLoadStatus(status) {
+    this._loadStatus = status;
+    this.notify();
+  }
+  setError(error) {
+    this._error = error;
+    this.notify();
+  }
+  // ============================================
+  // Snapshots (for useSyncExternalStore)
+  // ============================================
+  getThreadsSnapshot() {
+    return this._threads;
+  }
+  getCurrentThreadSnapshot() {
+    return this._currentThread;
+  }
+  getLoadStatusSnapshot() {
+    return this._loadStatus;
+  }
+  getErrorSnapshot() {
+    return this._error;
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  notify() {
+    this.subscribers.forEach((cb) => cb());
+  }
+  /**
+   * Cleanup subscriptions
+   */
+  dispose() {
+    this.subscribers.clear();
+  }
+};
+function createReactThreadManagerState(initialThreads) {
+  return new ReactThreadManagerState(initialThreads);
+}
+
+// src/react/internal/ReactThreadManager.ts
+var _ReactThreadManager = class _ReactThreadManager extends chunk42YQ4ATO_cjs.ThreadManager {
+  constructor(config = {}, callbacks = {}) {
+    const reactState = new ReactThreadManagerState();
+    super({ ...config, state: reactState }, callbacks);
+    // ============================================
+    // Subscription Methods (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Subscribe to state changes
+     * Use with useSyncExternalStore
+     */
+    this.subscribe = (callback) => {
+      return this.state.subscribe(callback);
+    };
+    // ============================================
+    // Snapshot Getters (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Get threads snapshot
+     */
+    this.getThreadsSnapshot = () => {
+      return this.state.getThreadsSnapshot();
+    };
+    /**
+     * Get current thread snapshot
+     */
+    this.getCurrentThreadSnapshot = () => {
+      return this.state.getCurrentThreadSnapshot();
+    };
+    /**
+     * Get current thread ID snapshot
+     */
+    this.getCurrentThreadIdSnapshot = () => {
+      return this.state.currentThreadId;
+    };
+    /**
+     * Get load status snapshot
+     */
+    this.getLoadStatusSnapshot = () => {
+      return this.state.getLoadStatusSnapshot();
+    };
+    /**
+     * Get error snapshot
+     */
+    this.getErrorSnapshot = () => {
+      return this.state.getErrorSnapshot();
+    };
+    /**
+     * Get isLoading snapshot
+     */
+    this.getIsLoadingSnapshot = () => {
+      return this.state.getLoadStatusSnapshot() === "loading";
+    };
+    /**
+     * Get threads snapshot for server (always empty for hydration consistency)
+     */
+    this.getThreadsServerSnapshot = () => {
+      return _ReactThreadManager.EMPTY_THREADS;
+    };
+    /**
+     * Get current thread snapshot for server (always null)
+     */
+    this.getCurrentThreadServerSnapshot = () => {
+      return null;
+    };
+    /**
+     * Get current thread ID snapshot for server (always null)
+     */
+    this.getCurrentThreadIdServerSnapshot = () => {
+      return null;
+    };
+    /**
+     * Get load status snapshot for server (always "idle")
+     */
+    this.getLoadStatusServerSnapshot = () => {
+      return _ReactThreadManager.IDLE_STATUS;
+    };
+    /**
+     * Get error snapshot for server (always undefined)
+     */
+    this.getErrorServerSnapshot = () => {
+      return void 0;
+    };
+    /**
+     * Get isLoading snapshot for server (always false)
+     */
+    this.getIsLoadingServerSnapshot = () => {
+      return false;
+    };
+  }
+  // ============================================
+  // Cleanup
+  // ============================================
+  /**
+   * Dispose of the manager
+   */
+  async dispose() {
+    this.state.dispose();
+    await super.dispose();
+  }
+};
+// ============================================
+// Server Snapshots (for SSR - stable cached values)
+// ============================================
+// Cached values for server snapshots (must be stable references)
+_ReactThreadManager.EMPTY_THREADS = [];
+_ReactThreadManager.IDLE_STATUS = "idle";
+var ReactThreadManager = _ReactThreadManager;
+function createReactThreadManager(config, callbacks) {
+  return new ReactThreadManager(config, callbacks);
+}
+
+// src/react/hooks/useThreadManager.ts
+var defaultManager = null;
+function getDefaultManager() {
+  if (!defaultManager) {
+    defaultManager = createReactThreadManager();
+  }
+  return defaultManager;
+}
+var internalManager = null;
+function getInternalManager(config) {
+  if (!internalManager) {
+    internalManager = createReactThreadManager(
+      {
+        adapter: config.adapter,
+        saveDebounce: config.saveDebounce,
+        autoLoad: config.autoLoad,
+        autoRestoreLastThread: config.autoRestoreLastThread
+      },
+      config.callbacks
+    );
+  }
+  return internalManager;
+}
+function useThreadManager(config) {
+  const manager = react.useMemo(() => {
+    if (!config) {
+      return getDefaultManager();
+    }
+    if (!config.adapter) {
+      return getInternalManager(config);
+    }
+    console.log("[useThreadManager] Creating new manager with custom adapter");
+    return createReactThreadManager(
+      {
+        adapter: config.adapter,
+        saveDebounce: config.saveDebounce,
+        autoLoad: config.autoLoad,
+        autoRestoreLastThread: config.autoRestoreLastThread
+      },
+      config.callbacks
+    );
+  }, [
+    config?.adapter,
+    config?.saveDebounce,
+    config?.autoLoad,
+    config?.autoRestoreLastThread
+    // Note: callbacks are intentionally not in deps to avoid recreating manager
+  ]);
+  const threads = react.useSyncExternalStore(
+    manager.subscribe,
+    manager.getThreadsSnapshot,
+    manager.getThreadsServerSnapshot
+    // SSR - always empty array
+  );
+  const currentThread = react.useSyncExternalStore(
+    manager.subscribe,
+    manager.getCurrentThreadSnapshot,
+    manager.getCurrentThreadServerSnapshot
+    // SSR - always null
+  );
+  const currentThreadId = react.useSyncExternalStore(
+    manager.subscribe,
+    manager.getCurrentThreadIdSnapshot,
+    manager.getCurrentThreadIdServerSnapshot
+    // SSR - always null
+  );
+  const loadStatus = react.useSyncExternalStore(
+    manager.subscribe,
+    manager.getLoadStatusSnapshot,
+    manager.getLoadStatusServerSnapshot
+    // SSR - always "idle"
+  );
+  const error = react.useSyncExternalStore(
+    manager.subscribe,
+    manager.getErrorSnapshot,
+    manager.getErrorServerSnapshot
+    // SSR - always undefined
+  );
+  const isLoading = react.useSyncExternalStore(
+    manager.subscribe,
+    manager.getIsLoadingSnapshot,
+    manager.getIsLoadingServerSnapshot
+    // SSR - always false
+  );
+  react.useEffect(() => {
+    return () => {
+      if (config?.adapter && manager !== defaultManager && manager !== internalManager) {
+        manager.dispose();
+      }
+    };
+  }, [manager, config]);
+  react.useEffect(() => {
+    const handleBeforeUnload = () => {
+      if (manager.hasPendingChanges) {
+        manager.saveNow().catch(() => {
+        });
+      }
+    };
+    if (typeof window !== "undefined") {
+      window.addEventListener("beforeunload", handleBeforeUnload);
+      return () => {
+        window.removeEventListener("beforeunload", handleBeforeUnload);
+      };
+    }
+  }, [manager]);
+  const createThread = react.useCallback(
+    (options) => manager.createThread(options),
+    [manager]
+  );
+  const switchThread = react.useCallback(
+    (id) => manager.switchThread(id),
+    [manager]
+  );
+  const updateCurrentThread = react.useCallback(
+    (updates) => manager.updateCurrentThread(updates),
+    [manager]
+  );
+  const deleteThread = react.useCallback(
+    (id) => manager.deleteThread(id),
+    [manager]
+  );
+  const clearCurrentThread = react.useCallback(
+    () => manager.clearCurrentThread(),
+    [manager]
+  );
+  const refreshThreads = react.useCallback(() => manager.loadThreads(), [manager]);
+  const saveNow = react.useCallback(() => manager.saveNow(), [manager]);
+  const clearAllThreads = react.useCallback(
+    () => manager.clearAllThreads(),
+    [manager]
+  );
+  const messages = react.useMemo(
+    () => currentThread?.messages ?? [],
+    [currentThread]
+  );
+  const setMessages = react.useCallback(
+    (newMessages) => updateCurrentThread({ messages: newMessages }),
+    [updateCurrentThread]
+  );
+  const hasPendingChanges = manager.hasPendingChanges;
+  return {
+    // State
+    threads,
+    currentThread,
+    currentThreadId,
+    isLoading,
+    loadStatus,
+    error,
+    // Actions
+    createThread,
+    switchThread,
+    updateCurrentThread,
+    deleteThread,
+    clearCurrentThread,
+    refreshThreads,
+    saveNow,
+    clearAllThreads,
+    // Utilities
+    messages,
+    setMessages,
+    hasPendingChanges
+  };
+}
+
 // src/react/utils/permission-storage.ts
 var DEFAULT_KEY_PREFIX = "yourgpt-permissions";
 function createPermissionStorage(config) {
@@ -3129,9 +3553,13 @@ exports.AbstractChat = AbstractChat;
 exports.CopilotProvider = CopilotProvider;
 exports.ReactChat = ReactChat;
 exports.ReactChatState = ReactChatState;
+exports.ReactThreadManager = ReactThreadManager;
+exports.ReactThreadManagerState = ReactThreadManagerState;
 exports.createPermissionStorage = createPermissionStorage;
 exports.createReactChat = createReactChat;
 exports.createReactChatState = createReactChatState;
+exports.createReactThreadManager = createReactThreadManager;
+exports.createReactThreadManagerState = createReactThreadManagerState;
 exports.createSessionPermissionCache = createSessionPermissionCache;
 exports.formatKnowledgeResultsForAI = formatKnowledgeResultsForAI;
 exports.initialAgentLoopState = initialAgentLoopState;
@@ -3150,10 +3578,11 @@ exports.useFeatureSupport = useFeatureSupport;
 exports.useKnowledgeBase = useKnowledgeBase;
 exports.useSuggestions = useSuggestions;
 exports.useSupportedMediaTypes = useSupportedMediaTypes;
+exports.useThreadManager = useThreadManager;
 exports.useTool = useTool;
 exports.useToolExecutor = useToolExecutor;
 exports.useToolWithSchema = useToolWithSchema;
 exports.useTools = useTools;
 exports.useToolsWithSchema = useToolsWithSchema;
-//# sourceMappingURL=chunk-R452HH3J.cjs.map
-//# sourceMappingURL=chunk-R452HH3J.cjs.map
+//# sourceMappingURL=chunk-BN75ZW24.cjs.map
+//# sourceMappingURL=chunk-BN75ZW24.cjs.map