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

package/dist/chunk-PURFAD2P.js

@@ -0,0 +1,2020 @@
+import { useCopilot, useSkillContext, AbstractChat, ReactChatState } from './chunk-I2XOCFHG.js';
+import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-PSNLKMZH.js';
+import { createContext, useEffect, useState, useRef, useCallback, useMemo, useSyncExternalStore, useReducer, useContext } from 'react';
+import * as z from 'zod';
+
+function useAIActions(actions) {
+  const { registerAction, unregisterAction } = useCopilot();
+  useEffect(() => {
+    for (const action of actions) {
+      registerAction(action);
+    }
+    return () => {
+      for (const action of actions) {
+        unregisterAction(action.name);
+      }
+    };
+  }, [actions, registerAction, unregisterAction]);
+}
+function useAIAction(action) {
+  useAIActions([action]);
+}
+function useAITools(options = {}) {
+  const {
+    screenshot = false,
+    console: consoleCapture = false,
+    network = false,
+    requireConsent = true,
+    screenshotOptions,
+    consoleOptions,
+    networkOptions,
+    onConsentRequest,
+    autoStart = true
+  } = options;
+  const [isEnabled] = useState(screenshot || consoleCapture || network);
+  const [activeCaptures, setActiveCaptures] = useState({
+    console: false,
+    network: false
+  });
+  const [pendingConsent, setPendingConsent] = useState(null);
+  const consentResolverRef = useRef(null);
+  const rememberedConsentRef = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    if (!autoStart || !isEnabled) return;
+    if (consoleCapture && !isConsoleCaptureActive()) {
+      startConsoleCapture(consoleOptions);
+      setActiveCaptures((prev) => ({ ...prev, console: true }));
+    }
+    if (network && !isNetworkCaptureActive()) {
+      startNetworkCapture(networkOptions);
+      setActiveCaptures((prev) => ({ ...prev, network: true }));
+    }
+    return () => {
+      stopConsoleCapture();
+      stopNetworkCapture();
+    };
+  }, [
+    autoStart,
+    isEnabled,
+    consoleCapture,
+    network,
+    consoleOptions,
+    networkOptions
+  ]);
+  const captureScreenshotFn = useCallback(
+    async (opts) => {
+      if (!screenshot) {
+        throw new Error("Screenshot capture is not enabled");
+      }
+      if (!isScreenshotSupported()) {
+        throw new Error(
+          "Screenshot capture is not supported in this environment"
+        );
+      }
+      return captureScreenshot({ ...screenshotOptions, ...opts });
+    },
+    [screenshot, screenshotOptions]
+  );
+  const getConsoleLogsFn = useCallback(
+    (opts) => {
+      if (!consoleCapture) {
+        return { logs: [], totalCaptured: 0 };
+      }
+      return getConsoleLogs({ ...consoleOptions, ...opts });
+    },
+    [consoleCapture, consoleOptions]
+  );
+  const getNetworkRequestsFn = useCallback(
+    (opts) => {
+      if (!network) {
+        return { requests: [], totalCaptured: 0 };
+      }
+      return getNetworkRequests({ ...networkOptions, ...opts });
+    },
+    [network, networkOptions]
+  );
+  const requestConsent = useCallback(
+    async (tools, reason = "") => {
+      const enabledTools = tools.filter((tool2) => {
+        if (tool2 === "screenshot") return screenshot;
+        if (tool2 === "console") return consoleCapture;
+        if (tool2 === "network") return network;
+        return false;
+      });
+      if (enabledTools.length === 0) {
+        return { approved: [], denied: [] };
+      }
+      if (!requireConsent) {
+        return { approved: enabledTools, denied: [] };
+      }
+      const needsConsent = enabledTools.filter(
+        (tool2) => !rememberedConsentRef.current.has(tool2)
+      );
+      if (needsConsent.length === 0) {
+        return { approved: enabledTools, denied: [] };
+      }
+      const request = {
+        tools: needsConsent,
+        reason,
+        keywords: []
+      };
+      if (onConsentRequest) {
+        const response = await onConsentRequest(request);
+        if (response.remember) {
+          response.approved.forEach(
+            (tool2) => rememberedConsentRef.current.add(tool2)
+          );
+        }
+        return response;
+      }
+      return new Promise((resolve) => {
+        setPendingConsent(request);
+        consentResolverRef.current = (response) => {
+          if (response.remember) {
+            response.approved.forEach(
+              (tool2) => rememberedConsentRef.current.add(tool2)
+            );
+          }
+          resolve(response);
+        };
+      });
+    },
+    [screenshot, consoleCapture, network, requireConsent, onConsentRequest]
+  );
+  const respondToConsent = useCallback((response) => {
+    if (consentResolverRef.current) {
+      consentResolverRef.current(response);
+      consentResolverRef.current = null;
+    }
+    setPendingConsent(null);
+  }, []);
+  const captureContext = useCallback(
+    async (tools) => {
+      const toolsToCapture = tools || ["screenshot", "console", "network"];
+      const context = {
+        timestamp: Date.now()
+      };
+      const captures = [];
+      if (toolsToCapture.includes("screenshot") && screenshot) {
+        captures.push(
+          captureScreenshotFn().then((result) => {
+            context.screenshot = result;
+          }).catch(() => {
+          })
+        );
+      }
+      if (toolsToCapture.includes("console") && consoleCapture) {
+        context.consoleLogs = getConsoleLogsFn();
+      }
+      if (toolsToCapture.includes("network") && network) {
+        context.networkRequests = getNetworkRequestsFn();
+      }
+      await Promise.all(captures);
+      return context;
+    },
+    [
+      screenshot,
+      consoleCapture,
+      network,
+      captureScreenshotFn,
+      getConsoleLogsFn,
+      getNetworkRequestsFn
+    ]
+  );
+  const startCapturing = useCallback(() => {
+    if (consoleCapture && !isConsoleCaptureActive()) {
+      startConsoleCapture(consoleOptions);
+      setActiveCaptures((prev) => ({ ...prev, console: true }));
+    }
+    if (network && !isNetworkCaptureActive()) {
+      startNetworkCapture(networkOptions);
+      setActiveCaptures((prev) => ({ ...prev, network: true }));
+    }
+  }, [consoleCapture, network, consoleOptions, networkOptions]);
+  const stopCapturing = useCallback(() => {
+    stopConsoleCapture();
+    stopNetworkCapture();
+    setActiveCaptures({ console: false, network: false });
+  }, []);
+  const clearCaptured = useCallback(() => {
+    clearConsoleLogs();
+    clearNetworkRequests();
+  }, []);
+  const formatForAI = useCallback((context) => {
+    const parts = [];
+    if (context.screenshot) {
+      parts.push(
+        `Screenshot captured (${context.screenshot.width}x${context.screenshot.height}, ${context.screenshot.format})`
+      );
+    }
+    if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
+      parts.push(formatLogsForAI(context.consoleLogs.logs));
+    }
+    if (context.networkRequests && context.networkRequests.requests.length > 0) {
+      parts.push(formatRequestsForAI(context.networkRequests.requests));
+    }
+    return parts.length > 0 ? parts.join("\n\n---\n\n") : "No context captured.";
+  }, []);
+  const detectIntentFn = useCallback(
+    (message) => {
+      const result = detectIntent(message);
+      result.suggestedTools = result.suggestedTools.filter((tool2) => {
+        if (tool2 === "screenshot") return screenshot;
+        if (tool2 === "console") return consoleCapture;
+        if (tool2 === "network") return network;
+        return false;
+      });
+      return result;
+    },
+    [screenshot, consoleCapture, network]
+  );
+  return useMemo(
+    () => ({
+      isEnabled,
+      activeCaptures,
+      captureScreenshot: captureScreenshotFn,
+      getConsoleLogs: getConsoleLogsFn,
+      getNetworkRequests: getNetworkRequestsFn,
+      captureContext,
+      detectIntent: detectIntentFn,
+      requestConsent,
+      startCapturing,
+      stopCapturing,
+      clearCaptured,
+      formatForAI,
+      pendingConsent,
+      respondToConsent
+    }),
+    [
+      isEnabled,
+      activeCaptures,
+      captureScreenshotFn,
+      getConsoleLogsFn,
+      getNetworkRequestsFn,
+      captureContext,
+      detectIntentFn,
+      requestConsent,
+      startCapturing,
+      stopCapturing,
+      clearCaptured,
+      formatForAI,
+      pendingConsent,
+      respondToConsent
+    ]
+  );
+}
+function convertZodSchema(schema, _toolName) {
+  try {
+    const zodWithJsonSchema = z;
+    if (typeof zodWithJsonSchema.toJSONSchema === "function") {
+      const jsonSchema = zodWithJsonSchema.toJSONSchema(
+        schema
+      );
+      if (jsonSchema.type === "object") {
+        return {
+          type: "object",
+          properties: jsonSchema.properties || {},
+          required: jsonSchema.required
+        };
+      }
+    }
+  } catch {
+  }
+  return zodObjectToInputSchema(schema);
+}
+function useToolWithSchema(config, dependencies = []) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const configRef = useRef(config);
+  configRef.current = config;
+  const inputSchema = useMemo(() => {
+    try {
+      return convertZodSchema(config.schema, config.name);
+    } catch (error) {
+      console.warn(
+        `[useToolWithSchema] Failed to convert Zod schema for tool "${config.name}"`,
+        error
+      );
+      return {
+        type: "object",
+        properties: {}
+      };
+    }
+  }, [config.schema, config.name]);
+  useEffect(() => {
+    const tool2 = {
+      name: config.name,
+      description: config.description,
+      location: "client",
+      inputSchema,
+      handler: async (params, context) => {
+        return configRef.current.handler(params, context);
+      },
+      render: config.render,
+      available: config.available ?? true
+    };
+    registerTool(tool2);
+    return () => {
+      unregisterTool(config.name);
+    };
+  }, [config.name, inputSchema, ...dependencies]);
+}
+function useToolsWithSchema(tools, dependencies = []) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const toolsRef = useRef(tools);
+  toolsRef.current = tools;
+  useEffect(() => {
+    const toolNames = [];
+    for (const config of tools) {
+      let inputSchema;
+      try {
+        inputSchema = convertZodSchema(config.schema, config.name);
+      } catch (error) {
+        console.warn(
+          `[useToolsWithSchema] Failed to convert Zod schema for tool "${config.name}"`,
+          error
+        );
+        inputSchema = { type: "object", properties: {} };
+      }
+      const tool2 = {
+        name: config.name,
+        description: config.description,
+        location: "client",
+        inputSchema,
+        handler: async (params, context) => {
+          const currentConfig = toolsRef.current.find(
+            (t) => t.name === config.name
+          );
+          if (currentConfig) {
+            return currentConfig.handler(params, context);
+          }
+          return { success: false, error: "Tool handler not found" };
+        },
+        available: config.available ?? true
+      };
+      registerTool(tool2);
+      toolNames.push(config.name);
+    }
+    return () => {
+      for (const name of toolNames) {
+        unregisterTool(name);
+      }
+    };
+  }, [tools.map((t) => t.name).join(","), ...dependencies]);
+}
+var CopilotContext = createContext(null);
+function useCopilotContext() {
+  const context = useContext(CopilotContext);
+  if (!context) {
+    throw new Error("useCopilotContext must be used within a CopilotProvider");
+  }
+  return context;
+}
+
+// src/react/hooks/useToolExecutor.ts
+function useToolExecutor() {
+  const {
+    registeredTools,
+    config,
+    chat,
+    addToolExecution,
+    updateToolExecution
+  } = useCopilotContext();
+  const toolsRef = useRef(registeredTools);
+  toolsRef.current = registeredTools;
+  const executeTool = useCallback(
+    async (toolCall) => {
+      const tool2 = toolsRef.current.find((t) => t.name === toolCall.name);
+      if (!tool2) {
+        return {
+          success: false,
+          error: `Unknown tool: ${toolCall.name}`
+        };
+      }
+      if (!tool2.handler) {
+        return {
+          success: false,
+          error: `Tool "${toolCall.name}" has no handler`
+        };
+      }
+      const execution = {
+        id: toolCall.id,
+        name: toolCall.name,
+        args: toolCall.input,
+        status: "executing",
+        timestamp: Date.now(),
+        approvalStatus: "none",
+        hidden: tool2.hidden
+      };
+      addToolExecution?.(execution);
+      try {
+        const startTime = Date.now();
+        const result = await tool2.handler(toolCall.input);
+        const duration = Date.now() - startTime;
+        updateToolExecution?.(toolCall.id, {
+          status: result.success ? "completed" : "error",
+          result,
+          error: result.error,
+          duration
+        });
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+        updateToolExecution?.(toolCall.id, {
+          status: "error",
+          error: errorMessage
+        });
+        return {
+          success: false,
+          error: errorMessage
+        };
+      }
+    },
+    [addToolExecution, updateToolExecution]
+  );
+  const sendToolResult = useCallback(
+    async (toolCallId, result) => {
+      const runtimeUrl = config.runtimeUrl || config.cloud?.endpoint;
+      if (!runtimeUrl) {
+        console.warn(
+          "[useToolExecutor] No runtime URL configured, cannot send tool result"
+        );
+        return;
+      }
+      const baseUrl = runtimeUrl.replace(/\/chat\/?$/, "");
+      try {
+        const response = await fetch(`${baseUrl}/tool-result`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            threadId: chat.threadId || "default",
+            toolCallId,
+            result
+          })
+        });
+        if (!response.ok) {
+          console.error(
+            "[useToolExecutor] Failed to send tool result:",
+            await response.text()
+          );
+        }
+      } catch (error) {
+        console.error("[useToolExecutor] Error sending tool result:", error);
+      }
+    },
+    [config.runtimeUrl, config.cloud?.endpoint, chat.threadId]
+  );
+  const getTool = useCallback((name) => {
+    return toolsRef.current.find((t) => t.name === name);
+  }, []);
+  const hasTool = useCallback((name) => {
+    return toolsRef.current.some((t) => t.name === name);
+  }, []);
+  return {
+    executeTool,
+    sendToolResult,
+    getTool,
+    hasTool
+  };
+}
+function useSuggestions(options = {}) {
+  const {
+    count = 3,
+    context,
+    suggestions: staticSuggestions,
+    autoRefresh = true
+  } = options;
+  const { chat, actions, config } = useCopilotContext();
+  const [suggestions, setSuggestions] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const normalizedStatic = useMemo(
+    () => staticSuggestions?.map((s) => typeof s === "string" ? { text: s } : s),
+    [staticSuggestions]
+  );
+  const refresh = useCallback(async () => {
+    if (normalizedStatic) {
+      setSuggestions(normalizedStatic.slice(0, count));
+      return;
+    }
+    if (!config.cloud) {
+      return;
+    }
+    setIsLoading(true);
+    try {
+      const endpoint = config.cloud.endpoint || "https://api.yourgpt.ai/v1";
+      const response = await fetch(`${endpoint}/suggestions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.cloud.apiKey}`
+        },
+        body: JSON.stringify({
+          botId: config.cloud.botId,
+          count,
+          context,
+          messages: chat.messages.slice(-5)
+          // Last 5 messages for context
+        })
+      });
+      if (response.ok) {
+        const data = await response.json();
+        setSuggestions(
+          data.suggestions.map(
+            (s) => typeof s === "string" ? { text: s } : s
+          )
+        );
+      }
+    } catch (error) {
+      console.error("Failed to fetch suggestions:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [config.cloud, count, context, chat.messages, normalizedStatic]);
+  const select = useCallback(
+    (suggestion) => {
+      const text = typeof suggestion === "string" ? suggestion : suggestion.text;
+      actions.sendMessage(text);
+    },
+    [actions]
+  );
+  useEffect(() => {
+    if (autoRefresh && chat.messages.length === 0) {
+      refresh();
+    }
+  }, [autoRefresh, chat.messages.length, refresh]);
+  return {
+    suggestions: normalizedStatic?.slice(0, count) || suggestions,
+    isLoading,
+    refresh,
+    select
+  };
+}
+function useAgent(options) {
+  const { name, initialState = {}, onStateChange } = options;
+  const { config } = useCopilotContext();
+  const [state, setStateInternal] = useState(initialState);
+  const [isRunning, setIsRunning] = useState(false);
+  const [nodeName, setNodeName] = useState(null);
+  const [error, setError] = useState(null);
+  const abortControllerRef = useRef(null);
+  const getEndpoint = useCallback(() => {
+    if (config.cloud) {
+      return `${config.cloud.endpoint || "https://api.yourgpt.ai/v1"}/agents/${name}`;
+    }
+    return `${config.runtimeUrl || "/api"}/agents/${name}`;
+  }, [config, name]);
+  const start = useCallback(
+    async (input) => {
+      setIsRunning(true);
+      setError(null);
+      abortControllerRef.current = new AbortController();
+      try {
+        const endpoint = getEndpoint();
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (config.cloud?.apiKey) {
+          headers["Authorization"] = `Bearer ${config.cloud.apiKey}`;
+        }
+        const response = await fetch(`${endpoint}/start`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            input: typeof input === "string" ? { message: input } : input,
+            state
+          }),
+          signal: abortControllerRef.current.signal
+        });
+        if (!response.ok) {
+          throw new Error(`Agent error: ${response.status}`);
+        }
+        for await (const event of streamSSE(response)) {
+          handleAgentEvent(event);
+        }
+      } catch (err) {
+        if (err.name !== "AbortError") {
+          setError(err instanceof Error ? err : new Error("Unknown error"));
+        }
+      } finally {
+        setIsRunning(false);
+        abortControllerRef.current = null;
+      }
+    },
+    [config, getEndpoint, state]
+  );
+  const handleAgentEvent = useCallback(
+    (event) => {
+      if (event.type === "error") {
+        setError(new Error(event.message));
+        return;
+      }
+      if ("state" in event && event.state) {
+        setStateInternal(event.state);
+        onStateChange?.(event.state);
+      }
+      if ("nodeName" in event && event.nodeName) {
+        setNodeName(event.nodeName);
+      }
+    },
+    [onStateChange]
+  );
+  const stop = useCallback(() => {
+    abortControllerRef.current?.abort();
+  }, []);
+  const setState = useCallback(
+    (partialState) => {
+      setStateInternal((prev) => {
+        const newState = { ...prev, ...partialState };
+        onStateChange?.(newState);
+        return newState;
+      });
+    },
+    [onStateChange]
+  );
+  useEffect(() => {
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+  return {
+    state,
+    isRunning,
+    nodeName,
+    start,
+    stop,
+    setState,
+    error
+  };
+}
+
+// src/react/utils/knowledge-base.ts
+var KNOWLEDGE_BASE_API = "https://api.yourgpt.ai/chatbot/v1/searchIndexDocument";
+async function searchKnowledgeBase(query, config) {
+  try {
+    const response = await fetch(KNOWLEDGE_BASE_API, {
+      method: "POST",
+      headers: {
+        accept: "*/*",
+        "content-type": "application/json",
+        authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify({
+        project_uid: config.projectUid,
+        query,
+        page: 1,
+        limit: String(config.limit || 10),
+        app_id: config.appId || "1"
+      })
+    });
+    if (!response.ok) {
+      return {
+        success: false,
+        results: [],
+        error: `API error: ${response.status} ${response.statusText}`
+      };
+    }
+    const data = await response.json();
+    const results = (data.data || data.results || []).map((item) => ({
+      id: item.id || item._id || String(Math.random()),
+      title: item.title || item.name || void 0,
+      content: item.content || item.text || item.snippet || "",
+      score: item.score || item.relevance || void 0,
+      url: item.url || item.source_url || void 0,
+      metadata: item.metadata || {}
+    }));
+    return {
+      success: true,
+      results,
+      total: data.total || results.length,
+      page: data.page || 1
+    };
+  } catch (error) {
+    return {
+      success: false,
+      results: [],
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function formatKnowledgeResultsForAI(results) {
+  if (results.length === 0) {
+    return "No relevant documents found in the knowledge base.";
+  }
+  return results.map((result, index) => {
+    const parts = [`[${index + 1}]`];
+    if (result.title) parts.push(`**${result.title}**`);
+    parts.push(result.content);
+    if (result.url) parts.push(`Source: ${result.url}`);
+    return parts.join("\n");
+  }).join("\n\n---\n\n");
+}
+
+// src/react/hooks/useKnowledgeBase.ts
+function useKnowledgeBase(config) {
+  const { registerTool, unregisterTool } = useCopilot();
+  const configRef = useRef(config);
+  configRef.current = config;
+  const handleSearch = useCallback(
+    async (params) => {
+      const query = params.query;
+      if (!query) {
+        return {
+          success: false,
+          error: "Query is required"
+        };
+      }
+      const currentConfig = configRef.current;
+      const kbConfig = {
+        projectUid: currentConfig.projectUid,
+        token: currentConfig.token,
+        appId: currentConfig.appId,
+        limit: currentConfig.limit || 5
+      };
+      const response = await searchKnowledgeBase(
+        query,
+        kbConfig
+      );
+      if (!response.success) {
+        return {
+          success: false,
+          error: response.error || "Knowledge base search failed"
+        };
+      }
+      const formattedResults = formatKnowledgeResultsForAI(response.results);
+      return {
+        success: true,
+        message: formattedResults,
+        data: {
+          resultCount: response.results.length,
+          total: response.total
+        }
+      };
+    },
+    []
+  );
+  useEffect(() => {
+    if (config.enabled === false) {
+      return;
+    }
+    registerTool({
+      name: "search_knowledge",
+      description: "Search the knowledge base for relevant information about the product, documentation, or company. Use this to answer questions about features, pricing, policies, guides, or any factual information.",
+      location: "client",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query to find relevant information in the knowledge base"
+          }
+        },
+        required: ["query"]
+      },
+      handler: handleSearch
+    });
+    return () => {
+      unregisterTool("search_knowledge");
+    };
+  }, [
+    config.enabled,
+    config.projectUid,
+    config.token,
+    registerTool,
+    unregisterTool,
+    handleSearch
+  ]);
+}
+var DEFAULT_CAPABILITIES = {
+  supportsVision: false,
+  supportsTools: true,
+  supportsThinking: false,
+  supportsStreaming: true,
+  supportsPDF: false,
+  supportsAudio: false,
+  supportsVideo: false,
+  maxTokens: 8192,
+  supportedImageTypes: [],
+  supportsJsonMode: false,
+  supportsSystemMessages: true
+};
+function useCapabilities() {
+  const { config } = useCopilotContext();
+  const [capabilities, setCapabilities] = useState(DEFAULT_CAPABILITIES);
+  const [provider, setProvider] = useState("unknown");
+  const [model, setModel] = useState("unknown");
+  const [supportedModels, setSupportedModels] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const capabilitiesUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/chat\/?$/, "/capabilities") : null;
+  const fetchCapabilities = useCallback(async () => {
+    if (!capabilitiesUrl) {
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const response = await fetch(capabilitiesUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch capabilities: ${response.status}`);
+      }
+      const data = await response.json();
+      setCapabilities(data.capabilities);
+      setProvider(data.provider);
+      setModel(data.model);
+      setSupportedModels(data.supportedModels);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Unknown error"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [capabilitiesUrl]);
+  useEffect(() => {
+    fetchCapabilities();
+  }, [fetchCapabilities]);
+  return {
+    /** Current model capabilities */
+    capabilities,
+    /** Current provider name */
+    provider,
+    /** Current model ID */
+    model,
+    /** List of supported models for current provider */
+    supportedModels,
+    /** Whether capabilities are being loaded */
+    isLoading,
+    /** Error if fetch failed */
+    error,
+    /** Refetch capabilities */
+    refetch: fetchCapabilities
+  };
+}
+function useFeatureSupport(feature) {
+  const { capabilities } = useCapabilities();
+  return capabilities[feature] ?? false;
+}
+function useSupportedMediaTypes() {
+  const { capabilities } = useCapabilities();
+  return {
+    /** Supported image MIME types */
+    imageTypes: capabilities.supportedImageTypes || [],
+    /** Supported audio MIME types */
+    audioTypes: capabilities.supportedAudioTypes || [],
+    /** Supported video MIME types */
+    videoTypes: capabilities.supportedVideoTypes || [],
+    /** Whether any image types are supported */
+    hasImageSupport: (capabilities.supportedImageTypes?.length ?? 0) > 0,
+    /** Whether any audio types are supported */
+    hasAudioSupport: (capabilities.supportedAudioTypes?.length ?? 0) > 0,
+    /** Whether any video types are supported */
+    hasVideoSupport: (capabilities.supportedVideoTypes?.length ?? 0) > 0
+  };
+}
+function useDevLogger() {
+  const ctx = useCopilotContext();
+  return useMemo(() => {
+    const toolExecutions = (ctx.agentLoop?.toolExecutions || []).map(
+      (exec) => ({
+        id: exec.id,
+        name: exec.name,
+        status: exec.status,
+        approvalStatus: exec.approvalStatus || "not_required"
+      })
+    );
+    const pendingApprovalsCount = ctx.pendingApprovals?.length || 0;
+    const registeredTools = (ctx.registeredTools || []).map((tool2) => ({
+      name: tool2.name,
+      location: tool2.location || "client"
+    }));
+    const registeredActions = (ctx.registeredActions || []).map((action) => ({
+      name: action.name
+    }));
+    const storedPermissions = (ctx.storedPermissions || []).map((p) => ({
+      toolName: p.toolName,
+      level: p.level
+    }));
+    return {
+      chat: {
+        isLoading: ctx.chat?.isLoading || false,
+        messageCount: ctx.chat?.messages?.length || 0,
+        threadId: ctx.chat?.threadId || "none",
+        error: ctx.chat?.error?.message || null
+      },
+      tools: {
+        isEnabled: !!ctx.toolsConfig,
+        isCapturing: ctx.tools?.isCapturing || false,
+        pendingConsent: !!ctx.tools?.pendingConsent
+      },
+      agentLoop: {
+        toolExecutions,
+        pendingApprovals: pendingApprovalsCount,
+        iteration: ctx.agentLoop?.iteration || 0,
+        maxIterations: ctx.agentLoop?.maxIterations || 10
+      },
+      registered: {
+        tools: registeredTools,
+        actions: registeredActions,
+        contextCount: ctx.contextTree?.length || 0
+      },
+      permissions: {
+        stored: storedPermissions,
+        loaded: ctx.permissionsLoaded || false
+      },
+      config: {
+        runtimeUrl: ctx.config?.runtimeUrl || ctx.config?.cloud?.endpoint || ""
+      }
+    };
+  }, [
+    ctx.chat,
+    ctx.tools,
+    ctx.toolsConfig,
+    ctx.agentLoop,
+    ctx.pendingApprovals,
+    ctx.registeredTools,
+    ctx.registeredActions,
+    ctx.contextTree,
+    ctx.storedPermissions,
+    ctx.permissionsLoaded,
+    ctx.config
+  ]);
+}
+
+// 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);
+    }
+    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/hooks/useThread.ts
+function useThread() {
+  const { threadId, setActiveThread, renewSession, sessionStatus } = useCopilot();
+  return {
+    threadId,
+    sessionStatus,
+    switchThread: setActiveThread,
+    newThread: () => setActiveThread(null),
+    renewSession
+  };
+}
+function useMCPUIIntents(config = {}) {
+  const {
+    onToolCall,
+    onIntent,
+    onPrompt,
+    onNotify,
+    onLink,
+    requireConsent = { tool: false, link: true }
+  } = config;
+  const handleIntent = useCallback(
+    async (intent, context) => {
+      switch (intent.type) {
+        case "tool": {
+          if (requireConsent.tool) ;
+          await onToolCall?.(intent.name, intent.arguments, context);
+          break;
+        }
+        case "intent": {
+          await onIntent?.(intent.action, intent.data, context);
+          break;
+        }
+        case "prompt": {
+          onPrompt?.(intent.text, context);
+          break;
+        }
+        case "notify": {
+          onNotify?.(intent.message, intent.level, context);
+          break;
+        }
+        case "link": {
+          const shouldContinue = onLink?.(intent.url, intent.newTab, context);
+          if (shouldContinue === false) {
+            break;
+          }
+          if (requireConsent.link) {
+            const isSafeUrl = intent.url.startsWith("https://") || intent.url.startsWith("http://localhost");
+            if (!isSafeUrl) {
+              console.warn(
+                "[MCP-UI] Blocked potentially unsafe link:",
+                intent.url
+              );
+              break;
+            }
+          }
+          if (typeof window !== "undefined") {
+            if (intent.newTab !== false) {
+              window.open(intent.url, "_blank", "noopener,noreferrer");
+            } else {
+              window.location.href = intent.url;
+            }
+          }
+          break;
+        }
+        default: {
+          console.warn(
+            "[MCP-UI] Unknown intent type:",
+            intent.type
+          );
+        }
+      }
+    },
+    [onToolCall, onIntent, onPrompt, onNotify, onLink, requireConsent]
+  );
+  return useMemo(
+    () => ({
+      handleIntent
+    }),
+    [handleIntent]
+  );
+}
+function createMessageIntentHandler(sendMessage) {
+  return {
+    onIntent: async (action, data) => {
+      const dataStr = data ? ` with ${JSON.stringify(data)}` : "";
+      await sendMessage(`User action: ${action}${dataStr}`);
+    },
+    onPrompt: (text) => {
+      sendMessage(text);
+    },
+    onNotify: (message, level) => {
+      if (level === "error") {
+        sendMessage(`Error: ${message}`);
+      }
+    }
+  };
+}
+function createToolIntentHandler(callTool) {
+  return {
+    onToolCall: async (name, args) => {
+      await callTool(name, args);
+    }
+  };
+}
+function getLastResponseUsage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "assistant" && msg.metadata?.usage) {
+      const u = msg.metadata.usage;
+      const prompt = u.prompt_tokens ?? 0;
+      const completion = u.completion_tokens ?? 0;
+      return {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: u.total_tokens ?? prompt + completion
+      };
+    }
+  }
+  return null;
+}
+function useContextStats() {
+  const { contextChars, contextUsage, registeredTools, messages } = useCopilot();
+  const toolCount = useMemo(() => registeredTools.length, [registeredTools]);
+  const messageCount = useMemo(
+    () => messages.filter((m) => m.role !== "system").length,
+    [messages]
+  );
+  const totalTokens = useMemo(() => {
+    if (contextUsage) return contextUsage.total.tokens;
+    return Math.ceil(contextChars / 3.5);
+  }, [contextUsage, contextChars]);
+  const usagePercent = useMemo(() => {
+    if (contextUsage) return contextUsage.total.percent;
+    return 0;
+  }, [contextUsage]);
+  const lastResponseUsage = useMemo(
+    () => getLastResponseUsage(messages),
+    [messages]
+  );
+  return {
+    contextUsage,
+    totalTokens,
+    usagePercent,
+    contextChars,
+    toolCount,
+    messageCount,
+    lastResponseUsage
+  };
+}
+var DEV_CONTENT_WARN_THRESHOLD = 2e3;
+function useSkill(skill) {
+  const { register, unregister } = useSkillContext();
+  if (process.env.NODE_ENV !== "production" && skill.source.type === "inline" && skill.source.content.length > DEV_CONTENT_WARN_THRESHOLD) {
+    console.warn(
+      `[copilot-sdk/skills] Inline skill "${skill.name}" has ${skill.source.content.length} characters. Inline skills are sent on every request \u2014 keep them under ${DEV_CONTENT_WARN_THRESHOLD} characters. Consider using a file or URL skill instead.`
+    );
+  }
+  useEffect(() => {
+    if (skill.source.type !== "inline") {
+      console.warn(
+        `[copilot-sdk/skills] useSkill only supports inline skills client-side. Skill "${skill.name}" has source type "${skill.source.type}" and will be skipped.`
+      );
+      return;
+    }
+    const resolved = {
+      ...skill,
+      content: skill.source.content
+    };
+    register(resolved);
+    return () => {
+      unregister(skill.name);
+    };
+  }, [
+    skill.name,
+    skill.source.type === "inline" ? skill.source.content : "",
+    skill.strategy,
+    skill.description
+  ]);
+}
+function useSkillStatus() {
+  const { skills, registry } = useSkillContext();
+  const has = useCallback(
+    (name) => registry.has(name),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [skills]
+  );
+  return {
+    skills,
+    count: skills.length,
+    has
+  };
+}
+function useMessageCheckpoints() {
+  const { messages, setMessages } = useCopilot();
+  const checkpointMapRef = useRef(/* @__PURE__ */ new Map());
+  const prevUserMsgCountRef = useRef(0);
+  const [revision, bump] = useReducer((n) => n + 1, 0);
+  useEffect(() => {
+    const userMessages = messages.filter((m) => m.role === "user");
+    const count = userMessages.length;
+    if (count > prevUserMsgCountRef.current) {
+      const newUserMsg = userMessages[count - 1];
+      if (!checkpointMapRef.current.has(newUserMsg.id)) {
+        const msgIndex = messages.findIndex((m) => m.id === newUserMsg.id);
+        checkpointMapRef.current.set(newUserMsg.id, {
+          id: `cp_${newUserMsg.id}`,
+          messageId: newUserMsg.id,
+          timestamp: Date.now(),
+          messages: structuredClone(messages.slice(0, msgIndex))
+        });
+        bump();
+      }
+      prevUserMsgCountRef.current = count;
+    }
+  }, [messages]);
+  const hasCheckpoint = useCallback(
+    (messageId) => checkpointMapRef.current.has(messageId),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [revision]
+  );
+  const getCheckpoint = useCallback(
+    (messageId) => checkpointMapRef.current.get(messageId),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [revision]
+  );
+  const restore = useCallback(
+    (messageId) => {
+      const cp = checkpointMapRef.current.get(messageId);
+      if (!cp) return void 0;
+      setMessages(cp.messages);
+      checkpointMapRef.current.forEach((c, k) => {
+        if (c.timestamp > cp.timestamp) checkpointMapRef.current.delete(k);
+      });
+      prevUserMsgCountRef.current = cp.messages.filter(
+        (m) => m.role === "user"
+      ).length;
+      bump();
+      return cp;
+    },
+    [setMessages]
+  );
+  const save = useCallback(
+    (messageId, label) => {
+      const msgIndex = messages.findIndex((m) => m.id === messageId);
+      if (msgIndex === -1) return void 0;
+      const cp = {
+        id: `cp_${messageId}`,
+        messageId,
+        timestamp: Date.now(),
+        label,
+        messages: structuredClone(messages.slice(0, msgIndex))
+      };
+      checkpointMapRef.current.set(messageId, cp);
+      bump();
+      return cp;
+    },
+    [messages]
+  );
+  const clear = useCallback(() => {
+    checkpointMapRef.current.clear();
+    prevUserMsgCountRef.current = 0;
+    bump();
+  }, []);
+  const checkpoints = useMemo(
+    () => Array.from(checkpointMapRef.current.values()).sort(
+      (a, b) => a.timestamp - b.timestamp
+    ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [revision]
+  );
+  return { checkpoints, hasCheckpoint, getCheckpoint, restore, save, clear };
+}
+
+// src/react/utils/permission-storage.ts
+var DEFAULT_KEY_PREFIX = "yourgpt-permissions";
+function createPermissionStorage(config) {
+  switch (config.type) {
+    case "localStorage":
+      return createBrowserStorageAdapter(
+        typeof window !== "undefined" ? localStorage : null,
+        config.keyPrefix
+      );
+    case "sessionStorage":
+      return createBrowserStorageAdapter(
+        typeof window !== "undefined" ? sessionStorage : null,
+        config.keyPrefix
+      );
+    case "memory":
+    default:
+      return createMemoryStorageAdapter();
+  }
+}
+function createBrowserStorageAdapter(storage, keyPrefix = DEFAULT_KEY_PREFIX) {
+  const getStorageKey = () => keyPrefix;
+  const loadPermissions = () => {
+    if (!storage) return /* @__PURE__ */ new Map();
+    try {
+      const data = storage.getItem(getStorageKey());
+      if (!data) return /* @__PURE__ */ new Map();
+      const parsed = JSON.parse(data);
+      return new Map(parsed.map((p) => [p.toolName, p]));
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  };
+  const savePermissions = (permissions) => {
+    if (!storage) return;
+    try {
+      storage.setItem(
+        getStorageKey(),
+        JSON.stringify(Array.from(permissions.values()))
+      );
+    } catch (e) {
+      console.warn("[PermissionStorage] Failed to save permissions:", e);
+    }
+  };
+  return {
+    async get(toolName) {
+      const permissions = loadPermissions();
+      return permissions.get(toolName) || null;
+    },
+    async set(permission) {
+      const permissions = loadPermissions();
+      permissions.set(permission.toolName, permission);
+      savePermissions(permissions);
+    },
+    async remove(toolName) {
+      const permissions = loadPermissions();
+      permissions.delete(toolName);
+      savePermissions(permissions);
+    },
+    async getAll() {
+      const permissions = loadPermissions();
+      return Array.from(permissions.values());
+    },
+    async clear() {
+      if (!storage) return;
+      storage.removeItem(getStorageKey());
+    }
+  };
+}
+function createMemoryStorageAdapter() {
+  const permissions = /* @__PURE__ */ new Map();
+  return {
+    async get(toolName) {
+      return permissions.get(toolName) || null;
+    },
+    async set(permission) {
+      permissions.set(permission.toolName, permission);
+    },
+    async remove(toolName) {
+      permissions.delete(toolName);
+    },
+    async getAll() {
+      return Array.from(permissions.values());
+    },
+    async clear() {
+      permissions.clear();
+    }
+  };
+}
+function createSessionPermissionCache() {
+  return /* @__PURE__ */ new Map();
+}
+
+// src/react/internal/ReactChat.ts
+var ReactChat = class extends AbstractChat {
+  constructor(config) {
+    const reactState = new ReactChatState(config.initialMessages);
+    const init = {
+      runtimeUrl: config.runtimeUrl,
+      systemPrompt: config.systemPrompt,
+      llm: config.llm,
+      threadId: config.threadId,
+      onCreateSession: config.onCreateSession,
+      yourgptConfig: config.yourgptConfig,
+      streaming: config.streaming ?? true,
+      headers: config.headers,
+      initialMessages: config.initialMessages,
+      state: reactState,
+      callbacks: config.callbacks,
+      debug: config.debug
+    };
+    super(init);
+    // ============================================
+    // Subscribe (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const messages = useSyncExternalStore(
+     *   chat.subscribe,
+     *   () => chat.messages
+     * );
+     * ```
+     */
+    this.subscribe = (callback) => {
+      return this.reactState.subscribe(callback);
+    };
+    this.reactState = reactState;
+  }
+  // ============================================
+  // Event handling shortcuts
+  // ============================================
+  /**
+   * Subscribe to tool calls events
+   */
+  onToolCalls(handler) {
+    return this.on("toolCalls", handler);
+  }
+  /**
+   * Subscribe to done events
+   */
+  onDone(handler) {
+    return this.on("done", handler);
+  }
+  /**
+   * Subscribe to error events
+   */
+  onError(handler) {
+    return this.on("error", handler);
+  }
+  // ============================================
+  // Branching API — pass-throughs to ReactChatState
+  // ============================================
+  /**
+   * Navigate to a sibling branch (makes it the active path).
+   */
+  switchBranch(messageId) {
+    this.reactState.switchBranch(messageId);
+  }
+  /**
+   * Get branch navigation info for a message.
+   * Returns null if the message has no siblings.
+   */
+  getBranchInfo(messageId) {
+    return this.reactState.getBranchInfo(messageId);
+  }
+  /**
+   * Get all messages across all branches (for persistence).
+   */
+  getAllMessages() {
+    return this.reactState.getAllMessages();
+  }
+  /**
+   * Whether any message has siblings (branching has occurred).
+   */
+  get hasBranches() {
+    return this.reactState.hasBranches;
+  }
+  // ============================================
+  // Override dispose to clean up state
+  // ============================================
+  dispose() {
+    super.dispose();
+    this.reactState.dispose();
+  }
+  /**
+   * Revive a disposed instance (for React StrictMode compatibility)
+   */
+  revive() {
+    super.revive();
+    this.reactState.revive();
+  }
+};
+function createReactChat(config) {
+  return new ReactChat(config);
+}
+function useChat(config) {
+  const chatRef = useRef(null);
+  const isThreadIdControlled = Object.prototype.hasOwnProperty.call(
+    config,
+    "threadId"
+  );
+  const lastControlledThreadIdRef = useRef({
+    controlled: isThreadIdControlled,
+    value: config.threadId
+  });
+  const [input, setInput] = useState("");
+  if (chatRef.current !== null && chatRef.current.disposed) {
+    chatRef.current.revive();
+  }
+  if (chatRef.current === null) {
+    chatRef.current = createReactChat({
+      runtimeUrl: config.runtimeUrl,
+      systemPrompt: config.systemPrompt,
+      llm: config.llm,
+      threadId: config.threadId,
+      onCreateSession: config.onCreateSession,
+      yourgptConfig: config.yourgptConfig,
+      streaming: config.streaming,
+      headers: config.headers,
+      initialMessages: config.initialMessages,
+      debug: config.debug,
+      callbacks: {
+        onMessagesChange: config.onMessagesChange,
+        onError: config.onError,
+        onFinish: config.onFinish,
+        onToolCalls: config.onToolCalls
+      }
+    });
+  }
+  useEffect(() => {
+    const prev = lastControlledThreadIdRef.current;
+    const controlChanged = prev.controlled !== isThreadIdControlled;
+    const valueChanged = prev.value !== config.threadId;
+    if (!controlChanged && !valueChanged) {
+      return;
+    }
+    lastControlledThreadIdRef.current = {
+      controlled: isThreadIdControlled,
+      value: config.threadId
+    };
+    if (!isThreadIdControlled) {
+      return;
+    }
+    chatRef.current?.setActiveThread(config.threadId ?? null);
+  }, [config.threadId, isThreadIdControlled]);
+  const messages = useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.messages,
+    () => chatRef.current.messages
+    // Server snapshot
+  );
+  const status = useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.status,
+    () => "ready"
+    // Server snapshot
+  );
+  const error = useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.error,
+    () => void 0
+    // Server snapshot
+  );
+  const hasBranches = useSyncExternalStore(
+    chatRef.current.subscribe,
+    () => chatRef.current.hasBranches,
+    () => false
+  );
+  const isLoading = status === "streaming" || status === "submitted";
+  const sendMessage = useCallback(
+    async (content, attachments) => {
+      await chatRef.current?.sendMessage(content, attachments);
+      setInput("");
+    },
+    []
+  );
+  const stop = useCallback(() => {
+    chatRef.current?.stop();
+  }, []);
+  const clearMessages = useCallback(() => {
+    chatRef.current?.clearMessages();
+  }, []);
+  const setMessages = useCallback((messages2) => {
+    chatRef.current?.setMessages(messages2);
+  }, []);
+  const regenerate = useCallback(async (messageId) => {
+    await chatRef.current?.regenerate(messageId);
+  }, []);
+  const continueWithToolResults = useCallback(
+    async (toolResults) => {
+      await chatRef.current?.continueWithToolResults(toolResults);
+    },
+    []
+  );
+  const switchBranch = useCallback((messageId) => {
+    chatRef.current?.switchBranch(messageId);
+  }, []);
+  const getBranchInfo = useCallback((messageId) => {
+    return chatRef.current?.getBranchInfo(messageId) ?? null;
+  }, []);
+  const editMessage = useCallback(
+    async (messageId, newContent) => {
+      await chatRef.current?.sendMessage(newContent, void 0, {
+        editMessageId: messageId
+      });
+      setInput("");
+    },
+    []
+  );
+  useEffect(() => {
+    return () => {
+      chatRef.current?.dispose();
+    };
+  }, []);
+  return {
+    messages,
+    status,
+    error,
+    isLoading,
+    input,
+    setInput,
+    sendMessage,
+    stop,
+    clearMessages,
+    setMessages,
+    regenerate,
+    continueWithToolResults,
+    chatRef,
+    // Branching
+    switchBranch,
+    getBranchInfo,
+    editMessage,
+    hasBranches
+  };
+}
+
+// src/react/skill/define-skill.ts
+function defineSkill(def) {
+  return def;
+}
+function useCopilotEvent(eventType, handler) {
+  const { subscribeToStreamEvents } = useCopilot();
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+  useEffect(() => {
+    const unsub = subscribeToStreamEvents((chunk) => {
+      if (eventType === "*" || chunk.type === eventType) {
+        handlerRef.current(chunk);
+      }
+    });
+    return unsub;
+  }, [subscribeToStreamEvents, eventType]);
+}
+var EMPTY_META = {};
+function useMessageMeta(messageId) {
+  const { messageMeta } = useCopilot();
+  const meta = useSyncExternalStore(
+    messageMeta.subscribe,
+    () => messageId ? messageMeta.getMeta(messageId) : EMPTY_META,
+    () => EMPTY_META
+  );
+  const setMeta = useCallback(
+    (next) => {
+      if (!messageId) return;
+      messageMeta.setMeta(messageId, next);
+    },
+    [messageMeta, messageId]
+  );
+  const updateMeta = useCallback(
+    (updater) => {
+      if (!messageId) return;
+      messageMeta.updateMeta(
+        messageId,
+        (prev) => updater(prev)
+      );
+    },
+    [messageMeta, messageId]
+  );
+  return { meta, setMeta, updateMeta };
+}
+
+export { ReactChat, ReactThreadManager, ReactThreadManagerState, createMessageIntentHandler, createPermissionStorage, createReactChat, createReactThreadManager, createReactThreadManagerState, createSessionPermissionCache, createToolIntentHandler, defineSkill, formatKnowledgeResultsForAI, searchKnowledgeBase, useAIAction, useAIActions, useAITools, useAgent, useCapabilities, useChat, useContextStats, useCopilotEvent, useDevLogger, useFeatureSupport, useKnowledgeBase, useMCPUIIntents, useMessageCheckpoints, useMessageMeta, useSkill, useSkillStatus, useSuggestions, useSupportedMediaTypes, useThread, useThreadManager, useToolExecutor, useToolWithSchema, useToolsWithSchema };
+//# sourceMappingURL=chunk-PURFAD2P.js.map
+//# sourceMappingURL=chunk-PURFAD2P.js.map