@copilotz/chat-adapter 0.1.11 → 0.1.13

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { ReactNode } from 'react';
 import { ChatUserContext, ChatConfig, ChatCallbacks, MemoryItem, AgentOption, ChatMessage, ChatThread, MediaAttachment } from '@copilotz/chat-ui';
 export { ChatCallbacks, ChatConfig, ChatMessage, ChatThread, ChatUserContext, MediaAttachment, MemoryItem } from '@copilotz/chat-ui';
 
@@ -88,6 +88,23 @@ interface UseUrlStateReturn {
  */
 declare function useUrlState(config?: UrlSyncConfig): UseUrlStateReturn;
 
+type SpecialChatState = {
+    kind: string;
+    title?: string;
+    message?: string;
+    payload?: Record<string, unknown>;
+};
+type SpecialStateControls = {
+    clear: () => void;
+};
+type RenderSpecialState = (state: SpecialChatState, controls: SpecialStateControls) => ReactNode | null;
+type EventInterceptorResult = void | {
+    handled?: boolean;
+    specialState?: SpecialChatState | null;
+};
+type EventInterceptor = (event: unknown) => EventInterceptorResult;
+type RunErrorInterceptor = (error: unknown) => SpecialChatState | null | undefined;
+
 interface CopilotzChatProps {
     userId: string;
     userName?: string;
@@ -133,6 +150,9 @@ interface CopilotzChatProps {
     selectedAgentId?: string | null;
     onSelectAgent?: (agentId: string) => void;
     className?: string;
+    eventInterceptor?: EventInterceptor;
+    runErrorInterceptor?: RunErrorInterceptor;
+    renderSpecialState?: RenderSpecialState;
     /**
      * URL state synchronization configuration.
      * When enabled, syncs thread ID, agent, and prompt to/from URL parameters.
@@ -177,6 +197,8 @@ interface UseCopilotzOptions {
     defaultThreadName?: string;
     onToolOutput?: (output: Record<string, unknown>) => void;
     preferredAgentName?: string | null;
+    eventInterceptor?: EventInterceptor;
+    runErrorInterceptor?: RunErrorInterceptor;
     /**
      * URL state synchronization configuration.
      * When enabled, thread ID and agent are synced to/from URL parameters.
@@ -195,12 +217,14 @@ interface UseCopilotzOptions {
      */
     urlSync?: UrlSyncConfig;
 }
-declare function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onToolOutput, preferredAgentName, urlSync }: UseCopilotzOptions): {
+declare function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onToolOutput, preferredAgentName, eventInterceptor, runErrorInterceptor, urlSync, }: UseCopilotzOptions): {
     messages: ChatMessage[];
     isMessagesLoading: boolean;
     threads: ChatThread[];
     currentThreadId: string | null;
     isStreaming: boolean;
+    specialState: SpecialChatState | null;
+    clearSpecialState: () => void;
     userContextSeed: Partial<ChatUserContext>;
     sendMessage: (content: string, attachments?: MediaAttachment[]) => Promise<void>;
     createThread: (title?: string) => void;
@@ -276,6 +300,16 @@ type CopilotzStreamResult = {
     messages: any[];
     media: Record<string, string> | null;
 };
+declare class CopilotzRequestError extends Error {
+    status: number;
+    code?: string;
+    details?: unknown;
+    constructor(message: string, options: {
+        status: number;
+        code?: string;
+        details?: unknown;
+    });
+}
 declare function runCopilotzStream(options: RunOptions): Promise<CopilotzStreamResult>;
 declare function fetchThreads(userId: string): Promise<RestThread[]>;
 declare function fetchThreadMessages(threadId: string): Promise<RestMessage[]>;
@@ -300,4 +334,4 @@ type WithMetadata = {
 };
 declare function resolveAssetsInMessages<T extends WithMetadata>(messages: T[]): Promise<T[]>;
 
-export { CopilotzChat, type CopilotzStreamResult, type UrlParamsConfig, type UrlState, type UrlSyncConfig, type UseUrlStateReturn, copilotzService, deleteMessagesByThreadId, deleteThread, fetchThreadMessages, fetchThreads, getAssetDataUrl, resolveAssetsInMessages, runCopilotzStream, updateThread, useCopilotz, useUrlState };
+export { CopilotzChat, CopilotzRequestError, type CopilotzStreamResult, type EventInterceptor, type EventInterceptorResult, type RenderSpecialState, type RunErrorInterceptor, type SpecialChatState, type SpecialStateControls, type UrlParamsConfig, type UrlState, type UrlSyncConfig, type UseUrlStateReturn, copilotzService, deleteMessagesByThreadId, deleteThread, fetchThreadMessages, fetchThreads, getAssetDataUrl, resolveAssetsInMessages, runCopilotzStream, updateThread, useCopilotz, useUrlState };

package/dist/index.js

@@ -124,6 +124,18 @@ var withAuthHeaders = (headers = {}) => {
   }
   return headers;
 };
