@adecore/agents-react 0.0.1 → 0.17.0-beta.1

package/dist/host.d.ts

@@ -0,0 +1,195 @@
+import type { ComponentProps, ComponentType, ReactNode, RefObject } from 'react';
+import type { Extension } from '@codemirror/state';
+import type { EditorView } from '@codemirror/view';
+import type { ThemeRegistration } from 'shiki';
+import type { AgentKind, ChatCheckpointDiff, ChatConfigurePayload, ChatItem, ChatSubagentItem } from '@adecore/agent-contracts';
+import type { TimelineRow } from './chat/logic/timeline.js';
+import type { FindReveal } from './chat/ui/find-reveal.js';
+import type { PromptAction } from './prompts/logic/prompts.js';
+import type { HostPrompt, PromptViewProps } from './prompts/logic/subjects.js';
+import { type ChatStorageOptions } from './storage.js';
+export interface AccentChoice {
+    id: string;
+    color: string;
+}
+export interface ChatToast {
+    id?: string;
+    title: string;
+    description?: string;
+    kind: 'success' | 'error' | 'deleted';
+    action?: {
+        label: string;
+        run(): void;
+    };
+}
+export interface ChatActions {
+    clear(chatId: string, force: boolean): Promise<void>;
+    stopTurn(chatId: string, subagents: boolean): Promise<void>;
+    unqueue(chatId: string, messageId: string): Promise<void>;
+    sendNow(chatId: string, messageId: string): Promise<void>;
+    compact(chatId: string): Promise<void>;
+    configure(chatId: string, patch: Omit<ChatConfigurePayload, 'chatId'>): Promise<void>;
+    continueOn(chatId: string, account: string): Promise<void>;
+    turnDiff(chatId: string, turnId: string): Promise<ChatCheckpointDiff | null>;
+    stopSubagent(chatId: string, toolUseId: string): Promise<void>;
+    stopTask(chatId: string, taskId: string): Promise<void>;
+    approve(chatId: string, requestId: string, decision: 'allow' | 'allow-always' | 'deny', message?: string): Promise<void>;
+    answer(chatId: string, requestId: string, answers: Record<string, string>): Promise<void>;
+    dismiss(chatId: string, itemId: string): Promise<void>;
+}
+export interface FileRef {
+    path: string;
+    line?: number;
+    directory: boolean;
+}
+export interface ChatPlace {
+    title: string | null;
+    go(): void;
+}
+export interface SubagentTask {
+    status: 'open' | 'done' | 'failed' | 'cancelled';
+    createdAt: number;
+    settledAt: number | null;
+    paused?: {
+        until?: number;
+    };
+}
+export interface TimelineFindOptions {
+    chatId: string;
+    frame: RefObject<HTMLDivElement | null>;
+    thread: RefObject<HTMLDivElement | null>;
+    scroller: RefObject<HTMLDivElement | null>;
+    enabled: boolean;
+    rows: readonly TimelineRow[];
+    structure: Readonly<Record<string, ChatItem>> | undefined;
+    order: readonly string[] | undefined;
+    firstRowInView(): number;
+    openTurn(turnId: string): void;
+    openGroup(id: string): void;
+    openSubagent(id: string): void;
+    scrollToRow(index: number): void;
+    coveredHeight(): number;
+    stopFollowing(): void;
+}
+export interface TimelineFind {
+    open: boolean;
+    bar: ReactNode;
+    reveal: FindReveal | null;
+    hitRows: readonly number[];
+    currentRow: number | null;
+}
+export interface ComposerDictationProps {
+    targetRef: RefObject<HTMLElement | null>;
+    buttonContainer: HTMLElement | null | undefined;
+    disabled: boolean;
+    editor(): EditorView | null;
+}
+export type TextareaProps = ComponentProps<'textarea'> & {
+    buttonClassName?: string;
+};
+export interface ResourceUrl {
+    url: string | null;
+    failure: string | null;
+}
+export interface ComposerSlotProps {
+    scopeId: string;
+    chatId: string;
+    disabled: boolean;
+    insert(text: string): void;
+}
+export interface SubagentSlotProps {
+    chatId: string;
+    items: readonly ChatSubagentItem[];
+}
+export interface ThreadCard {
+    id: string;
+    at: number;
+    render(): ReactNode;
+}
+export interface ReplyAuthor {
+    name: string;
+    mark?: ReactNode;
+}
+export interface ChatHost {
+    storage?: ChatStorageOptions;
+    accents: {
+        all: readonly AccentChoice[];
+        featured: readonly string[];
+        label(id: string): string;
+        current(): string;
+    };
+    isApplePlatform(): boolean;
+    isAppShortcut(event: KeyboardEvent): boolean;
+    notify(toast: ChatToast): void;
+    actions: ChatActions | null;
+    searchFiles: ((scopeId: string, cwd: string, query: string, limit: number) => Promise<string[]>) | null;
+    attachments: {
+        useUrl(scopeId: string, chatId: string, attachmentId: string): ResourceUrl;
+        read(scopeId: string, chatId: string, attachmentId: string): Promise<Blob>;
+    };
+    ReadImage: ComponentType<{
+        path: string;
+    }> | null;
+    code: {
+        useMode(): 'light' | 'dark';
+        useThemes(): {
+            light: string;
+            dark: string;
+        };
+        custom: ReadonlyArray<ThemeRegistration & {
+            name: string;
+        }>;
+    };
+    useStreaming(): 'words' | 'blocks' | 'whole';
+    fileLinks: {
+        target(text: string, cwd: string | null): FileRef | null;
+        open(cwd: string | null, ref: FileRef): void;
+    } | null;
+    useTimelineFind(options: TimelineFindOptions): TimelineFind;
+    dictation: {
+        Textarea: ComponentType<TextareaProps>;
+        composer: {
+            extensions: Extension;
+            Control: ComponentType<ComposerDictationProps>;
+        } | null;
+    };
+    prompts: {
+        useExtra(scopeId: string, chatId: string): readonly HostPrompt[];
+        render(prompt: HostPrompt, props: PromptViewProps): ReactNode;
+        answer(prompt: HostPrompt, action: PromptAction): Promise<void>;
+    };
+    useReferableChats(): ReadonlyArray<{
+        id: string;
+        title: string;
+    }>;
+    openLogin: ((scopeId: string, kind: AgentKind, accountId: string, name: string) => Promise<void>) | null;
+    useLoginBlocked(scopeId: string): string | null;
+    useProjectLook(scopeId: string, projectId: string | null): {
+        name: string;
+        mark: ReactNode;
+    } | null;
+    useChatPlace(chatId: string): ChatPlace;
+    useContextSources(chatId: string): ReadonlyArray<{
+        title: string;
+    }>;
+    useHidesFolder(chatId: string): boolean;
+    useWelcome(chatId: string): boolean;
+    tasks: {
+        useTasks(scopeId: string): Readonly<Record<string, SubagentTask>> | undefined;
+        useTask(scopeId: string, taskId: string | null): SubagentTask | null;
+    };
+    confirm: {
+        stopSubagents(scopeId: string, chatId: string, run: () => void): void;
+        stopTask(scopeId: string, childId: string, title: string, run: () => void): void;
+    };
+    fork: ((chatId: string, turnId: string) => void) | null;
+    openSettings(section: 'providers' | 'agents'): void;
+    useResumeAtReset(scopeId: string): boolean;
+    useComposerPlaceholder(scopeId: string, chatId: string): string | null;
+    ComposerSlot: ComponentType<ComposerSlotProps> | null;
+    SubagentSlot: ComponentType<SubagentSlotProps> | null;
+    useThreadCards(scopeId: string, chatId: string): readonly ThreadCard[];
+    useReplyAuthor(scopeId: string, chatId: string): ReplyAuthor | null;
+}
+export declare function setChatHost(patch: Partial<ChatHost>): void;
+export declare function chatHost(): ChatHost;

