@yourgpt/copilot-sdk 0.1.1 → 1.0.1

package/dist/{chunk-IH7WXWX4.cjs → chunk-42YQ4ATO.cjs}

@@ -1841,9 +1841,890 @@ function fileToBase64(file) {
   });
 }
 
+// src/thread/interfaces/ThreadManagerState.ts
+var SimpleThreadManagerState = class {
+  constructor() {
+    this._threads = [];
+    this._currentThreadId = null;
+    this._currentThread = null;
+    this._loadStatus = "idle";
+    this._error = void 0;
+    this.callbacks = /* @__PURE__ */ new Set();
+  }
+  // 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 with notification
+  set threads(value) {
+    this._threads = value;
+    this.notify();
+  }
+  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 (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();
+  }
+  // Subscription
+  subscribe(callback) {
+    this.callbacks.add(callback);
+    return () => this.callbacks.delete(callback);
+  }
+  // Snapshots
+  getThreadsSnapshot() {
+    return this._threads;
+  }
+  getCurrentThreadSnapshot() {
+    return this._currentThread;
+  }
+  getLoadStatusSnapshot() {
+    return this._loadStatus;
+  }
+  getErrorSnapshot() {
+    return this._error;
+  }
+  notify() {
+    this.callbacks.forEach((cb) => cb());
+  }
+};
+
+// src/thread/adapters/localStorageAdapter.ts
+var DEFAULT_STORAGE_KEY = "copilot-sdk-store";
+var STORE_VERSION = 1;
+function isLocalStorageAvailable() {
+  if (typeof window === "undefined") return false;
+  try {
+    const testKey = "__copilot_test__";
+    window.localStorage.setItem(testKey, testKey);
+    window.localStorage.removeItem(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createEmptyStore() {
+  return {
+    version: STORE_VERSION,
+    lastActiveThreadId: null,
+    threads: []
+  };
+}
+function serializeThread(thread) {
+  return {
+    id: thread.id,
+    title: thread.title,
+    preview: thread.preview,
+    messageCount: thread.messageCount,
+    createdAt: thread.createdAt.toISOString(),
+    updatedAt: thread.updatedAt.toISOString(),
+    sources: thread.sources || [],
+    messages: thread.messages.map((m) => ({
+      id: m.id,
+      role: m.role,
+      content: m.content,
+      created_at: m.created_at instanceof Date ? m.created_at.toISOString() : m.created_at,
+      tool_calls: m.tool_calls,
+      tool_call_id: m.tool_call_id,
+      metadata: m.metadata
+    }))
+  };
+}
+function deserializeThread(data) {
+  return {
+    id: data.id,
+    title: data.title,
+    preview: data.preview,
+    messageCount: data.messageCount ?? data.messages?.length ?? 0,
+    createdAt: new Date(data.createdAt),
+    updatedAt: new Date(data.updatedAt),
+    sources: data.sources || [],
+    messages: (data.messages || []).map((m) => ({
+      id: m.id,
+      role: m.role,
+      content: m.content,
+      created_at: new Date(m.created_at),
+      tool_calls: m.tool_calls,
+      tool_call_id: m.tool_call_id,
+      metadata: m.metadata
+    }))
+  };
+}
+function readStore(storageKey) {
+  if (!isLocalStorageAvailable()) {
+    return createEmptyStore();
+  }
+  try {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw) {
+      return createEmptyStore();
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      console.warn("[CopilotSDK] Invalid store format, resetting");
+      return createEmptyStore();
+    }
+    if (parsed.version !== STORE_VERSION) {
+      console.log(
+        `[CopilotSDK] Migrating store from v${parsed.version} to v${STORE_VERSION}`
+      );
+    }
+    return {
+      version: STORE_VERSION,
+      lastActiveThreadId: parsed.lastActiveThreadId ?? null,
+      threads: Array.isArray(parsed.threads) ? parsed.threads : []
+    };
+  } catch (e) {
+    console.warn("[CopilotSDK] Failed to read store, resetting:", e);
+    return createEmptyStore();
+  }
+}
+function writeStore(storageKey, store) {
+  if (!isLocalStorageAvailable()) return;
+  try {
+    const serialized = JSON.stringify(store);
+    localStorage.setItem(storageKey, serialized);
+  } catch (e) {
+    if (e instanceof DOMException && e.name === "QuotaExceededError") {
+      console.error(
+        "[CopilotSDK] localStorage quota exceeded. Consider clearing old threads."
+      );
+    } else {
+      console.warn("[CopilotSDK] Failed to write store:", e);
+    }
+  }
+}
+function updateStore(storageKey, updater) {
+  const store = readStore(storageKey);
+  const updates = updater(store);
+  const newStore = { ...store, ...updates };
+  writeStore(storageKey, newStore);
+  return newStore;
+}
+function createLocalStorageAdapter(config) {
+  const storageKey = config?.storageKey ?? DEFAULT_STORAGE_KEY;
+  return {
+    save: async (threads) => {
+      updateStore(storageKey, (store) => ({
+        threads: threads.map(serializeThread)
+      }));
+    },
+    load: async () => {
+      const store = readStore(storageKey);
+      return store.threads.map(deserializeThread);
+    },
+    clear: async () => {
+      if (!isLocalStorageAvailable()) return;
+      try {
+        localStorage.removeItem(storageKey);
+      } catch (e) {
+        console.warn("[CopilotSDK] Failed to clear store:", e);
+      }
+    },
+    getLastActiveThreadId: async () => {
+      const store = readStore(storageKey);
+      return store.lastActiveThreadId;
+    },
+    setLastActiveThreadId: async (threadId) => {
+      updateStore(storageKey, () => ({
+        lastActiveThreadId: threadId
+      }));
+    }
+  };
+}
+var localStorageAdapter = createLocalStorageAdapter();
+
+// src/thread/adapters/serverAdapter.ts
+function parseThread(data) {
+  return {
+    id: data.id,
+    title: data.title,
+    preview: data.preview,
+    messageCount: data.messageCount,
+    createdAt: new Date(data.createdAt),
+    updatedAt: new Date(data.updatedAt),
+    messages: (data.messages ?? []).map((m) => ({
+      id: m.id,
+      role: m.role,
+      content: m.content,
+      created_at: m.created_at ? new Date(m.created_at) : /* @__PURE__ */ new Date(),
+      tool_calls: m.tool_calls,
+      tool_call_id: m.tool_call_id,
+      metadata: m.metadata
+    })),
+    sources: data.sources ?? []
+  };
+}
+function serializeThread2(thread) {
+  const serialized = {};
+  if (thread.id !== void 0) serialized.id = thread.id;
+  if (thread.title !== void 0) serialized.title = thread.title;
+  if (thread.preview !== void 0) serialized.preview = thread.preview;
+  if (thread.messageCount !== void 0)
+    serialized.messageCount = thread.messageCount;
+  if (thread.createdAt !== void 0)
+    serialized.createdAt = thread.createdAt.toISOString();
+  if (thread.updatedAt !== void 0)
+    serialized.updatedAt = thread.updatedAt.toISOString();
+  if (thread.messages !== void 0) {
+    serialized.messages = thread.messages.map((m) => ({
+      id: m.id,
+      role: m.role,
+      content: m.content,
+      created_at: m.created_at instanceof Date ? m.created_at.toISOString() : m.created_at,
+      tool_calls: m.tool_calls,
+      tool_call_id: m.tool_call_id,
+      metadata: m.metadata
+    }));
+  }
+  if (thread.sources !== void 0) serialized.sources = thread.sources;
+  return serialized;
+}
+function createServerAdapter(config) {
+  const { endpoint, headers = {} } = config;
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const buildUrl = (path = "", params) => {
+    const url = new URL(
+      path ? `${endpoint}/${path}` : endpoint,
+      globalThis.location?.origin ?? "http://localhost"
+    );
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
+    }
+    return url.toString();
+  };
+  const request = async (method, path = "", body, params) => {
+    const url = buildUrl(path, params);
+    const response = await fetchFn(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Server adapter request failed: ${response.status} ${response.statusText} - ${errorText}`
+      );
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  };
+  return {
+    // ============================================
+    // Basic Operations (required by ThreadStorageAdapter)
+    // ============================================
+    /**
+     * Load all threads from server
+     * Note: For large datasets, prefer using listThreads with pagination
+     */
+    load: async () => {
+      const response = await request("GET");
+      const threads = Array.isArray(response) ? response : response.threads;
+      return threads.map(parseThread);
+    },
+    /**
+     * Save all threads to server (batch upsert)
+     * Note: This is a fallback - prefer using individual CRUD operations
+     */
+    save: async (threads) => {
+      await request("PUT", "", {
+        threads: threads.map(serializeThread2)
+      });
+    },
+    /**
+     * Clear all threads
+     */
+    clear: async () => {
+      await request("DELETE", "");
+    },
+    // ============================================
+    // Optimized Single-Thread Operations
+    // ============================================
+    /**
+     * Get a single thread by ID with messages
+     */
+    getThread: async (id) => {
+      try {
+        const response = await request("GET", id);
+        return parseThread(response);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("404")) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    /**
+     * Create a new thread
+     */
+    createThread: async (thread) => {
+      const response = await request(
+        "POST",
+        "",
+        serializeThread2(thread)
+      );
+      return parseThread(response);
+    },
+    /**
+     * Update an existing thread
+     */
+    updateThread: async (id, updates) => {
+      const response = await request(
+        "PATCH",
+        id,
+        serializeThread2(updates)
+      );
+      return parseThread(response);
+    },
+    /**
+     * Delete a thread by ID
+     */
+    deleteThread: async (id) => {
+      await request("DELETE", id);
+    },
+    /**
+     * List threads with pagination
+     */
+    listThreads: async (options) => {
+      const params = {};
+      if (options?.limit) params.limit = String(options.limit);
+      if (options?.offset) params.offset = String(options.offset);
+      if (options?.orderBy) params.orderBy = options.orderBy;
+      if (options?.orderDir) params.orderDir = options.orderDir;
+      const response = await request(
+        "GET",
+        "",
+        void 0,
+        params
+      );
+      return {
+        threads: response.threads.map((t) => ({
+          id: t.id,
+          title: t.title,
+          preview: t.preview,
+          messageCount: t.messageCount,
+          createdAt: new Date(t.createdAt),
+          updatedAt: new Date(t.updatedAt)
+        })),
+        total: response.total,
+        hasMore: response.hasMore ?? false
+      };
+    },
+    // ============================================
+    // Session Persistence
+    // ============================================
+    /**
+     * Get the last active thread ID from localStorage
+     */
+    getLastActiveThreadId: async () => {
+      if (typeof window === "undefined") return null;
+      try {
+        return localStorage.getItem("yourgpt-last-thread-id");
+      } catch {
+        return null;
+      }
+    },
+    /**
+     * Store the last active thread ID in localStorage
+     */
+    setLastActiveThreadId: async (threadId) => {
+      if (typeof window === "undefined") return;
+      try {
+        if (threadId) {
+          localStorage.setItem("yourgpt-last-thread-id", threadId);
+        } else {
+          localStorage.removeItem("yourgpt-last-thread-id");
+        }
+      } catch {
+      }
+    }
+  };
+}
+
+// src/thread/adapters/memoryAdapter.ts
+function createMemoryAdapter(initialThreads) {
+  let threads = initialThreads ? [...initialThreads] : [];
+  return {
+    save: async (newThreads) => {
+      threads = JSON.parse(JSON.stringify(newThreads));
+      threads = threads.map((t) => ({
+        ...t,
+        createdAt: new Date(t.createdAt),
+        updatedAt: new Date(t.updatedAt),
+        messages: t.messages.map((m) => ({
+          ...m,
+          created_at: new Date(m.created_at)
+        }))
+      }));
+    },
+    load: async () => {
+      return threads.map((t) => ({
+        ...t,
+        messages: [...t.messages],
+        sources: [...t.sources]
+      }));
+    },
+    clear: async () => {
+      threads = [];
+    }
+  };
+}
+var noopAdapter = {
+  save: async () => {
+  },
+  load: async () => [],
+  clear: async () => {
+  }
+};
+
+// src/thread/ThreadManager.ts
+function generateThreadId2() {
+  return `thread_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateThreadTitle2(content) {
+  const trimmed = content.trim();
+  if (trimmed.length <= 50) return trimmed;
+  return trimmed.substring(0, 47) + "...";
+}
+function generatePreview(content) {
+  const trimmed = content.trim();
+  if (trimmed.length <= 100) return trimmed;
+  return trimmed.substring(0, 97) + "...";
+}
+var ThreadManager = class {
+  constructor(config = {}, callbacks = {}) {
+    // Debounce timer for auto-save
+    this.saveTimer = null;
+    // Full thread data cache (for localStorage adapter)
+    this.threadsData = /* @__PURE__ */ new Map();
+    // Initialization promise
+    this.initPromise = null;
+    this.state = config.state ?? new SimpleThreadManagerState();
+    this.adapter = config.adapter ?? localStorageAdapter;
+    this.callbacks = callbacks;
+    this.saveDebounce = config.saveDebounce ?? 1e3;
+    this.autoLoad = config.autoLoad ?? true;
+    this.autoRestoreLastThread = config.autoRestoreLastThread ?? true;
+    if (this.autoLoad) {
+      this.initPromise = this.loadThreads().catch((err) => {
+        console.warn("[ThreadManager] Auto-load failed:", err);
+      });
+    }
+  }
+  // ============================================
+  // Getters
+  // ============================================
+  /** All threads (metadata) */
+  get threads() {
+    return this.state.threads;
+  }
+  /** Currently selected thread ID */
+  get currentThreadId() {
+    return this.state.currentThreadId;
+  }
+  /** Currently loaded thread (with messages) */
+  get currentThread() {
+    return this.state.currentThread;
+  }
+  /** Whether threads are currently loading */
+  get isLoading() {
+    return this.state.loadStatus === "loading";
+  }
+  /** Current load status */
+  get loadStatus() {
+    return this.state.loadStatus;
+  }
+  /** Current error */
+  get error() {
+    return this.state.error;
+  }
+  /** Whether there are pending changes waiting to be saved */
+  get hasPendingChanges() {
+    return this.saveTimer !== null;
+  }
+  // ============================================
+  // Public Methods
+  // ============================================
+  /**
+   * Load all threads from storage
+   */
+  async loadThreads() {
+    this.state.setLoadStatus("loading");
+    this.state.setError(void 0);
+    try {
+      const threadsData = await this.adapter.load();
+      this.threadsData.clear();
+      for (const thread of threadsData) {
+        this.threadsData.set(thread.id, thread);
+      }
+      const threads = threadsData.map((t) => ({
+        id: t.id,
+        title: t.title,
+        preview: t.preview ?? (t.messages[0]?.content ? generatePreview(
+          typeof t.messages[0].content === "string" ? t.messages[0].content : ""
+        ) : void 0),
+        messageCount: t.messageCount ?? t.messages.length,
+        createdAt: t.createdAt,
+        updatedAt: t.updatedAt
+      }));
+      threads.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+      this.state.setThreads(threads);
+      this.state.setLoadStatus("loaded");
+      this.callbacks.onThreadsLoaded?.(threads);
+      if (this.autoRestoreLastThread && this.adapter.getLastActiveThreadId) {
+        const lastActiveId = await this.adapter.getLastActiveThreadId();
+        if (lastActiveId && this.threadsData.has(lastActiveId)) {
+          this.switchThread(lastActiveId).catch((err) => {
+            console.warn(
+              "[ThreadManager] Failed to restore last active thread:",
+              err
+            );
+          });
+        }
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.state.setError(error);
+      this.state.setLoadStatus("error");
+      this.callbacks.onError?.(error);
+      throw error;
+    }
+  }
+  /**
+   * Wait for initialization to complete
+   */
+  async waitForInit() {
+    if (this.initPromise) {
+      await this.initPromise;
+    }
+  }
+  /**
+   * Create a new thread
+   */
+  async createThread(options) {
+    const now = /* @__PURE__ */ new Date();
+    const id = options?.id ?? generateThreadId2();
+    let title = options?.title;
+    if (!title && options?.messages) {
+      const firstUserMsg = options.messages.find((m) => m.role === "user");
+      if (firstUserMsg?.content) {
+        title = generateThreadTitle2(
+          typeof firstUserMsg.content === "string" ? firstUserMsg.content : ""
+        );
+      }
+    }
+    const thread = {
+      id,
+      title,
+      messages: options?.messages ?? [],
+      sources: [],
+      createdAt: now,
+      updatedAt: now,
+      preview: options?.messages?.[0]?.content ? generatePreview(
+        typeof options.messages[0].content === "string" ? options.messages[0].content : ""
+      ) : void 0,
+      messageCount: options?.messages?.length ?? 0
+    };
+    const asyncAdapter = this.adapter;
+    if (asyncAdapter.createThread) {
+      try {
+        const created = await asyncAdapter.createThread(thread);
+        this.threadsData.set(created.id, created);
+        this.state.addThread(created);
+        this.state.setCurrentThread(created);
+        this.callbacks.onThreadCreated?.(created);
+        this.saveLastActiveThread(created.id);
+        return created;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.state.setError(error);
+        this.callbacks.onError?.(error);
+        throw error;
+      }
+    }
+    this.threadsData.set(id, thread);
+    this.state.addThread(thread);
+    this.state.setCurrentThread(thread);
+    this.scheduleSave();
+    this.callbacks.onThreadCreated?.(thread);
+    this.saveLastActiveThread(id);
+    return thread;
+  }
+  /**
+   * Switch to a different thread
+   */
+  async switchThread(id) {
+    if (this.currentThreadId === id && this.currentThread) {
+      return this.currentThread;
+    }
+    const asyncAdapter = this.adapter;
+    if (asyncAdapter.getThread) {
+      try {
+        const thread2 = await asyncAdapter.getThread(id);
+        this.state.setCurrentThread(thread2);
+        if (thread2) {
+          this.threadsData.set(id, thread2);
+          this.saveLastActiveThread(id);
+        }
+        this.callbacks.onThreadSwitched?.(thread2);
+        return thread2;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.state.setError(error);
+        this.callbacks.onError?.(error);
+        throw error;
+      }
+    }
+    const thread = this.threadsData.get(id) ?? null;
+    this.state.setCurrentThread(thread);
+    if (thread) {
+      this.saveLastActiveThread(id);
+    }
+    this.callbacks.onThreadSwitched?.(thread);
+    return thread;
+  }
+  /**
+   * Update the current thread
+   */
+  async updateCurrentThread(updates) {
+    if (!this.currentThread) {
+      throw new Error("No thread selected");
+    }
+    const now = /* @__PURE__ */ new Date();
+    const id = this.currentThread.id;
+    const updatedThread = {
+      ...this.currentThread,
+      ...updates,
+      updatedAt: now
+    };
+    if (updates.messages) {
+      updatedThread.messageCount = updates.messages.length;
+      if (updates.messages[0]?.content) {
+        updatedThread.preview = generatePreview(
+          typeof updates.messages[0].content === "string" ? updates.messages[0].content : ""
+        );
+      }
+      if (!updatedThread.title) {
+        const firstUserMsg = updates.messages.find((m) => m.role === "user");
+        if (firstUserMsg?.content) {
+          updatedThread.title = generateThreadTitle2(
+            typeof firstUserMsg.content === "string" ? firstUserMsg.content : ""
+          );
+        }
+      }
+    }
+    const asyncAdapter = this.adapter;
+    if (asyncAdapter.updateThread) {
+      try {
+        const updated = await asyncAdapter.updateThread(id, updatedThread);
+        this.threadsData.set(id, updated);
+        this.state.setCurrentThread(updated);
+        this.state.updateThread(id, {
+          title: updated.title,
+          preview: updated.preview,
+          messageCount: updated.messageCount,
+          updatedAt: updated.updatedAt
+        });
+        this.callbacks.onThreadUpdated?.(updated);
+        return;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.state.setError(error);
+        this.callbacks.onError?.(error);
+        throw error;
+      }
+    }
+    this.threadsData.set(id, updatedThread);
+    this.state.setCurrentThread(updatedThread);
+    this.state.updateThread(id, {
+      title: updatedThread.title,
+      preview: updatedThread.preview,
+      messageCount: updatedThread.messageCount,
+      updatedAt: updatedThread.updatedAt
+    });
+    this.scheduleSave();
+    this.callbacks.onThreadUpdated?.(updatedThread);
+  }
+  /**
+   * Delete a thread
+   */
+  async deleteThread(id) {
+    const isDeletingCurrent = this.currentThreadId === id;
+    const asyncAdapter = this.adapter;
+    if (asyncAdapter.deleteThread) {
+      try {
+        await asyncAdapter.deleteThread(id);
+        this.threadsData.delete(id);
+        this.state.removeThread(id);
+        if (isDeletingCurrent) {
+          this.state.setCurrentThread(null);
+          this.saveLastActiveThread(null);
+        }
+        this.callbacks.onThreadDeleted?.(id);
+        return;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.state.setError(error);
+        this.callbacks.onError?.(error);
+        throw error;
+      }
+    }
+    this.threadsData.delete(id);
+    this.state.removeThread(id);
+    if (isDeletingCurrent) {
+      this.state.setCurrentThread(null);
+      this.saveLastActiveThread(null);
+    }
+    this.scheduleSave();
+    this.callbacks.onThreadDeleted?.(id);
+  }
+  /**
+   * Clear the current thread selection
+   */
+  clearCurrentThread() {
+    this.state.setCurrentThread(null);
+    this.saveLastActiveThread(null);
+    this.callbacks.onThreadSwitched?.(null);
+  }
+  /**
+   * Clear all threads
+   */
+  async clearAllThreads() {
+    try {
+      await this.adapter.clear();
+      this.threadsData.clear();
+      this.state.setThreads([]);
+      this.state.setCurrentThread(null);
+      this.saveLastActiveThread(null);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.state.setError(error);
+      this.callbacks.onError?.(error);
+      throw error;
+    }
+  }
+  /**
+   * Save changes immediately (bypass debounce)
+   */
+  async saveNow() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    try {
+      const threads = Array.from(this.threadsData.values());
+      await this.adapter.save(threads);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.state.setError(error);
+      this.callbacks.onError?.(error);
+      throw error;
+    }
+  }
+  /**
+   * Dispose of the manager and save pending changes
+   */
+  async dispose() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+      await this.saveNow();
+    }
+  }
+  // ============================================
+  // Protected Methods
+  // ============================================
+  /**
+   * Schedule a debounced save
+   */
+  scheduleSave() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+    }
+    this.saveTimer = setTimeout(async () => {
+      this.saveTimer = null;
+      try {
+        await this.saveNow();
+      } catch (err) {
+        console.warn("[ThreadManager] Auto-save failed:", err);
+      }
+    }, this.saveDebounce);
+  }
+  /**
+   * Save the last active thread ID (for session persistence)
+   */
+  saveLastActiveThread(threadId) {
+    if (this.adapter.setLastActiveThreadId) {
+      this.adapter.setLastActiveThreadId(threadId).catch((err) => {
+        console.warn("[ThreadManager] Failed to save last active thread:", err);
+      });
+    }
+  }
+};
+function createThreadManager(config, callbacks) {
+  return new ThreadManager(config, callbacks);
+}
+
 exports.CLOUD_MAX_FILE_SIZE = CLOUD_MAX_FILE_SIZE;
 exports.DEFAULT_MODELS = DEFAULT_MODELS;
 exports.DEFAULT_YOURGPT_ENDPOINT = DEFAULT_YOURGPT_ENDPOINT;
+exports.SimpleThreadManagerState = SimpleThreadManagerState;
+exports.ThreadManager = ThreadManager;
 exports.actionToTool = actionToTool;
 exports.builtinTools = builtinTools;
 exports.captureCurrentLogs = captureCurrentLogs;
@@ -1855,10 +2736,14 @@ exports.createAssistantMessage = createAssistantMessage;
 exports.createCloudStorage = createCloudStorage;
 exports.createConsoleLogsTool = createConsoleLogsTool;
 exports.createCustomDetector = createCustomDetector;
+exports.createLocalStorageAdapter = createLocalStorageAdapter;
+exports.createMemoryAdapter = createMemoryAdapter;
 exports.createMessage = createMessage;
 exports.createNetworkRequestsTool = createNetworkRequestsTool;
 exports.createSSEStream = createSSEStream;
 exports.createScreenshotTool = createScreenshotTool;
+exports.createServerAdapter = createServerAdapter;
+exports.createThreadManager = createThreadManager;
 exports.createToolCall = createToolCall;
 exports.createToolMessage = createToolMessage;
 exports.createToolResult = createToolResult;
@@ -1892,7 +2777,9 @@ exports.isConsoleCaptureActive = isConsoleCaptureActive;
 exports.isNetworkCaptureActive = isNetworkCaptureActive;
 exports.isScreenshotSupported = isScreenshotSupported;
 exports.isToolResult = isToolResult;
+exports.localStorageAdapter = localStorageAdapter;
 exports.networkRequestsTool = networkRequestsTool;
+exports.noopAdapter = noopAdapter;
 exports.parseSSELine = parseSSELine;
 exports.parseStreamEvent = parseStreamEvent;
 exports.parseToolCallArgs = parseToolCallArgs;
@@ -1911,5 +2798,5 @@ exports.toolToAnthropicFormat = toolToAnthropicFormat;
 exports.toolToOpenAIFormat = toolToOpenAIFormat;
 exports.zodObjectToInputSchema = zodObjectToInputSchema;
 exports.zodToJsonSchema = zodToJsonSchema;
-//# sourceMappingURL=chunk-IH7WXWX4.cjs.map
-//# sourceMappingURL=chunk-IH7WXWX4.cjs.map
+//# sourceMappingURL=chunk-42YQ4ATO.cjs.map
+//# sourceMappingURL=chunk-42YQ4ATO.cjs.map