@adecore/agents-react 0.39.0 → 0.40.0

package/src/chat/attachments.ts

@@ -29,10 +29,13 @@ export function isImageAttachment(mime: string): boolean {
 /* The type on a file card: the extension, as long as it is short enough to read as one. */
 export function fileBadge(name: string): string | null {
     const dot = name.lastIndexOf('.');
+
     if (dot <= 0 || dot === name.length - 1) {
         return null;
     }
+
     const extension = name.slice(dot + 1);
+
     return extension.length <= 5 ? extension.toUpperCase() : null;
 }
 
@@ -46,6 +49,7 @@ export function checkAttachmentLimits<T extends IncomingFile>(current: number, i
     const accepted: T[] = [];
     const rejected: Array<{ name: string; reason: string }> = [];
     let bytes = currentBytes;
+
     for (const file of incoming) {
         if (file.bytes === 0) {
             rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.empty') });
@@ -63,6 +67,7 @@ export function checkAttachmentLimits<T extends IncomingFile>(current: number, i
             bytes += file.bytes;
         }
     }
+
     return { accepted, rejected };
 }
 
@@ -75,10 +80,12 @@ function readAsBase64(file: File): Promise<string> {
     return new Promise((resolve, reject) => {
         const reader = new FileReader();
         reader.onerror = () => reject(reader.error ?? new Error(i18next.t('agent-chat:attachments.unreadable', { name: file.name })));
+
         reader.onload = () => {
             const url = String(reader.result);
             resolve(url.slice(url.indexOf(',') + 1));
         };
+
         reader.readAsDataURL(file);
     });
 }
@@ -104,6 +111,7 @@ export async function readStoredAttachments(
     stored: readonly ChatAttachment[]
 ): Promise<ChatAttachmentUpload[]> {
     const files = await Promise.all(stored.map(async (attachment) => new File([await read(attachment)], attachment.name, { type: attachment.mime })));
+
     return readAttachments(files);
 }
 

package/src/chat/bookmarks.ts

@@ -3,6 +3,7 @@ import { create } from 'zustand';
 import type { ChatBookmark } from '@adecore/agent-contracts';
 import type { ChatHost } from '../host';
 import type { ChatScope } from '../scope';
+import { errorMessage } from '../transport';
 import { jumpToTimelineItem } from './timeline-scroll';
 
 /* The one message in the window whose bookmark has its name field open, by the scope's key of its chat. */
@@ -23,15 +24,17 @@ export const useBookmarkNaming = create<BookmarkNaming>((set) => ({
 type Notifier = Pick<ChatHost, 'notify'>;
 
 function failed(host: Notifier, title: string, e: unknown): void {
-    host.notify({ title, description: e instanceof Error ? e.message : String(e), kind: 'error' });
+    host.notify({ title, description: errorMessage(e), kind: 'error' });
 }
 
 async function add(scope: ChatScope, host: Notifier, chatId: string, itemId: string, name?: string): Promise<boolean> {
     try {
         await scope.chats.addBookmark(chatId, itemId, name);
+
         return true;
     } catch (e) {
         failed(host, i18next.t('agent-chat:bookmarks.addFailed'), e);
+
         return false;
     }
 }
@@ -39,6 +42,7 @@ async function add(scope: ChatScope, host: Notifier, chatId: string, itemId: str
 /* Marks a message and opens the field for its name at once, before the host answered. */
 export async function placeBookmark(scope: ChatScope, host: Notifier, chatId: string, itemId: string): Promise<void> {
     useBookmarkNaming.getState().open(scope.keyOf(chatId), itemId);
+
     if (!(await add(scope, host, chatId, itemId))) {
         useBookmarkNaming.getState().close();
     }
@@ -57,13 +61,17 @@ export async function nameBookmark(
     previous: string | undefined
 ): Promise<void> {
     const next = name.trim();
+
     if (next === (previous ?? '')) {
         return;
     }
+
     if (next !== '') {
         await add(scope, host, chatId, itemId, next);
+
         return;
     }
+
     try {
         await scope.chats.renameBookmark(chatId, itemId, '');
     } catch (e) {
@@ -77,8 +85,10 @@ export async function removeBookmark(scope: ChatScope, host: Notifier, chatId: s
         await scope.chats.removeBookmark(chatId, bookmark.itemId);
     } catch (e) {
         failed(host, i18next.t('agent-chat:bookmarks.removeFailed'), e);
+
         return;
     }
+
     host.notify({
         title: i18next.t('agent-chat:bookmarks.removed'),
         kind: 'deleted',
@@ -89,8 +99,10 @@ export async function removeBookmark(scope: ChatScope, host: Notifier, chatId: s
 /* Scrolls the chat's thread to the message, and opens its name field for a rename. False when no thread of it is on screen yet. */
 export function goToBookmark(scope: ChatScope, chatId: string, itemId: string, rename = false): boolean {
     const key = scope.keyOf(chatId);
+
     if (rename) {
         useBookmarkNaming.getState().open(key, itemId);
     }
+
     return jumpToTimelineItem(key, itemId);
 }

package/src/chat/chat-client.ts

@@ -78,10 +78,12 @@ export class ChatClient {
         this.transport = transport;
         this.sink = sink;
         this.providers = providers;
+
         this.unsubscribe.push(
             transport.on('chat.event', ({ chatId, event, seq }) => {
                 const previous = this.sequence(chatId);
                 this.sink.apply(chatId, event);
+
                 if (previous !== undefined || (!this.sink.historyIdentity && this.mounted.get(chatId)?.attached)) {
                     this.rememberSequence(chatId, seq);
                 }
@@ -92,6 +94,7 @@ export class ChatClient {
             transport.on('chat.visuals', ({ chatId, visuals }) => this.sink.visuals(chatId, visuals)),
             transport.subscribeStatus((status) => this.onStatus(status))
         );
+
         if (transport.status === 'open') {
             void this.loadProviders();
             void this.loadStatuses();
@@ -100,39 +103,52 @@ export class ChatClient {
 
     inspect(chatId: string): Promise<ChatAttachResult> {
         const pending = this.inspections.get(chatId);
+
         if (pending) {
             return pending;
         }
+
         const read = this.transport.request('chat.attach', { chatId, historyLimit: 100 }).finally(async () => {
             this.inspections.delete(chatId);
+
             // A visible chat owns its attachment; an inspection must never release it.
             if (!this.mounted.get(chatId)) {
                 await this.transport.request('chat.detach', { chatId }).catch(() => undefined);
             }
         });
+
         this.inspections.set(chatId, read);
+
         return read;
     }
 
     /* Shares a live attachment without creating a chat; a visible composer and several ancestors may hold it together. */
     observe(chatId: string): () => void {
         this.observers.set(chatId, (this.observers.get(chatId) ?? 0) + 1);
+
         if (!this.mounted.has(chatId)) {
             this.mounted.set(chatId, { attached: false, observerOnly: true });
             void this.attach(chatId).catch(() => undefined);
         }
+
         let released = false;
+
         return () => {
             if (released) {
                 return;
             }
+
             released = true;
             const remaining = (this.observers.get(chatId) ?? 1) - 1;
+
             if (remaining > 0) {
                 this.observers.set(chatId, remaining);
+
                 return;
             }
+
             this.observers.delete(chatId);
+
             if (this.mounted.get(chatId)?.observerOnly) {
                 void this.detach(chatId);
             }
@@ -142,13 +158,16 @@ export class ChatClient {
     /* Answers false when the transport is not connected; the chat opens once it is. */
     async open(chatId: string, options: ChatOpenOptions): Promise<boolean> {
         this.mounted.set(chatId, { ...options, attached: false });
+
         try {
             await this.attach(chatId);
+
             return true;
         } catch (e) {
             if (isConnectionError(e)) {
                 return false;
             }
+
             throw e;
         }
     }
@@ -160,19 +179,23 @@ export class ChatClient {
      */
     async retarget(chatId: string, provider: AgentKind, selection: ModelSelection): Promise<void> {
         const entry = this.mounted.get(chatId);
+
         if (!entry) {
             return;
         }
+
         // The account belonged to the CLI the chat leaves, and the seq to its stream: the new chat's
         // stream starts over, so offering it the old seq would read as nothing missed and reset nothing.
         const { attached: _attached, account: _account, seq: _seq, observerOnly: _observerOnly, ...options } = entry;
         this.rememberSequence(chatId, undefined);
         this.mounted.delete(chatId);
         await this.transport.request('chat.kill', { chatId });
+
         try {
             await this.open(chatId, { ...options, provider, selection });
         } catch (e) {
             this.sink.forget(chatId);
+
             throw e;
         }
     }
@@ -188,14 +211,19 @@ export class ChatClient {
 
     async detach(chatId: string): Promise<void> {
         const entry = this.mounted.get(chatId);
+
         if (entry && this.observers.has(chatId)) {
             entry.observerOnly = true;
+
             return;
         }
+
         this.mounted.delete(chatId);
+
         if (!entry?.attached) {
             return;
         }
+
         try {
             await this.transport.request('chat.detach', { chatId });
         } catch {
@@ -221,29 +249,34 @@ export class ChatClient {
     /* Marks a message; the list every client of the chat holds comes back as `chat.bookmarks`. */
     async addBookmark(chatId: string, itemId: string, name?: string): Promise<ChatBookmark[]> {
         const { bookmarks } = await this.transport.request('chat.addBookmark', { chatId, itemId, ...(name === undefined ? {} : { name }) });
+
         return bookmarks;
     }
 
     /* An empty name takes the name away. */
     async renameBookmark(chatId: string, itemId: string, name: string): Promise<ChatBookmark[]> {
         const { bookmarks } = await this.transport.request('chat.renameBookmark', { chatId, itemId, name });
+
         return bookmarks;
     }
 
     async removeBookmark(chatId: string, itemId: string): Promise<ChatBookmark[]> {
         const { bookmarks } = await this.transport.request('chat.removeBookmark', { chatId, itemId });
+
         return bookmarks;
     }
 
     /* Takes a visual and its page out of the chat for good; the list every client of the chat holds comes back as `chat.visuals`. */
     async removeVisual(chatId: string, visualId: string): Promise<ChatVisual[]> {
         const { visuals } = await this.transport.request('chat.removeVisual', { chatId, visualId });
+
         return visuals;
     }
 
     /* What this chat's CLI would run as a skill, for the composer's `$` picker. */
     async listSkills(chatId: string): Promise<ChatSkill[]> {
         const { skills } = await this.transport.request('skills.list', { chatId });
+
         return skills;
     }
 
@@ -273,6 +306,7 @@ export class ChatClient {
     async loadStatuses(): Promise<void> {
         try {
             const { chats } = await this.transport.request('chat.list', {});
+
             for (const info of chats) {
                 this.sink.status(info.chatId, info);
             }
@@ -285,6 +319,7 @@ export class ChatClient {
         if (!this.providers) {
             return;
         }
+
         try {
             const { providers } = await this.transport.request('provider.list', {});
             this.providers.setProviders(providers);
@@ -299,9 +334,11 @@ export class ChatClient {
      */
     loadEarlier(chatId: string, cursor: string): Promise<void> {
         const running = this.earlier.get(chatId);
+
         if (running) {
             return running;
         }
+
         const read = this.transport
             .request('chat.history', { chatId, cursor, limit: HISTORY_PAGE })
             .then((page) => {
@@ -311,14 +348,18 @@ export class ChatClient {
             })
             .catch(async (e: unknown) => {
                 const entry = this.mounted.get(chatId);
+
                 if (errorCode(e) !== 'history-expired' || !entry) {
                     throw e;
                 }
+
                 this.rememberSequence(chatId, undefined);
                 await this.attach(chatId);
             })
             .finally(() => this.earlier.delete(chatId));
+
         this.earlier.set(chatId, read);
+
         return read;
     }
 
@@ -331,9 +372,11 @@ export class ChatClient {
         for (const off of this.unsubscribe) {
             off();
         }
+
         this.unsubscribe.length = 0;
         this.observers.clear();
         this.checkpoints = new WeakMap();
+
         for (const chatId of [...this.mounted.keys()]) {
             void this.detach(chatId);
         }
@@ -346,9 +389,11 @@ export class ChatClient {
      */
     private async attach(chatId: string): Promise<void> {
         const entry = this.mounted.get(chatId);
+
         if (!entry) {
             return;
         }
+
         if (!entry.observerOnly) {
             await this.transport.request('chat.create', {
                 chatId,
@@ -360,26 +405,34 @@ export class ChatClient {
                 runtimeMode: entry.runtimeMode
             });
         }
+
         // Closed or opened again in the meantime: an opening that is still there attaches itself.
         if (this.mounted.get(chatId) !== entry) {
             return;
         }
+
         const since = this.sequence(chatId);
         const result = await this.transport.request('chat.attach', { chatId, historyLimit: HISTORY_PAGE, ...(since === undefined ? {} : { since }) });
         const current = this.mounted.get(chatId);
+
         if (current !== entry) {
             // Its detach found nothing attached yet, and the host would stream this chat here until the socket closes.
             if (!current) {
                 await this.transport.request('chat.detach', { chatId }).catch(() => undefined);
             }
+
             return;
         }
+
         // A cache eviction while the request was in flight also invalidates its replay base.
         if (result.events && since !== undefined && this.sequence(chatId) === undefined) {
             await this.attach(chatId);
+
             return;
         }
+
         entry.attached = true;
+
         if (result.events && since !== undefined) {
             if (this.sink.replay) {
                 this.sink.replay(chatId, result.events);
@@ -391,8 +444,10 @@ export class ChatClient {
         } else {
             const page =
                 result.history === undefined ? undefined : { history: result.history, pending: result.pending ?? [], subagents: result.subagents ?? [] };
+
             this.sink.reset(chatId, result.info, result.items, page);
         }
+
         this.rememberSequence(chatId, result.seq);
         // A host without bookmarks or visuals sends none, and then this chat has none.
         this.sink.bookmarks(chatId, result.bookmarks ?? []);
@@ -403,16 +458,21 @@ export class ChatClient {
         if (!this.sink.historyIdentity) {
             return this.mounted.get(chatId)?.seq;
         }
+
         const identity = this.sink.historyIdentity(chatId);
+
         return identity === undefined ? undefined : this.checkpoints.get(identity);
     }
 
     private rememberSequence(chatId: string, seq: number | undefined): void {
         const entry = this.mounted.get(chatId);
+
         if (entry) {
             entry.seq = seq;
         }
+
         const identity = this.sink.historyIdentity?.(chatId);
+
         if (identity !== undefined) {
             if (seq === undefined) {
                 this.checkpoints.delete(identity);
@@ -426,6 +486,7 @@ export class ChatClient {
         if (this.preferences === null) {
             return;
         }
+
         void this.transport.request('chat.setPreferences', this.preferences).catch(() => undefined);
     }
 
@@ -435,8 +496,10 @@ export class ChatClient {
             void this.loadProviders();
             void this.loadStatuses();
             void this.mounted.reattachAll((chatId) => this.attach(chatId));
+
             return;
         }
+
         this.mounted.detachAll();
     }
 }

package/src/chat/chat-references.ts

@@ -38,6 +38,7 @@ export function referablesOfChats(chats: readonly ProjectChat[]): Referables {
 export function referenceTokens(ids: readonly string[], items: readonly Referable[], spelled: Readonly<Record<string, string>> = {}): ReferenceToken[] {
     return [...new Set(ids)].flatMap((id) => {
         const name = spelled[id] ?? items.find((item) => item.id === id)?.name;
+
         return name === undefined || name === '' ? [] : [{ id, name }];
     });
 }
@@ -45,8 +46,10 @@ export function referenceTokens(ids: readonly string[], items: readonly Referabl
 /* What a `#query` offers, the canvas first: never an id in `exclude`, and only chats where the machine takes no more. */
 export function referenceSuggestions(referables: Referables, query: string, exclude: readonly string[], limit: number): Referable[] {
     const needle = query.toLowerCase();
+
     const matches = referables.items.filter(
         (item) => item.name !== '' && (!referables.chatsOnly || item.kind === 'chat') && !exclude.includes(item.id) && item.name.toLowerCase().includes(needle)
     );
+
     return [...matches.filter((item) => item.group === 'canvas'), ...matches.filter((item) => item.group === 'views')].slice(0, limit);
 }

package/src/chat/composer-effort.ts

@@ -11,8 +11,10 @@ const steppers = new Map<string, Stepper[]>();
 
 export function registerEffortStepper(key: string, stepper: Stepper): () => void {
     steppers.set(key, [...(steppers.get(key) ?? []), stepper]);
+
     return () => {
         const left = (steppers.get(key) ?? []).filter((entry) => entry !== stepper);
+
         if (left.length > 0) {
             steppers.set(key, left);
         } else {
@@ -24,9 +26,12 @@ export function registerEffortStepper(key: string, stepper: Stepper): () => void
 /* False when that chat has no composer on screen. At either end of the model's efforts the composer says so and nothing changes. */
 export function stepEffortFromComposer(key: string, step: EffortStep): boolean {
     const stepper = steppers.get(key)?.at(-1);
+
     if (stepper === undefined) {
         return false;
     }
+
     stepper(step);
+
     return true;
 }

package/src/chat/composer-send.ts

@@ -9,6 +9,7 @@ const senders = new Map<string, (how: ComposerSend) => void>();
 
 export function registerComposerSender(key: string, send: (how: ComposerSend) => void): () => void {
     senders.set(key, send);
+
     return () => {
         if (senders.get(key) === send) {
             senders.delete(key);
@@ -19,9 +20,12 @@ export function registerComposerSender(key: string, send: (how: ComposerSend) =>
 /* False when that chat has no composer on screen. An empty or unsendable draft sends nothing, as with the keys. */
 export function sendFromComposer(key: string, how: ComposerSend = 'default'): boolean {
     const send = senders.get(key);
+
     if (send === undefined) {
         return false;
     }
+
     send(how);
+
     return true;
 }

package/src/chat/drafts.ts

@@ -57,21 +57,20 @@ export const useDrafts = createChatStore<{ ids: string[] }>(
     (store) => store.setState({ ids: Object.keys(storage.read()) })
 );
 
-export function useHasDraft(chatId: string): boolean {
-    return useDrafts((s) => s.ids.includes(chatId));
-}
-
 function trackDraft(chatId: string, held: boolean): void {
     const { ids } = useDrafts.getState();
+
     if (ids.includes(chatId) === held) {
         return;
     }
+
     useDrafts.setState({ ids: held ? [...ids, chatId] : ids.filter((id) => id !== chatId) });
 }
 
 /* An unsent prompt per chat node, kept across reloads so a half-written message is never lost. */
 export function readDraft(chatId: string): ChatDraft {
     const record = storage.read()[chatId];
+
     return record
         ? {
               text: record.text,
@@ -90,37 +89,37 @@ export function readDraft(chatId: string): ChatDraft {
 export function writeDraft(chatId: string, draft: ChatDraft): void {
     const drafts = storage.read();
     trackDraft(chatId, !isEmptyDraft(draft));
+
     if (isEmptyDraft(draft)) {
         delete drafts[chatId];
         storage.write(drafts);
+
         return;
     }
-    drafts[chatId] = {
-        text: draft.text,
-        mentions: draft.mentions,
-        skills: draft.skills,
-        chats: draft.chats,
-        attachments: draft.attachments,
-        quote: draft.quote,
-        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource }),
-        references: draft.references,
-        ...namesOf(draft)
-    };
+
+    drafts[chatId] = recordOf(draft, true);
+
     if (storage.write(drafts)) {
         return;
     }
+
     // A file can outgrow the storage quota; the text is the part worth keeping then.
-    drafts[chatId] = {
+    drafts[chatId] = recordOf(draft, false);
+    storage.write(drafts);
+}
+
+function recordOf(draft: ChatDraft, withFiles: boolean): DraftRecord {
+    return {
         text: draft.text,
         mentions: draft.mentions,
         skills: draft.skills,
         chats: draft.chats,
+        ...(withFiles ? { attachments: draft.attachments } : {}),
         quote: draft.quote,
         ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource }),
         references: draft.references,
         ...namesOf(draft)
     };
-    storage.write(drafts);
 }
 
 function namesOf(draft: ChatDraft): Pick<DraftRecord, 'referenceNames'> {
@@ -150,6 +149,7 @@ export function takeBackIntoDraft(
         taken.attachments.map((upload) => ({ name: upload.name, mime: upload.mime, bytes: uploadBytes(upload), upload })),
         current.attachments.reduce((bytes, upload) => bytes + uploadBytes(upload), 0)
     );
+
     return {
         draft: {
             text: current.text.trim() === '' ? taken.text : joinDraftText(taken.text, current.text),
@@ -173,6 +173,7 @@ const takers = new Map<string, DraftTaker>();
 
 export function takeDraftOffers(chatId: string, take: DraftTaker): () => void {
     takers.set(chatId, take);
+
     return () => {
         if (takers.get(chatId) === take) {
             takers.delete(chatId);
@@ -186,10 +187,13 @@ export function takeDraftOffers(chatId: string, take: DraftTaker): () => void {
  */
 export function offerDraft(chatId: string, text: string): void {
     const take = takers.get(chatId);
+
     if (take) {
         take(text);
+
         return;
     }
+
     const current = readDraft(chatId);
     writeDraft(chatId, { ...current, text: joinDraftText(current.text, text) });
 }

package/src/chat/forks.ts

@@ -23,11 +23,13 @@ function joinedForks(
 ): (state: { statusByKey: ChatStatuses }) => string {
     let statuses: ChatStatuses | null = null;
     let joined = '';
+
     return (state) => {
         if (state.statusByKey !== statuses) {
             statuses = state.statusByKey;
             joined = [...collect(forkInfosOn(statuses, owns))].join('\n');
         }
+
         return joined;
     };
 }
@@ -41,6 +43,7 @@ export function useForkedTurns(chatId: string): ReadonlySet<string> {
     const { owns } = useChatScope();
     const select = joinedForks(owns, (infos) => forkedTurnIds(infos, chatId));
     const joined = useChats(select);
+
     return new Set(splitIds(joined));
 }
 
@@ -49,5 +52,6 @@ export function useForkIdsAfter(chatId: string, turnId: string): string[] {
     const { owns } = useChatScope();
     const select = joinedForks(owns, (infos) => forkIdsAfter(infos, chatId, turnId));
     const joined = useChats(select);
+
     return splitIds(joined);
 }

package/src/chat/guards.ts

@@ -23,9 +23,11 @@ export function pasteBecomesAttachment(text: string): boolean {
 export function pastedTextName(taken: string[]): string {
     const names = new Set(taken);
     let index = 1;
+
     while (names.has(`paste-${index}.txt`)) {
         index += 1;
     }
+
     return `paste-${index}.txt`;
 }