+var CopilotzRequestError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "CopilotzRequestError";
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+  }
+};
 var SSE_LINE_BREAK = "\n\n";
 var appendChunk = (buffer, chunk) => {
   if (!buffer) return chunk;
@@ -138,6 +150,14 @@ var appendChunk = (buffer, chunk) => {
   }
   return buffer + chunk;
 };
+var parseErrorText = (rawText) => {
+  if (!rawText) return null;
+  try {
+    return JSON.parse(rawText);
+  } catch {
+    return null;
+  }
+};
 var toAttachmentPayload = (attachments) => {
   if (!attachments || attachments.length === 0) return void 0;
   return attachments.map((att) => {
@@ -365,7 +385,16 @@ async function runCopilotzStream(options) {
   });
   if (!response.ok || !response.body) {
     const errorText = await response.text().catch(() => response.statusText);
-    throw new Error(errorText || "Failed to run Copilotz agent");
+    const parsed = parseErrorText(errorText);
+    const details = parsed && typeof parsed === "object" ? parsed : void 0;
+    const detailsRecord = details;
+    const message = typeof detailsRecord?.message === "string" && detailsRecord.message || typeof detailsRecord?.error === "string" && detailsRecord.error || errorText || response.statusText || "Failed to run Copilotz agent";
+    const code = typeof detailsRecord?.code === "string" ? detailsRecord.code : typeof detailsRecord?.error === "string" && detailsRecord.error !== message ? detailsRecord.error : void 0;
+    throw new CopilotzRequestError(message, {
+      status: response.status,
+      code,
+      details
+    });
   }
   const reader = response.body.getReader();
   const decoder = new TextDecoder("utf-8");
@@ -478,6 +507,33 @@ async function fetchThreads(userId) {
   return data;
 }
 async function fetchThreadMessages(threadId) {
+  const graphParams = new URLSearchParams();
+  graphParams.set("threadId", threadId);
+  graphParams.set("limit", "500");
+  try {
+    const graphRes = await fetch(apiUrl(`/v1/messages?${graphParams.toString()}`), {
+      headers: withAuthHeaders({ Accept: "application/json" })
+    });
+    if (graphRes.ok) {
+      const graphData = await graphRes.json();
+      if (Array.isArray(graphData)) {
+        return graphData;
+      }
+      if (Array.isArray(graphData?.data)) {
+        return graphData.data;
+      }
+      return [];
+    }
+    if (![404, 405, 501, 502, 503, 504].includes(graphRes.status)) {
+      const errorText = await graphRes.text().catch(() => graphRes.statusText);
+      throw new Error(errorText || `Failed to load graph thread messages (${graphRes.status})`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    if (!/Failed to fetch/i.test(message)) {
+      throw error;
+    }
+  }
   const params = new URLSearchParams();
   params.set("filters", JSON.stringify({ threadId }));
   params.set("sort", "createdAt:asc");
@@ -508,6 +564,23 @@ async function updateThread(threadId, updates) {
   return data?.body ?? data;
 }
 async function deleteMessagesByThreadId(threadId) {
+  const graphParams = new URLSearchParams();
+  graphParams.set("threadId", threadId);
+  try {
+    const graphRes = await fetch(apiUrl(`/v1/messages?${graphParams.toString()}`), {
+      method: "DELETE",
+      headers: withAuthHeaders({ Accept: "application/json" })
+    });
+    if (!graphRes.ok && ![404, 405, 501].includes(graphRes.status)) {
+      const errorText = await graphRes.text().catch(() => graphRes.statusText);
+      throw new Error(errorText || `Failed to delete graph messages (${graphRes.status})`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    if (!/Failed to fetch/i.test(message)) {
+      throw error;
+    }
+  }
   const params = new URLSearchParams();
   params.set("filters", JSON.stringify({ threadId }));
   const res = await fetch(apiUrl(`/v1/rest/messages?${params.toString()}`), {
@@ -718,6 +791,114 @@ function useUrlState(config = {}) {
 var nowTs = () => Date.now();
 var generateId = () => globalThis.crypto?.randomUUID?.() ?? `id-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError" || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+var normalizeToolStatus = (status) => {
+  if (status === "pending") return "pending";
+  if (status === "running" || status === "processing") return "running";
+  if (status === "failed") return "failed";
+  return "completed";
+};
+var parseToolArguments = (value) => {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return {};
+};
+var extractToolCallsFromServerMessage = (msg) => {
+  const metadata = msg.metadata ?? void 0;
+  const topLevelToolCalls = Array.isArray(msg.toolCalls) ? msg.toolCalls || [] : [];
+  const metadataToolCalls = Array.isArray(metadata?.toolCalls) ? metadata.toolCalls : [];
+  const usedMetadataIndexes = /* @__PURE__ */ new Set();
+  const parsed = [];
+  const findMatchingMetadataIndex = (toolCall) => {
+    const id = typeof toolCall.id === "string" ? toolCall.id : void 0;
+    const name = typeof toolCall.name === "string" ? toolCall.name : void 0;
+    const byId = id ? metadataToolCalls.findIndex((candidate, idx) => !usedMetadataIndexes.has(idx) && candidate?.id === id) : -1;
+    if (byId >= 0) return byId;
+    return name ? metadataToolCalls.findIndex((candidate, idx) => !usedMetadataIndexes.has(idx) && candidate?.name === name) : -1;
+  };
+  const parseToolCall = (primary, secondary) => {
+    const id = typeof primary.id === "string" ? primary.id : typeof secondary?.id === "string" ? secondary.id : void 0;
+    const name = typeof primary.name === "string" ? primary.name : typeof secondary?.name === "string" ? secondary.name : "tool";
+    const argsRaw = primary.args ?? primary.arguments ?? secondary?.args ?? secondary?.arguments;
+    const result = primary.output !== void 0 ? primary.output : primary.result !== void 0 ? primary.result : secondary?.output !== void 0 ? secondary.output : secondary?.result;
+    const status = normalizeToolStatus(primary.status ?? secondary?.status);
+    return {
+      ...id ? { id } : {},
+      name,
+      arguments: parseToolArguments(argsRaw),
+      ...result !== void 0 ? { result } : {},
+      status
+    };
+  };
+  topLevelToolCalls.forEach((toolCall) => {
+    const metadataIndex = findMatchingMetadataIndex(toolCall);
+    const metadataCall = metadataIndex >= 0 ? metadataToolCalls[metadataIndex] : void 0;
+    if (metadataIndex >= 0) usedMetadataIndexes.add(metadataIndex);
+    parsed.push(parseToolCall(toolCall, metadataCall));
+  });
+  metadataToolCalls.forEach((toolCall, index) => {
+    if (usedMetadataIndexes.has(index)) return;
+    parsed.push(parseToolCall(toolCall));
+  });
+  return parsed;
+};
+var extractToolResultUpdateFromMessage = (msg) => {
+  if (msg.senderType !== "tool") return null;
+  const toolCalls = extractToolCallsFromServerMessage(msg);
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) return null;
+  const firstToolCall = toolCalls[0];
+  const metadata = msg.metadata ?? void 0;
+  const fallbackResult = metadata?.output;
+  const result = firstToolCall.result !== void 0 ? firstToolCall.result : fallbackResult;
+  return {
+    ...firstToolCall.id ? { id: firstToolCall.id } : {},
+    ...firstToolCall.name ? { name: firstToolCall.name } : {},
+    ...result !== void 0 ? { result } : {},
+    status: firstToolCall.status,
+    endTime: msg.createdAt ? new Date(msg.createdAt).getTime() : nowTs()
+  };
+};
+var mergePersistedToolResults = (messages, updates) => {
+  if (updates.length === 0) return messages;
+  const nextMessages = [...messages];
+  for (const update of updates) {
+    for (let i = nextMessages.length - 1; i >= 0; i--) {
+      const message = nextMessages[i];
+      if (message.role !== "assistant" || !Array.isArray(message.toolCalls) || message.toolCalls.length === 0) {
+        continue;
+      }
+      const toolCalls = message.toolCalls;
+      let toolCallIndex = update.id ? toolCalls.findIndex((toolCall) => toolCall.id === update.id) : -1;
+      if (toolCallIndex === -1 && update.name) {
+        toolCallIndex = toolCalls.findIndex((toolCall) => toolCall.name === update.name && (toolCall.status === "pending" || toolCall.status === "running" || typeof toolCall.result === "undefined"));
+      }
+      if (toolCallIndex === -1) continue;
+      const updatedToolCalls = [...toolCalls];
+      const current = updatedToolCalls[toolCallIndex];
+      updatedToolCalls[toolCallIndex] = {
+        ...current,
+        status: update.status,
+        ...update.result !== void 0 ? { result: update.result } : {},
+        endTime: update.endTime
+      };
+      nextMessages[i] = {
+        ...message,
+        toolCalls: updatedToolCalls
+      };
+      break;
+    }
+  }
+  return nextMessages;
+};
 var convertServerMessage = (msg) => {
   const timestamp = msg.createdAt ? new Date(msg.createdAt).getTime() : nowTs();
   const metadata = msg.metadata ?? void 0;
@@ -750,13 +931,15 @@ var convertServerMessage = (msg) => {
     return [];
   });
   const role = msg.senderType === "agent" ? "assistant" : msg.senderType === "user" ? "user" : "assistant";
-  const mappedToolCalls = Array.isArray(msg.toolCalls) ? (msg.toolCalls || []).map((tc) => ({
-    id: typeof tc?.id === "string" ? tc.id : generateId(),
-    name: typeof tc?.name === "string" ? tc.name : "tool",
-    arguments: tc?.args || {},
-    status: "completed"
-  })) : void 0;
-  const hasToolCalls = Array.isArray(mappedToolCalls) && mappedToolCalls.length > 0;
+  const parsedToolCalls = extractToolCallsFromServerMessage(msg);
+  const mappedToolCalls = parsedToolCalls.map((toolCall) => ({
+    id: toolCall.id ?? generateId(),
+    name: toolCall.name,
+    arguments: toolCall.arguments,
+    status: toolCall.status,
+    ...toolCall.result !== void 0 ? { result: toolCall.result } : {}
+  }));
+  const hasToolCalls = mappedToolCalls.length > 0;
   const isToolSender = msg.senderType === "tool";
   const content = isToolSender ? "" : (msg.content ?? "") || (hasToolCalls ? "" : "");
   return {
@@ -771,7 +954,17 @@ var convertServerMessage = (msg) => {
     toolCalls: hasToolCalls ? mappedToolCalls : void 0
   };
 };
-function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onToolOutput, preferredAgentName, urlSync }) {
+function useCopilotz({
+  userId,
+  initialContext,
+  bootstrap,
+  defaultThreadName,
+  onToolOutput,
+  preferredAgentName,
+  eventInterceptor,
+  runErrorInterceptor,
+  urlSync
+}) {
   const {
     state: urlState,
     setThreadId: setUrlThreadId,
@@ -787,6 +980,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
   const [messages, setMessages] = useState2([]);
   const [isMessagesLoading, setIsMessagesLoading] = useState2(false);
   const [isStreaming, setIsStreaming] = useState2(false);
+  const [specialState, setSpecialState] = useState2(null);
   const [userContextSeed, setUserContextSeed] = useState2(initialContext || {});
   const preferredAgentRef = useRef2(preferredAgentName ?? null);
   const threadsRef = useRef2(threads);
@@ -821,6 +1015,31 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     }
     onToolOutput?.(output);
   }, [onToolOutput]);
+  const clearSpecialState = useCallback2(() => {
+    setSpecialState(null);
+  }, []);
+  const applyEventInterceptor = useCallback2((event) => {
+    if (!eventInterceptor) return void 0;
+    try {
+      const result = eventInterceptor(event);
+      if (result?.specialState) {
+        setSpecialState(result.specialState);
+      }
+      return result;
+    } catch (error) {
+      console.error("Error in Copilotz event interceptor", error);
+      return void 0;
+    }
+  }, [eventInterceptor]);
+  const getSpecialStateFromError = useCallback2((error) => {
+    if (!runErrorInterceptor) return null;
+    try {
+      return runErrorInterceptor(error) ?? null;
+    } catch (interceptorError) {
+      console.error("Error in Copilotz run error interceptor", interceptorError);
+      return null;
+    }
+  }, [runErrorInterceptor]);
   const handleStreamMessageEvent = useCallback2((event) => {
     const payload = event?.payload;
     if (!payload) return;
@@ -945,10 +1164,11 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
           if (output) processToolOutput(output);
         }
       });
+      const toolResultUpdates = resolvedMessages.map((msg) => extractToolResultUpdateFromMessage(msg)).filter((update) => update !== null);
       const viewMessages = resolvedMessages.filter((msg) => {
         const text = (typeof msg.content === "string" ? msg.content : "").trim();
         const hasText = text.length > 0;
-        const hasToolCalls = Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0;
+        const hasToolCalls = extractToolCallsFromServerMessage(msg).length > 0;
         const meta = msg.metadata ?? {};
         const hasAttachments = Array.isArray(meta.attachments) && meta.attachments.length > 0;
         if (msg.senderType === "tool") {
@@ -956,7 +1176,8 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
         }
         return hasText || hasToolCalls || hasAttachments;
       }).map(convertServerMessage);
-      setMessages(viewMessages);
+      const hydratedMessages = mergePersistedToolResults(viewMessages, toolResultUpdates);
+      setMessages(hydratedMessages);
     } catch (error) {
       if (isAbortError(error)) return;
       console.error(`Error loading messages for thread ${threadId}`, error);
@@ -1292,6 +1513,10 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
         selectedAgent: params.agentName ?? preferredAgentRef.current ?? null,
         onToken: (token, isComplete) => updateStreamingMessage(token, isComplete),
         onMessageEvent: async (event) => {
+          const intercepted = applyEventInterceptor(event);
+          if (intercepted?.handled) {
+            return;
+          }
           const type = event?.type || "";
           const payload = event?.payload ?? event;
           if (type === "MESSAGE" || type === "NEW_MESSAGE") {
@@ -1404,6 +1629,10 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
           handleStreamMessageEvent(event);
         },
         onAssetEvent: async (payload) => {
+          const intercepted = applyEventInterceptor({ type: "ASSET_CREATED", payload });
+          if (intercepted?.handled) {
+            return;
+          }
           await (async () => {
             if (!hasStreamProgress) return;
             finalizeCurrentAssistantBubble();
@@ -1423,7 +1652,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       abortControllerRef.current = null;
     }
     return currentAssistantId;
-  }, [handleStreamMessageEvent, handleStreamAssetEvent]);
+  }, [applyEventInterceptor, handleStreamMessageEvent, handleStreamAssetEvent]);
   const handleSendMessage = useCallback2(async (content, attachments = []) => {
     if (!content.trim() && attachments.length === 0) return;
     if (!userId) return;
@@ -1463,6 +1692,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
       isComplete: false
     };
     setMessages((prev) => [...prev, userMessage, assistantPlaceholder]);
+    setSpecialState(null);
     if (!threadsRef.current.some((t) => t.id === conversationKey)) {
       const newThread = {
         id: conversationKey,
@@ -1493,6 +1723,12 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     } catch (error) {
       if (isAbortError(error)) return;
       console.error("Error sending Copilotz message", error);
+      const nextSpecialState = getSpecialStateFromError(error);
+      if (nextSpecialState) {
+        setSpecialState(nextSpecialState);
+        setMessages((prev) => prev.filter((msg) => !msg.isStreaming));
+        return;
+      }
       setMessages((prev) => prev.map((msg) => msg.isStreaming ? {
         ...msg,
         isStreaming: false,
@@ -1500,7 +1736,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
         content: "Desculpe, ocorreu um erro ao gerar a resposta. Por favor, tente novamente."
       } : msg));
     }
-  }, [userId, fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage]);
+  }, [userId, fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, getSpecialStateFromError]);
   const bootstrapConversation = useCallback2(async (uid) => {
     if (!bootstrap?.initialToolCalls && !bootstrap?.initialMessage) return;
     const bootstrapThreadExternalId = generateId();
@@ -1509,6 +1745,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     setThreadExternalIdMap((prev) => ({ ...prev, [bootstrapThreadExternalId]: bootstrapThreadExternalId }));
     setThreadMetadataMap((prev) => ({ ...prev, [bootstrapThreadExternalId]: {} }));
     setMessages([]);
+    setSpecialState(null);
     try {
       await sendCopilotzMessage({
         threadExternalId: bootstrapThreadExternalId,
@@ -1525,6 +1762,12 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     } catch (error) {
       if (isAbortError(error)) return;
       console.error("Error bootstrapping conversation", error);
+      const nextSpecialState = getSpecialStateFromError(error);
+      if (nextSpecialState) {
+        setSpecialState(nextSpecialState);
+        setMessages([]);
+        return;
+      }
       setMessages([
         {
           id: generateId(),
@@ -1536,7 +1779,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
         }
       ]);
     }
-  }, [fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, bootstrap, defaultThreadName]);
+  }, [fetchAndSetThreadsState, loadThreadMessages, sendCopilotzMessage, bootstrap, defaultThreadName, getSpecialStateFromError]);
   const reset = useCallback2(() => {
     messagesRequestRef.current += 1;
     setThreads([]);
@@ -1548,6 +1791,7 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     setUserContextSeed({});
     setIsMessagesLoading(false);
     setIsStreaming(false);
+    setSpecialState(null);
     abortControllerRef.current?.abort();
   }, []);
   useEffect2(() => {
@@ -1590,6 +1834,8 @@ function useCopilotz({ userId, initialContext, bootstrap, defaultThreadName, onT
     threads,
     currentThreadId,
     isStreaming,
+    specialState,
+    clearSpecialState,
     userContextSeed,
     sendMessage: handleSendMessage,
     createThread: handleCreateThread,
@@ -1636,6 +1882,9 @@ var CopilotzChat = ({
   selectedAgentId = null,
   onSelectAgent,
   className,
+  eventInterceptor,
+  runErrorInterceptor,
+  renderSpecialState,
   urlSync
 }) => {
   const selectedAgent = agentOptions.find((agent) => agent.id === selectedAgentId) || null;
@@ -1645,6 +1894,8 @@ var CopilotzChat = ({
     threads,
     currentThreadId,
     isStreaming,
+    specialState,
+    clearSpecialState,
     userContextSeed,
     sendMessage,
     createThread,
@@ -1664,6 +1915,8 @@ var CopilotzChat = ({
     defaultThreadName: userConfig?.labels?.defaultThreadName,
     onToolOutput,
     preferredAgentName: selectedAgent?.name ?? null,
+    eventInterceptor,
+    runErrorInterceptor,
     urlSync
   });
   const [promptHandled, setPromptHandled] = useState3(false);
@@ -1748,7 +2001,8 @@ var CopilotzChat = ({
   }, [userConfig, customComponent]);
   const effectiveUserName = userName || userId;
   const effectiveUserAvatar = userAvatar;
-  return /* @__PURE__ */ jsx(ChatUserContextProvider, { initial: userContextSeed, children: /* @__PURE__ */ jsx(
+  const specialStateContent = specialState ? renderSpecialState?.(specialState, { clear: clearSpecialState }) : null;
+  return /* @__PURE__ */ jsx(ChatUserContextProvider, { initial: userContextSeed, children: specialStateContent ?? /* @__PURE__ */ jsx(
     ChatUI,
     {
       messages,
@@ -1787,6 +2041,7 @@ var CopilotzChat = ({
 };
 export {
   CopilotzChat,
+  CopilotzRequestError,
   copilotzService,
   deleteMessagesByThreadId,
   deleteThread,