@yourgpt/copilot-sdk 2.1.5-alpha.4 → 2.1.5-alpha.6

package/dist/react/index.d.cts

@@ -1,16 +1,16 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { U as UIMessage, B as BranchInfo } from '../MessageTree-B0JGQOCi.cjs';
-export { M as MessageTree } from '../MessageTree-B0JGQOCi.cjs';
+import { U as UIMessage, B as BranchInfo } from '../MessageTree-Dt9qfJ55.cjs';
+export { M as MessageTree } from '../MessageTree-Dt9qfJ55.cjs';
 import * as React$1 from 'react';
 import React__default from 'react';
 import { L as LLMConfig, l as ToolsConfig, s as ActionDefinition, o as CapturedContext, m as ToolConsentRequest, T as ToolType, n as ToolConsentResponse, S as ScreenshotOptions, C as ConsoleLogOptions, N as NetworkRequestOptions, I as IntentDetectionResult, y as InternalKnowledgeBaseConfig, B as InternalKnowledgeBaseSearchResponse, z as InternalKnowledgeBaseResult, Y as ThreadManagerState, Z as LoadStatus, U as ThreadManagerConfig, F as ThreadManager, V as ThreadManagerCallbacks, W as CreateThreadOptions, X as UpdateThreadOptions } from '../ThreadManager-DK46fVl3.cjs';
 export { A as ActionParameter, q as CloudConfig, r as CopilotConfig, _ as LocalStorageAdapterConfig, J as createLocalStorageAdapter, O as createMemoryAdapter, i as generateSuggestionReason } from '../ThreadManager-DK46fVl3.cjs';
-import { T as ToolDefinition, t as ToolOptimizationConfig, r as ContextUsage, f as ToolSource, P as PermissionLevel, c as ToolInputSchema, y as ToolExecution$1, e as ToolContext, b as ToolResponse$1, g as ToolRenderProps, i as ToolResultConfig, D as AIResponseMode, u as ToolSet, U as UnifiedToolCall, G as PermissionStorageConfig, H as PermissionStorageAdapter } from '../tools-tmksfhUo.cjs';
-export { z as AgentLoopConfig, q as ContextUsagePart, h as ToolConfig, a as ToolExecutionStatus, F as ToolPermission, v as ToolSetEntry, I as tool } from '../tools-tmksfhUo.cjs';
+import { T as ToolDefinition, t as ToolOptimizationConfig, r as ContextUsage, f as ToolSource, P as PermissionLevel, c as ToolInputSchema, y as ToolExecution$1, e as ToolContext, b as ToolResponse$1, g as ToolRenderProps, i as ToolResultConfig, D as AIResponseMode, u as ToolSet, U as UnifiedToolCall, G as PermissionStorageConfig, H as PermissionStorageAdapter } from '../tools-DcS6Aeao.cjs';
+export { z as AgentLoopConfig, q as ContextUsagePart, h as ToolConfig, a as ToolExecutionStatus, F as ToolPermission, v as ToolSetEntry, I as tool } from '../tools-DcS6Aeao.cjs';
 import { A as AsyncThreadStorageAdapter, M as MessageAttachment, T as ToolCall, d as Message, S as Source, a as Thread, b as ThreadData, c as ThreadStorageAdapter } from '../types-waEqyE4K.cjs';
 export { P as PersistenceConfig, j as ThreadStorageAdapter } from '../types-waEqyE4K.cjs';
-import { G as MCPServerConfig, U as UseMCPClientConfig, D as UseMCPClientReturn, E as UseMCPToolsConfig, F as UseMCPToolsReturn } from '../types-BLw7mxtW.cjs';
-export { b as MCPClientState } from '../types-BLw7mxtW.cjs';
+import { G as MCPServerConfig, U as UseMCPClientConfig, D as UseMCPClientReturn, E as UseMCPToolsConfig, F as UseMCPToolsReturn } from '../types-Cvg4DUoc.cjs';
+export { b as MCPClientState } from '../types-Cvg4DUoc.cjs';
 import { S as SkillDefinition, R as ResolvedSkill } from '../types-BckL3hiw.cjs';
 export { C as ClientInlineSkill, b as SkillSource, c as SkillStrategy } from '../types-BckL3hiw.cjs';
 import { U as UseMCPUIIntentsConfig, m as UseMCPUIIntentsReturn } from '../types-B20VCJXL.cjs';
