@agentforge-io/chat-sdk 2.1.0 → 2.2.0

package/dist/entities.d.ts

@@ -160,6 +160,17 @@ export type ChatEvent = {
     type: 'error';
     message: string;
     code?: string;
+}
+/**
+ * Emitted exactly once per session, the moment the server hands us
+ * back the new conversation id after the visitor sent the first
+ * message. View layers use this to write the id into URL query
+ * (`?c=<id>`), localStorage, etc. so a refresh / drawer-reopen
+ * resumes the same conversation instead of starting fresh.
+ */
+ | {
+    type: 'conversation_started';
+    conversationId: string;
 } | {
     type: 'destroyed';
 };

package/dist/react.d.ts

@@ -77,6 +77,14 @@ export interface ChatWidgetProps {
     browserSessionId?: string;
     /** Existing conversation id to resume. */
     resumeConversationId?: string;
+    /**
+     * Fired exactly once per session, when the server hands back the
+     * new conversation id after the visitor sends their first message.
+     * Hosts use this to write the id to URL query, localStorage, etc.
+     * so a refresh or drawer-reopen resumes the same conversation.
+     * Not called when resuming an existing conversation (the host
+     * already has the id in that case). */
+    onConversationStart?: (conversationId: string) => void;
     /** Disable SSE streaming and use plain POSTs. */
     stream?: boolean;
     /** Extra class on the root container. */
@@ -151,6 +159,17 @@ export interface ChatWidgetProps {
      * behaviour).
      */
     members?: ChatTeamMember[];
+    /**
+     * Slot rendered inside the composer row, BEFORE the textarea. Hosts
+     * use this for affordances that scope or augment the next turn —
+     * e.g. a Team chat's member-picker chip (the "@<agent>" affordance),
+     * a tools menu à la Gemini, an attachment button.
+     *
+     * Kept as a generic React slot rather than a typed prop list so the
+     * SDK doesn't have to learn every product surface that wants to put
+     * something there.
+     */
+    composerLeftSlot?: React.ReactNode;
     /**
      * Imperative handle. The widget fills this ref on mount with a
      * small command object the host can call to drive the session
@@ -170,6 +189,15 @@ export interface ChatWidgetHandle {
      *  entirely. No-op if the session isn't ready yet (status ===
      *  'idle' / 'loading'). */
     sendNow(text: string): void;
+    /**
+     * Insert `text` into the composer's draft at the current cursor
+     * position (replacing any selection). Used by mention pickers,
+     * suggested-fragment chips, or slash-menu commands — the user
+     * sees the text appear in the input as if they had typed it and
+     * can keep editing before sending. Focus stays on the textarea
+     * and the cursor lands at the end of the inserted text.
+     */
+    insertText(text: string): void;
 }
 /**
  * Drop-in chat widget. Owns its own `ChatSession` and re-renders on every

package/dist/react.js

@@ -227,7 +227,7 @@ function fallbackCopy(ctx) {
  * SDK event. Consumers don't need to read `session.getState()` themselves.
  */
 function ChatWidget(props) {
-    const { token, apiBaseUrl, inline = false, position, browserSessionId, resumeConversationId, stream, className, style, onApprovalDecision, readOnlyApprovals = false, variant = 'card', greeting, personaName, shortcuts, onShortcutClick, inputPlaceholder, members, } = props;
+    const { token, apiBaseUrl, inline = false, position, browserSessionId, resumeConversationId, onConversationStart, stream, className, style, onApprovalDecision, readOnlyApprovals = false, variant = 'card', greeting, personaName, shortcuts, onShortcutClick, inputPlaceholder, members, composerLeftSlot, handleRef, } = props;
     // Build a lookup so MessageBubble can resolve actingAgentId → identity
     // in O(1) per render without re-walking the members array. Stable
     // identity per `members` prop change.
@@ -250,17 +250,44 @@ function ChatWidget(props) {
     const messagesRef = (0, react_1.useRef)(null);
     const inputRef = (0, react_1.useRef)(null);
     const styleId = (0, react_1.useId)();
-    // Auto-focus the composer on desktop (pointer:fine) once the session
-    // is ready. Skipped on touch devices — focusing a textarea on iOS /
-    // Android opens the on-screen keyboard, which is hostile on a public
-    // profile page where the visitor probably wants to read first.
+    // Track whether the user has already engaged with the widget. We
+    // start at false (just landed on the page) and flip to true the
+    // moment `handleSend` fires. The auto-focus effect below uses this
+    // to decide whether the impending `status = 'ready'` is the first
+    // landing (skip focus on touch — opening the keyboard unprompted
+    // is hostile) or a return from a send-streaming cycle (re-focus
+    // ALWAYS — the user is mid-conversation, losing the cursor
+    // breaks the typing-rhythm).
+    const hasInteractedRef = (0, react_1.useRef)(false);
+    // Hold the latest `onConversationStart` in a ref so the session
+    // effect doesn't recreate the ChatSession every time the parent
+    // passes a new function identity (typical with inline arrow props).
+    // Recreating the session would wipe the transcript on every render.
+    const onConversationStartRef = (0, react_1.useRef)(onConversationStart);
+    (0, react_1.useEffect)(() => {
+        onConversationStartRef.current = onConversationStart;
+    }, [onConversationStart]);
+    // Auto-focus the composer once the session is ready.
+    //
+    //   Landing (hasInteractedRef.current === false):
+    //     • pointer:fine → focus  (desktop user expects ready-to-type)
+    //     • pointer:coarse → skip (iOS/Android opening the keyboard
+    //                              before the visitor reads anything
+    //                              is jarring)
+    //
+    //   Returning from a send (hasInteractedRef.current === true):
+    //     • always focus, including touch — the user just hit Send,
+    //       they're in conversation mode, their next thought is the
+    //       next message, the keyboard should stay alive.
     (0, react_1.useEffect)(() => {
         if (status !== 'ready')
             return;
         if (typeof window === 'undefined')
             return;
-        if (!window.matchMedia('(pointer: fine)').matches)
+        if (!hasInteractedRef.current &&
+            !window.matchMedia('(pointer: fine)').matches) {
             return;
+        }
         inputRef.current?.focus({ preventScroll: true });
     }, [status]);
     // ── Session lifecycle. Recreate when token / apiBaseUrl changes. ──────
@@ -297,6 +324,10 @@ function ChatWidget(props) {
                 setLastError(evt.message);
                 return;
             }
+            if (evt.type === 'conversation_started') {
+                onConversationStartRef.current?.(evt.conversationId);
+                return;
+            }
         });
         void s.start();
         return () => {
@@ -306,11 +337,26 @@ function ChatWidget(props) {
         };
     }, [token, apiBaseUrl, browserSessionId, resumeConversationId, stream]);
     // Auto-scroll on new tokens.
