@adecore/agents-react 0.23.1 → 0.24.0

package/README.md

@@ -27,35 +27,38 @@ Import the theme after the one of `@adecore/ui`, let Tailwind scan the package,
 @source "../node_modules/@adecore/agents-react/dist";
 ```
 
-Add the words of `AGENTS_LOCALES` to your i18next, call `setChatHost` once, and render the views in a `ChatScopeContext`:
+Add the words of `AGENTS_LOCALES` to your i18next, and render the views in a `ChatHostProvider` and a `ChatScopeContext`:
 
 ```tsx
-import { Composer } from '@adecore/agents-react/chat/ui/Composer';
-import { Timeline } from '@adecore/agents-react/chat/ui/Timeline';
-import { ChatScopeContext } from '@adecore/agents-react/scope';
-
-<ChatScopeContext.Provider value={scope}>
-    <Timeline chatId={chatId} composer={<Composer chatId={chatId} info={info} {...composerProps} />} />
-</ChatScopeContext.Provider>;
+import { ChatHostProvider, ChatScopeContext } from '@adecore/agents-react';
+import { Composer, Timeline } from '@adecore/agents-react/chat/ui';
+
+<ChatHostProvider host={CHAT_HOST}>
+    <ChatScopeContext.Provider value={scope}>
+        <Timeline chatId={chatId} composer={<Composer chatId={chatId} info={info} {...composerProps} />} />
+    </ChatScopeContext.Provider>
+</ChatHostProvider>;
 ```
 
 [Getting started](https://adecore.dev/agents-react/guide/getting-started) covers the words, the host, the scope and its transport.
 
-Every module has its own subpath, `@adecore/agents-react/<path>`; there is no root import.
+The root holds the host, the scope and the transport; `/chat`, `/chat/ui`, `/prompts`, `/providers`, `/state`, `/usage`, `/locales` and `/testing` hold the rest. A module that no entry exports is internal.
 
 ## Documentation
 
 | Page | What it covers |
 |---|---|
 | [Getting started](https://adecore.dev/agents-react/guide/getting-started) | Install, CSS, words, the host and a first chat |
-| [Host adapters](https://adecore.dev/agents-react/guide/host) | Everything `setChatHost` takes |
+| [Host adapters](https://adecore.dev/agents-react/guide/host) | Everything a `ChatHostProvider` takes |
 | [Chat client and state](https://adecore.dev/agents-react/guide/chat-client) | The transport, `ChatClient` and the stores |
 | [Persistence](https://adecore.dev/agents-react/guide/persistence) | Drafts, preferences and their storage keys |
 | [Chat](https://adecore.dev/agents-react/chat/timeline) | The timeline, the composer, prompts and their parts, each with a live demo |
 | [Providers](https://adecore.dev/agents-react/providers/providers-pane) | The settings of the CLIs and their accounts |
 | [Usage](https://adecore.dev/agents-react/usage/usage-page) | Cost, charts and plan limits |
-| [Modules](https://adecore.dev/agents-react/reference) | Every subpath and its exports |
+| [Exports](https://adecore.dev/agents-react/reference) | Every entry point and its exports |
 
 ## License
 
 FSL-1.1-MIT. See [LICENSE](./LICENSE).
+
+Diagrams in a reply are drawn by [Mermaid](https://github.com/mermaid-js/mermaid), a dependency under the MIT license, loaded only when a reply holds one.

package/dist/agents/AccountDot.js

@@ -1,8 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import clsx from 'clsx';
+import { useChatHost } from '../host.js';
 import { accountColor } from './accounts.js';
 /* The color an account wears, or the app's accent while it wears none of the accents. */
 export function AccountDot({ color, className }) {
-    const paint = accountColor(color);
+    const { accents } = useChatHost();
+    const paint = accountColor(color, accents.all);
     return (_jsx("span", { "aria-hidden": true, className: clsx('shrink-0 rounded-full', paint === undefined && 'bg-accent', className ?? 'size-2'), style: paint === undefined ? undefined : { background: paint } }));
 }

package/dist/agents/accounts.d.ts

@@ -1,5 +1,6 @@
 import type { AgentKind, ProviderAccount, ProviderAccounts, ProviderAccountStatus } from '@adecore/agent-contracts';
-export declare function accountColor(color: string | undefined): string | undefined;
+import type { AccentChoice, ChatHost } from '../host.js';
+export declare function accountColor(color: string | undefined, accents: readonly AccentChoice[]): string | undefined;
 export declare const FOLDER_VARIABLES: Partial<Record<AgentKind, string>>;
 export interface AccountEntry {
     id: string;
@@ -16,7 +17,7 @@ export declare function accountStatusLine(status: ProviderAccountStatus | null,
     tone: AccountTone;
 };
 export declare function mintAccountId(kind: AgentKind, label: string, taken: ReadonlySet<string>): string;
-export declare function freeAccountColor(entries: readonly AccountEntry[], fallback: string): string;
+export declare function freeAccountColor(entries: readonly AccountEntry[], accents: ChatHost['accents'], fallback: string): string;
 export declare function offeredAccounts(entries: readonly AccountEntry[], current: string | undefined): AccountEntry[];
 export declare function hasAccountChoice(entries: readonly AccountEntry[]): boolean;
 export declare function canContinueOn(accounts: ProviderAccounts | null, kind: AgentKind, from: string | undefined, to: string | undefined): boolean;

package/dist/agents/accounts.js

@@ -1,11 +1,10 @@
 import i18next from 'i18next';
-import { chatHost } from '../host.js';
 /*
  * 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) {
-    return chatHost().accents.all.find((entry) => entry.id === color)?.color;
+export function accountColor(color, accents) {
+    return accents.find((entry) => entry.id === color)?.color;
 }
 /*
  * The variable each CLI reads its config folder from, as the host's providers name them. Only for
@@ -82,9 +81,9 @@ export function mintAccountId(kind, label, taken) {
  * 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, fallback) {
-    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, accents, fallback) {
+    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/dist/chat/actions.d.ts

@@ -1,6 +1,6 @@
-import { type ChatActions } from '../host.js';
+import { type ChatActions, type ChatHost } from '../host.js';
 import { type ChatScope } from '../scope.js';
 import { type ChatTransport } from '../transport.js';
 export declare function transportActions(transport: ChatTransport): ChatActions;
-export declare function actionsOf(scope: ChatScope): ChatActions;
+export declare function actionsOf(scope: ChatScope, host: Pick<ChatHost, 'actions'>): ChatActions;
 export declare function useChatActions(): ChatActions;

package/dist/chat/actions.js

@@ -1,5 +1,5 @@
 import i18next from 'i18next';
-import { chatHost } from '../host.js';
+import { useChatHost } from '../host.js';
 import { useChatScope } from '../scope.js';
 import { ChatTransportError } from '../transport.js';
 /* Every action as the request a chat host answers, for an app that runs them through nothing of its own. */
@@ -37,6 +37,9 @@ export function transportActions(transport) {
         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 }) });
         },
@@ -49,9 +52,9 @@ export function transportActions(transport) {
     };
 }
 const byTransport = new WeakMap();
-/* The app's own actions when it has them, and the requests of this scope's host otherwise. */
-export function actionsOf(scope) {
-    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, host) {
+    const own = host.actions;
     if (own !== null) {
         return own;
     }
@@ -64,5 +67,5 @@ export function actionsOf(scope) {
     return actions;
 }
 export function useChatActions() {
-    return actionsOf(useChatScope());
+    return actionsOf(useChatScope(), useChatHost());
 }

package/dist/chat/bookmarks.d.ts

@@ -1,4 +1,5 @@
 import type { ChatBookmark } from '@adecore/agent-contracts';
+import type { ChatHost } from '../host.js';
 import type { ChatScope } from '../scope.js';
 interface BookmarkNaming {
     chatKey: string | null;
@@ -7,8 +8,9 @@ interface BookmarkNaming {
     close(): void;
 }
 export declare const useBookmarkNaming: import("zustand").UseBoundStore<import("zustand").StoreApi<BookmarkNaming>>;
-export declare function placeBookmark(scope: ChatScope, chatId: string, itemId: string): Promise<void>;
-export declare function nameBookmark(scope: ChatScope, chatId: string, itemId: string, name: string, previous: string | undefined): Promise<void>;
-export declare function removeBookmark(scope: ChatScope, chatId: string, bookmark: ChatBookmark): Promise<void>;
+type Notifier = Pick<ChatHost, 'notify'>;
+export declare function placeBookmark(scope: ChatScope, host: Notifier, chatId: string, itemId: string): Promise<void>;
+export declare function nameBookmark(scope: ChatScope, host: Notifier, chatId: string, itemId: string, name: string, previous: string | undefined): Promise<void>;
+export declare function removeBookmark(scope: ChatScope, host: Notifier, chatId: string, bookmark: ChatBookmark): Promise<void>;
 export declare function goToBookmark(scope: ChatScope, chatId: string, itemId: string, rename?: boolean): boolean;
 export {};

package/dist/chat/bookmarks.js

@@ -1,6 +1,5 @@
 import i18next from 'i18next';
 import { create } from 'zustand';
-import { chatHost } from '../host.js';
 import { jumpToTimelineItem } from './timeline-scroll.js';
 export const useBookmarkNaming = create((set) => ({
     chatKey: null,
@@ -8,23 +7,23 @@ export const useBookmarkNaming = create((set) => ({
     open: (chatKey, itemId) => set({ chatKey, itemId }),
     close: () => set({ chatKey: null, itemId: null })
 }));
-function failed(title, e) {
-    chatHost().notify({ title, description: e instanceof Error ? e.message : String(e), kind: 'error' });
+function failed(host, title, e) {
+    host.notify({ title, description: e instanceof Error ? e.message : String(e), kind: 'error' });
 }
-async function add(scope, chatId, itemId, name) {
+async function add(scope, host, chatId, itemId, name) {
     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, chatId, itemId) {
+export async function placeBookmark(scope, host, chatId, itemId) {
     useBookmarkNaming.getState().open(scope.keyOf(chatId), itemId);
-    if (!(await add(scope, chatId, itemId))) {
+    if (!(await add(scope, host, chatId, itemId))) {
         useBookmarkNaming.getState().close();
     }
 }
@@ -32,35 +31,35 @@ export async function placeBookmark(scope, chatId, itemId) {
  * 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, chatId, itemId, name, previous) {
+export async function nameBookmark(scope, host, chatId, itemId, name, previous) {
     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, chatId, bookmark) {
+export async function removeBookmark(scope, host, chatId, bookmark) {
     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) }
     });
 }
 /* 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. */

package/dist/chat/chat-client.d.ts

@@ -45,6 +45,7 @@ export declare class ChatClient {
     removeVisual(chatId: string, visualId: string): Promise<ChatVisual[]>;
     listSkills(chatId: string): Promise<ChatSkill[]>;
     clear(chatId: string, force?: boolean): Promise<void>;
+    restart(chatId: string): Promise<void>;
     kill(chatId: string): Promise<void>;
     loadStatuses(): Promise<void>;
     loadProviders(): Promise<void>;

package/dist/chat/chat-client.js

@@ -149,6 +149,13 @@ export class ChatClient {
     async clear(chatId, force = false) {
         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) {
+        await this.transport.request('chat.restart', { chatId });
+    }
     async kill(chatId) {
         this.mounted.delete(chatId);
         this.sink.forget(chatId);

package/dist/chat/composer-send.d.ts

@@ -0,0 +1,3 @@
+export type ComposerSend = 'default' | 'alternate' | 'and-new';
+export declare function registerComposerSender(key: string, send: (how: ComposerSend) => void): () => void;
+export declare function sendFromComposer(key: string, how?: ComposerSend): boolean;

package/dist/chat/composer-send.js

@@ -0,0 +1,22 @@
+/*
+ * 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();
+export function registerComposerSender(key, send) {
+    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, how = 'default') {
+    const send = senders.get(key);
+    if (send === undefined) {
+        return false;
+    }
+    send(how);
+    return true;
+}

package/dist/chat/forks.js

@@ -3,26 +3,43 @@ import { forkIdsAfter, forkedTurnIds } from './logic/fork.js';
 import { useChatScope } from '../scope.js';
 import { useChats } from '../state/chats.js';
 /* The chats this client holds of one host, which is where the forks it knows of are. */
-function* forkInfosOn(byKey, owns) {
-    for (const [key, state] of Object.entries(byKey)) {
+function* forkInfosOn(statuses, owns) {
+    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, collect) {
+    let statuses = null;
+    let joined = '';
+    return (state) => {
+        if (state.statusByKey !== statuses) {
+            statuses = state.statusByKey;
+            joined = [...collect(forkInfosOn(statuses, owns))].join('\n');
+        }
+        return joined;
+    };
+}
 function splitIds(joined) {
     return joined === '' ? [] : joined.split('\n');
 }
 /* The turns of this chat a fork went on after, for the thread to put a line under. */
 export function useForkedTurns(chatId) {
     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, turnId) {
     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/dist/chat/index.d.ts

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

package/dist/chat/index.js

@@ -0,0 +1,28 @@
+// Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { useAccountChoice } from './account-choice.js';
+export { transportActions, actionsOf, useChatActions } from './actions.js';
+export { backgroundCounts } from './activity.js';
+export { isImageAttachment, fileBadge, formatBytes, checkAttachmentLimits, filesOf, readAttachments, readStoredAttachments, uploadPreviewUrl, uploadBytes } from './attachments.js';
+export { ChatClient } from './chat-client.js';
+export { sendFromComposer } from './composer-send.js';
+export { EMPTY_DRAFT, useDrafts, readDraft, writeDraft, offerDraft } from './drafts.js';
+export { stripAnsi } from './logic/ansi.js';
+export { FORKABLE_PROVIDERS, forkRefusal, summaryRefusal, lastSettledTurn, forkPointOf, forkPointLabel, forkShapes, forkPayload, branchRefusal } from './logic/fork.js';
+export { handbackReportOf } from './logic/handback.js';
+export { limitView } from './logic/limit.js';
+export { cardRows, visualRows, withTimedRows, timedRowsOf, withThreadCards } from './logic/thread-cards.js';
+export { EMPTY_TARGET, readTimelineTarget } from './logic/timeline-target.js';
+export { summarizeGroup, deriveTimelineRows } from './logic/timeline.js';
+export { toolSummary, fileChanges, unifiedChanges, approvalChanges, hasFileChanges } from './logic/tools.js';
+export { MENTION_DRAG_TYPE, LEGACY_MENTION_DRAG_TYPE, MENTION_DRAG_TYPES, carriesMentions, droppedMentions, writeMentionDrag, findMentionQuery, findSkillQuery, insertMention, insertSkill, presentMentions, chipText, tokenizeChips } from './mentions.js';
+export { defaultProvider, selectionFor, startingSelection, accountFor, chatPreferencesPayload, useChatPreferences, readChatPreferences, CHAT_PREFERENCES_KEY, chatPreferencesKey, reloadChatPreferences, rememberChatPreferences, rememberReadingWidth, rememberSendKey, rememberChatSelection } from './preferences.js';
+export { CHAT_READING_WIDTHS, readingWidthLabel, readingWidthHint } from './reading-width.js';
+export { recentChatMessages, recentSubagentMessages } from './recent-messages.js';
+export { RUNTIME_MODES, runtimeModeLabel, runtimeModeHint } from './runtime-modes.js';
+export { CHAT_SEND_KEYS, SEND_AND_NEW_SHORTCUT, sendKeyLabel, sendKeyHint } from './send-key.js';
+export { subagentTitle, summaryWordOf, stopOf } from './subagent-list.js';
+export { useSubagentSupport } from './subagent-support.js';
+export { crumbOf, openFromMain, composerWrites, canOpenSubagent, useSubagentView, useSubagentTrail, useSubagentItem } from './subagent-view.js';
+export { THUMBNAIL_PX, useUploadThumbnail } from './thumbnails.js';
+export { stepTimelineMessage, jumpToTimelineItem, registerTurnJumper, jumpToTimelineTurn } from './timeline-scroll.js';
+export { statusLookOf, taskStatusWord } from '../agents/status-look.js';

package/dist/chat/logic/embedded-code.d.ts

@@ -0,0 +1,8 @@
+export interface EmbeddedCode {
+    readonly start: number;
+    readonly end: number;
+    readonly language: string;
+}
+export declare const SHELL_LANGUAGE = "shellscript";
+export declare const EMBEDDED_CODE_LIMIT = 20000;
+export declare function embeddedCode(command: string): EmbeddedCode[];