package/dist/host.js

@@ -0,0 +1,55 @@
+import { isApplePlatform } from '@adecore/ui';
+import { PlainTextarea } from './ui/PlainTextarea.js';
+import { configureChatStorage } from './storage.js';
+const NO_PROMPTS = [];
+const NO_CHATS = [];
+const NO_ROWS = [];
+const NO_FIND = { open: false, bar: null, reveal: null, hitRows: NO_ROWS, currentRow: null };
+const NO_SOURCES = [];
+const NO_URL = { url: null, failure: null };
+const NOWHERE = { title: null, go: () => undefined };
+const NO_CARDS = [];
+const DEFAULT_HOST = {
+    accents: { all: [], featured: [], label: (id) => id, current: () => '' },
+    isApplePlatform,
+    isAppShortcut: () => false,
+    notify: () => undefined,
+    actions: null,
+    searchFiles: null,
+    attachments: { useUrl: () => NO_URL, read: () => Promise.reject(new Error('This app keeps no attached files')) },
+    ReadImage: null,
+    code: { useMode: () => 'light', useThemes: () => ({ light: 'github-light', dark: 'github-dark' }), custom: [] },
+    useStreaming: () => 'words',
+    fileLinks: null,
+    useTimelineFind: () => NO_FIND,
+    dictation: { Textarea: PlainTextarea, composer: null },
+    prompts: { useExtra: () => NO_PROMPTS, render: () => null, answer: () => Promise.reject(new Error('This app raises no prompts of its own')) },
+    useReferableChats: () => NO_CHATS,
+    openLogin: null,
+    useLoginBlocked: () => null,
+    useProjectLook: () => null,
+    useChatPlace: () => NOWHERE,
+    useContextSources: () => NO_SOURCES,
+    useHidesFolder: () => false,
+    useWelcome: () => false,
+    tasks: { useTasks: () => undefined, useTask: () => null },
+    confirm: { stopSubagents: (_scopeId, _chatId, run) => run(), stopTask: (_scopeId, _childId, _title, run) => run() },
+    fork: null,
+    openSettings: () => undefined,
+    useResumeAtReset: () => true,
+    useComposerPlaceholder: () => null,
+    ComposerSlot: null,
+    SubagentSlot: null,
+    useThreadCards: () => NO_CARDS,
+    useReplyAuthor: () => null
+};
+let host = DEFAULT_HOST;
+export function setChatHost(patch) {
+    if (patch.storage !== undefined) {
+        configureChatStorage(patch.storage);
+    }
+    host = { ...host, ...patch };
+}
+export function chatHost() {
+    return host;
+}

