@yourgpt/copilot-sdk 0.1.0 → 1.0.0

package/dist/ThreadManager-BCVt-_k_.d.cts

@@ -0,0 +1,863 @@
+import { k as Thread, l as ThreadData, _ as ThreadStorageAdapter, X as AsyncThreadStorageAdapter, g as Message } from './types-BtAaOV07.cjs';
+
+/**
+ * Tool types for App Context Awareness
+ */
+interface ScreenshotOptions {
+    /** Target element to capture (defaults to document.body) */
+    element?: HTMLElement;
+    /** Image quality (0.1-1.0, default 0.8) */
+    quality?: number;
+    /** Image format */
+    format?: "png" | "jpeg" | "webp";
+    /** Max width to scale down to */
+    maxWidth?: number;
+    /** Max height to scale down to */
+    maxHeight?: number;
+    /** Whether to include cursor */
+    includeCursor?: boolean;
+}
+interface ScreenshotResult {
+    /** Base64-encoded image data */
+    data: string;
+    /** Image format */
+    format: "png" | "jpeg" | "webp";
+    /** Image width */
+    width: number;
+    /** Image height */
+    height: number;
+    /** Timestamp of capture */
+    timestamp: number;
+}
+type ConsoleLogType = "log" | "info" | "warn" | "error" | "debug";
+interface ConsoleLogEntry {
+    /** Type of console method */
+    type: ConsoleLogType;
+    /** Log message(s) */
+    message: string;
+    /** Additional arguments passed to console */
+    args?: unknown[];
+    /** Stack trace (for errors) */
+    stack?: string;
+    /** Timestamp */
+    timestamp: number;
+}
+interface ConsoleLogOptions {
+    /** Types of logs to capture */
+    types?: ConsoleLogType[];
+    /** Maximum number of logs to store */
+    limit?: number;
+    /** Filter function */
+    filter?: (entry: ConsoleLogEntry) => boolean;
+}
+interface ConsoleLogResult {
+    /** Captured log entries */
+    logs: ConsoleLogEntry[];
+    /** Total logs captured (before limit) */
+    totalCaptured: number;
+}
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+interface NetworkRequestEntry {
+    /** Request URL */
+    url: string;
+    /** HTTP method */
+    method: HttpMethod;
+    /** Response status code */
+    status: number;
+    /** Status text */
+    statusText: string;
+    /** Whether request failed (non-2xx or error) */
+    failed: boolean;
+    /** Request headers (sanitized) */
+    requestHeaders?: Record<string, string>;
+    /** Response headers (sanitized) */
+    responseHeaders?: Record<string, string>;
+    /** Request body (if captured) */
+    requestBody?: unknown;
+    /** Response body (if captured and failed) */
+    responseBody?: unknown;
+    /** Request duration in ms */
+    duration: number;
+    /** Timestamp of request start */
+    timestamp: number;
+    /** Error message if request failed */
+    error?: string;
+}
+interface NetworkRequestOptions {
+    /** Maximum number of requests to store */
+    limit?: number;
+    /** Only capture failed requests (default: true) */
+    failedOnly?: boolean;
+    /** HTTP methods to capture */
+    methods?: HttpMethod[];
+    /** URL patterns to include (regex) */
+    includeUrls?: RegExp[];
+    /** URL patterns to exclude (regex) */
+    excludeUrls?: RegExp[];
+    /** Whether to capture request body */
+    captureRequestBody?: boolean;
+    /** Whether to capture response body */
+    captureResponseBody?: boolean;
+    /** Max body size to capture (bytes) */
+    maxBodySize?: number;
+}
+interface NetworkRequestResult {
+    /** Captured network requests */
+    requests: NetworkRequestEntry[];
+    /** Total requests captured (before limit) */
+    totalCaptured: number;
+}
+type ToolType = "screenshot" | "console" | "network";
+interface IntentDetectionResult {
+    /** Detected tools that might be helpful */
+    suggestedTools: ToolType[];
+    /** Confidence score (0-1) for each tool */
+    confidence: Record<ToolType, number>;
+    /** Keywords that triggered detection */
+    matchedKeywords: Record<ToolType, string[]>;
+}
+interface ToolsConfig {
+    /** Enable screenshot capture */
+    screenshot?: boolean;
+    /** Enable console log capture */
+    console?: boolean;
+    /** Enable network request capture */
+    network?: boolean;
+    /** Always require user consent before capturing (default: true) */
+    requireConsent?: boolean;
+    /** Screenshot-specific options */
+    screenshotOptions?: ScreenshotOptions;
+    /** Console-specific options */
+    consoleOptions?: ConsoleLogOptions;
+    /** Network-specific options */
+    networkOptions?: NetworkRequestOptions;
+}
+interface ToolConsentRequest {
+    /** Tools being requested */
+    tools: ToolType[];
+    /** Reason for request (from intent detection) */
+    reason: string;
+    /** Keywords that triggered this request */
+    keywords: string[];
+}
+interface ToolConsentResponse {
+    /** Tools user approved */
+    approved: ToolType[];
+    /** Tools user denied */
+    denied: ToolType[];
+    /** Remember preference for session */
+    remember?: boolean;
+}
+interface CapturedContext {
+    /** Screenshot data (if captured) */
+    screenshot?: ScreenshotResult;
+    /** Console logs (if captured) */
+    consoleLogs?: ConsoleLogResult;
+    /** Network requests (if captured) */
+    networkRequests?: NetworkRequestResult;
+    /** Timestamp of capture */
+    timestamp: number;
+}
+
+/**
+ * Intent Detector
+ *
+ * Detects user intent from messages to suggest relevant tools.
+ * Framework-agnostic implementation using keyword matching.
+ */
+
+/**
+ * Detect user intent from a message
+ *
+ * @param message - User message to analyze
+ * @returns Detection result with suggested tools
+ *
+ * @example
+ * ```typescript
+ * const result = detectIntent("I'm seeing an error on my screen");
+ * // Returns:
+ * // {
+ * //   suggestedTools: ['screenshot', 'console'],
+ * //   confidence: { screenshot: 0.6, console: 0.8, network: 0 },
+ * //   matchedKeywords: { screenshot: ['seeing', 'screen'], console: ['error'] }
+ * // }
+ * ```
+ */
+declare function detectIntent(message: string): IntentDetectionResult;
+/**
+ * Check if a message suggests any tools
+ */
+declare function hasToolSuggestions(message: string): boolean;
+/**
+ * Get the primary suggested tool (highest confidence)
+ */
+declare function getPrimaryTool(message: string): ToolType | null;
+/**
+ * Generate a reason string for why tools are being suggested
+ */
+declare function generateSuggestionReason(result: IntentDetectionResult): string;
+/**
+ * Custom keyword configuration
+ */
+interface CustomKeywords {
+    screenshot?: string[];
+    console?: string[];
+    network?: string[];
+}
+/**
+ * Create a custom intent detector with additional keywords
+ */
+declare function createCustomDetector(customKeywords: CustomKeywords): (message: string) => IntentDetectionResult;
+
+/**
+ * Supported LLM providers
+ */
+type LLMProvider = "openai" | "anthropic" | "google" | "groq" | "ollama" | "custom";
+/**
+ * LLM configuration
+ */
+interface LLMConfig {
+    /** LLM provider */
+    provider: LLMProvider;
+    /** Model name (e.g., 'gpt-4o', 'claude-3-5-sonnet-latest') */
+    model?: string;
+    /** API key for the provider */
+    apiKey?: string;
+    /** Base URL for custom/self-hosted models */
+    baseUrl?: string;
+    /** Temperature (0-2) */
+    temperature?: number;
+    /** Maximum tokens in response */
+    maxTokens?: number;
+    /** Top P sampling */
+    topP?: number;
+    /** Frequency penalty */
+    frequencyPenalty?: number;
+    /** Presence penalty */
+    presencePenalty?: number;
+    /** Enable streaming responses (default: true) */
+    streaming?: boolean;
+}
+/**
+ * Cloud configuration (for managed hosting)
+ */
+interface CloudConfig {
+    /** API key */
+    apiKey: string;
+    /** Bot ID */
+    botId: string;
+    /** Custom API endpoint (optional) */
+    endpoint?: string;
+}
+/**
+ * Extension configuration
+ */
+interface Extension {
+    /** Extension name */
+    name: string;
+    /** Extension configuration */
+    config: Record<string, unknown>;
+    /** Initialize the extension */
+    init?: () => Promise<void>;
+}
+/**
+ * Main SDK configuration
+ */
+interface CopilotConfig {
+    /** LLM configuration (for self-hosted) */
+    config?: LLMConfig;
+    /** Cloud configuration (for managed hosting) */
+    cloud?: CloudConfig;
+    /** Runtime URL for self-hosted backend */
+    runtimeUrl?: string;
+    /** System prompt */
+    systemPrompt?: string;
+    /** Extensions (like knowledge base) */
+    extensions?: Extension[];
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Default LLM configurations per provider
+ */
+declare const DEFAULT_MODELS: Record<LLMProvider, string>;
+/**
+ * Get default model for a provider
+ */
+declare function getDefaultModel(provider: LLMProvider): string;
+
+/**
+ * Parameter types for actions
+ */
+type ParameterType = "string" | "number" | "boolean" | "object" | "array";
+/**
+ * Action parameter definition
+ */
+interface ActionParameter {
+    /** Parameter type */
+    type: ParameterType;
+    /** Description of the parameter */
+    description?: string;
+    /** Whether the parameter is required */
+    required?: boolean;
+    /** Default value */
+    default?: unknown;
+    /** Enum values for string type */
+    enum?: string[];
+    /** Properties for object type */
+    properties?: Record<string, ActionParameter>;
+    /** Items schema for array type */
+    items?: ActionParameter;
+}
+/**
+ * Action definition
+ */
+interface ActionDefinition<TParams = Record<string, unknown>> {
+    /** Unique name for the action */
+    name: string;
+    /** Description of what the action does */
+    description: string;
+    /** Parameter definitions */
+    parameters?: Record<string, ActionParameter>;
+    /** Handler function */
+    handler: (params: TParams) => unknown | Promise<unknown>;
+    /** Optional render function for UI */
+    render?: (props: ActionRenderProps<TParams>) => unknown;
+}
+/**
+ * Props passed to action render function
+ */
+interface ActionRenderProps<TParams = Record<string, unknown>> {
+    /** Current status */
+    status: "pending" | "executing" | "completed" | "error";
+    /** Arguments passed to the action */
+    args: TParams;
+    /** Result if completed */
+    result?: unknown;
+    /** Error if failed */
+    error?: string;
+}
+/**
+ * Convert action definition to OpenAI tool format
+ */
+declare function actionToTool(action: ActionDefinition): object;
+
+/**
+ * Knowledge Base Types
+ *
+ * Configuration and types for Knowledge Base (RAG) integration.
+ * Currently a placeholder - full implementation coming soon.
+ */
+/**
+ * Supported vector database providers
+ */
+type KnowledgeBaseProvider = "pinecone" | "qdrant" | "chroma" | "supabase" | "weaviate" | "custom";
+/**
+ * Knowledge Base configuration
+ */
+interface KnowledgeBaseConfig {
+    /** Unique identifier for this knowledge base */
+    id: string;
+    /** Display name */
+    name?: string;
+    /** Vector database provider */
+    provider: KnowledgeBaseProvider;
+    /** API key for the vector database */
+    apiKey?: string;
+    /** Index/collection name */
+    index?: string;
+    /** Namespace within the index */
+    namespace?: string;
+    /** Custom endpoint URL (for self-hosted or custom providers) */
+    endpoint?: string;
+    /** Number of results to return (default: 5) */
+    topK?: number;
+    /** Minimum similarity score threshold (0-1) */
+    scoreThreshold?: number;
+    /** Whether to include source metadata in results */
+    includeMetadata?: boolean;
+}
+/**
+ * Knowledge Base search result
+ */
+interface KnowledgeBaseResult {
+    /** Result content/text */
+    content: string;
+    /** Similarity score (0-1) */
+    score: number;
+    /** Source metadata */
+    metadata?: {
+        /** Source document/URL */
+        source?: string;
+        /** Document title */
+        title?: string;
+        /** Page number (for PDFs) */
+        page?: number;
+        /** Chunk index */
+        chunk?: number;
+        /** Any additional metadata */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Knowledge Base search request
+ */
+interface KnowledgeBaseSearchRequest {
+    /** Search query */
+    query: string;
+    /** Knowledge base ID to search */
+    knowledgeBaseId: string;
+    /** Number of results (overrides config) */
+    limit?: number;
+    /** Filter by metadata */
+    filter?: Record<string, unknown>;
+}
+/**
+ * Knowledge Base search response
+ */
+interface KnowledgeBaseSearchResponse {
+    /** Search results */
+    results: KnowledgeBaseResult[];
+    /** Knowledge base ID */
+    knowledgeBaseId: string;
+    /** Query that was searched */
+    query: string;
+    /** Search duration in ms */
+    durationMs?: number;
+}
+/**
+ * Internal Knowledge Base configuration
+ * Used for managed cloud searchIndexDocument API
+ */
+interface InternalKnowledgeBaseConfig {
+    /** Project UID for the knowledge base */
+    projectUid: string;
+    /** Auth token for API calls */
+    token: string;
+    /** App ID (default: "1") */
+    appId?: string;
+    /** Results limit (default: 5) */
+    limit?: number;
+    /** Whether KB is enabled (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Internal Knowledge Base search result
+ */
+interface InternalKnowledgeBaseResult {
+    /** Document ID */
+    id: string;
+    /** Document title */
+    title?: string;
+    /** Matched content snippet */
+    content: string;
+    /** Relevance score */
+    score?: number;
+    /** Source URL if available */
+    url?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Internal Knowledge Base search response
+ */
+interface InternalKnowledgeBaseSearchResponse {
+    /** Whether the search was successful */
+    success: boolean;
+    /** Search results */
+    results: InternalKnowledgeBaseResult[];
+    /** Total number of results */
+    total?: number;
+    /** Error message if failed */
+    error?: string;
+}
+
+/**
+ * ThreadManagerState Interface
+ *
+ * Contract for framework-specific state implementations.
+ * Following the same pattern as ChatState for framework agnosticism.
+ */
+
+/**
+ * Load status for async operations
+ */
+type LoadStatus = "idle" | "loading" | "loaded" | "error";
+/**
+ * ThreadManagerState interface - Framework adapters implement this
+ *
+ * This is the key abstraction that enables framework-agnostic code.
+ * The ThreadManager class uses this interface, and each framework
+ * provides its own implementation.
+ *
+ * @example React implementation
+ * ```typescript
+ * class ReactThreadManagerState implements ThreadManagerState {
+ *   #threads: Thread[] = [];
+ *   #callbacks = new Set<() => void>();
+ *
+ *   get threads() { return this.#threads; }
+ *   set threads(t) {
+ *     this.#threads = t;
+ *     this.#callbacks.forEach(cb => cb()); // Trigger re-render
+ *   }
+ *
+ *   subscribe(cb: () => void) {
+ *     this.#callbacks.add(cb);
+ *     return () => this.#callbacks.delete(cb);
+ *   }
+ * }
+ * ```
+ */
+interface ThreadManagerState {
+    /** All threads (metadata only) */
+    threads: Thread[];
+    /** Currently selected thread ID */
+    currentThreadId: string | null;
+    /** Currently loaded thread data (with messages) */
+    currentThread: ThreadData | null;
+    /** Current loading status */
+    loadStatus: LoadStatus;
+    /** Current error if any */
+    error: Error | undefined;
+    /**
+     * Set all threads
+     */
+    setThreads(threads: Thread[]): void;
+    /**
+     * Set the current thread
+     */
+    setCurrentThread(thread: ThreadData | null): void;
+    /**
+     * Set the current thread ID
+     */
+    setCurrentThreadId(id: string | null): void;
+    /**
+     * Add a new thread to the list
+     */
+    addThread(thread: Thread): void;
+    /**
+     * Update a thread's metadata
+     */
+    updateThread(id: string, updates: Partial<Thread>): void;
+    /**
+     * Remove a thread from the list
+     */
+    removeThread(id: string): void;
+    /**
+     * Set loading status
+     */
+    setLoadStatus(status: LoadStatus): void;
+    /**
+     * Set error
+     */
+    setError(error: Error | undefined): void;
+    /**
+     * Subscribe to state changes
+     * Returns unsubscribe function
+     *
+     * This is used by React's useSyncExternalStore.
+     * Vue/Svelte may not need this (they use refs/stores).
+     */
+    subscribe?(callback: () => void): () => void;
+    /**
+     * Get immutable snapshot of threads
+     */
+    getThreadsSnapshot?(): Thread[];
+    /**
+     * Get current thread snapshot
+     */
+    getCurrentThreadSnapshot?(): ThreadData | null;
+    /**
+     * Get load status snapshot
+     */
+    getLoadStatusSnapshot?(): LoadStatus;
+    /**
+     * Get error snapshot
+     */
+    getErrorSnapshot?(): Error | undefined;
+}
+/**
+ * Default in-memory state implementation (for testing/vanilla JS)
+ */
+declare class SimpleThreadManagerState implements ThreadManagerState {
+    private _threads;
+    private _currentThreadId;
+    private _currentThread;
+    private _loadStatus;
+    private _error;
+    private callbacks;
+    get threads(): Thread[];
+    get currentThreadId(): string | null;
+    get currentThread(): ThreadData | null;
+    get loadStatus(): LoadStatus;
+    get error(): Error | undefined;
+    set threads(value: Thread[]);
+    setThreads(threads: Thread[]): void;
+    setCurrentThread(thread: ThreadData | null): void;
+    setCurrentThreadId(id: string | null): void;
+    addThread(thread: Thread): void;
+    updateThread(id: string, updates: Partial<Thread>): void;
+    removeThread(id: string): void;
+    setLoadStatus(status: LoadStatus): void;
+    setError(error: Error | undefined): void;
+    subscribe(callback: () => void): () => void;
+    getThreadsSnapshot(): Thread[];
+    getCurrentThreadSnapshot(): ThreadData | null;
+    getLoadStatusSnapshot(): LoadStatus;
+    getErrorSnapshot(): Error | undefined;
+    private notify;
+}
+
+/**
+ * localStorage Thread Storage Adapter
+ *
+ * Default adapter for thread persistence using browser localStorage.
+ * Stores all data in a single key for cleaner storage management.
+ */
+
+/**
+ * Configuration for localStorage adapter
+ */
+interface LocalStorageAdapterConfig {
+    /**
+     * Storage key to use
+     * @default "copilot-sdk-store"
+     */
+    storageKey?: string;
+}
+/**
+ * Create a localStorage adapter for thread storage
+ *
+ * All data is stored in a single key for cleaner storage management.
+ *
+ * @example Default usage
+ * ```typescript
+ * const adapter = createLocalStorageAdapter();
+ * const threadManager = new ThreadManager({ adapter });
+ * ```
+ *
+ * @example With custom key
+ * ```typescript
+ * const adapter = createLocalStorageAdapter({
+ *   storageKey: "my-app-copilot-store"
+ * });
+ * ```
+ */
+declare function createLocalStorageAdapter(config?: LocalStorageAdapterConfig): ThreadStorageAdapter;
+/**
+ * Default localStorage adapter instance
+ */
+declare const localStorageAdapter: ThreadStorageAdapter;
+
+/**
+ * In-Memory Thread Storage Adapter
+ *
+ * Non-persistent adapter useful for testing or ephemeral sessions.
+ */
+
+/**
+ * Create an in-memory adapter for thread storage
+ *
+ * This adapter stores threads in memory only - data is lost on page refresh.
+ * Useful for:
+ * - Testing
+ * - Server-side rendering (where localStorage is unavailable)
+ * - Ephemeral sessions where persistence isn't needed
+ *
+ * @example
+ * ```typescript
+ * const adapter = createMemoryAdapter();
+ * const threadManager = new ThreadManager({ adapter });
+ * ```
+ *
+ * @example Pre-populate with threads
+ * ```typescript
+ * const adapter = createMemoryAdapter([
+ *   { id: "1", title: "Test", messages: [], sources: [], createdAt: new Date(), updatedAt: new Date() }
+ * ]);
+ * ```
+ */
+declare function createMemoryAdapter(initialThreads?: ThreadData[]): ThreadStorageAdapter;
+/**
+ * No-op adapter that never saves or loads
+ * Useful when you want to completely disable persistence
+ */
+declare const noopAdapter: ThreadStorageAdapter;
+
+/**
+ * ThreadManager - Framework-agnostic Thread Management
+ *
+ * Manages thread state and persistence with pluggable storage adapters.
+ * Similar pattern to AbstractChat for framework agnosticism.
+ */
+
+/**
+ * Configuration for ThreadManager
+ */
+interface ThreadManagerConfig {
+    /**
+     * Storage adapter for persistence
+     * @default localStorage adapter
+     */
+    adapter?: ThreadStorageAdapter | AsyncThreadStorageAdapter;
+    /**
+     * Debounce delay for auto-save (ms)
+     * @default 1000
+     */
+    saveDebounce?: number;
+    /**
+     * Whether to auto-load threads on initialization
+     * @default true
+     */
+    autoLoad?: boolean;
+    /**
+     * Whether to auto-restore the last active thread on load
+     * Requires adapter to support getLastActiveThreadId/setLastActiveThreadId
+     * @default true
+     */
+    autoRestoreLastThread?: boolean;
+    /**
+     * Custom state implementation (for framework adapters)
+     * @default SimpleThreadManagerState
+     */
+    state?: ThreadManagerState;
+}
+/**
+ * Callbacks for ThreadManager events
+ */
+interface ThreadManagerCallbacks {
+    /** Called when threads are loaded */
+    onThreadsLoaded?: (threads: Thread[]) => void;
+    /** Called when a thread is created */
+    onThreadCreated?: (thread: ThreadData) => void;
+    /** Called when a thread is switched */
+    onThreadSwitched?: (thread: ThreadData | null) => void;
+    /** Called when a thread is updated */
+    onThreadUpdated?: (thread: ThreadData) => void;
+    /** Called when a thread is deleted */
+    onThreadDeleted?: (threadId: string) => void;
+    /** Called when an error occurs */
+    onError?: (error: Error) => void;
+}
+/**
+ * Options for creating a new thread
+ */
+interface CreateThreadOptions {
+    /** Custom thread ID (auto-generated if not provided) */
+    id?: string;
+    /** Thread title */
+    title?: string;
+    /** Initial messages */
+    messages?: Message[];
+}
+/**
+ * Options for updating a thread
+ */
+interface UpdateThreadOptions {
+    /** Update title */
+    title?: string;
+    /** Update messages */
+    messages?: Message[];
+    /** Custom metadata updates */
+    [key: string]: unknown;
+}
+/**
+ * ThreadManager - Manages thread state and persistence
+ *
+ * @example Basic usage with localStorage (default)
+ * ```typescript
+ * const manager = new ThreadManager();
+ * await manager.loadThreads();
+ *
+ * const thread = await manager.createThread();
+ * console.log(manager.threads);
+ * ```
+ *
+ * @example With custom adapter
+ * ```typescript
+ * const manager = new ThreadManager({
+ *   adapter: myDatabaseAdapter,
+ * });
+ * ```
+ */
+declare class ThreadManager {
+    protected state: ThreadManagerState;
+    protected adapter: ThreadStorageAdapter | AsyncThreadStorageAdapter;
+    protected callbacks: ThreadManagerCallbacks;
+    protected saveDebounce: number;
+    protected autoLoad: boolean;
+    protected autoRestoreLastThread: boolean;
+    private saveTimer;
+    private threadsData;
+    private initPromise;
+    constructor(config?: ThreadManagerConfig, callbacks?: ThreadManagerCallbacks);
+    /** All threads (metadata) */
+    get threads(): Thread[];
+    /** Currently selected thread ID */
+    get currentThreadId(): string | null;
+    /** Currently loaded thread (with messages) */
+    get currentThread(): ThreadData | null;
+    /** Whether threads are currently loading */
+    get isLoading(): boolean;
+    /** Current load status */
+    get loadStatus(): LoadStatus;
+    /** Current error */
+    get error(): Error | undefined;
+    /** Whether there are pending changes waiting to be saved */
+    get hasPendingChanges(): boolean;
+    /**
+     * Load all threads from storage
+     */
+    loadThreads(): Promise<void>;
+    /**
+     * Wait for initialization to complete
+     */
+    waitForInit(): Promise<void>;
+    /**
+     * Create a new thread
+     */
+    createThread(options?: CreateThreadOptions): Promise<ThreadData>;
+    /**
+     * Switch to a different thread
+     */
+    switchThread(id: string): Promise<ThreadData | null>;
+    /**
+     * Update the current thread
+     */
+    updateCurrentThread(updates: UpdateThreadOptions): Promise<void>;
+    /**
+     * Delete a thread
+     */
+    deleteThread(id: string): Promise<void>;
+    /**
+     * Clear the current thread selection
+     */
+    clearCurrentThread(): void;
+    /**
+     * Clear all threads
+     */
+    clearAllThreads(): Promise<void>;
+    /**
+     * Save changes immediately (bypass debounce)
+     */
+    saveNow(): Promise<void>;
+    /**
+     * Dispose of the manager and save pending changes
+     */
+    dispose(): Promise<void>;
+    /**
+     * Schedule a debounced save
+     */
+    protected scheduleSave(): void;
+    /**
+     * Save the last active thread ID (for session persistence)
+     */
+    protected saveLastActiveThread(threadId: string | null): void;
+}
+/**
+ * Create a ThreadManager instance
+ */
+declare function createThreadManager(config?: ThreadManagerConfig, callbacks?: ThreadManagerCallbacks): ThreadManager;
+
+export { type ThreadManagerState as $, type ActionParameter as A, type InternalKnowledgeBaseResult as B, type ConsoleLogOptions as C, type InternalKnowledgeBaseSearchResponse as D, type Extension as E, actionToTool as F, getDefaultModel as G, type HttpMethod as H, type IntentDetectionResult as I, DEFAULT_MODELS as J, type KnowledgeBaseProvider as K, type LLMProvider as L, ThreadManager as M, type NetworkRequestOptions as N, createThreadManager as O, type ParameterType as P, createLocalStorageAdapter as Q, localStorageAdapter as R, type ScreenshotOptions as S, type ToolType as T, createMemoryAdapter as U, noopAdapter as V, SimpleThreadManagerState as W, type ThreadManagerConfig as X, type ThreadManagerCallbacks as Y, type CreateThreadOptions as Z, type UpdateThreadOptions as _, type ScreenshotResult as a, type LoadStatus as a0, type LocalStorageAdapterConfig as a1, type ConsoleLogResult as b, type ConsoleLogEntry as c, type NetworkRequestResult as d, type NetworkRequestEntry as e, detectIntent as f, getPrimaryTool as g, hasToolSuggestions as h, generateSuggestionReason as i, createCustomDetector as j, type ConsoleLogType as k, type ToolsConfig as l, type ToolConsentRequest as m, type ToolConsentResponse as n, type CapturedContext as o, type CustomKeywords as p, type LLMConfig as q, type CloudConfig as r, type CopilotConfig as s, type ActionDefinition as t, type ActionRenderProps as u, type KnowledgeBaseConfig as v, type KnowledgeBaseResult as w, type KnowledgeBaseSearchRequest as x, type KnowledgeBaseSearchResponse as y, type InternalKnowledgeBaseConfig as z };