+    //
+    // We defer the scroll into a requestAnimationFrame so the DOM has
+    // actually grown by the time we read `scrollHeight`. Without that
+    // tick, a stream of small text_deltas can leave the scroll lagging
+    // 1–2 chunks behind because the effect runs synchronously after
+    // the React commit but BEFORE the browser paints the new rows.
+    // Result: the user sees the latest sentence half-cut at the bottom.
+    //
+    // `behavior: 'smooth'` doesn't help much during a fast stream (each
+    // rAF queues a new smooth-scroll that cancels the previous one) but
+    // it does make the FINAL settle look fluid — and that's the part
+    // the user notices when the stream stops.
     (0, react_1.useEffect)(() => {
         const el = messagesRef.current;
         if (!el)
             return;
-        el.scrollTop = el.scrollHeight;
+        const raf = requestAnimationFrame(() => {
+            el.scrollTo({ top: el.scrollHeight, behavior: 'smooth' });
+        });
+        return () => cancelAnimationFrame(raf);
     }, [messages]);
     // Inject the widget stylesheet exactly once per page. We key the <style>
     // tag by a fixed id so multiple widget mounts share it.
@@ -331,6 +377,11 @@ function ChatWidget(props) {
         const text = draft.trim();
         if (!text)
             return;
+        // Mark engagement BEFORE the status flip so the auto-focus
+        // effect (which watches `status`) sees the flag when it
+        // re-runs after `ready` returns. Subsequent renders will
+        // refocus the textarea on every send completion.
+        hasInteractedRef.current = true;
         setDraft('');
         void session.send(text);
     }, [session, draft]);
@@ -340,6 +391,63 @@ function ChatWidget(props) {
             handleSend();
         }
     }, [handleSend]);