package/dist/lazy.d.ts

@@ -0,0 +1,6 @@
+import { type ComponentProps, type ComponentType } from 'react';
+type Loader = () => Promise<unknown>;
+export declare function setLazyPrefetch(next: (load: Loader) => void): void;
+export declare function onLazyOpenError(listener: (error: unknown) => void): () => void;
+export declare function lazyNamed<Module extends Record<Name, ComponentType<any>>, Name extends keyof Module>(load: () => Promise<Module>, name: Name): ComponentType<ComponentProps<Module[Name]>>;
+export {};

package/dist/lazy.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy } from 'react';
+const loaders = [];
+let register = null;
+const openErrorListeners = new Set();
+/*
+ * Hands every module the chat loads lazily to the app's prefetcher: the ones made so far, and each
+ * one made from now on. Without it they load on their first render, as `React.lazy` does.
+ */
+export function setLazyPrefetch(next) {
+    register = next;
+    for (const load of loaders) {
+        next(load);
+    }
+}
+/*
+ * Tells `listener` when a module the chat loads for a render fails to load, the way `onLazyOpenError`
+ * of `@adecore/ui` does for the app's own. A failed prefetch never reaches it.
+ */
+export function onLazyOpenError(listener) {
+    openErrorListeners.add(listener);
+    return () => {
+        openErrorListeners.delete(listener);
+    };
+}
+/*
+ * `React.lazy` for a module that exports its component by name, `default` included. Once the module
+ * is here the component is drawn straight away, since `React.lazy` suspends for a tick even on a
+ * module the prefetcher already fetched.
+ */
+export function lazyNamed(load, name) {
+    let loaded = null;
+    const open = async () => {
+        const component = (await load())[name];
+        loaded ??= component;
+        return component;
+    };
+    loaders.push(open);
+    register?.(open);
+    // Only a render loads through here; a prefetch calls `open` itself, so its failures report nothing.
+    const Lazy = lazy(async () => {
+        try {
+            return { default: await open() };
+        }
+        catch (error) {
+            for (const listener of openErrorListeners) {
+                listener(error);
+            }
+            throw error;
+        }
+    });
+    const LazyNamed = (props) => {
+        const Component = loaded ?? Lazy;
+        return _jsx(Component, { ...props });
+    };
+    return LazyNamed;
+}