@eloquentai/chat-sdk 0.29.0-dev → 0.29.0-dev.1

package/README.md

@@ -4,7 +4,7 @@ React SDK for integrating Eloquent AI's chat functionality into your application
 
 ## Prerequisites
 
-- React 18 or higher
+- React 18 or higher (only for the React implementation)
 - Node.js 18 or higher
 - A modern browser that supports ES6+
 
@@ -25,7 +25,7 @@ pnpm add @eloquentai/chat-sdk
 
 ### React Implementation
 
-To use the SDK in a React application, you can import the Chat component from the SDK.
+To use the SDK in a React application, import the `Chat` component from the SDK.
 
 ```jsx
 import { Chat } from "@eloquentai/chat-sdk";
@@ -35,28 +35,168 @@ function App() {
     <Chat
       // REQUIRED - Your Eloquent AI app ID
       appId="YOUR_APP_ID"
-      // OPTIONAL - You can provide an unique id that should be used to identify the user
+      // OPTIONAL - You can provide a unique id that should be used to identify the user
       userId={crypto.randomUUID()}
     />
   );
 }
 ```
 
+Don't forget to import the base styles once, somewhere in your app:
+
+```jsx
+import "@eloquentai/chat-sdk/index.css";
+```
+
 ### Vanilla Implementation
 
-To use the SDK in a vanilla environment, you can include the script tag in your HTML file.
+To use the SDK in a vanilla environment, include the script tag in your HTML file and call `renderChat`.
 
 ```html
 <script src="https://unpkg.com/@eloquentai/chat-sdk"></script>
 
-<div id="chat"></div>
+<div id="chat-container"></div>
 
 <script>
   EloquentChatSDK.renderChat(document.getElementById("chat-container"), {
     // REQUIRED - Your Eloquent AI app ID
     appId: "YOUR_APP_ID",
-    // OPTIONAL - You can provide an unique id that should be used to identify the user
+    // OPTIONAL - You can provide a unique id that should be used to identify the user
     userId: crypto.randomUUID(),
   });
 </script>
 ```
+
+`renderChat` returns an unmount function you can call to remove the chat widget:
+
+```html
+<script>
+  const unmount = EloquentChatSDK.renderChat(
+    document.getElementById("chat-container"),
+    { appId: "YOUR_APP_ID" },
+  );
+
+  // Later, to remove the widget:
+  unmount();
+</script>
+```
+
+## Features
+
+- **Floating chat widget** — a launcher bubble plus chat window, rendered in an isolated iframe so host page styles never leak in or out.
+- **Real-time messaging** — assistant replies stream in over a WebSocket connection (AWS AppSync), with automatic reconnect and a backup polling fallback if the socket drops.
+- **Conversation persistence** — the active conversation is restored automatically (e.g. on page reload) via local storage.
+- **User identification** — supports anonymous device-based identity as well as an optional external user ID and custom user metadata.
+- **Proactive/welcome messages** — an optional message bubble can appear automatically to invite users to start a conversation.
+- **Chat ratings** — users can rate a conversation after it's closed or escalated.
+- **Human handoff / escalation** — the SDK recognizes when a conversation is escalated to a human agent and closes the AI chat session accordingly.
+- **Theming** — customize bubble colors and legal text to match your brand.
+- **Mobile responsive** — automatically adapts layout for mobile viewports.
+
+## Configuration
+
+### `Chat` component props
+
+| Prop                        | Type                                          | Required | Description                                                                            |
+| --------------------------- | --------------------------------------------- | -------- | -------------------------------------------------------------------------------------- |
+| `appId`                     | `string`                                      | Yes      | Your Eloquent AI application ID.                                                       |
+| `userId`                    | `string`                                      | No       | A unique identifier for the user. If omitted, an anonymous device ID is used instead.  |
+| `userName`                  | `string`                                      | No       | A display name for the user.                                                           |
+| `userData`                  | `Record<string, string \| number \| boolean>` | No       | Arbitrary metadata attached to the user/conversation (e.g. plan, account type).        |
+| `theme`                     | `Partial<ThemeContextType>`                   | No       | Theming overrides — see [Theming](#theming) below.                                     |
+| `chatProps`                 | `Partial<ChatInterfaceProps>`                 | No       | Fine-grained UI configuration — see [Chat interface options](#chat-interface-options). |
+| `isMobile`                  | `boolean`                                     | No       | Force mobile layout instead of relying on automatic viewport detection.                |
+| `closeButton`               | `boolean` (default: `true`)                   | No       | Show/hide the close button in the chat header.                                         |
+| `cleanChatButton`           | `boolean` (default: `true`)                   | No       | Show/hide the "start new chat" button.                                                 |
+| `initialOpen`               | `boolean` (default: `false`)                  | No       | Whether the chat window is open by default.                                            |
+| `proactiveMessageHideDelay` | `number` (default: `5000`)                    | No       | Milliseconds before the proactive/welcome message auto-hides.                          |
+
+### Chat interface options
+
+Passed via the `chatProps` prop.
+
+| Prop                     | Type                             | Description                                           |
+| ------------------------ | -------------------------------- | ----------------------------------------------------- |
+| `displayWelcomeMessages` | `boolean`                        | Enable the proactive welcome message bubble.          |
+| `assistantName`          | `string`                         | Name shown for the assistant in the chat header.      |
+| `assistantLogo`          | `string`                         | URL of the logo shown for the assistant.              |
+| `legalText`              | `string`                         | Legal/disclaimer text shown in the chat window.       |
+| `hasCopyButton`          | `boolean`                        | Show the "copy message" button on assistant messages. |
+| `collectUserFeedback`    | `boolean`                        | Enable thumbs up/down feedback on assistant messages. |
+| `suggestedMessages`      | `boolean`                        | Show suggested message chips to the user.             |
+| `title`                  | `string`                         | Title shown in the chat header.                       |
+| `subtitle`               | `string`                         | Subtitle shown in the chat header.                    |
+| `onMessageClick`         | `(message: MessageData) => void` | Callback fired when a message is clicked.             |
+
+### Theming
+
+```jsx
+<Chat
+  appId="YOUR_APP_ID"
+  theme={{
+    userBubbleColor: "#6f34b7",
+    legalText: "Powered by Eloquent AI",
+  }}
+/>
+```
+
+| Property          | Description                                      |
+| ----------------- | ------------------------------------------------ |
+| `userBubbleColor` | Background color of the end-user's chat bubbles. |
+| `legalText`       | Legal/disclaimer text rendered below the input.  |
+
+## Advanced usage
+
+### `renderChat`
+
+Programmatically mount the chat widget into any DOM element — used internally by the vanilla/UMD build, but also available from the ES module for non-JSX setups:
+
+```js
+import { renderChat } from "@eloquentai/chat-sdk";
+
+const unmount = renderChat(document.getElementById("chat-container"), {
+  appId: "YOUR_APP_ID",
+});
+```
+
+### `ChatInterface`
+
+The chat window UI without the floating launcher bubble or iframe isolation, for embedding the chat directly into your own layout (e.g. a dedicated support page).
+
+```jsx
+import { ChatInterface } from "@eloquentai/chat-sdk";
+
+<ChatInterface
+  isOpen
+  closeButton={false}
+  cleanChatButton
+  messages={messages}
+  onSendMessage={onSendMessage}
+/>;
+```
+
+### `useRealtimeSocket`
+
+A lower-level hook for subscribing directly to the real-time conversation event stream, if you need custom message handling outside of the provided components.
+
+```jsx
+import { useRealtimeSocket } from "@eloquentai/chat-sdk";
+
+const { connect, disconnect, clearProcessedIds } = useRealtimeSocket({
+  chatSettings,
+  chatId,
+  messages,
+  onMessage: (response, chatId) => {
+    /* handle incoming assistant message */
+  },
+  onCognition: (content) => {
+    /* assistant is "thinking" */
+  },
+  onCognitionComplete: () => {},
+  fetchHistory: async (chatId) => [],
+});
+```
+
+## Support
+
+For issues, feature requests, or questions, please contact the Eloquent AI team.

package/dist/components/banner.d.ts

@@ -2,5 +2,5 @@ interface BannerProps {
     message: string;
     type: "warning" | "error" | "info" | "success";
 }
-export declare const Banner: ({ message, type }: BannerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Banner: ({ message, type }: BannerProps) => import("react").JSX.Element;
 export {};

package/dist/components/chat/chat.d.ts

@@ -0,0 +1,22 @@
+import { Message } from '../../types/message';
+import { UseChatProps } from './hooks/use-chat';
+/** @internal */
+type InternalChatProps = {
+    INTERNAL_ONLY_CHAT_INTERFACE_ONLY?: boolean;
+    INTERNAL_ONLY_BLOCK_STYLE?: boolean;
+    /**
+     * Force the clear-chat button on or off, winning over both the boot
+     * `chat_settings.clean_chat_button` and the public `hasCleanChatButton`
+     * prop. Leave unset to keep the normal boot ?? prop resolution.
+     */
+    INTERNAL_ONLY_SHOW_CLEAN_CHAT_BUTTON?: boolean;
+    /** Show the copy-message button on assistant messages (default false). */
+    INTERNAL_ONLY_SHOW_COPY_BUTTON?: boolean;
+    INTERNAL_ONLY_ENVIRONMENT?: "test" | "live";
+    INTERNAL_ONLY_API_URL?: string;
+    INTERNAL_ONLY_FEATURE_MESSAGE_CLICK?: (message: Message) => void;
+    INTERNAL_ONLY_FEATURE_CLEAR_CHAT_CLICK?: () => void;
+};
+export type ChatProps = UseChatProps & InternalChatProps;
+export declare function Chat(props: Readonly<ChatProps>): import("react").JSX.Element;
+export {};

package/dist/components/chat/hooks/use-chat.d.ts

@@ -0,0 +1,79 @@
+import { Message, MessageData } from '../../../types/message';
+import { ThemeContextType } from '../../../contexts/theme.context';
+import { ChatInterfaceProps } from '../../chat-interface';
+export interface UseChatProps {
+    appId: string;
+    userId?: string;
+    userName?: string;
+    userData?: Record<string, string | number | boolean>;
+    theme?: Partial<ThemeContextType>;
+    chatProps?: Partial<ChatInterfaceProps>;
+    isMobile?: boolean;
+    /** Show the close (X) button in the chat header. */
+    hasCloseButton?: boolean;
+    /** Show the clear-conversation button in the chat header. */
+    hasCleanChatButton?: boolean;
+    /** Open the chat window on load (desktop only). */
+    isInitiallyOpen?: boolean;
+    /** @deprecated Use `hasCloseButton` instead. Ignored when `hasCloseButton` is set. */
+    closeButton?: boolean;
+    /** @deprecated Use `hasCleanChatButton` instead. Ignored when `hasCleanChatButton` is set. */
+    cleanChatButton?: boolean;
+    /** @deprecated Use `isInitiallyOpen` instead. Ignored when `isInitiallyOpen` is set. */
+    initialOpen?: boolean;
+    proactiveMessageHideDelay?: number;
+}
+export interface UseChatReturn {
+    isReady: boolean;
+    isChatActive: boolean;
+    /** Effective initial-open (boot chat_settings.initial_open ?? prop). */
+    isInitiallyOpen: boolean;
+    /** Effective close-button visibility (boot chat_settings.close_button ?? prop). */
+    hasCloseButton: boolean;
+    /** Effective clear-chat-button visibility (boot chat_settings.clean_chat_button ?? prop). */
+    hasCleanChatButton: boolean;
+    isMobile: boolean;
+    chatInterfaceProps: Partial<ChatInterfaceProps>;
+    chatOpen: boolean;
+    chatOpenDebounced: boolean;
+    messages: Message[];
+    portalContainer: HTMLElement | null;
+    onSendMessage: (message: MessageData) => Promise<void>;
+    setChatOpen: (value: boolean | ((prev: boolean) => boolean)) => void;
+    onCleanMessages: () => void;
+    proactiveMessage?: {
+        text: string;
+        isVisible: boolean;
+        autoHideDelay: number;
+    };
+    hideProactiveMessage: () => void;
+    isChatClosed: boolean;
+    onStartNewChat: () => void;
+    onRateChat: (rating: number) => Promise<void>;
+}
+/**
+ * The primary chat hook, responsible for managing the chat state and operations.
+ * @param options The hook parameters
+ * @returns The chat hook return type
+ */
+export declare function useChat({ environment, apiUrl, appId, userId: initialUserId, userName, userData, chatProps, isMobile: propIsMobile, isInitiallyOpen: propIsInitiallyOpen, hasCloseButton: propHasCloseButton, hasCleanChatButton: propHasCleanChatButton, initialOpen: deprecatedInitialOpen, closeButton: deprecatedCloseButton, cleanChatButton: deprecatedCleanChatButton, proactiveMessageHideDelay: propProactiveMessageHideDelay, isAlwaysOpen, hasCleanChatButtonOverride, }: Readonly<Partial<UseChatProps> & {
+    environment: "test" | "live";
+    apiUrl?: string;
+    appId: string;
+    /**
+     * Internal-only kill-switch (INTERNAL_ONLY_SHOW_CLEAN_CHAT_BUTTON): when
+     * set, wins over both the boot `chat_settings.clean_chat_button` and the
+     * `hasCleanChatButton` prop. Leave undefined for the normal boot ?? prop
+     * resolution.
+     */
+    hasCleanChatButtonOverride?: boolean;
+    /**
+     * Embedded mode (INTERNAL_ONLY_CHAT_INTERFACE_ONLY): the interface is the
+     * page content and there is no launcher bubble to reopen a closed chat, so
+     * open/close state does not apply — not the isInitiallyOpen prop, not the
+     * boot `chat_settings.initial_open`, and not the closed-cookie. Without
+     * this, a boot `initial_open: false` closes the widget from under the
+     * host page a moment after it renders.
+     */
+    isAlwaysOpen?: boolean;
+}>): UseChatReturn;

package/dist/components/chat/{interface-props.hook.d.ts → hooks/use-interface-props.d.ts}

@@ -1,5 +1,5 @@
-import { BootResponse } from '../../lib/eloquent-ai-api-client';
-import { ChatInterfaceProps } from '../chat-interface';
+import { BootResponse } from '../../../lib/eloquent-ai-api-client';
+import { ChatInterfaceProps } from '../../chat-interface';
 export interface UseInterfacePropsParams {
     chatProps?: Partial<ChatInterfaceProps>;
     chatSettings: BootResponse["chat_settings"] | null;

package/dist/components/chat/hooks/use-keyboard-inset.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tracks how much the on-screen keyboard overlaps the layout viewport, using
+ * the VisualViewport API. Used to lift the chat input above the keyboard
+ * without moving/resizing the rest of the chat window.
+ */
+export declare function useKeyboardInset(enabled: boolean): number;

package/dist/components/chat/{message-events.hook.d.ts → hooks/use-message-events.d.ts}

@@ -1,6 +1,6 @@
-import { default as React } from 'react';
-import { Message, MessageData } from '../../type';
-import { BootResponse, EloquentAiApiClient } from '../../lib/eloquent-ai-api-client';
+import { Dispatch, SetStateAction } from 'react';
+import { Message, MessageData } from '../../../types/message';
+import { BootResponse, EloquentAiApiClient } from '../../../lib/eloquent-ai-api-client';
 export interface UseMessageEventsProps {
     appId: string;
     userId: string;
@@ -11,11 +11,11 @@ export interface UseMessageEventsProps {
     apiClient: EloquentAiApiClient | null;
     chatSettings: BootResponse["chat_settings"] | null;
     messages: Message[];
-    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    setMessages: Dispatch<SetStateAction<Message[]>>;
     currentChat: {
         id: string;
     } | null;
-    setCurrentChat: React.Dispatch<React.SetStateAction<{
+    setCurrentChat: Dispatch<SetStateAction<{
         id: string;
     } | null>>;
     onChatClosed?: () => void;

package/dist/components/chat/{persistence.hook.d.ts → hooks/use-persistence.d.ts}

@@ -1,4 +1,4 @@
-import { Message } from '../../type';
+import { Message } from '../../../types/message';
 export interface ChatData {
     conversationId: string | null;
     userId: string | null;
@@ -6,6 +6,8 @@ export interface ChatData {
     deviceId: string | null;
     messages: Message[];
     lastActivity?: number;
+    isChatClosed?: boolean;
+    chatToken?: string | null;
 }
 /**
  * Hook to manage persistence of chat data, including conversation ID, user ID, last activity time, and messages.
@@ -15,8 +17,9 @@ export declare function usePersistence({ appId }: {
     appId: string;
 }): {
     isChatExpired: () => boolean;
-    saveChatData: (conversationId: string, userId: string, messages: Message[], deviceId: string) => void;
+    saveChatData: (conversationId: string, userId: string, messages: Message[], deviceId: string, chatToken?: string | null) => void;
     clearChatData: () => void;
     getSavedChatData: () => ChatData;
     updateLastActivity: () => void;
+    markChatClosed: () => void;
 };

package/dist/components/chat/{realtime-socket.hook.d.ts → hooks/use-realtime-socket.d.ts}

@@ -1,6 +1,6 @@
-import { BootResponse, MessageResponse } from '../../lib/eloquent-ai-api-client';
-import { Message } from '../../type';
-import { ChatResponse } from './validations';
+import { BootResponse, MessageResponse } from '../../../lib/eloquent-ai-api-client';
+import { Message } from '../../../types/message';
+import { ChatResponse } from '../validations';
 export type UseRealtimeSocketOptions = {
     chatSettings: BootResponse["chat_settings"] | null;
     chatId: string | null;
@@ -16,6 +16,7 @@ export type UseRealtimeSocketOptions = {
     onRatingRequest?: () => void;
     onBreadcrumb?: () => void;
     fetchHistory: (chatId: string) => Promise<MessageResponse[]>;
+    getChatToken: () => string | null;
     backupPollingInterval?: number;
 };
 export type UseRealtimeSocketReturn = {
@@ -23,4 +24,4 @@ export type UseRealtimeSocketReturn = {
     disconnect: () => void;
     clearProcessedIds: () => void;
 };
-export declare function useRealtimeSocket({ chatSettings, chatId, messages, onMessage, onCognition, onCognitionComplete, onError, onChatClosed, onAgentCapturedUrl, onAgentTopic, onAgentSummary, onRatingRequest, onBreadcrumb, fetchHistory, backupPollingInterval, }: UseRealtimeSocketOptions): UseRealtimeSocketReturn;
+export declare function useRealtimeSocket({ chatSettings, chatId, messages, onMessage, onCognition, onCognitionComplete, onError, onChatClosed, onAgentCapturedUrl, onAgentTopic, onAgentSummary, onRatingRequest, onBreadcrumb, fetchHistory, getChatToken, backupPollingInterval, }: UseRealtimeSocketOptions): UseRealtimeSocketReturn;

package/dist/components/chat/hooks/use-scroll-lock.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Locks scrolling on the host page while active. Uses the fixed-body trick
+ * (rather than plain `overflow: hidden`) so it also holds on iOS Safari,
+ * which otherwise still allows background scroll/bounce behind the chat.
+ */
+export declare function useScrollLock(locked: boolean): void;

package/dist/components/chat/{sdk-initialization.hook.d.ts → hooks/use-sdk-initialization.d.ts}

@@ -1,5 +1,5 @@
-import { Message } from '../../type';
-import { BootResponse, EloquentAiApiClient } from '../../lib/eloquent-ai-api-client';
+import { Message } from '../../../types/message';
+import { BootResponse, EloquentAiApiClient } from '../../../lib/eloquent-ai-api-client';
 export interface UseSdkInitializationProps {
     environment: "test" | "live";
     apiUrl?: string;
@@ -21,6 +21,8 @@ export interface UseSdkInitializationReturn {
     } | null;
     messages: Message[];
     isReady: boolean;
+    isChatClosed: boolean;
+    isChatActive: boolean;
 }
 /**
  * Hook to handle SDK initialization for the EloquentAI Chat SDK

package/dist/components/chat/index.d.ts

@@ -1,3 +1 @@
-import { UseChatProps } from './chat.hook';
-export type ChatProps = UseChatProps;
-export declare function Chat(props: Readonly<ChatProps>): import("react/jsx-runtime").JSX.Element;
+export { Chat, type ChatProps } from './chat';

package/dist/components/chat/message-mapping.d.ts

@@ -0,0 +1,17 @@
+import { ChatResponse } from './validations';
+import { Message } from '../../types/message';
+/**
+ * The single place where API/wire shapes become domain `Message`s.
+ *
+ * Everything here is a pure function: the hooks own state and timing, this
+ * module owns shape. A backend field change should only ever touch this file
+ * (and validations.ts), not the hooks.
+ */
+/** A realtime/polled assistant reply, as appended to the transcript. */
+export declare function messageFromChatResponse(response: ChatResponse): Message;
+/** The configured welcome message, shown before any conversation exists. */
+export declare function createWelcomeMessage(content: string): Message;
+/** The star-rating prompt appended when the server requests feedback. */
+export declare function createRatingRequestMessage(): Message;
+/** The notice shown when the user writes into a closed conversation. */
+export declare function createChatClosedNoticeMessage(): Message;

package/dist/components/chat/validations.d.ts

@@ -1,60 +1,67 @@
-import { z } from 'zod';
-export declare const chatResponseApiSchema: z.ZodUnion<readonly [z.ZodObject<{
-    message_id: z.ZodNullable<z.ZodString>;
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"utterance">;
-        content: z.ZodString;
-        role: z.ZodString;
+import * as z from "zod/mini";
+export declare const chatResponseApiSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    message_id: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"utterance">;
+        content: z.ZodMiniString<string>;
+        role: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"error">;
-        code: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"error">;
+        code: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"agent_cognition">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"agent_cognition">;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"agent_captured_url">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"agent_captured_url">;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"agent_topic">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"agent_topic">;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"agent_summary">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"agent_summary">;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    message_id: z.ZodNullable<z.ZodString>;
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"chat_closed_expired">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    message_id: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"chat_closed_expired">;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"chat_rating">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"chat_rating">;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    created_at: z.ZodString;
-    data: z.ZodObject<{
-        type: z.ZodLiteral<"breadcrumb">;
-        content: z.ZodString;
+}, z.core.$strip>, z.ZodMiniObject<{
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"breadcrumb">;
+        content: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodMiniObject<{
+    message_id: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    created_at: z.ZodMiniString<string>;
+    data: z.ZodMiniObject<{
+        type: z.ZodMiniLiteral<"chat_escalated">;
+        content: z.ZodMiniNull;
     }, z.core.$strip>;
 }, z.core.$strip>]>;
 export type ChatResponseApi = z.infer<typeof chatResponseApiSchema>;
@@ -96,31 +103,12 @@ export type AgentSummaryNotification = {
         type: "agent_summary";
     }>;
 };
-export type ChatClosedExpiredNotification = {
-    message_id: string | null;
-    created_at: string;
-    data: Extract<NotificationData, {
-        type: "chat_closed_expired";
-    }>;
-};
-export type ChatRatingNotification = {
-    created_at: string;
-    data: Extract<NotificationData, {
-        type: "chat_rating";
-    }>;
-};
-export type BreadcrumbNotification = {
-    created_at: string;
-    data: Extract<NotificationData, {
-        type: "breadcrumb";
-    }>;
-};
-export declare const chatResponseSchema: z.ZodObject<{
-    message_id: z.ZodString;
-    response: z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodString;
-        content: z.ZodString;
+export declare const chatResponseSchema: z.ZodMiniObject<{
+    message_id: z.ZodMiniString<string>;
+    response: z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+        type: z.ZodMiniString<string>;
+        content: z.ZodMiniString<string>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ChatResponse = z.infer<typeof chatResponseSchema>;

package/dist/components/chat-interface/chat-interface.d.ts

@@ -0,0 +1,2 @@
+import { ChatInterfaceProps } from './types';
+export declare function ChatInterface(props: ChatInterfaceProps): import("react").JSX.Element;

package/dist/components/chat-interface/content.d.ts

@@ -1 +1 @@
-export declare function ChatInterfaceContent(): import("react/jsx-runtime").JSX.Element;
+export declare function ChatInterfaceContent(): import("react").JSX.Element;

package/dist/components/chat-interface/context.d.ts

@@ -1,6 +1,6 @@
 import { PropsWithChildren } from 'react';
-import { ChatInterfaceProps } from '.';
+import { ChatInterfaceProps } from './types';
 declare const ChatContext: import('react').Context<ChatInterfaceProps | undefined>;
-export declare function ChatInterfaceProvider({ children, ...props }: PropsWithChildren<ChatInterfaceProps>): import("react/jsx-runtime").JSX.Element;
+export declare function ChatInterfaceProvider({ children, ...props }: PropsWithChildren<ChatInterfaceProps>): import("react").JSX.Element;
 export declare function useChatInterfaceContext(): ChatInterfaceProps;
 export { ChatContext, type ChatInterfaceProps };

package/dist/components/chat-interface/footer.d.ts

@@ -1 +1 @@
-export declare function ChatInterfaceFooter(): import("react/jsx-runtime").JSX.Element;
+export declare function ChatInterfaceFooter(): import("react").JSX.Element;

package/dist/components/chat-interface/header.d.ts

@@ -1,4 +1,4 @@
 export declare function ChatInterfaceHeader({ onCleanChat, onClose, }: {
     onCleanChat: () => void;
     onClose: () => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;