@@ -142,6 +142,8 @@ interface ChatResponse {
         /** Tool call ID for tool result messages */
         tool_call_id?: string;
     }>;
+    /** Session ID — present when server storage adapter created/resolved a session */
+    threadId?: string;
     /** Whether client needs to execute tools */
     requiresAction?: boolean;
     /** Tool calls with metadata (includes hidden flag for server-side tools) */
@@ -211,6 +213,8 @@ type StreamChunk = {
         tool_call_id?: string;
     }>;
     requiresAction?: boolean;
+    /** Session ID from server storage adapter */
+    threadId?: string;
 } | {
     type: "action:start";
     id: string;
@@ -427,6 +431,17 @@ interface ChatState$1<T extends UIMessage = UIMessage> {
  * Chat status
  */
 type ChatStatus$1 = "ready" | "submitted" | "streaming" | "error";
+/**
+ * YourGPT configuration for automatic session management
+ */
+interface YourGPTConfig {
+    /** YourGPT API key (sent as api-key header) */
+    apiKey: string;
+    /** Widget UID to scope sessions to */
+    widgetUid: string;
+    /** API base URL (default: https://api.yourgpt.ai) */
+    endpoint?: string;
+}
 /**
  * Chat configuration
  *
@@ -462,6 +477,37 @@ interface ChatConfig {
     body?: Resolvable<Record<string, unknown>>;
     /** Thread ID for conversation persistence */
     threadId?: string;
+    /**
+     * Called once before the first message on a new thread to obtain a session/thread ID.
+     * The returned value IS the thread ID — session and thread are the same identity.
+     *
+     * Only called when `config.threadId` is not set (new thread).
+     * If `threadId` is already provided, this is skipped entirely.
+     * Takes priority over `yourgptConfig` when both are provided.
+     *
+     * @example Async server session
+     * ```ts
+     * onCreateSession={async () => {
+     *   const res = await fetch('/api/sessions', { method: 'POST' })
+     *   return (await res.json()).id
+     * }}
+     * ```
+     */
+    onCreateSession?: () => string | Promise<string>;
+    /**
+     * YourGPT config — enables automatic session creation with zero boilerplate.
+     * When provided, the SDK calls YourGPT's createSession API before the first
+     * message and uses the returned session_uid as `threadId`.
+     *
+     * @example
+     * ```tsx
+     * yourgptConfig={{
+     *   apiKey: process.env.YOURGPT_API_KEY,
+     *   widgetUid: widgetUid,
+     * }}
+     * ```
+     */
+    yourgptConfig?: YourGPTConfig;
     /** Enable debug logging */
     debug?: boolean;
     /** Available tools (passed to LLM) */
@@ -500,6 +546,17 @@ interface ChatCallbacks<T extends UIMessage = UIMessage> {
     onFinish?: (messages: T[]) => void;
     /** Called when prompt context usage changes */
     onContextUsageChange?: (usage: ContextUsage) => void;
+    /**
+     * Called once when a new session/thread ID is assigned (null → sessionId transition).
+     * Use this to persist the session ID in your storage layer.
+     * The returned ID is the same as the threadId that will be used for all subsequent requests.
+     */
+    onThreadChange?: (id: string) => void;
+    /**
+     * Called when the session creation status changes.
+     * Use this to show/hide a spinner while the session is being created.
+     */
+    onSessionStatusChange?: (status: "idle" | "creating" | "ready" | "error") => void;
     /** Called when a server-side tool starts executing (action:start event) */
     onServerToolStart?: (info: ServerToolInfo) => void;
     /** Called when a server-side tool receives args (action:args event) */
@@ -509,6 +566,15 @@ interface ChatCallbacks<T extends UIMessage = UIMessage> {
         result?: unknown;
         error?: string;
     }) => void;
+    /**
+     * Called for every raw stream chunk as it arrives.
+     * Use this to build custom real-time UI on top of the SDK — e.g. thinking
+     * step parsers, tool progress trackers, loop iteration counters.
+     * The `messageId` field is the ID of the assistant message being streamed.
+     */
+    onStreamChunk?: (chunk: StreamChunk & {
+        messageId?: string;
+    }) => void;
 }
 /**
  * Chat initialization options
@@ -722,6 +788,9 @@ declare class AbstractChat<T extends UIMessage = UIMessage> {
     protected callbacks: ChatCallbacks<T>;
     protected optimizer: ChatContextOptimizer;
     protected lastContextUsage: ContextUsage | null;
+    private onCreateSession?;
+    private sessionInitPromise;
+    private sessionStatus;
     private eventHandlers;
     private streamState;
     constructor(init: ChatInit<T>);
@@ -763,6 +832,17 @@ declare class AbstractChat<T extends UIMessage = UIMessage> {
         toolCallId: string;
         result: unknown;
     }>): Promise<void>;
+    /**
+     * Add tool result messages to history and stop — does NOT trigger a new LLM request.
+     *
+     * Use this instead of continueWithToolResults when you want to close out pending
+     * tool_use blocks (so the history stays valid) without letting the AI continue.
+     * Optionally appends a final assistant message (e.g. an iteration-limit notice).
+     */
+    addToolResultMessages(toolResults: Array<{
+        toolCallId: string;
+        result: unknown;
+    }>, finalAssistantContent?: string): Promise<void>;
     /**
      * Stop generation
      */
@@ -804,7 +884,9 @@ declare class AbstractChat<T extends UIMessage = UIMessage> {
     /**
      * Process a chat request
      */
-    protected processRequest(): Promise<void>;
+    protected processRequest(options?: {
+        preCreatedMessageId?: string;
+    }): Promise<void>;
     /**
      * Set tools available for the LLM
      */
@@ -858,6 +940,27 @@ declare class AbstractChat<T extends UIMessage = UIMessage> {
      * Set dynamic context (appended to system prompt)
      */
     setContext(context: string): void;
+    /**
+     * Switch to a different thread (or start a new one).
+     *
+     * - Pass the session/thread ID from persistence → used as-is, no session creation call.
+     * - Pass null → threadId cleared, new session created on first sendMessage.
+     *
+     * The session ID IS the thread ID: whatever is stored in persistence is passed here directly.
+     */
+    setActiveThread(id: string | null): void;
+    /**
+     * Force a new session to be created on the next sendMessage.
+     * Call this when the current session has expired or credits are exhausted.
+     * After calling this, the next sendMessage will invoke onCreateSession/yourgptConfig
+     * again and onThreadChange will fire with the new session ID.
+     */
+    renewSession(): void;
+    private setSessionStatus;
+    /**
+     * Get the current session creation status.
+     */
+    getSessionStatus(): "idle" | "creating" | "ready" | "error";
     /**
      * Set system prompt dynamically
      * This allows updating the system prompt after initialization
@@ -878,9 +981,17 @@ declare class AbstractChat<T extends UIMessage = UIMessage> {
      * Additional properties merged into every request body
      */
     setBody(body: ChatConfig["body"]): void;
+    /**
+     * Default session creation via yourgptConfig.
+     * Only called when yourgptConfig is set and no onCreateSession is provided.
+     * The returned session_uid IS the thread ID going forward.
+     */
+    private _defaultCreateSession;
     /**
      * Build the request payload
      */
+    /** Inline text-file attachments into message content for the LLM */
+    private inlineTextAttachments;
     protected buildRequest(): {
         messages: {
             role: string;
@@ -1315,8 +1426,39 @@ interface CopilotProviderProps {
     tools?: ToolsConfig;
     /** Thread ID for conversation persistence */
     threadId?: string;
+    /**
+     * Called once before the first message on a new thread to create a session.
+     * The returned value IS the thread ID — session and thread are the same identity.
+     * Only called when `threadId` is not set. If `threadId` is provided, this is skipped.
+     * Takes priority over `yourgptConfig`.
+     *
+     * @example
+     * ```tsx
+     * onCreateSession={async () => {
+     *   const res = await fetch('/api/sessions', { method: 'POST', headers })
+     *   return (await res.json()).id
+     * }}
+     * ```
+     */
+    onCreateSession?: () => string | Promise<string>;
+    /**
+     * Called when a new session/thread ID is assigned (new thread created).
+     * Use this to persist the session ID in your storage layer.
+     */
+    onThreadChange?: (id: string) => void;
+    /**
+     * YourGPT config — enables automatic session creation with zero boilerplate.
+     * The SDK calls YourGPT's createSession API before the first message and
+     * uses the returned session_uid as `threadId`.
+     *
+     * @example
+     * ```tsx
+     * yourgptConfig={{ apiKey: "your-api-key", widgetUid: widgetUid }}
+     * ```
+     */
+    yourgptConfig?: YourGPTConfig;
     /** Initial messages to populate the chat */
-    initialMessages?: Message[];
+    initialMessages?: UIMessage[];
     /** Callback when messages change */
     onMessagesChange?: (messages: Message[]) => void;
     /** Callback when an error occurs */
@@ -1356,6 +1498,26 @@ interface CopilotProviderProps {
      */
     skills?: SkillDefinition[];
 }
+type StreamChunkWithMessageId = StreamChunk & {
+    messageId?: string;
+};
+type StreamEventHandler = (chunk: StreamChunkWithMessageId) => void;
+/**
+ * Reactive store for custom per-message metadata.
+ * Powers useMessageMeta() — consumers write any shape they want,
+ * all components reading the same messageId react automatically.
+ */
+declare class MessageMetaStore {
+    private store;
+    private listeners;
+    private static readonly EMPTY;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => Map<string, Record<string, unknown>>;
+    getMeta: (messageId: string) => Record<string, unknown>;
+    setMeta: (messageId: string, meta: Record<string, unknown>) => void;
+    updateMeta: (messageId: string, updater: (prev: Record<string, unknown>) => Record<string, unknown>) => void;
+    clear: () => void;
+}
 interface CopilotContextValue {
     messages: UIMessage[];
     status: "ready" | "submitted" | "streaming" | "error";
@@ -1399,16 +1561,48 @@ interface CopilotContextValue {
         content: string;
         strategy?: string;
     }>) => void;
+    agentIteration: number;
     threadId?: string;
+    /**
+     * Switch to a different thread (or start a new one).
+     * Pass the session/thread ID from persistence to reuse it (no new session call),
+     * or null to start a fresh thread (new session created on first sendMessage).
+     */
+    setActiveThread: (id: string | null) => void;
+    /**
+     * Force a new session to be created on the next sendMessage.
+     * Call when the current session has expired or credits are exhausted.
+     */
+    renewSession: () => void;
+    /** Current session creation status */
+    sessionStatus: "idle" | "creating" | "ready" | "error";
     /**
      * Runtime URL configuration.
      * Can be a static string or getter function (matches what was passed to provider).
      */
     runtimeUrl: Resolvable<string>;
     toolsConfig?: ToolsConfig;
+    /**
+     * Subscribe to raw stream chunks as they arrive.
+     * Returns an unsubscribe function. Use useCopilotEvent() for the hook API.
+     *
+     * @example
+     * ```ts
+     * const unsub = subscribeToStreamEvents((chunk) => {
+     *   if (chunk.type === 'thinking:delta') { ... }
+     * })
+     * return unsub // cleanup
+     * ```
+     */
+    subscribeToStreamEvents: (handler: StreamEventHandler) => () => void;
+    /**
+     * Reactive per-message metadata store.
+     * Use useMessageMeta(messageId) for the hook API.
+     */
+    messageMeta: MessageMetaStore;
 }
 declare function useCopilot(): CopilotContextValue;
-declare function CopilotProvider({ children, runtimeUrl, systemPrompt, tools: toolsConfig, threadId, initialMessages, onMessagesChange, onError, streaming, headers, body, debug, maxIterations, maxIterationsMessage, mcpServers, optimization, messageHistory, skills, }: CopilotProviderProps): react_jsx_runtime.JSX.Element;
+declare function CopilotProvider(props: CopilotProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Chat UI state interface (UI-only state, not message data)
@@ -2661,6 +2855,71 @@ interface UseThreadManagerReturn {
  */
 declare function useThreadManager(config?: UseThreadManagerConfig): UseThreadManagerReturn;
 
+/**
+ * useThread — Session/thread management hook
+ *
+ * Provides clean semantics for managing the active session/thread.
+ * When yourgptConfig or onCreateSession is configured, the session ID
+ * IS the thread ID — they are the same identity.
+ *
+ * Use this hook instead of calling setActiveThread/renewSession directly.
+ */
+interface UseThreadReturn {
+    /**
+     * Current session/thread ID.
+     * undefined until the first session is created (new thread not yet sent).
+     */
+    threadId: string | undefined;
+    /**
+     * Current session creation status.
+     * - "idle"     — no session config, or threadId already set
+     * - "creating" — session creation request in flight
+     * - "ready"    — threadId is set and usable
+     * - "error"    — session creation failed
+     */
+    sessionStatus: "idle" | "creating" | "ready" | "error";
+    /**
+     * Switch to an existing thread/session.
+     * Pass the session ID from your persistence layer — it is used as-is,
+     * no new session creation call is made.
+     */
+    switchThread: (sessionId: string) => void;
+    /**
+     * Start a fresh thread.
+     * Clears the current session; a new session is created on the next sendMessage.
+     * onThreadChange fires with the new session ID once it is assigned.
+     */
+    newThread: () => void;
+    /**
+     * Force a new session to be created on the next sendMessage.
+     * Call this when the current session has expired or credits are exhausted.
+     * onThreadChange fires with the new session ID once it is assigned.
+     */
+    renewSession: () => void;
+}
+/**
+ * useThread — Clean hook for session/thread management
+ *
+ * @example
+ * ```tsx
+ * function ChatHeader() {
+ *   const { threadId, sessionStatus, newThread, switchThread, renewSession } = useThread();
+ *
+ *   const loadThread = (stored: { sessionId: string }) => {
+ *     switchThread(stored.sessionId);   // session ID IS the thread ID
+ *   };
+ *
+ *   return (
+ *     <>
+ *       {sessionStatus === "creating" && <Spinner />}
+ *       <button onClick={newThread}>New Chat</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useThread(): UseThreadReturn;
+
 /**
  * React hook for managing an MCP client connection
  *
@@ -2892,6 +3151,72 @@ interface UseSkillStatusReturn {
 }
 declare function useSkillStatus(): UseSkillStatusReturn;
 
+interface MessageCheckpoint {
+    /** Unique checkpoint ID */
+    id: string;
+    /** ID of the user message that triggered this checkpoint */
+    messageId: string;
+    /** When this checkpoint was created */
+    timestamp: number;
+    /** Optional human-readable label */
+    label?: string;
+    /** Full message list BEFORE the user message was processed */
+    messages: UIMessage[];
+}
+interface UseMessageCheckpointsReturn {
+    /** All saved checkpoints, oldest first */
+    checkpoints: MessageCheckpoint[];
+    /** True if a checkpoint exists for the given user message ID */
+    hasCheckpoint: (messageId: string) => boolean;
+    /** Get the checkpoint for a user message ID, or undefined */
+    getCheckpoint: (messageId: string) => MessageCheckpoint | undefined;
+    /**
+     * Restore chat to the state before the user message with the given ID.
+     * Returns the checkpoint if found, undefined otherwise.
+     * Checkpoints created after this one are pruned.
+     */
+    restore: (messageId: string) => MessageCheckpoint | undefined;
+    /**
+     * Manually save a checkpoint for a message ID.
+     * Auto-save already runs on every new user message — use this for
+     * programmatic checkpoints (e.g. before a destructive tool call).
+     */
+    save: (messageId: string, label?: string) => MessageCheckpoint | undefined;
+    /** Clear all saved checkpoints */
+    clear: () => void;
+}
+/**
+ * useMessageCheckpoints
+ *
+ * Automatically saves a checkpoint before each user message is sent to the
+ * agent. Each checkpoint captures the full chat state that existed BEFORE
+ * that user message, so restoring it rolls the conversation back to exactly
+ * that point.
+ *
+ * Generic — works for any agentic app (flow builders, code editors, document
+ * assistants, etc.). App-specific side effects (e.g. restoring a canvas or
+ * database state) can be layered on top via the returned `restore` value.
+ *
+ * @example
+ * ```tsx
+ * // Inside <CopilotChat> children
+ * function MyCheckpointActions() {
+ *   const { hasCheckpoint, restore } = useMessageCheckpoints();
+ *   return (
+ *     <CopilotChat.MessageActions role="user">
+ *       <CopilotChat.Action
+ *         icon={<RotateCcw className="size-3.5" />}
+ *         tooltip="Restore to before this message"
+ *         onClick={({ message }) => restore(message.id)}
+ *         hidden={({ message }) => !hasCheckpoint(message.id)}
+ *       />
+ *     </CopilotChat.MessageActions>
+ *   );
+ * }
+ * ```
+ */
+declare function useMessageCheckpoints(): UseMessageCheckpointsReturn;
+
 /**
  * Create a permission storage adapter based on config
  */
@@ -3032,6 +3357,10 @@ interface ReactChatConfig {
     llm?: ChatConfig["llm"];
     /** Thread ID */
     threadId?: string;
+    /** Called once before first message to obtain a session/thread ID */
+    onCreateSession?: () => string | Promise<string>;
+    /** YourGPT config — enables automatic session creation */
+    yourgptConfig?: YourGPTConfig;
     /** Enable streaming (default: true) */
     streaming?: boolean;
     /** Request headers */
@@ -3306,4 +3635,43 @@ declare function toLLMMessages(messages: DisplayMessage[]): LLMMessage[];
 declare function keepToolPairsAtomic(messages: DisplayMessage[]): DisplayMessage[];
 declare function isCompactionMarker(msg: DisplayMessage): msg is CompactionMarker;
 
-export { type AIContextItem, AbstractAgentLoop, AbstractChat, ActionDefinition, type AgentLoopActions, type AgentLoopCallbacks, type AgentLoopState, AsyncThreadStorageAdapter, BranchInfo, type CapabilitiesResponse, CapturedContext, type ChatActions, type ChatCallbacks, type ChatConfig, type ChatState, type ChatStatus, type ToolExecution as ChatToolExecution, type ToolResponse as ChatToolResponse, type CombinedChatState, type CompactedToolResult, type CompactionEvent, type CompactionMarker, type CompactionStrategy, type ContextStats, ContextUsage, type CopilotContextValue, CopilotProvider, type CopilotProviderProps, type AgentLoopState$1 as CoreAgentLoopState, type ChatState$1 as CoreChatState, type DevLoggerState, type DisplayMessage, IntentDetectionResult, type KnowledgeBaseConfig, type KnowledgeBaseResult, type KnowledgeBaseSearchResponse, LLMConfig, type LLMMessage, Message, type MessageHistoryConfig, MessageHistoryContext, type MessageHistoryContextValue, type MessageTokenUsage, PermissionLevel, PermissionStorageAdapter, PermissionStorageConfig, type ProviderCapabilities, ReactChat, type ReactChatConfig, ReactChatState, ReactThreadManager, type ReactThreadManagerConfig, ReactThreadManagerState, ResolvedSkill, type ServerAdapterConfig, type SessionCompactionState, SkillDefinition, SkillProvider, type SkillProviderProps, Source, type Suggestion, Thread, ThreadData, type TokenUsage, ToolConsentRequest, ToolConsentResponse, ToolContext, ToolDefinition, ToolExecution$1 as ToolExecution, ToolResponse$1 as ToolResponse, ToolSet, ToolType, type ToolsActions, ToolsConfig, type ToolsState, UIMessage, UnifiedToolCall, type UseAIToolsOptions, type UseAIToolsReturn, type UseAgentOptions, type UseAgentReturn, type UseChatConfig, type UseChatReturn, type UseKnowledgeBaseConfig, UseMCPClientConfig, UseMCPClientReturn, UseMCPToolsConfig, UseMCPToolsReturn, UseMCPUIIntentsConfig, UseMCPUIIntentsReturn, type UseMessageHistoryOptions, type UseMessageHistoryReturn, type UseSkillStatusReturn, type UseSuggestionsOptions, type UseSuggestionsReturn, type UseThreadManagerConfig, type UseThreadManagerReturn, type UseToolConfig, type UseToolExecutorReturn, type UseToolWithSchemaConfig, createMessageIntentHandler, createPermissionStorage, createReactChat, createReactChatState, createReactThreadManager, createReactThreadManagerState, createServerAdapter, createSessionPermissionCache, createToolIntentHandler, defaultMessageHistoryConfig, defineSkill, formatKnowledgeResultsForAI, initialAgentLoopState, isCompactionMarker, keepToolPairsAtomic, searchKnowledgeBase, toDisplayMessage, toLLMMessage, toLLMMessages, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useContextStats, useCopilot, useDevLogger, useFeatureSupport, useKnowledgeBase, useMCPClient, useMCPTools, useMCPUIIntents, useMessageHistory, useMessageHistoryContext, useSkill, useSkillStatus, useSuggestions, useSupportedMediaTypes, useThreadManager, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };
+type StreamChunkType = StreamChunk["type"];
+type ChunkOfType<T extends StreamChunkType | "*"> = T extends "*" ? StreamChunkWithMessageId : Extract<StreamChunk, {
+    type: T;
+}> & {
+    messageId?: string;
+};
+/**
+ * Subscribe to a specific stream event type (or all events with '*').
+ *
+ * The handler is called synchronously during streaming — keep it fast.
+ * Handler identity doesn't need to be stable; the hook re-subscribes
+ * automatically when it changes.
+ *
+ * @param eventType - Stream chunk type to listen for, or '*' for all
+ * @param handler   - Callback invoked for each matching chunk
+ */
+declare function useCopilotEvent<T extends StreamChunkType | "*">(eventType: T, handler: (chunk: ChunkOfType<T>) => void): void;
+
+interface UseMessageMetaReturn<T extends Record<string, unknown>> {
+    /** Current metadata for this message. Empty object if nothing set yet. */
+    meta: T;
+    /**
+     * Replace metadata entirely.
+     */
+    setMeta: (meta: T) => void;
+    /**
+     * Merge/update metadata using an updater function.
+     * Receives previous meta, return next meta.
+     */
+    updateMeta: (updater: (prev: T) => T) => void;
+}
+/**
+ * Read and write custom metadata for a specific message ID.
+ *
+ * @param messageId - The message to attach metadata to.
+ *                   Pass undefined to get a no-op instance (safe for conditional use).
+ */
+declare function useMessageMeta<T extends Record<string, unknown> = Record<string, unknown>>(messageId: string | undefined): UseMessageMetaReturn<T>;
+
+export { type AIContextItem, AbstractAgentLoop, AbstractChat, ActionDefinition, type AgentLoopActions, type AgentLoopCallbacks, type AgentLoopState, AsyncThreadStorageAdapter, BranchInfo, type CapabilitiesResponse, CapturedContext, type ChatActions, type ChatCallbacks, type ChatConfig, type ChatState, type ChatStatus, type ToolExecution as ChatToolExecution, type ToolResponse as ChatToolResponse, type CombinedChatState, type CompactedToolResult, type CompactionEvent, type CompactionMarker, type CompactionStrategy, type ContextStats, ContextUsage, type CopilotContextValue, CopilotProvider, type CopilotProviderProps, type AgentLoopState$1 as CoreAgentLoopState, type ChatState$1 as CoreChatState, type DevLoggerState, type DisplayMessage, IntentDetectionResult, type KnowledgeBaseConfig, type KnowledgeBaseResult, type KnowledgeBaseSearchResponse, LLMConfig, type LLMMessage, Message, type MessageCheckpoint, type MessageHistoryConfig, MessageHistoryContext, type MessageHistoryContextValue, MessageMetaStore, type MessageTokenUsage, PermissionLevel, PermissionStorageAdapter, PermissionStorageConfig, type ProviderCapabilities, ReactChat, type ReactChatConfig, ReactChatState, ReactThreadManager, type ReactThreadManagerConfig, ReactThreadManagerState, ResolvedSkill, type ServerAdapterConfig, type SessionCompactionState, SkillDefinition, SkillProvider, type SkillProviderProps, Source, type StreamChunkWithMessageId, type StreamEventHandler, type Suggestion, Thread, ThreadData, type TokenUsage, ToolConsentRequest, ToolConsentResponse, ToolContext, ToolDefinition, ToolExecution$1 as ToolExecution, ToolResponse$1 as ToolResponse, ToolSet, ToolType, type ToolsActions, ToolsConfig, type ToolsState, UIMessage, UnifiedToolCall, type UseAIToolsOptions, type UseAIToolsReturn, type UseAgentOptions, type UseAgentReturn, type UseChatConfig, type UseChatReturn, type UseKnowledgeBaseConfig, UseMCPClientConfig, UseMCPClientReturn, UseMCPToolsConfig, UseMCPToolsReturn, UseMCPUIIntentsConfig, UseMCPUIIntentsReturn, type UseMessageCheckpointsReturn, type UseMessageHistoryOptions, type UseMessageHistoryReturn, type UseMessageMetaReturn, type UseSkillStatusReturn, type UseSuggestionsOptions, type UseSuggestionsReturn, type UseThreadManagerConfig, type UseThreadManagerReturn, type UseThreadReturn, type UseToolConfig, type UseToolExecutorReturn, type UseToolWithSchemaConfig, createMessageIntentHandler, createPermissionStorage, createReactChat, createReactChatState, createReactThreadManager, createReactThreadManagerState, createServerAdapter, createSessionPermissionCache, createToolIntentHandler, defaultMessageHistoryConfig, defineSkill, formatKnowledgeResultsForAI, initialAgentLoopState, isCompactionMarker, keepToolPairsAtomic, searchKnowledgeBase, toDisplayMessage, toLLMMessage, toLLMMessages, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useContextStats, useCopilot, useCopilotEvent, useDevLogger, useFeatureSupport, useKnowledgeBase, useMCPClient, useMCPTools, useMCPUIIntents, useMessageCheckpoints, useMessageHistory, useMessageHistoryContext, useMessageMeta, useSkill, useSkillStatus, useSuggestions, useSupportedMediaTypes, useThread, useThreadManager, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };