@yourgpt/copilot-sdk 0.1.0 → 1.0.0

package/dist/{chunk-QUGTRQSS.js → chunk-XAVZZVUL.js}

@@ -1,4 +1,4 @@
-import { isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-N4OA2J32.js';
+import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-QSEGNATZ.js';
 import { createContext, useContext, useCallback, useEffect, useState, useRef, useSyncExternalStore, useMemo } from 'react';
 import { jsx } from 'react/jsx-runtime';
 import * as z from 'zod';
@@ -822,7 +822,7 @@ var AbstractAgentLoop = class {
     this._isProcessing = false;
     // Registered tools
     this.registeredTools = /* @__PURE__ */ new Map();
-    // Pending approvals
+    // Pending approvals - resolve with approval result including extraData
     this.pendingApprovals = /* @__PURE__ */ new Map();
     this.config = config;
     this.callbacks = callbacks;
@@ -968,15 +968,18 @@ var AbstractAgentLoop = class {
       });
       return errorResult;
     }
+    let approvalData;
     if (tool.needsApproval && !this.config.autoApprove) {
-      typeof tool.approvalMessage === "function" ? tool.approvalMessage(toolCall.args) : tool.approvalMessage;
+      const approvalMessage = typeof tool.approvalMessage === "function" ? tool.approvalMessage(toolCall.args) : tool.approvalMessage;
       execution.approvalStatus = "required";
+      execution.approvalMessage = approvalMessage;
       this.updateToolExecution(toolCall.id, {
-        approvalStatus: "required"
+        approvalStatus: "required",
+        approvalMessage
       });
       this.callbacks.onApprovalRequired?.(execution);
-      const approved = await this.waitForApproval(toolCall.id, execution);
-      if (!approved) {
+      const approvalResult = await this.waitForApproval(toolCall.id, execution);
+      if (!approvalResult.approved) {
         const rejectedResult = {
           toolCallId: toolCall.id,
           success: false,
@@ -990,9 +993,7 @@ var AbstractAgentLoop = class {
         });
         return rejectedResult;
       }
-      this.updateToolExecution(toolCall.id, {
-        approvalStatus: "approved"
-      });
+      approvalData = approvalResult.extraData;
     }
     this.updateToolExecution(toolCall.id, { status: "executing" });
     try {
@@ -1000,7 +1001,8 @@ var AbstractAgentLoop = class {
         throw new Error(`Tool "${toolCall.name}" has no handler`);
       }
       const result = await tool.handler(toolCall.args, {
-        data: { toolCallId: toolCall.id }
+        data: { toolCallId: toolCall.id },
+        approvalData
       });
       this.updateToolExecution(toolCall.id, {
         status: "completed",
@@ -1034,6 +1036,7 @@ var AbstractAgentLoop = class {
   }
   /**
    * Wait for user approval
+   * Returns approval result with optional extraData from user's action
    */
   waitForApproval(executionId, execution) {
     return new Promise((resolve) => {
@@ -1044,13 +1047,17 @@ var AbstractAgentLoop = class {
   // Actions (implements AgentLoopActions)
   // ============================================
   /**
-   * Approve a tool execution
+   * Approve a tool execution with optional extra data
    */
-  approveToolExecution(executionId, _permissionLevel) {
+  approveToolExecution(executionId, extraData, _permissionLevel) {
     const pending = this.pendingApprovals.get(executionId);
     if (pending) {
-      pending.resolve(true);
+      pending.resolve({ approved: true, extraData });
       this.pendingApprovals.delete(executionId);
+      this.updateToolExecution(executionId, {
+        approvalStatus: "approved",
+        approvalData: extraData
+      });
     }
   }
   /**
@@ -1064,7 +1071,7 @@ var AbstractAgentLoop = class {
           error: reason
         });
       }
-      pending.resolve(false);
+      pending.resolve({ approved: false });
       this.pendingApprovals.delete(executionId);
     }
   }
@@ -1108,8 +1115,8 @@ var AbstractAgentLoop = class {
    * Dispose of resources
    */
   dispose() {
-    for (const [id, pending] of this.pendingApprovals) {
-      pending.resolve(false);
+    for (const [_id, pending] of this.pendingApprovals) {
+      pending.resolve({ approved: false });
     }
     this.pendingApprovals.clear();
     this.registeredTools.clear();
@@ -1299,10 +1306,10 @@ var ChatWithTools = class {
   // Tool Approval
   // ============================================
   /**
-   * Approve a tool execution
+   * Approve a tool execution with optional extra data
    */
-  approveToolExecution(id, permissionLevel) {
-    this.agentLoop.approveToolExecution(id, permissionLevel);
+  approveToolExecution(id, extraData, permissionLevel) {
+    this.agentLoop.approveToolExecution(id, extraData, permissionLevel);
   }
   /**
    * Reject a tool execution
@@ -1645,8 +1652,8 @@ function CopilotProvider({
     chatRef.current?.unregisterTool(name);
   }, []);
   const approveToolExecution = useCallback(
-    (id, permissionLevel) => {
-      chatRef.current?.approveToolExecution(id, permissionLevel);
+    (id, extraData, permissionLevel) => {
+      chatRef.current?.approveToolExecution(id, extraData, permissionLevel);
     },
     []
   );
@@ -1713,6 +1720,9 @@ function CopilotProvider({
   const clearMessages = useCallback(() => {
     chatRef.current?.clearMessages();
   }, []);
+  const setMessages = useCallback((messages2) => {
+    chatRef.current?.setMessages(messages2);
+  }, []);
   const regenerate = useCallback(async (messageId) => {
     await chatRef.current?.regenerate(messageId);
   }, []);
@@ -1754,6 +1764,7 @@ function CopilotProvider({
       sendMessage,
       stop,
       clearMessages,
+      setMessages,
       regenerate,
       // Tool execution
       registerTool,
@@ -1783,6 +1794,7 @@ function CopilotProvider({
       sendMessage,
       stop,
       clearMessages,
+      setMessages,
       regenerate,
       registerTool,
       unregisterTool,
@@ -2847,6 +2859,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 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 = 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 = useSyncExternalStore(
+    manager.subscribe,
+    manager.getThreadsSnapshot,
+    manager.getThreadsServerSnapshot
+    // SSR - always empty array
+  );
+  const currentThread = useSyncExternalStore(
+    manager.subscribe,
+    manager.getCurrentThreadSnapshot,
+    manager.getCurrentThreadServerSnapshot
+    // SSR - always null
+  );
+  const currentThreadId = useSyncExternalStore(
+    manager.subscribe,
+    manager.getCurrentThreadIdSnapshot,
+    manager.getCurrentThreadIdServerSnapshot
+    // SSR - always null
+  );
+  const loadStatus = useSyncExternalStore(
+    manager.subscribe,
+    manager.getLoadStatusSnapshot,
+    manager.getLoadStatusServerSnapshot
+    // SSR - always "idle"
+  );
+  const error = useSyncExternalStore(
+    manager.subscribe,
+    manager.getErrorSnapshot,
+    manager.getErrorServerSnapshot
+    // SSR - always undefined
+  );
+  const isLoading = useSyncExternalStore(
+    manager.subscribe,
+    manager.getIsLoadingSnapshot,
+    manager.getIsLoadingServerSnapshot
+    // SSR - always false
+  );
+  useEffect(() => {
+    return () => {
+      if (config?.adapter && manager !== defaultManager && manager !== internalManager) {
+        manager.dispose();
+      }
+    };
+  }, [manager, config]);
+  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 = useCallback(
+    (options) => manager.createThread(options),
+    [manager]
+  );
+  const switchThread = useCallback(
+    (id) => manager.switchThread(id),
+    [manager]
+  );
+  const updateCurrentThread = useCallback(
+    (updates) => manager.updateCurrentThread(updates),
+    [manager]
+  );
+  const deleteThread = useCallback(
+    (id) => manager.deleteThread(id),
+    [manager]
+  );
+  const clearCurrentThread = useCallback(
+    () => manager.clearCurrentThread(),
+    [manager]
+  );
+  const refreshThreads = useCallback(() => manager.loadThreads(), [manager]);
+  const saveNow = useCallback(() => manager.saveNow(), [manager]);
+  const clearAllThreads = useCallback(
+    () => manager.clearAllThreads(),
+    [manager]
+  );
+  const messages = useMemo(
+    () => currentThread?.messages ?? [],
+    [currentThread]
+  );
+  const setMessages = 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) {
@@ -3095,6 +3526,6 @@ function useChat(config) {
   };
 }
 
-export { AbstractAgentLoop, AbstractChat, CopilotProvider, ReactChat, ReactChatState, createPermissionStorage, createReactChat, createReactChatState, createSessionPermissionCache, formatKnowledgeResultsForAI, initialAgentLoopState, searchKnowledgeBase, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useCopilot, useDevLogger, useFeatureSupport, useKnowledgeBase, useSuggestions, useSupportedMediaTypes, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };
-//# sourceMappingURL=chunk-QUGTRQSS.js.map
-//# sourceMappingURL=chunk-QUGTRQSS.js.map
+export { AbstractAgentLoop, AbstractChat, CopilotProvider, ReactChat, ReactChatState, ReactThreadManager, ReactThreadManagerState, createPermissionStorage, createReactChat, createReactChatState, createReactThreadManager, createReactThreadManagerState, createSessionPermissionCache, formatKnowledgeResultsForAI, initialAgentLoopState, searchKnowledgeBase, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useCopilot, useDevLogger, useFeatureSupport, useKnowledgeBase, useSuggestions, useSupportedMediaTypes, useThreadManager, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };
+//# sourceMappingURL=chunk-XAVZZVUL.js.map
+//# sourceMappingURL=chunk-XAVZZVUL.js.map