+    // Insert `text` at the current cursor position of the composer
+    // textarea. Replaces any active selection, advances the cursor to
+    // the end of the inserted slice, and keeps focus on the input so
+    // the user can keep typing without a click. Falls back to "append
+    // at the end" when the textarea isn't mounted yet (e.g. the host
+    // calls insertText before the session has booted).
+    const insertText = (0, react_1.useCallback)((text) => {
+        if (!text)
+            return;
+        const el = inputRef.current;
+        if (!el) {
+            setDraft((prev) => prev + text);
+            return;
+        }
+        const start = el.selectionStart ?? el.value.length;
+        const end = el.selectionEnd ?? el.value.length;
+        const before = el.value.slice(0, start);
+        const after = el.value.slice(end);
+        const next = before + text + after;
+        setDraft(next);
+        // Imperatively place the cursor after the commit. React's
+        // state update is async, so we wait one tick — by then the
+        // controlled value has flushed into the DOM and we can move
+        // the selection without it being clobbered.
+        queueMicrotask(() => {
+            const cursor = before.length + text.length;
+            el.focus({ preventScroll: true });
+            el.setSelectionRange(cursor, cursor);
+        });
+    }, []);
+    // Wire the imperative handle. The host's ref slot is filled in on
+    // every render so a late-binding consumer still gets the live
+    // closure (sendNow reads the latest session/state via the closure
+    // it captures here).
+    (0, react_1.useEffect)(() => {
+        if (!handleRef)
+            return;
+        handleRef.current = {
+            sendNow: (text) => {
+                if (!session)
+                    return;
+                const trimmed = text.trim();
+                if (!trimmed)
+                    return;
+                hasInteractedRef.current = true;
+                setDraft('');
+                void session.send(trimmed);
+            },
+            insertText,
+        };
+        return () => {
+            // Drop the handle on unmount so a stale ref can't fire send
+            // after the component is gone.
+            if (handleRef.current)
+                handleRef.current = null;
+        };
+    }, [handleRef, session, insertText]);
     const sendDisabled = !session ||
         status === 'idle' ||
         status === 'loading' ||
