@copilotz/chat-adapter 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/CopilotzChat.tsx
-import { useMemo } from "react";
+import { useMemo, useEffect as useEffect3, useState as useState3 } from "react";
 import { ChatUI, ChatUserContextProvider } from "@copilotz/chat-ui";
 
 // ../node_modules/lucide-react/dist/esm/createLucideIcon.js
@@ -99,7 +99,7 @@ var __iconNode = [
 var User = createLucideIcon("user", __iconNode);
 
 // src/useCopilotzChat.ts
-import { useState, useCallback, useRef, useEffect } from "react";
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
 
 // src/copilotzService.ts
 var rawBaseValue = import.meta.env?.VITE_API_URL;
@@ -259,6 +259,7 @@ async function runCopilotzStream(options) {
     metadata,
     threadMetadata,
     toolCalls,
+    selectedAgent,
     onToken,
     onMessageEvent,
     onAssetEvent,
@@ -304,7 +305,7 @@ async function runCopilotzStream(options) {
     id: threadId ?? null,
     externalId: threadExternalId ?? null,
     name: threadName,
-    participants: ["assistant"],
+    participants: [selectedAgent || "assistant"],
     metadata: Object.keys(restThreadMetadata).length > 0 ? restThreadMetadata : null
   } : void 0;
   const preparedAudioParts = [];
@@ -610,6 +611,110 @@ async function resolveAssetsInMessages(messages) {
   return resolved;
 }
 
+// src/useUrlState.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+var DEFAULT_PARAMS = {
+  thread: "thread",
+  agent: "agent",
+  prompt: "prompt"
+};
+var isBrowser = typeof globalThis !== "undefined" && typeof globalThis.location !== "undefined";
+var getSearchParams = () => {
+  if (!isBrowser) return new URLSearchParams();
+  return new URLSearchParams(globalThis.location.search);
+};
+var updateUrl = (params, mode) => {
+  if (!isBrowser) return;
+  const url = new URL(globalThis.location.href);
+  url.search = params.toString();
+  if (mode === "push") {
+    globalThis.history.pushState({}, "", url.toString());
+  } else {
+    globalThis.history.replaceState({}, "", url.toString());
+  }
+};
+function useUrlState(config = {}) {
+  const {
+    enabled = true,
+    mode = "replace",
+    params: userParams = {},
+    clearPromptAfterRead = true
+  } = config;
+  const params = { ...DEFAULT_PARAMS, ...userParams };
+  const isReadOnly = mode === "read-only";
+  const updateMode = mode === "read-only" ? "replace" : mode;
+  const initialReadDone = useRef(false);
+  const promptCleared = useRef(false);
+  const parseUrlState = useCallback(() => {
+    if (!enabled || !isBrowser) {
+      return { threadId: null, agentId: null, prompt: null };
+    }
+    const searchParams = getSearchParams();
+    return {
+      threadId: searchParams.get(params.thread) || null,
+      agentId: searchParams.get(params.agent) || null,
+      prompt: promptCleared.current ? null : searchParams.get(params.prompt) || null
+    };
+  }, [enabled, params.thread, params.agent, params.prompt]);
+  const [state, setState] = useState(parseUrlState);
+  useEffect(() => {
+    if (!enabled || !isBrowser) return;
+    if (!initialReadDone.current) {
+      const initialState = parseUrlState();
+      setState(initialState);
+      initialReadDone.current = true;
+      if (clearPromptAfterRead && initialState.prompt && !isReadOnly) {
+        const searchParams = getSearchParams();
+        searchParams.delete(params.prompt);
+        updateUrl(searchParams, "replace");
+        promptCleared.current = true;
+      }
+    }
+    const handlePopState = () => {
+      setState(parseUrlState());
+    };
+    globalThis.addEventListener("popstate", handlePopState);
+    return () => globalThis.removeEventListener("popstate", handlePopState);
+  }, [enabled, parseUrlState, clearPromptAfterRead, params.prompt, isReadOnly]);
+  const setThreadId = useCallback((threadId) => {
+    if (!enabled || isReadOnly || !isBrowser) return;
+    const searchParams = getSearchParams();
+    if (threadId) {
+      searchParams.set(params.thread, threadId);
+    } else {
+      searchParams.delete(params.thread);
+    }
+    updateUrl(searchParams, updateMode);
+    setState((prev) => ({ ...prev, threadId }));
+  }, [enabled, isReadOnly, params.thread, updateMode]);
+  const setAgentId = useCallback((agentId) => {
+    if (!enabled || isReadOnly || !isBrowser) return;
+    const searchParams = getSearchParams();
+    if (agentId) {
+      searchParams.set(params.agent, agentId);
+    } else {
+      searchParams.delete(params.agent);
+    }
+    updateUrl(searchParams, updateMode);
+    setState((prev) => ({ ...prev, agentId }));
+  }, [enabled, isReadOnly, params.agent, updateMode]);
+  const clearPrompt = useCallback(() => {
+    if (!enabled || isReadOnly || !isBrowser) return;
+    const searchParams = getSearchParams();
+    searchParams.delete(params.prompt);
+    updateUrl(searchParams, "replace");
+    promptCleared.current = true;
+    setState((prev) => ({ ...prev, prompt: null }));
+  }, [enabled, isReadOnly, params.prompt]);
+  return {
+    state,
+    setThreadId,
+    setAgentId,
+    clearPrompt,
+    isEnabled: enabled
+  };
+}
+
 // src/useCopilotzChat.ts
 var nowTs = () => Date.now();
 var generateId = () => globalThis.crypto?.randomUUID?.() ?? `id-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
@@ -667,48 +772,45 @@ var convertServerMessage = (msg) => {
     toolCalls: hasToolCalls ? mappedToolCalls : void 0
   };
 };
-function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onToolOutput }) {
-  const [threads, setThreads] = useState([]);
-  const [threadMetadataMap, setThreadMetadataMap] = useState({});
-  const [threadExternalIdMap, setThreadExternalIdMap] = useState({});
-  const [currentThreadId, setCurrentThreadId] = useState(null);
-  const [currentThreadExternalId, setCurrentThreadExternalId] = useState(null);
-  const [messages, setMessages] = useState([]);
-  const [isStreaming, setIsStreaming] = useState(false);
-  const [userContextSeed, setUserContextSeed] = useState(initialContext || {});
-  const threadsRef = useRef(threads);
-  const threadMetadataMapRef = useRef(threadMetadataMap);
-  const threadExternalIdMapRef = useRef(threadExternalIdMap);
-  const currentThreadIdRef = useRef(currentThreadId);
-  const currentThreadExternalIdRef = useRef(currentThreadExternalId);
-  const userContextSeedRef = useRef(userContextSeed);
-  useEffect(() => {
-    threadsRef.current = threads;
-  }, [threads]);
-  useEffect(() => {
-    threadMetadataMapRef.current = threadMetadataMap;
-  }, [threadMetadataMap]);
-  useEffect(() => {
-    threadExternalIdMapRef.current = threadExternalIdMap;
-  }, [threadExternalIdMap]);
-  useEffect(() => {
-    currentThreadIdRef.current = currentThreadId;
-  }, [currentThreadId]);
-  useEffect(() => {
-    currentThreadExternalIdRef.current = currentThreadExternalId;
-  }, [currentThreadExternalId]);
-  useEffect(() => {
-    userContextSeedRef.current = userContextSeed;
-  }, [userContextSeed]);
-  const abortControllerRef = useRef(null);
-  const messagesRequestRef = useRef(0);
-  const initializationRef = useRef({ userId: null, started: false });
-  useEffect(() => {
+function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onToolOutput, preferredAgentName, urlSync }) {
+  const {
+    state: urlState,
+    setThreadId: setUrlThreadId,
+    setAgentId: setUrlAgentId,
+    clearPrompt: clearUrlPrompt,
+    isEnabled: isUrlSyncEnabled
+  } = useUrlState(urlSync);
+  const [threads, setThreads] = useState2([]);
+  const [threadMetadataMap, setThreadMetadataMap] = useState2({});
+  const [threadExternalIdMap, setThreadExternalIdMap] = useState2({});
+  const [currentThreadId, setCurrentThreadId] = useState2(null);
+  const [currentThreadExternalId, setCurrentThreadExternalId] = useState2(null);
+  const [messages, setMessages] = useState2([]);
+  const [isStreaming, setIsStreaming] = useState2(false);
+  const [userContextSeed, setUserContextSeed] = useState2(initialContext || {});
+  const preferredAgentRef = useRef2(preferredAgentName ?? null);
+  const threadsRef = useRef2(threads);
+  const threadMetadataMapRef = useRef2(threadMetadataMap);
+  const threadExternalIdMapRef = useRef2(threadExternalIdMap);
+  const currentThreadIdRef = useRef2(currentThreadId);
+  const currentThreadExternalIdRef = useRef2(currentThreadExternalId);
+  const userContextSeedRef = useRef2(userContextSeed);
+  threadsRef.current = threads;
+  threadMetadataMapRef.current = threadMetadataMap;
+  threadExternalIdMapRef.current = threadExternalIdMap;
+  currentThreadIdRef.current = currentThreadId;
+  currentThreadExternalIdRef.current = currentThreadExternalId;
+  userContextSeedRef.current = userContextSeed;
+  preferredAgentRef.current = preferredAgentName ?? null;
+  const abortControllerRef = useRef2(null);
+  const messagesRequestRef = useRef2(0);
+  const initializationRef = useRef2({ userId: null, started: false });
+  useEffect2(() => {
     if (initialContext) {
       setUserContextSeed((prev) => ({ ...prev, ...initialContext }));
     }
   }, [initialContext]);
-  const processToolOutput = useCallback((output) => {
+  const processToolOutput = useCallback2((output) => {
     if (!output) return;
     const contextPatch = {};
     if (output.userContext && typeof output.userContext === "object") {
@@ -719,7 +821,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     }
     onToolOutput?.(output);
   }, [onToolOutput]);
-  const handleStreamMessageEvent = useCallback((event) => {
+  const handleStreamMessageEvent = useCallback2((event) => {
     const payload = event?.payload;
     if (!payload) return;
     if (payload.senderType === "tool") {
@@ -776,7 +878,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       });
     }
   }, [processToolOutput]);
-  const updateThreadsState = useCallback((rawThreads, preferredExternalId) => {
+  const updateThreadsState = useCallback2((rawThreads, preferredExternalId) => {
     const metadataMap = {};
     const externalMap = {};
     const normalized = rawThreads.map((thread) => {
@@ -818,7 +920,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     setCurrentThreadExternalId(nextThreadId ? externalMap[nextThreadId] ?? null : null);
     return nextThreadId;
   }, []);
-  const fetchAndSetThreadsState = useCallback(async (uid, preferredExternalId) => {
+  const fetchAndSetThreadsState = useCallback2(async (uid, preferredExternalId) => {
     try {
       const rawThreads = await fetchThreads(uid);
       return updateThreadsState(rawThreads, preferredExternalId);
@@ -828,7 +930,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       return null;
     }
   }, [updateThreadsState]);
-  const loadThreadMessages = useCallback(async (threadId) => {
+  const loadThreadMessages = useCallback2(async (threadId) => {
     const requestId = Date.now();
     messagesRequestRef.current = requestId;
     try {
@@ -859,13 +961,13 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       console.error(`Error loading messages for thread ${threadId}`, error);
     }
   }, [processToolOutput]);
-  const handleSelectThread = useCallback(async (threadId) => {
+  const handleSelectThread = useCallback2(async (threadId) => {
     setCurrentThreadId(threadId);
     const extMap = threadExternalIdMapRef.current;
     setCurrentThreadExternalId(extMap[threadId] ?? null);
     await loadThreadMessages(threadId);
   }, [loadThreadMessages]);
-  const handleCreateThread = useCallback((title) => {
+  const handleCreateThread = useCallback2((title) => {
     const id = generateId();
     const now = nowTs();
     const newThread = {
@@ -883,7 +985,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     setCurrentThreadExternalId(id);
     setMessages([]);
   }, []);
-  const handleRenameThread = useCallback(async (threadId, newTitle) => {
+  const handleRenameThread = useCallback2(async (threadId, newTitle) => {
     const trimmedTitle = newTitle.trim();
     if (!trimmedTitle) return;
     setThreads(
@@ -907,7 +1009,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       }
     }
   }, [userId, fetchAndSetThreadsState]);
-  const handleArchiveThread = useCallback(async (threadId) => {
+  const handleArchiveThread = useCallback2(async (threadId) => {
     const thread = threadsRef.current.find((t) => t.id === threadId);
     if (!thread) return;
     const newArchivedStatus = !thread.isArchived;
@@ -927,7 +1029,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       }
     }
   }, [userId, fetchAndSetThreadsState]);
-  const handleDeleteThread = useCallback(async (threadId) => {
+  const handleDeleteThread = useCallback2(async (threadId) => {
     const extMap = threadExternalIdMapRef.current;
     const isPlaceholder = extMap[threadId] === threadId;
     setThreads((prev) => prev.filter((t) => t.id !== threadId));
@@ -964,13 +1066,17 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       }
     }
   }, [userId, fetchAndSetThreadsState, loadThreadMessages]);
-  const handleStop = useCallback(() => {
+  const handleStop = useCallback2(() => {
     abortControllerRef.current?.abort();
     abortControllerRef.current = null;
     setIsStreaming(false);
-    setMessages((prev) => prev.map((msg) => msg.isStreaming ? { ...msg, isStreaming: false, isComplete: true } : msg));
+    setMessages((prev) => {
+      const hasStreaming = prev.some((msg) => msg.isStreaming);
+      if (!hasStreaming) return prev;
+      return prev.map((msg) => msg.isStreaming ? { ...msg, isStreaming: false, isComplete: true } : msg);
+    });
   }, []);
-  const handleStreamAssetEvent = useCallback((payload, assistantMessageId) => {
+  const handleStreamAssetEvent = useCallback2((payload, assistantMessageId) => {
     if (!payload?.dataUrl) return;
     const mimeType = payload.mime || "image/png";
     const dataUrl = payload.dataUrl;
@@ -992,22 +1098,36 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       isComplete: true
     } : msg));
   }, []);
-  const sendCopilotzMessage = useCallback(async (params) => {
+  const sendCopilotzMessage = useCallback2(async (params) => {
     let currentAssistantId = generateId();
     params.onBeforeStart?.(currentAssistantId);
     let hasStreamProgress = false;
     let pendingStartNewAssistantBubble = false;
-    const ensureStreamingBubble = () => {
+    const updateStreamingMessage = (partial, isComplete) => {
+      if (partial && partial.length > 0) {
+        hasStreamProgress = true;
+      }
       setMessages((prev) => {
         const idx = prev.findIndex((m) => m.id === currentAssistantId);
-        if (idx >= 0 && prev[idx].role === "assistant" && prev[idx].isStreaming) {
-          return prev;
+        if (idx >= 0 && prev[idx].role === "assistant") {
+          const msg = prev[idx];
+          if (msg.content === partial && msg.isStreaming === !isComplete && msg.isComplete === isComplete) {
+            return prev;
+          }
+          const updated = [...prev];
+          updated[idx] = { ...msg, content: partial, isStreaming: !isComplete, isComplete };
+          return updated;
         }
         const last = prev[prev.length - 1];
         if (last && last.role === "assistant" && last.isStreaming) {
           currentAssistantId = last.id;
           pendingStartNewAssistantBubble = false;
-          return prev;
+          if (last.content === partial && last.isStreaming === !isComplete && last.isComplete === isComplete) {
+            return prev;
+          }
+          const updated = [...prev];
+          updated[prev.length - 1] = { ...last, content: partial, isStreaming: !isComplete, isComplete };
+          return updated;
         }
         if (pendingStartNewAssistantBubble || !prev.length || (prev[prev.length - 1].role !== "assistant" || !prev[prev.length - 1].isStreaming)) {
           const newId = generateId();
@@ -1018,25 +1138,26 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
             {
               id: newId,
               role: "assistant",
-              content: "",
+              content: partial,
               timestamp: nowTs(),
-              isStreaming: true,
-              isComplete: false
+              isStreaming: !isComplete,
+              isComplete
             }
           ];
         }
         return prev;
       });
     };
-    const updateStreamingMessage = (partial, isComplete) => {
-      if (partial && partial.length > 0) {
-        hasStreamProgress = true;
-      }
-      ensureStreamingBubble();
-      setMessages((prev) => prev.map((msg) => msg.id === currentAssistantId ? { ...msg, content: partial, isStreaming: !isComplete, isComplete } : msg));
-    };
     const finalizeCurrentAssistantBubble = () => {
-      setMessages((prev) => prev.map((msg) => msg.id === currentAssistantId ? { ...msg, isStreaming: false, isComplete: true } : msg));
+      setMessages((prev) => {
+        const idx = prev.findIndex((m) => m.id === currentAssistantId);
+        if (idx < 0) return prev;
+        const msg = prev[idx];
+        if (!msg.isStreaming && msg.isComplete) return prev;
+        const updated = [...prev];
+        updated[idx] = { ...msg, isStreaming: false, isComplete: true };
+        return updated;
+      });
     };
     const curThreadId = currentThreadIdRef.current;
     const toServerMessageFromEvent = async (event) => {
@@ -1139,6 +1260,11 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       const currentThreadMetadataMap = threadMetadataMapRef.current;
       const messageMetadata = metadataKey ? currentThreadMetadataMap[metadataKey]?.userContext : void 0;
       const threadMetadata = metadataKey ? currentThreadMetadataMap[metadataKey] : void 0;
+      const mergedMetadata = {
+        ...messageMetadata ?? {},
+        ...params.metadata ?? {}
+      };
+      const finalMetadata = Object.keys(mergedMetadata).length > 0 ? mergedMetadata : void 0;
       await runCopilotzStream({
         threadId: params.threadId ?? void 0,
         threadExternalId: params.threadExternalId ?? void 0,
@@ -1152,9 +1278,10 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
           }
         },
         attachments: params.attachments,
-        metadata: params.metadata ?? messageMetadata,
+        metadata: finalMetadata,
         threadMetadata: params.threadMetadata ?? threadMetadata,
         toolCalls: params.toolCalls,
+        selectedAgent: params.agentName ?? preferredAgentRef.current ?? null,
         onToken: (token, isComplete) => updateStreamingMessage(token, isComplete),
         onMessageEvent: async (event) => {
           const type = event?.type || "";
@@ -1289,7 +1416,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     }
     return currentAssistantId;
   }, [handleStreamMessageEvent, handleStreamAssetEvent]);
-  const handleSendMessage = useCallback(async (content, attachments = []) => {
+  const handleSendMessage = useCallback2(async (content, attachments = []) => {
     if (!content.trim() && attachments.length === 0) return;
     if (!userId) return;
     const timestamp = nowTs();
@@ -1349,6 +1476,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
         userId,
         // userName can be anything, but let's try to find it in context or just fallback
         userName: userContextSeedRef.current?.profile?.full_name ?? userId,
+        agentName: preferredAgentRef.current,
         // Include pending title for new threads
         threadMetadata: pendingTitle ? { name: pendingTitle } : void 0
       });
@@ -1365,7 +1493,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       } : msg));
     }
   }, [userId, fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage]);
-  const bootstrapConversation = useCallback(async (uid) => {
+  const bootstrapConversation = useCallback2(async (uid) => {
     if (!bootstrap?.initialToolCalls && !bootstrap?.initialMessage) return;
     const bootstrapThreadExternalId = generateId();
     setCurrentThreadId(bootstrapThreadExternalId);
@@ -1379,6 +1507,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
         content: bootstrap.initialMessage || "",
         toolCalls: bootstrap.initialToolCalls,
         userId: uid,
+        agentName: preferredAgentRef.current,
         threadMetadata: {
           name: defaultThreadName || "Main Thread"
         }
@@ -1400,7 +1529,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       ]);
     }
   }, [fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, bootstrap, defaultThreadName]);
-  const reset = useCallback(() => {
+  const reset = useCallback2(() => {
     setThreads([]);
     setThreadMetadataMap({});
     setThreadExternalIdMap({});
@@ -1411,14 +1540,15 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     setIsStreaming(false);
     abortControllerRef.current?.abort();
   }, []);
-  useEffect(() => {
+  useEffect2(() => {
     if (userId) {
       if (initializationRef.current.userId === userId && initializationRef.current.started) {
         return;
       }
       initializationRef.current = { userId, started: true };
       const init = async () => {
-        const preferredThreadId = await fetchAndSetThreadsState(userId, void 0);
+        const urlPreferredThread = isUrlSyncEnabled ? urlState.threadId : void 0;
+        const preferredThreadId = await fetchAndSetThreadsState(userId, urlPreferredThread);
         if (preferredThreadId) {
           await loadThreadMessages(preferredThreadId);
         } else if (bootstrap) {
@@ -1430,8 +1560,13 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       initializationRef.current = { userId: null, started: false };
       reset();
     }
-  }, [userId, fetchAndSetThreadsState, loadThreadMessages, bootstrapConversation, reset, bootstrap]);
-  useEffect(() => {
+  }, [userId, fetchAndSetThreadsState, loadThreadMessages, bootstrapConversation, reset, bootstrap, isUrlSyncEnabled, urlState.threadId]);
+  useEffect2(() => {
+    if (!isUrlSyncEnabled) return;
+    if (!initializationRef.current.started) return;
+    setUrlThreadId(currentThreadExternalId);
+  }, [currentThreadExternalId, isUrlSyncEnabled, setUrlThreadId]);
+  useEffect2(() => {
     if (!currentThreadId) return;
     const metadata = threadMetadataMap[currentThreadId];
     if (!metadata) return;
@@ -1454,7 +1589,16 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     stopGeneration: handleStop,
     fetchAndSetThreadsState,
     loadThreadMessages,
-    reset
+    reset,
+    // URL state
+    /** Initial prompt from URL (if urlSync enabled) - use for pre-filling input */
+    initialPrompt: isUrlSyncEnabled ? urlState.prompt : null,
+    /** Clear the initial prompt from URL (call after consuming it) */
+    clearInitialPrompt: clearUrlPrompt,
+    /** URL agent ID (if urlSync enabled) - use for agent pre-selection */
+    urlAgentId: isUrlSyncEnabled ? urlState.agentId : null,
+    /** Update agent ID in URL */
+    setUrlAgentId
   };
 }
 
@@ -1476,8 +1620,14 @@ var CopilotzChat = ({
   onAddMemory,
   onUpdateMemory,
   onDeleteMemory,
-  className
+  suggestions,
+  agentOptions = [],
+  selectedAgentId = null,
+  onSelectAgent,
+  className,
+  urlSync
 }) => {
+  const selectedAgent = agentOptions.find((agent) => agent.id === selectedAgentId) || null;
   const {
     messages,
     threads,
@@ -1490,14 +1640,44 @@ var CopilotzChat = ({
     renameThread,
     archiveThread,
     deleteThread: deleteThread2,
-    stopGeneration
+    stopGeneration,
+    initialPrompt,
+    clearInitialPrompt,
+    urlAgentId,
+    setUrlAgentId
   } = useCopilotz({
     userId,
     initialContext,
     bootstrap,
     defaultThreadName: userConfig?.labels?.defaultThreadName,
-    onToolOutput
+    onToolOutput,
+    preferredAgentName: selectedAgent?.name ?? null,
+    urlSync
   });
+  const [promptHandled, setPromptHandled] = useState3(false);
+  useEffect3(() => {
+    if (urlAgentId && onSelectAgent && urlAgentId !== selectedAgentId) {
+      const agentExists = agentOptions.some((a) => a.id === urlAgentId);
+      if (agentExists) {
+        onSelectAgent(urlAgentId);
+      }
+    }
+  }, [urlAgentId, selectedAgentId, onSelectAgent, agentOptions]);
+  useEffect3(() => {
+    if (selectedAgentId && urlSync?.enabled) {
+      setUrlAgentId(selectedAgentId);
+    }
+  }, [selectedAgentId, urlSync?.enabled, setUrlAgentId]);
+  useEffect3(() => {
+    if (initialPrompt && !promptHandled && urlSync?.promptBehavior === "auto-send") {
+      const timer = setTimeout(() => {
+        void sendMessage(initialPrompt);
+        clearInitialPrompt();
+        setPromptHandled(true);
+      }, 500);
+      return () => clearTimeout(timer);
+    }
+  }, [initialPrompt, promptHandled, urlSync?.promptBehavior, sendMessage, clearInitialPrompt]);
   const chatCallbacks = useMemo(() => ({
     onSendMessage: (content, attachments) => {
       void sendMessage(content, attachments);
@@ -1565,6 +1745,10 @@ var CopilotzChat = ({
       config: mergedConfig,
       callbacks: chatCallbacks,
       isGenerating: isStreaming,
+      suggestions,
+      agentOptions,
+      selectedAgentId,
+      onSelectAgent,
       user: {
         id: userId,
         name: effectiveUserName,
@@ -1579,7 +1763,12 @@ var CopilotzChat = ({
       onAddMemory,
       onUpdateMemory,
       onDeleteMemory,
-      className
+      className,
+      initialInput: initialPrompt && !promptHandled && urlSync?.promptBehavior !== "auto-send" ? initialPrompt : void 0,
+      onInitialInputConsumed: () => {
+        clearInitialPrompt();
+        setPromptHandled(true);
+      }
     }
   ) });
 };
@@ -1594,7 +1783,8 @@ export {
   resolveAssetsInMessages,
   runCopilotzStream,
   updateThread,
-  useCopilotz
+  useCopilotz,
+  useUrlState
 };
 /*! Bundled license information: