fauna-api 1.0.783 → 1.0.785

package/dist/src/parrot/room.d.ts

@@ -1,28 +1,30 @@
 import { Credentials, ApiKey, Profile } from "../authentification.js";
-import { Function, Role, Tool } from "./generative.js";
+import { Author, Function, Role, Text, Tool } from "./generative.js";
 import { Room, Presence, Authorization } from "../shared/server.js";
+import { Parrot } from "./index.js";
 import { ChatTarget, AppendResult, Attachment } from "./share.js";
 import type { Repository } from "../termite/versioning.js";
 import type { Group } from "../groups.js";
 import type { Target } from "../view.js";
 export { Attachment } from "./share.js";
 /**
- * One durable message in a room transcript. Parts keep their file refs as
- * streaming `FaunaFile`s (no bytes over the socket) — `download()` them when you
- * need the bytes. `author` is the sender's public Profile (USER turns only).
+ * One durable message in a room transcript, as the room sends it: its parts as they're
+ * stored (file refs, no bytes over the socket), its author and model as on `Content`.
  */
 export type RoomMessage = {
     id: string;
     position: number;
     role: Role;
     parts: any[];
-    author?: Profile;
+    author?: Author;
     replyTo?: string;
-    /** LLM id that produced a MODEL turn (for UI avatar / rehydrate). */
-    model?: string;
+    /** The model that wrote a MODEL turn. */
+    model?: Text;
     created: number;
-    /** The name of the API key an agent posted this with, for its author. */
-    via?: string;
+};
+export declare const RoomMessage: {
+    /** FILE parts arrive as `{ accessCode | path | ref }` and stream lazily through `FaunaFile`. */
+    fromJSON(json: any, authorization: Credentials | ApiKey, target: ChatTarget): RoomMessage;
 };
 /**
  * One buffered send in the shared room queue. When a member sends while the

package/dist/src/parrot/room.js

@@ -1,9 +1,39 @@
-import { Role } from "./generative.js";
+import { Author, Role } from "./generative.js";
+import * as Drive from "../drive.js";
 import { Room, Presence, connect } from "../shared/server.js";
 import { Parrot } from "./index.js";
 import { appendRoomMessage, steerRoom, unqueueRoomMessage, pageMessages, setRoomRepository, listRoomAttachments, Attachment, } from "./share.js";
 import { File as FaunaFile } from "../drive.js";
 export { Attachment } from "./share.js";
+export const RoomMessage = {
+    /** FILE parts arrive as `{ accessCode | path | ref }` and stream lazily through `FaunaFile`. */
+    fromJSON(json, authorization, target) {
+        const parts = (json.parts ?? []).map((part) => {
+            if (part.type !== "FILE")
+                return part;
+            const meta = { ...part, name: part.name ?? "file", contentType: part.contentType ?? "application/octet-stream" };
+            if (part.accessCode)
+                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, accessCode: part.accessCode }) };
+            if (part.path)
+                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, path: part.path, group: part.group }) };
+            if ("code" in target)
+                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, accessCode: target.code }) };
+            if (part.ref)
+                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, path: part.ref }) };
+            return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, accessCode: "" }) };
+        });
+        return {
+            id: String(json.id ?? ""),
+            position: Number(json.position ?? 0),
+            role: json.role,
+            parts,
+            author: Author.fromJSON(json.author),
+            replyTo: json.replyTo,
+            model: json.model ? json.model : undefined,
+            created: Number(json.created ?? 0),
+        };
+    },
+};
 /**
  * A live, domain-agnostic chat room. `ChatRoom extends Room` and owns everything
  * chat-transcript-specific: a WINDOWED transcript (the last page hydrated on
@@ -208,19 +238,7 @@ export class ChatRoom extends Room {
     async loadOlder() {
         const page = await pageMessages(this.getAuthorization(), this.target, { cursor: this.messages.length, max: OLDER_PAGE });
         const known = new Set(this.messages.map((m) => m.position));
-        const older = page
-            .filter((m) => !known.has(m.position))
-            .map((m) => ({
-            id: m.id,
-            position: m.position,
-            role: m.role,
-            parts: m.parts,
-            author: m.author,
-            replyTo: m.replyTo,
-            model: m.model,
-            created: m.created,
-            ...(m.via ? { via: m.via } : {}),
-        }));
+        const older = page.filter((m) => !known.has(m.position));
         this.messages = [...older, ...this.messages].sort((a, b) => a.position - b.position);
         this._hasMore = page.length === OLDER_PAGE;
         return older;

package/dist/src/parrot/share.d.ts

@@ -1,7 +1,8 @@
 import { Parrot } from "./index.js";
 import { Credentials, ApiKey, Profile } from "../authentification.js";
-import { Content, Function, Role } from "./generative.js";
+import { Content, Function } from "./generative.js";
 import * as Drive from "../drive.js";
+import { RoomMessage } from "./room.js";
 /**
  * Address a live room by a redeemable access code or by its globally-unique
  * reference (`parrot:chat:{chatId}` for a durable-bound room, `parrot:room:{uuid}`
@@ -35,24 +36,6 @@ export declare function openRoom(authorization: Credentials | ApiKey, options?:
     roomId: string;
     code?: string;
 }>;
-/** One transcript message on the wire (parts keep file refs as streaming
- *  `FaunaFile`s). Matches the room's live `chat-message` shape. */
-export type WireMessage = {
-    id: string;
-    position: number;
-    role: Role;
-    parts: any[];
-    author?: Profile;
-    replyTo?: string;
-    model?: string;
-    created: number;
-    /** The name of the API key an agent posted this with, for its author. */
-    via?: string;
-};
-export declare const WireMessage: {
-    /** FILE parts arrive as `{ accessCode | path | ref }` and stream lazily through `FaunaFile`. */
-    fromJSON(json: any, authorization: Credentials | ApiKey, target: ChatTarget): WireMessage;
-};
 /**
  * Page older room transcript messages, newest first. `cursor` is how many
  * messages to skip from the newest.
@@ -60,7 +43,7 @@ export declare const WireMessage: {
 export declare function pageMessages(authorization: Credentials | ApiKey, target: ChatTarget, query: {
     cursor: number;
     max: number;
-}): Promise<WireMessage[]>;
+}): Promise<RoomMessage[]>;
 /** Result of appending to a live room: either the durable transcript row (when
  *  the room was idle) or a queued buffer row (when the model was mid-reply). */
 export type AppendResult = {

package/dist/src/parrot/share.js

@@ -1,5 +1,6 @@
 import { Parrot } from "./index.js";
 import * as Drive from "../drive.js";
+import { RoomMessage } from "./room.js";
 export async function moveChatToGroup(credentials, chatId, groupId) {
     const response = await fetch(`${Parrot.getURL()}/chat/move`, {
         method: "POST",
@@ -37,35 +38,6 @@ export async function openRoom(authorization, options = {}) {
         throw new Error(await response.text());
     return await response.json();
 }
-export const WireMessage = {
-    /** FILE parts arrive as `{ accessCode | path | ref }` and stream lazily through `FaunaFile`. */
-    fromJSON(json, authorization, target) {
-        const parts = (json.parts ?? []).map((part) => {
-            if (part.type !== "FILE")
-                return part;
-            const meta = { ...part, name: part.name ?? "file", contentType: part.contentType ?? "application/octet-stream" };
-            if (part.accessCode)
-                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, accessCode: part.accessCode }) };
-            if (part.path)
-                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, path: part.path, group: part.group }) };
-            if ("code" in target)
-                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, accessCode: target.code }) };
-            if (part.ref)
-                return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, path: part.ref }) };
-            return { type: "FILE", file: Drive.File.fromJSON(meta, { authorization, accessCode: "" }) };
-        });
-        return {
-            id: String(json.id ?? ""),
-            position: Number(json.position ?? 0),
-            role: json.role,
-            parts,
-            author: json.author,
-            replyTo: json.replyTo,
-            model: json.model,
-            created: Number(json.created ?? 0),
-        };
-    },
-};
 /**
  * Page older room transcript messages, newest first. `cursor` is how many
  * messages to skip from the newest.
@@ -82,7 +54,7 @@ export async function pageMessages(authorization, target, query) {
     if (!response.ok)
         throw new Error(await response.text());
     const json = await response.json();
-    return (Array.isArray(json) ? json : []).map((m) => WireMessage.fromJSON(m, authorization, target));
+    return (Array.isArray(json) ? json : []).map((m) => RoomMessage.fromJSON(m, authorization, target));
 }
 /**
  * Append one message to a live room's single transcript. Any member may append;

package/dist/src/tickets.d.ts

@@ -1,9 +1,8 @@
 import { Fauna } from "../index.js";
 import { ChatRoom, type RoomHooks } from "./parrot/room.js";
-import { LastMessage } from "./parrot/chat.js";
+import { Content } from "./parrot/generative.js";
 import { Authorization, Presence, Room, Hooks as ServerHooks } from "./shared/server.js";
 export declare function ticketChatAutoEnabled(emails: Iterable<string>, reporter: string): boolean;
-export type TicketLast = LastMessage;
 export type Ticket = {
     id: string;
     title: string;
@@ -13,7 +12,7 @@ export type Ticket = {
     roomReference?: string;
     createdAt: Date;
     updatedAt: Date;
-    last: TicketLast | null;
+    last: Content | null;
     unread: boolean;
 };
 export declare const Ticket: {

package/dist/src/tickets.js

@@ -1,6 +1,6 @@
 import { Fauna } from "../index.js";
 import { connectRoom } from "./parrot/room.js";
-import { LastMessage } from "./parrot/chat.js";
+import { Content } from "./parrot/generative.js";
 import { Room, connect as connectServer } from "./shared/server.js";
 export function ticketChatAutoEnabled(emails, reporter) {
     const reporterEmail = reporter.trim().toLowerCase();
@@ -30,7 +30,7 @@ export const Ticket = {
             roomReference: json.roomReference || json.room_reference || undefined,
             createdAt: new Date(json.createdAt ?? json.created_at),
             updatedAt: new Date(json.updatedAt ?? json.updated_at),
-            last: LastMessage.fromJSON(json.last),
+            last: json.last ? Content.fromJSON(json.last) : null,
             unread: Boolean(json.unread),
         };
     },

package/dist/src/ui/chat.d.ts

@@ -32,6 +32,10 @@ export type ChatMessage = {
     author?: Author;
     /** LLM id that produced a MODEL turn — drives the left avatar icon. */
     model?: string;
+    /** Where it sits, when the app decides (`side`). */
+    side?: 'left' | 'right';
+    /** A line under it, such as why it wasn't delivered (`note`). */
+    note?: string;
 };
 export type { ChatMessageBlock };
 export type StreamEvent = {
@@ -89,6 +93,8 @@ export type ChatInstance = {
     setReasoning: (reasoning: string | undefined) => void;
     setMode: (mode: ChatMode) => void;
     setModels: (models?: Fauna.Parrot.Generative.Text | Fauna.Parrot.Generative.Text[]) => void;
+    /** Reads every drawn message's `note` again, after what it depends on changed. */
+    refreshNotes: () => void;
     insertToken: (token: Token) => void;
     getParts: () => Part[];
     watchInput: (handler: (parts: Part[]) => void) => () => void;
@@ -164,6 +170,21 @@ export type ChatOptions = Partial<{
     onRepositoryChange?: (repository: number | null) => void;
     /** The app's own buttons at the chat's top right, beside the side panel's, in the same style. */
     actions?: ChatAction[];
+    /** Which side each message sits on, when the app decides. A model turn streaming in is
+     *  asked as `{ role: MODEL }`. Omit for the default (see `mode`). */
+    side?: (message: {
+        role: Fauna.Parrot.Generative.Role;
+        author?: Fauna.Parrot.Generative.Author;
+    }) => 'left' | 'right';
+    /** A name and an icon for an outside address (a phone number or an email) a message is by. */
+    nameAddress?: (address: string) => {
+        name: string;
+        icon?: string;
+    } | undefined;
+    /** A line under a message, such as why it wasn't delivered. */
+    note?: (message: RoomMessage) => string | undefined;
+    /** Suggest how to finish a reply in a saved chat's room, as ghost text Tab takes. */
+    autocomplete?: boolean;
 }>;
 /** A button at the chat's top right: a Material Symbols icon, its label, and what it does. */
 export type ChatAction = {

package/dist/src/ui/chat.js

@@ -12,12 +12,16 @@ import { ChatPanel, askForComputer, attachmentOf, buildAttachmentCard, chatToolL
 export { RepositoryControl, askForComputer, pickedRepository } from "./chatPanel.js";
 import { createTooltip } from "./hover.js";
 import { sendInformaticToast } from "./toast.js";
-import { buildAvatar, createSelector, stampModelAvatar, stampUserAvatar } from "./generative.js";
+import { buildAvatar, buildModelAvatar, createSelector, stampModelAvatar, stampUserAvatar } from "./generative.js";
 import { authorColorSeed, colorFromSeed } from "./cursor.js";
 import { render as renderMarkdown } from "./markdown.js";
 // Re-export so apps can flatten serialized token markers (e.g. before sending
 // history to the LLM) without reaching into the tokenized-input module.
 export { toPlainText } from "./tokenized.js";
+/** The person behind a message's author, when it's one. */
+function personOf(author) {
+    return typeof author === 'object' && 'email' in author && typeof author.email === 'string' ? author : undefined;
+}
 // ---- Message builders ----
 function buildThinkingIndicator() {
     const indicator = document.createElement('div');
@@ -231,6 +235,55 @@ function isIncomingAuthor(message, mode = 'assistant', selfEmail) {
         return false;
     return email !== selfEmail;
 }
+/** Whether a message sits on the left: where the app put it, else the model and other
+ *  people in a thread. */
+function placedLeft(message, mode, selfEmail) {
+    if (message.side)
+        return message.side === 'left';
+    return message.role === 'model' || isIncomingAuthor(message, mode, selfEmail);
+}
+/** A model's icon on whichever side its turn sits. */
+function stampModelAvatarOn(el, left, model, icons) {
+    if (left)
+        return stampModelAvatar(el, model, icons);
+    el.classList.add('chat-message-authored');
+    el.appendChild(buildModelAvatar(model, icons));
+}
+/** How a message's author shows: a person by their profile, an API key or an outside
+ *  address by its name (an address named through `nameAddress`). */
+function uiAuthor(author, nameAddress) {
+    const person = personOf(author);
+    if (person)
+        return { id: person.email, profile: person };
+    if (typeof author === 'object' && 'name' in author && typeof author.name === 'string')
+        return { id: `apikey:${author.name}`, profile: { email: '', displayName: author.name } };
+    if (typeof author === 'string' && author !== 'MODEL') {
+        const named = nameAddress?.(author);
+        return { id: author, profile: { email: author, displayName: named?.name ?? author, icon: named?.icon } };
+    }
+    return undefined;
+}
+/** An HTML body, drawn as it is in a frame that runs no scripts. */
+function buildHtmlElement(html) {
+    const frame = document.createElement('iframe');
+    frame.className = 'chat-message-html';
+    frame.setAttribute('sandbox', 'allow-same-origin allow-popups allow-popups-to-escape-sandbox');
+    frame.srcdoc = `<base target="_blank">${html}`;
+    frame.addEventListener('load', () => {
+        const height = frame.contentDocument?.documentElement.scrollHeight;
+        if (height)
+            frame.style.height = `${height}px`;
+    });
+    return frame;
+}
+function appendNote(el, note) {
+    if (!note)
+        return;
+    const noteEl = document.createElement('div');
+    noteEl.className = 'chat-message-note';
+    noteEl.textContent = note;
+    el.appendChild(noteEl);
+}
 function applyUserBubbleLayout(el, incoming, profile) {
     el.querySelector('.chat-message-model-avatar')?.remove();
     el.querySelector(':scope > .chat-message-avatar:not(.chat-message-model-avatar)')?.remove();
@@ -283,15 +336,19 @@ function appendTextBlock(el, text, message, onTokenClick) {
     el.appendChild(textEl);
 }
 async function buildMessageElement(message, iconMap, modelIcons, renderToolCall, mode, selfUserId, onTokenClick, fileCards, sessions) {
-    const incoming = isIncomingAuthor(message, chatMode(mode), selfUserId);
+    const left = placedLeft(message, chatMode(mode), selfUserId);
     const el = document.createElement('div');
-    el.className = (message.role === 'user' && !incoming) ? 'chat-message-user' : 'chat-message-model';
+    el.className = left ? 'chat-message-model' : 'chat-message-user';
     if (message.role === 'user' && message.author?.id)
         el.dataset.author = message.author.id;
+    if (message.side)
+        el.dataset.side = message.side;
     if (message.sequence?.length) {
         for (const block of message.sequence) {
             if (block.type === 'text')
                 appendTextBlock(el, block.text, message, onTokenClick);
+            else if (block.type === 'html')
+                el.appendChild(buildHtmlElement(block.html));
             else if (block.type === 'tool')
                 el.appendChild(renderToolCallElement(block.call, renderToolCall, sessions));
             else
@@ -315,15 +372,16 @@ async function buildMessageElement(message, iconMap, modelIcons, renderToolCall,
     if (message.text) {
         addCopyButton(el, () => toPlainText(message.text), message.createdAt);
     }
-    if (incoming && message.author) {
+    appendNote(el, message.note);
+    if (message.role === 'model') {
+        stampModelAvatarOn(el, left, message.model, modelIcons);
+    }
+    else if (left && message.author) {
         stampIncomingAvatar(el, message.author.profile);
     }
-    else if (message.role === 'user' && message.author) {
+    else if (message.author) {
         stampUserAvatar(el, message.author.profile);
     }
-    if (message.role === 'model') {
-        stampModelAvatar(el, message.model, modelIcons);
-    }
     return el;
 }
 // ---- Streaming ----
@@ -510,6 +568,8 @@ function createStreamRenderer(modelEl, messagesEl, renderToolCall, sessions) {
         },
     };
 }
+/** How long typing pauses before a reply is suggested. */
+const AUTOCOMPLETE_IDLE_MS = 600;
 function chatAuthorization(options) {
     return options.authorization ?? options.room?.room.getAuthorization();
 }
@@ -768,6 +828,18 @@ class ChatEngine {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "autocompleteTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autocompleteAsked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         this.sessions = new SessionPopout(refs.root, () => chatAuthorization(this.options));
         const locked = lockedModels(options.models);
         const start = options.model && (!locked || locked.includes(options.model)) ? options.model : Fauna.Parrot.Generative.Text.AUTO;
@@ -781,6 +853,7 @@ class ChatEngine {
                 this.roomTypingHandler?.();
                 for (const handler of this.inputWatchers)
                     handler(parts);
+                this.scheduleAutocomplete();
             },
             onSubmit: () => {
                 this.doSend(this.tokenizedInput.getText(), this.tokenizedInput.getParts(), this.runningParts.length > 0 ? [...this.runningParts] : undefined);
@@ -1042,11 +1115,13 @@ class ChatEngine {
     }
     // ── Send / Queue ──
     renderUserMessage(message) {
-        const incoming = isIncomingAuthor(message, chatMode(this.options.mode), this.options.room?.self.profile.email);
+        const incoming = placedLeft(message, chatMode(this.options.mode), this.options.room?.self.profile.email);
         const userEl = document.createElement('div');
         userEl.className = incoming ? 'chat-message-model' : 'chat-message-user';
         if (message.role === 'user' && message.author?.id)
             userEl.dataset.author = message.author.id;
+        if (message.side)
+            userEl.dataset.side = message.side;
         if (message.text) {
             const textEl = document.createElement('div');
             textEl.className = 'chat-message-text';
@@ -1296,12 +1371,69 @@ class ChatEngine {
             role: isUser ? 'user' : 'model',
             createdAt: message.created ? new Date(message.created) : new Date(),
             model: isUser ? undefined : message.model,
-            author: isUser && message.author?.email
-                ? { id: message.author.email, profile: message.author }
-                : undefined,
+            author: isUser ? uiAuthor(message.author, this.options.nameAddress) : undefined,
+            side: this.options.side?.(message),
+            note: this.options.note?.(message),
             ...roomPartsToChatFields(message.parts),
         };
     }
+    /** Reads every drawn message's `note` again, after what it depends on changed. */
+    refreshNotes() {
+        const room = this.options.room?.room;
+        const note = this.options.note;
+        if (!room || !note)
+            return;
+        for (const message of room.getMessages()) {
+            const el = this.paintedMessage(message.id);
+            if (!el)
+                continue;
+            const text = note(message);
+            const noteEl = el.querySelector(':scope > .chat-message-note');
+            if (!text)
+                noteEl?.remove();
+            else if (noteEl)
+                noteEl.textContent = text;
+            else
+                appendNote(el, text);
+        }
+    }
+    /** After a pause in typing, asks for the rest of the reply and shows it as ghost text. */
+    scheduleAutocomplete() {
+        if (!this.options.autocomplete)
+            return;
+        clearTimeout(this.autocompleteTimer);
+        const asked = ++this.autocompleteAsked;
+        this.autocompleteTimer = setTimeout(() => void this.runAutocomplete(asked), AUTOCOMPLETE_IDLE_MS);
+    }
+    async runAutocomplete(asked) {
+        const room = this.options.room?.room;
+        const authorization = chatAuthorization(this.options);
+        const chatId = room?.chatId;
+        if (!room || !chatId || !authorization || !('email' in authorization || 'balance' in authorization))
+            return;
+        const editor = this.tokenizedInput.getElement();
+        if (!editor.contains(document.activeElement) && document.activeElement !== editor)
+            return;
+        if (!this.tokenizedInput.atEnd())
+            return;
+        const newest = [...room.getMessages()].reverse().find((m) => !isSystemRoomMessage(m));
+        if (!newest || personOf(newest.author)?.email === this.options.room?.self.profile.email)
+            return;
+        const text = this.tokenizedInput.getText();
+        try {
+            const rest = await Fauna.Parrot.Chat.autocomplete(authorization, chatId, text, room.group);
+            if (asked !== this.autocompleteAsked || this.tokenizedInput.getText() !== text)
+                return;
+            this.tokenizedInput.setGhost(rest);
+        }
+        catch (err) {
+            console.error('[autocomplete]', err instanceof Error ? err.message : err);
+        }
+    }
+    /** Where a model turn sits while it streams in. */
+    modelSide() {
+        return this.options.side?.({ role: Fauna.Parrot.Generative.Role.MODEL }) ?? 'left';
+    }
     // Insert a rendered message element at the position matching its durable
     // `position` in the transcript, so members render in a consistent order
     // regardless of event-arrival timing (fixes interleaving on multi-member
@@ -1377,7 +1509,8 @@ class ChatEngine {
     // A reaction arrives as its own room message; it never paints a bubble.
     // It folds into a row of emoji under the message at its target position.
     applyReaction(message, reaction) {
-        const email = message.author?.email;
+        const person = personOf(message.author);
+        const email = person?.email;
         if (!email)
             return;
         let byEmoji = this.reactions.get(reaction.position);
@@ -1393,7 +1526,7 @@ class ChatEngine {
         const latest = byPerson.get(email);
         if (latest && latest.at > message.position)
             return;
-        const name = message.author?.displayName ?? email.split('@')[0];
+        const name = person?.displayName ?? email.split('@')[0];
         byPerson.set(email, { on: reaction.on, at: message.position, name });
         this.paintReactions(reaction.position);
     }
@@ -1677,7 +1810,8 @@ class ChatEngine {
                         streamedEl.dataset.messageId = message.id;
                     if (chat.model)
                         streamedEl.dataset.model = chat.model;
-                    stampModelAvatar(streamedEl, chat.model ?? this.currentModel, this.modelIcons);
+                    stampModelAvatarOn(streamedEl, chat.side ? chat.side === 'left' : true, chat.model ?? this.currentModel, this.modelIcons);
+                    appendNote(streamedEl, chat.note);
                     this.enableReactions(streamedEl, message.position);
                     this.history.push(chat);
                     autoScroll(this.refs.messagesEl);
@@ -1686,6 +1820,7 @@ class ChatEngine {
                 }
                 this.renderRoomMessage(chat, message.id, message.position);
                 this.options.room?.onRoomMessage?.(message);
+                this.scheduleAutocomplete();
             },
             onQueue: (r) => {
                 if (liveEnded || this.destroyed)
@@ -1725,10 +1860,11 @@ class ChatEngine {
                         this.roomThinkingEl.remove();
                         this.roomThinkingEl = null;
                     }
+                    const left = this.modelSide() === 'left';
                     const el = document.createElement('div');
-                    el.className = 'chat-message-model';
+                    el.className = left ? 'chat-message-model' : 'chat-message-user';
                     el.dataset.model = this.currentModel;
-                    stampModelAvatar(el, this.currentModel, this.modelIcons);
+                    stampModelAvatarOn(el, left, this.currentModel, this.modelIcons);
                     this.refs.messagesEl.appendChild(el);
                     gsap.from(el, { duration: 0.4, y: 40, opacity: 0, ease: 'power2.out' });
                     this.roomStream = { turn, el, renderer: createStreamRenderer(el, this.refs.messagesEl, this.options.renderToolCall, this.sessions) };
@@ -1890,7 +2026,7 @@ class ChatEngine {
             return;
         if (thinking && !this.roomThinkingEl) {
             this.roomThinkingEl = document.createElement('div');
-            this.roomThinkingEl.className = 'chat-message-model';
+            this.roomThinkingEl.className = this.modelSide() === 'left' ? 'chat-message-model' : 'chat-message-user';
             this.roomThinkingEl.appendChild(buildThinkingIndicator());
             this.refs.messagesEl.appendChild(this.roomThinkingEl);
             gsap.from(this.roomThinkingEl, { duration: 0.4, y: 40, opacity: 0, ease: 'power2.out' });
@@ -2111,7 +2247,7 @@ class ChatEngine {
             return;
         this.options.mode = mode;
         const selfEmail = this.options.room?.self.profile.email;
-        for (const el of this.refs.messagesEl.querySelectorAll('[data-author]')) {
+        for (const el of this.refs.messagesEl.querySelectorAll('[data-author]:not([data-side])')) {
             const email = el.dataset.author;
             const incoming = mode === 'thread' && Boolean(email && selfEmail && email !== selfEmail);
             const profile = this.history.find((m) => m.author?.id === email)?.author?.profile;
@@ -2246,6 +2382,7 @@ export const Chat = forwardRef(function Chat({ options = {} }, ref) {
         setReasoning: (reasoning) => engineRef.current?.setReasoning(reasoning),
         setMode: (mode) => engineRef.current?.setMode(mode),
         setModels: (models) => engineRef.current?.setModels(models),
+        refreshNotes: () => engineRef.current?.refreshNotes(),
         insertToken: (token) => engineRef.current?.insertToken(token),
         getParts: () => engineRef.current?.getParts() ?? [],
         watchInput: (handler) => engineRef.current?.watchInput(handler) ?? (() => { }),
@@ -2299,6 +2436,7 @@ export function createChat(container, options = {}) {
         setReasoning: (reasoning) => get()?.setReasoning(reasoning),
         setMode: (mode) => get()?.setMode(mode),
         setModels: (models) => get()?.setModels(models),
+        refreshNotes: () => get()?.refreshNotes(),
         insertToken: (token) => get()?.insertToken(token),
         getParts: () => get()?.getParts() ?? [],
         watchInput: (handler) => get()?.watchInput(handler) ?? (() => { }),

package/dist/src/ui/chatSequence.d.ts

@@ -23,6 +23,9 @@ export type ChatFile = {
 export type ChatMessageBlock = {
     type: 'text';
     text: string;
+} | {
+    type: 'html';
+    html: string;
 } | {
     type: 'tool';
     call: ChatSequenceToolCall;

package/dist/src/ui/chatSequence.js

@@ -19,6 +19,9 @@ export function roomPartsToChatFields(parts) {
             if (part.text.trim())
                 sequence.push({ type: 'text', text: part.text });
         }
+        else if (part?.type === 'HTML' && typeof part.html === 'string') {
+            sequence.push({ type: 'html', html: part.html });
+        }
         else if (part?.type === 'FILE') {
             const file = { mime: part.contentType ?? '', name: part.name ?? part.ref ?? 'file', part };
             files.push(file);

package/dist/src/ui/tokenized.d.ts

@@ -30,6 +30,11 @@ export declare function createTokenizedInput(container: HTMLElement, options?: P
     focus: () => void;
     getElement: () => HTMLElement;
     setPlaceholder: (text: string) => void;
+    /** Show a suggested ending after the caret: Tab takes it, Shift+Tab or Escape drops it,
+     *  and typing clears it. Empty clears it. */
+    setGhost: (text: string) => void;
+    /** Whether the caret sits at the very end. */
+    atEnd: () => boolean;
 };
 /**
  * `@` mentions. By default it searches every Fauna user; pass `people` (a