@@ -397,7 +505,14 @@ function ChatWidget(props) {
                                 ? { ...theme, avatarUrl: member.avatarUrl }
                                 : theme;
                             const bubbleAvatarName = member?.name ?? personaName ?? agent?.name;
-                            return ((0, jsx_runtime_1.jsx)(MessageBubble, { message: m, session: session, readOnly: readOnlyApprovals, onDecision: onApprovalDecision, bare: bare, showAvatar: showAvatar, avatarTheme: bubbleAvatarTheme, avatarName: bubbleAvatarName, speakerLabel: member?.name, onContinue: () => {
+                            // Seed for the deterministic-hue fallback avatar. Prefer
+                            // the acting agent id (so each member in a team gets its
+                            // own stable color) and fall back to the primary agent's
+                            // slug for solo chats / orchestrator-self turns. The
+                            // `agent` summary doesn't carry an id — slug is stable
+                            // and unique, which is all hueFromSeed needs.
+                            const bubbleAgentId = m.actingAgentId ?? agent?.slug;
+                            return ((0, jsx_runtime_1.jsx)(MessageBubble, { message: m, session: session, readOnly: readOnlyApprovals, onDecision: onApprovalDecision, bare: bare, showAvatar: showAvatar, avatarTheme: bubbleAvatarTheme, avatarName: bubbleAvatarName, avatarAgentId: bubbleAgentId, speakerLabel: member?.name, onContinue: () => {
                                     // After a successful Approve, kick the next turn so the
                                     // gate's fast-path consumes the approval and the tool
                                     // actually runs. `silent: true` keeps the literal
@@ -410,23 +525,23 @@ function ChatWidget(props) {
                                         void session.send('continue', { silent: true });
                                     }, 250);
                                 } }, m.id));
-                        }) }), lastError && status === 'error' && ((0, jsx_runtime_1.jsx)("div", { className: "af-error", children: lastError })), bare && greeting && messages.length === 0 && status !== 'loading' && ((0, jsx_runtime_1.jsx)("div", { className: "af-greeting-slot", children: (0, jsx_runtime_1.jsxs)("div", { className: "af-msg-row af-msg-row-assistant af-msg-row-greeting", children: [(0, jsx_runtime_1.jsx)(AssistantAvatar, { theme: theme, name: personaName ?? agent?.name, show: true }), (0, jsx_runtime_1.jsx)("div", { className: "af-msg af-msg-assistant af-msg-greeting", dangerouslySetInnerHTML: { __html: renderMarkdown(greeting) } })] }) })), shortcuts && shortcuts.length > 0 && messages.length === 0 && ((0, jsx_runtime_1.jsx)("div", { className: "af-shortcut-row", children: shortcuts.map((text, i) => ((0, jsx_runtime_1.jsx)("button", { type: "button", className: "af-shortcut", onClick: () => {
+                        }) }), lastError && status === 'error' && ((0, jsx_runtime_1.jsx)("div", { className: "af-error", children: lastError })), bare && greeting && messages.length === 0 && status !== 'loading' && ((0, jsx_runtime_1.jsx)("div", { className: "af-greeting-slot", children: (0, jsx_runtime_1.jsxs)("div", { className: "af-msg-row af-msg-row-assistant af-msg-row-greeting", children: [(0, jsx_runtime_1.jsx)(AssistantAvatar, { theme: theme, name: personaName ?? agent?.name, agentId: agent?.slug, show: true }), (0, jsx_runtime_1.jsx)("div", { className: "af-msg af-msg-assistant af-msg-greeting", dangerouslySetInnerHTML: { __html: renderMarkdown(greeting) } })] }) })), shortcuts && shortcuts.length > 0 && messages.length === 0 && ((0, jsx_runtime_1.jsx)("div", { className: "af-shortcut-row", children: shortcuts.map((text, i) => ((0, jsx_runtime_1.jsx)("button", { type: "button", className: "af-shortcut", onClick: () => {
                                 if (onShortcutClick)
                                     onShortcutClick(text, i);
                                 else
                                     setDraft(text);
-                            }, children: text }, `${i}-${text}`))) })), (0, jsx_runtime_1.jsxs)("div", { className: "af-input-row", children: [(0, jsx_runtime_1.jsx)("textarea", { ref: inputRef, className: "af-input", value: draft, onChange: (e) => setDraft(e.target.value), onKeyDown: onKeyDown, placeholder: inputPlaceholder ?? 'Type a message…', rows: 1, disabled: status === 'ended' || status === 'loading' || status === 'idle' }), (0, jsx_runtime_1.jsx)("button", { type: "button", className: "af-send", onClick: handleSend, disabled: sendDisabled, "aria-label": "Send message", children: (0, jsx_runtime_1.jsx)(SendIcon, {}) })] }), !bare && (0, jsx_runtime_1.jsx)("div", { className: "af-footer", children: "Powered by AgentForge" })] })] }));
+                            }, children: text }, `${i}-${text}`))) })), (0, jsx_runtime_1.jsxs)("div", { className: "af-input-row", children: [composerLeftSlot && ((0, jsx_runtime_1.jsx)("div", { className: "af-input-left", children: composerLeftSlot })), (0, jsx_runtime_1.jsx)("textarea", { ref: inputRef, className: "af-input", value: draft, onChange: (e) => setDraft(e.target.value), onKeyDown: onKeyDown, placeholder: inputPlaceholder ?? 'Type a message…', rows: 1, disabled: status === 'ended' || status === 'loading' || status === 'idle' }), (0, jsx_runtime_1.jsx)("button", { type: "button", className: "af-send", onClick: handleSend, disabled: sendDisabled, "aria-label": "Send message", children: (0, jsx_runtime_1.jsx)(SendIcon, {}) })] }), !bare && (0, jsx_runtime_1.jsx)("div", { className: "af-footer", children: "Powered by AgentForge" })] })] }));
 }
