@adecore/agents-react 0.23.0 → 0.24.0

package/src/agents/AccountDot.tsx

@@ -1,9 +1,11 @@
 import clsx from 'clsx';
+import { useChatHost } from '../host';
 import { accountColor } from './accounts';
 
 /* The color an account wears, or the app's accent while it wears none of the accents. */
 export function AccountDot({ color, className }: { color: string | undefined; className?: string }) {
-    const paint = accountColor(color);
+    const { accents } = useChatHost();
+    const paint = accountColor(color, accents.all);
     return (
         <span
             aria-hidden

package/src/agents/accounts.ts

@@ -1,13 +1,13 @@
 import i18next from 'i18next';
 import type { AgentKind, ProviderAccount, ProviderAccounts, ProviderAccountStatus } from '@adecore/agent-contracts';
-import { chatHost } from '../host';
+import type { AccentChoice, ChatHost } from '../host';
 
 /*
  * An account wears one of the host's accents, so the app paints from one palette. A color that is none
  * of them (an older name, or one written by hand) reads as undefined, and the dot takes the accent.
  */
-export function accountColor(color: string | undefined): string | undefined {
-    return chatHost().accents.all.find((entry) => entry.id === color)?.color;
+export function accountColor(color: string | undefined, accents: readonly AccentChoice[]): string | undefined {
+    return accents.find((entry) => entry.id === color)?.color;
 }
 
 /*
@@ -102,9 +102,9 @@ export function mintAccountId(kind: AgentKind, label: string, taken: ReadonlySet
  * The first featured accent no account of the CLI wears yet, then any other, so a new one stands apart.
  * An account without a color of its own wears `fallback`, the accent the app is painted in.
  */
-export function freeAccountColor(entries: readonly AccountEntry[], fallback: string): string {
-    const { all, featured } = chatHost().accents;
-    const worn = new Set(entries.map((entry) => (accountColor(entry.account.color) === undefined ? fallback : entry.account.color)));
+export function freeAccountColor(entries: readonly AccountEntry[], accents: ChatHost['accents'], fallback: string): string {
+    const { all, featured } = accents;
+    const worn = new Set(entries.map((entry) => (accountColor(entry.account.color, all) === undefined ? fallback : entry.account.color)));
     const choices = [...featured, ...all.map((entry) => entry.id).filter((id) => !featured.includes(id))];
     return choices.find((id) => !worn.has(id)) ?? featured[entries.length % featured.length] ?? fallback;
 }

package/src/chat/actions.ts

@@ -1,5 +1,5 @@
 import i18next from 'i18next';
-import { chatHost, type ChatActions } from '../host';
+import { useChatHost, type ChatActions, type ChatHost } from '../host';
 import { useChatScope, type ChatScope } from '../scope';
 import { ChatTransportError, type ChatTransport } from '../transport';
 
@@ -38,6 +38,9 @@ export function transportActions(transport: ChatTransport): ChatActions {
         stopTask: async (chatId, taskId) => {
             await transport.request('chat.stopTask', { chatId, taskId });
         },
+        goal: async (chatId, action) => {
+            await transport.request('chat.goal', { chatId, action });
+        },
         approve: async (chatId, requestId, decision, message) => {
             await transport.request('chat.approve', { chatId, requestId, decision, ...(message === undefined ? {} : { message }) });
         },
@@ -52,9 +55,9 @@ export function transportActions(transport: ChatTransport): ChatActions {
 
 const byTransport = new WeakMap<ChatTransport, ChatActions>();
 
-/* The app's own actions when it has them, and the requests of this scope's host otherwise. */
-export function actionsOf(scope: ChatScope): ChatActions {
-    const own = chatHost().actions;
+/* The app's own actions when its host has them, and the requests of this scope's host of chats otherwise. */
+export function actionsOf(scope: ChatScope, host: Pick<ChatHost, 'actions'>): ChatActions {
+    const own = host.actions;
     if (own !== null) {
         return own;
     }
@@ -68,5 +71,5 @@ export function actionsOf(scope: ChatScope): ChatActions {
 }
 
 export function useChatActions(): ChatActions {
-    return actionsOf(useChatScope());
+    return actionsOf(useChatScope(), useChatHost());
 }

package/src/chat/bookmarks.ts

@@ -1,7 +1,7 @@
 import i18next from 'i18next';
 import { create } from 'zustand';
 import type { ChatBookmark } from '@adecore/agent-contracts';
-import { chatHost } from '../host';
+import type { ChatHost } from '../host';
 import type { ChatScope } from '../scope';
 import { jumpToTimelineItem } from './timeline-scroll';
 
@@ -20,24 +20,26 @@ export const useBookmarkNaming = create<BookmarkNaming>((set) => ({
     close: () => set({ chatKey: null, itemId: null })
 }));
 
-function failed(title: string, e: unknown): void {
-    chatHost().notify({ title, description: e instanceof Error ? e.message : String(e), kind: 'error' });
+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' });
 }
 
-async function add(scope: ChatScope, chatId: string, itemId: string, name?: string): Promise<boolean> {
+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(i18next.t('agent-chat:bookmarks.addFailed'), e);
+        failed(host, i18next.t('agent-chat:bookmarks.addFailed'), e);
         return false;
     }
 }
 
 /* Marks a message and opens the field for its name at once, before the host answered. */
-export async function placeBookmark(scope: ChatScope, chatId: string, itemId: string): Promise<void> {
+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, chatId, itemId))) {
+    if (!(await add(scope, host, chatId, itemId))) {
         useBookmarkNaming.getState().close();
     }
 }
@@ -46,34 +48,41 @@ export async function placeBookmark(scope: ChatScope, chatId: string, itemId: st
  * The name a field settles on. A name goes through `addBookmark`, which also names a bookmark that
  * already stands, so a name typed before the mark itself landed is not refused.
  */
-export async function nameBookmark(scope: ChatScope, chatId: string, itemId: string, name: string, previous: string | undefined): Promise<void> {
+export async function nameBookmark(
+    scope: ChatScope,
+    host: Notifier,
+    chatId: string,
+    itemId: string,
+    name: string,
+    previous: string | undefined
+): Promise<void> {
     const next = name.trim();
     if (next === (previous ?? '')) {
         return;
     }
     if (next !== '') {
-        await add(scope, chatId, itemId, next);
+        await add(scope, host, chatId, itemId, next);
         return;
     }
     try {
         await scope.chats.renameBookmark(chatId, itemId, '');
     } catch (e) {
-        failed(i18next.t('agent-chat:bookmarks.renameFailed'), e);
+        failed(host, i18next.t('agent-chat:bookmarks.renameFailed'), e);
     }
 }
 
 /* Takes a bookmark away at once; the toast puts it back, name and all. */
-export async function removeBookmark(scope: ChatScope, chatId: string, bookmark: ChatBookmark): Promise<void> {
+export async function removeBookmark(scope: ChatScope, host: Notifier, chatId: string, bookmark: ChatBookmark): Promise<void> {
     try {
         await scope.chats.removeBookmark(chatId, bookmark.itemId);
     } catch (e) {
-        failed(i18next.t('agent-chat:bookmarks.removeFailed'), e);
+        failed(host, i18next.t('agent-chat:bookmarks.removeFailed'), e);
         return;
     }
-    chatHost().notify({
+    host.notify({
         title: i18next.t('agent-chat:bookmarks.removed'),
         kind: 'deleted',
-        action: { label: i18next.t('agent-chat:common.action.undo'), run: () => void add(scope, chatId, bookmark.itemId, bookmark.name) }
+        action: { label: i18next.t('agent-chat:common.action.undo'), run: () => void add(scope, host, chatId, bookmark.itemId, bookmark.name) }
     });
 }
 

package/src/chat/chat-client.ts

@@ -216,6 +216,14 @@ export class ChatClient {
         await this.transport.request('chat.clear', { chatId, ...(force ? { force: true } : {}) });
     }
 
+    /*
+     * Ends the chat's CLI and keeps its conversation, which the next message resumes in a fresh process
+     * that reads its skills, plugins and servers again; refused with `chat-busy` while the chat works.
+     */
+    async restart(chatId: string): Promise<void> {
+        await this.transport.request('chat.restart', { chatId });
+    }
+
     async kill(chatId: string): Promise<void> {
         this.mounted.delete(chatId);
         this.sink.forget(chatId);

package/src/chat/composer-send.ts

@@ -0,0 +1,27 @@
+/* `alternate` sends with the delivery a running turn does not get by default; `and-new` also opens a new chat once it went. */
+export type ComposerSend = 'default' | 'alternate' | 'and-new';
+
+/*
+ * A command outside the composer, such as a menu row, sends what a composer on screen holds the way its
+ * keys do. Keyed with the scope's `keyOf`, the way the app's shortcuts name the chat that has the focus.
+ */
+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);
+        }
+    };
+}
+
+/* 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/forks.ts

@@ -2,18 +2,37 @@ import { useMemo } from 'react';
 import type { ChatInfo } from '@adecore/agent-contracts';
 import { forkIdsAfter, forkedTurnIds } from './logic/fork';
 import { useChatScope } from '../scope';
-import { useChats, type ChatsById } from '../state/chats';
+import { useChats, type ChatStatuses } from '../state/chats';
 
 /* The chats this client holds of one host, which is where the forks it knows of are. */
-function* forkInfosOn(byKey: ChatsById, owns: (key: string) => boolean): Generator<ChatInfo> {
-    for (const [key, state] of Object.entries(byKey)) {
+function* forkInfosOn(statuses: ChatStatuses, owns: (key: string) => boolean): Generator<ChatInfo> {
+    for (const [key, state] of Object.entries(statuses)) {
         if (state.info.forkOf !== undefined && owns(key)) {
             yield state.info;
         }
     }
 }
 
-/* Selectors answer a joined string, never a new array or set, and split it again in a memo. */
+/*
+ * Selectors answer a joined string, never a new array or set, and split it again in a memo. One runs on
+ * every write to the store, a streamed word included, so it walks the chats again only once the
+ * statuses, which change with an info alone, are others.
+ */
+function joinedForks(
+    owns: (key: string) => boolean,
+    collect: (infos: Iterable<ChatInfo>) => Iterable<string>
+): (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;
+    };
+}
+
 function splitIds(joined: string): string[] {
     return joined === '' ? [] : joined.split('\n');
 }
@@ -21,13 +40,15 @@ function splitIds(joined: string): string[] {
 /* The turns of this chat a fork went on after, for the thread to put a line under. */
 export function useForkedTurns(chatId: string): ReadonlySet<string> {
     const { owns } = useChatScope();
-    const joined = useChats((s) => [...forkedTurnIds(forkInfosOn(s.byKey, owns), chatId)].join('\n'));
+    const select = useMemo(() => joinedForks(owns, (infos) => forkedTurnIds(infos, chatId)), [owns, chatId]);
+    const joined = useChats(select);
     return useMemo(() => new Set(splitIds(joined)), [joined]);
 }
 
 /* The forks that went on after this turn of this chat. */
 export function useForkIdsAfter(chatId: string, turnId: string): string[] {
     const { owns } = useChatScope();
-    const joined = useChats((s) => forkIdsAfter(forkInfosOn(s.byKey, owns), chatId, turnId).join('\n'));
+    const select = useMemo(() => joinedForks(owns, (infos) => forkIdsAfter(infos, chatId, turnId)), [owns, chatId, turnId]);
+    const joined = useChats(select);
     return useMemo(() => splitIds(joined), [joined]);
 }

package/src/chat/index.ts

@@ -0,0 +1,98 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { type AccountChoice, useAccountChoice } from './account-choice';
+export { transportActions, actionsOf, useChatActions } from './actions';
+export { backgroundCounts } from './activity';
+export {
+    isImageAttachment,
+    fileBadge,
+    formatBytes,
+    checkAttachmentLimits,
+    filesOf,
+    readAttachments,
+    readStoredAttachments,
+    uploadPreviewUrl,
+    uploadBytes
+} from './attachments';
+export { type ChatSendExtras, ChatClient } from './chat-client';
+export type { ProjectChat } from './chat-references';
+export { sendFromComposer, type ComposerSend } from './composer-send';
+export { EMPTY_DRAFT, useDrafts, readDraft, writeDraft, offerDraft, type ChatDraft } from './drafts';
+export { stripAnsi } from './logic/ansi';
+export {
+    FORKABLE_PROVIDERS,
+    forkRefusal,
+    summaryRefusal,
+    lastSettledTurn,
+    forkPointOf,
+    forkPointLabel,
+    type ForkShape,
+    forkShapes,
+    type ForkCliChoice,
+    forkPayload,
+    branchRefusal,
+    type ForkPoint,
+    type ForkWorktreeChoice
+} from './logic/fork';
+export { handbackReportOf } from './logic/handback';
+export { limitView, type LimitView } from './logic/limit';
+export type { TickKind, ScrubberTick } from './logic/scrubber';
+export { type TimedRow, cardRows, visualRows, withTimedRows, timedRowsOf, withThreadCards } from './logic/thread-cards';
+export { EMPTY_TARGET, readTimelineTarget, type TimelineTarget } from './logic/timeline-target';
+export { type TimelineRow, summarizeGroup, deriveTimelineRows, type SubagentBranch, type BaseMoved } from './logic/timeline';
+export { toolSummary, fileChanges, unifiedChanges, approvalChanges, hasFileChanges, type FileChange } from './logic/tools';
+export {
+    MENTION_DRAG_TYPE,
+    LEGACY_MENTION_DRAG_TYPE,
+    MENTION_DRAG_TYPES,
+    carriesMentions,
+    droppedMentions,
+    writeMentionDrag,
+    findMentionQuery,
+    findSkillQuery,
+    insertMention,
+    insertSkill,
+    presentMentions,
+    chipText,
+    tokenizeChips,
+    type MentionQuery,
+    type ChipSegment
+} from './mentions';
+export {
+    defaultProvider,
+    selectionFor,
+    startingSelection,
+    accountFor,
+    chatPreferencesPayload,
+    useChatPreferences,
+    readChatPreferences,
+    CHAT_PREFERENCES_KEY,
+    chatPreferencesKey,
+    reloadChatPreferences,
+    rememberChatPreferences,
+    rememberReadingWidth,
+    rememberSendKey,
+    rememberChatSelection,
+    type ChatPreferences
+} from './preferences';
+export type { HoldRelease } from './prompt-hold';
+export { CHAT_READING_WIDTHS, readingWidthLabel, readingWidthHint, type ChatReadingWidth } from './reading-width';
+export { recentChatMessages, recentSubagentMessages, type RecentChatMessage, type RecentChatMessages } from './recent-messages';
+export { RUNTIME_MODES, runtimeModeLabel, runtimeModeHint } from './runtime-modes';
+export { CHAT_SEND_KEYS, SEND_AND_NEW_SHORTCUT, sendKeyLabel, sendKeyHint, type ChatSendKey } from './send-key';
+export type { StashedAttachment, StashedPrompt, StashedQuote } from './stash';
+export { subagentTitle, summaryWordOf, stopOf, type SubagentStop } from './subagent-list';
+export { useSubagentSupport } from './subagent-support';
+export {
+    crumbOf,
+    openFromMain,
+    composerWrites,
+    canOpenSubagent,
+    useSubagentView,
+    useSubagentTrail,
+    useSubagentItem,
+    type SubagentStep,
+    type SubagentTrail
+} from './subagent-view';
+export { THUMBNAIL_PX, useUploadThumbnail } from './thumbnails';
+export { stepTimelineMessage, jumpToTimelineItem, type TurnTarget, registerTurnJumper, jumpToTimelineTurn, type ItemJumpOptions } from './timeline-scroll';
+export { type StatusWord, statusLookOf, taskStatusWord, type StatusLook, type TaskState } from '../agents/status-look';