-function MessageBubble({ message, session, readOnly, onDecision, onContinue, bare = false, showAvatar = false, avatarTheme, avatarName, speakerLabel, }) {
+function MessageBubble({ message, session, readOnly, onDecision, onContinue, bare = false, showAvatar = false, avatarTheme, avatarName, avatarAgentId, speakerLabel, }) {
     const kind = message.metadata?.kind;
     if (kind === 'awaiting_approval') {
         // Approval / blocked bubbles also count as "assistant-side" so we
         // wrap them in the same row geometry — keeps the conversation
         // aligned even when a tool dispatch interrupts the regular flow.
-        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, (0, jsx_runtime_1.jsx)(ApprovalBubble, { message: message, session: session, readOnly: readOnly, onDecision: onDecision, onContinue: onContinue }), speakerLabel);
+        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, avatarAgentId, (0, jsx_runtime_1.jsx)(ApprovalBubble, { message: message, session: session, readOnly: readOnly, onDecision: onDecision, onContinue: onContinue }), speakerLabel);
     }
     if (kind === 'tool_blocked') {
-        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, (0, jsx_runtime_1.jsx)(BlockedBubble, { message: message }), speakerLabel);
+        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, avatarAgentId, (0, jsx_runtime_1.jsx)(BlockedBubble, { message: message }), speakerLabel);
     }
     const cls = `af-msg af-msg-${message.role}${message.role === 'assistant' && message.isStreaming
         ? message.content
@@ -435,10 +550,10 @@ function MessageBubble({ message, session, readOnly, onDecision, onContinue, bar
         : ''}`;
     // Typing state (no content yet): render the three-dot indicator, no markdown.
     if (message.role === 'assistant' && message.isStreaming && !message.content) {
-        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, (0, jsx_runtime_1.jsx)("div", { className: cls, children: (0, jsx_runtime_1.jsxs)("span", { className: "af-typing-dots", "aria-label": "Assistant is typing", children: [(0, jsx_runtime_1.jsx)("span", {}), " ", (0, jsx_runtime_1.jsx)("span", {}), " ", (0, jsx_runtime_1.jsx)("span", {})] }) }), speakerLabel);
+        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, avatarAgentId, (0, jsx_runtime_1.jsx)("div", { className: cls, children: (0, jsx_runtime_1.jsxs)("span", { className: "af-typing-dots", "aria-label": "Assistant is typing", children: [(0, jsx_runtime_1.jsx)("span", {}), " ", (0, jsx_runtime_1.jsx)("span", {}), " ", (0, jsx_runtime_1.jsx)("span", {})] }) }), speakerLabel);
     }
     if (message.role === 'assistant') {
-        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, (0, jsx_runtime_1.jsx)("div", { className: cls, 
+        return wrapAssistantRow(bare, showAvatar, avatarTheme, avatarName, avatarAgentId, (0, jsx_runtime_1.jsx)("div", { className: cls, 
             // Output is sanitized by escapeHtml + a fixed tag whitelist in
             // renderMarkdown — safe to inject as HTML.
             dangerouslySetInnerHTML: { __html: renderMarkdown(message.content) } }), speakerLabel);
@@ -452,22 +567,27 @@ function MessageBubble({ message, session, readOnly, onDecision, onContinue, bar
  * avatar column. Card variant skips the wrapper entirely so its
  * historical layout is unchanged.
  */
-function wrapAssistantRow(bare, showAvatar, theme, name, child, 
+function wrapAssistantRow(bare, showAvatar, theme, name, agentId, child, 
 /** When set + this is the first bubble of a speaker run (showAvatar
  *  is true), render the speaker's display name just above the
  *  bubble. Used by Team chats so members are visually attributed. */
 speakerLabel) {
     if (!bare)
         return child;
-    return ((0, jsx_runtime_1.jsxs)("div", { className: "af-msg-row af-msg-row-assistant", children: [(0, jsx_runtime_1.jsx)(AssistantAvatar, { theme: theme, name: name, show: showAvatar }), (0, jsx_runtime_1.jsxs)("div", { className: "af-msg-col", children: [showAvatar && speakerLabel ? ((0, jsx_runtime_1.jsx)("div", { className: "af-msg-speaker", children: speakerLabel })) : null, child] })] }));
+    return ((0, jsx_runtime_1.jsxs)("div", { className: "af-msg-row af-msg-row-assistant", children: [(0, jsx_runtime_1.jsx)(AssistantAvatar, { theme: theme, name: name, agentId: agentId, show: showAvatar }), (0, jsx_runtime_1.jsxs)("div", { className: "af-msg-col", children: [showAvatar && speakerLabel ? ((0, jsx_runtime_1.jsx)("div", { className: "af-msg-speaker", children: speakerLabel })) : null, child] })] }));
 }
 /**
  * Small circular avatar for the assistant-side column. Prefers the
- * agent's avatarUrl when set; otherwise renders a gradient circle
- * with the first letter of `name`. The slot reserves space even when
- * `show` is false so consecutive bubbles stay column-aligned.
+ * agent's avatarUrl when set; otherwise renders a SOLID circle with
+ * the first letter of `name` over a hue derived from `agentId`. The
+ * hash → HSL mapping means every agent in a team gets a stable,
+ * distinguishable color across renders without us needing a palette
+ * table or per-agent config.
+ *
+ * The slot reserves space even when `show` is false so consecutive
+ * bubbles stay column-aligned.
  */
-function AssistantAvatar({ theme, name, show, }) {
+function AssistantAvatar({ theme, name, agentId, show, }) {
     const initial = (name ?? 'A').trim().charAt(0).toUpperCase() || 'A';
     if (!show) {
         return (0, jsx_runtime_1.jsx)("div", { className: "af-msg-avatar af-msg-avatar-spacer", "aria-hidden": true });
@@ -477,7 +597,21 @@ function AssistantAvatar({ theme, name, show, }) {
         // eslint-disable-next-line @next/next/no-img-element -- vanilla widget; consumer can override host
         (0, jsx_runtime_1.jsx)("img", { className: "af-msg-avatar af-msg-avatar-img", src: theme.avatarUrl, alt: "", "aria-hidden": true }));
     }
-    return ((0, jsx_runtime_1.jsx)("div", { className: "af-msg-avatar af-msg-avatar-fallback", "aria-hidden": true, children: (0, jsx_runtime_1.jsx)("span", { children: initial }) }));
+    const seed = agentId || name || 'agent';
+    return ((0, jsx_runtime_1.jsx)("div", { className: "af-msg-avatar af-msg-avatar-fallback", "aria-hidden": true, style: { backgroundColor: hueFromSeed(seed) }, children: (0, jsx_runtime_1.jsx)("span", { children: initial }) }));
+}
+/**
+ * Deterministic per-agent hue. Hash the seed into the HSL hue space
+ * so an agent's avatar color stays stable across renders and looks
+ * varied across a roster. Saturation/lightness are tuned for both
+ * light + dark chat surfaces: mid-saturation + mid-lightness reads
+ * legibly with white text on either background.
+ */
+function hueFromSeed(seed) {
+    let h = 0;
+    for (let i = 0; i < seed.length; i++)
+        h = (h * 31 + seed.charCodeAt(i)) >>> 0;
+    return `hsl(${h % 360} 60% 52%)`;
 }
 /**
  * Awaiting-approval bubble. Renders the tool name + a countdown, and
@@ -653,6 +787,11 @@ const WIDGET_CSS = `
   to { opacity: 1; transform: translateY(0); }
 }
 .af-input-row { padding: 12px; border-top: 1px solid var(--af-border); background: var(--af-bg); display: flex; gap: 8px; align-items: flex-end; }
+/* Composer left slot — hosts use this for affordance buttons that
+   scope the next turn (member picker, tools menu, attachments).
+   align-items: center keeps a single-line chip vertically centered
+   against the auto-growing textarea. */
+.af-input-left { display: flex; align-items: center; padding-bottom: 4px; flex-shrink: 0; }
 .af-shortcut-row {
   display: flex;
   gap: 6px;
@@ -776,7 +915,13 @@ const WIDGET_CSS = `
   background: transparent;
   border-radius: 0;
   box-shadow: none;
-  overflow: visible;
+  /* overflow:hidden so a long transcript (markdown tables, long
+     lists) scrolls inside af-messages instead of pushing the
+     af-input-row past the bottom of the host envelope. Was 'visible'
+     before, which let a tall message break out of the host sized
+     container and shove the composer off-screen. The messages region
+     itself carries overflow-y:auto so internal scroll keeps working. */
+  overflow: hidden;
   display: flex;
   flex-direction: column;
   flex: 1;
@@ -1009,7 +1154,11 @@ const WIDGET_CSS = `
   font-size: 11.5px;
   font-weight: 600;
   letter-spacing: 0.01em;
-  background-image: linear-gradient(135deg, var(--af-primary, #8b5cf6), color-mix(in srgb, var(--af-primary, #8b5cf6) 60%, #6366f1));
+  /* SOLID fill — the React component sets the actual color via an
+   * inline style.backgroundColor (deterministic hash of agentId).
+   * No gradient here on purpose: the gradient was masking the
+   * inline color and made every agent avatar look the same. */
+  background-color: var(--af-primary, #8b5cf6);
 }
 @media (min-width: 768px) {
   .af-widget-root.af-variant-bare .af-msg-avatar { width: 30px; height: 30px; }

package/dist/session.js

@@ -211,6 +211,7 @@ class ChatSession {
             for await (const evt of generator) {
                 if (evt.kind === 'conversation') {
                     this.state.conversationId = evt.id;
+                    this.emit({ type: 'conversation_started', conversationId: evt.id });
                     continue;
                 }
                 if (evt.kind === 'chunk') {
@@ -398,6 +399,7 @@ class ChatSession {
             else {
                 const res = await this.transport.createConversation(text, this.browserSessionId);
                 this.state.conversationId = res.conversationId;
+                this.emit({ type: 'conversation_started', conversationId: res.conversationId });
                 content = res.content;
             }
             assistant.content = content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge-io/chat-sdk",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Framework-free chat session SDK for AgentForge public chat tokens. Headless — no DOM. Drop into any frontend (React, Vue, Svelte, vanilla) and listen for events.",
   "license": "MIT",
   "main": "dist/index.js",