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

package/dist/chat/recent-messages.d.ts

@@ -0,0 +1,17 @@
+import type { ChatItem } from '@adecore/agent-contracts';
+export interface RecentChatMessage {
+    role: 'user' | 'assistant';
+    text: string;
+    createdAt: number;
+}
+export interface RecentChatMessages {
+    messages: RecentChatMessage[];
+    truncated: boolean;
+}
+type MessageItem = Extract<ChatItem, {
+    kind: 'user' | 'assistant';
+}>;
+export declare function recentMessages(eligible: readonly MessageItem[], limit: number): RecentChatMessages;
+export declare function recentChatMessages(items: Record<string, ChatItem>, order: readonly string[], limit: number): RecentChatMessages;
+export declare function recentSubagentMessages(items: readonly ChatItem[], limit: number): RecentChatMessages;
+export {};

package/dist/chat/recent-messages.js

@@ -0,0 +1,36 @@
+const MAX_TOTAL_CHARACTERS = 12_000;
+const MAX_MESSAGE_CHARACTERS = 3_000;
+function clipped(text) {
+    return text.length <= MAX_MESSAGE_CHARACTERS ? { text, truncated: false } : { text: `${text.slice(0, MAX_MESSAGE_CHARACTERS - 1)}…`, truncated: true };
+}
+function isMessage(item) {
+    return item !== undefined && (item.kind === 'user' || item.kind === 'assistant') && item.text.trim() !== '';
+}
+/* The last messages of a conversation already cut down to the ones worth reading, clipped to what a reader can take in. */
+export function recentMessages(eligible, limit) {
+    const candidates = eligible.slice(-limit);
+    const messages = [];
+    let characters = 0;
+    let truncated = candidates.length < eligible.length;
+    for (const item of candidates.toReversed()) {
+        const message = clipped(item.text.trim());
+        const remaining = MAX_TOTAL_CHARACTERS - characters;
+        if (remaining <= 0) {
+            truncated = true;
+            break;
+        }
+        const text = message.text.length <= remaining ? message.text : `${message.text.slice(0, Math.max(0, remaining - 1))}…`;
+        messages.unshift({ role: item.kind, text, createdAt: item.createdAt });
+        characters += text.length;
+        truncated ||= message.truncated || text.length < message.text.length;
+    }
+    return { messages, truncated };
+}
+/* A sub-agent's replies sit in the thread too, and belong to its own conversation rather than the chat's. */
+export function recentChatMessages(items, order, limit) {
+    return recentMessages(order.map((id) => items[id]).filter((item) => isMessage(item) && !(item.kind === 'assistant' && item.parentToolUseId)), limit);
+}
+/* Everything in a sub-agent's conversation is its own, so nothing is left out for being nested. */
+export function recentSubagentMessages(items, limit) {
+    return recentMessages(items.filter(isMessage), limit);
+}

package/dist/chat/resume-compaction-dismissals.d.ts

@@ -0,0 +1,3 @@
+import { type ChatScope } from '../scope.js';
+export declare function useResumeCompactionDismissal(chatId: string): string | null;
+export declare function dismissResumeCompaction(scope: ChatScope, chatId: string, turnId: string): void;

package/dist/chat/resume-compaction-dismissals.js

@@ -0,0 +1,14 @@
+import { create } from 'zustand';
+import { useChatScope } from '../scope.js';
+/*
+ * Which turn a person answered "Keep full history" on, per chat. In memory only: the offer appears
+ * at most once per silence, so a reload asking again costs nothing, and a refusal is not a setting.
+ */
+const useDismissals = create(() => ({ byKey: {} }));
+export function useResumeCompactionDismissal(chatId) {
+    const { keyOf } = useChatScope();
+    return useDismissals((s) => s.byKey[keyOf(chatId)] ?? null);
+}
+export function dismissResumeCompaction(scope, chatId, turnId) {
+    useDismissals.setState((s) => ({ byKey: { ...s.byKey, [scope.keyOf(chatId)]: turnId } }));
+}

package/dist/chat/runtime-modes.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeMode } from '@adecore/agent-contracts';
+export declare const RUNTIME_MODES: readonly RuntimeMode[];
+export declare function runtimeModeLabel(mode: RuntimeMode): string;
+export declare function runtimeModeHint(mode: RuntimeMode): string;

package/dist/chat/runtime-modes.js

@@ -0,0 +1,15 @@
+import i18next from 'i18next';
+import { RuntimeModeSchema } from '@adecore/agent-contracts';
+/*
+ * The runtime modes in the order they are offered, shared by the composer's mode picker, the
+ * settings dialog and the agent menus. That order is the schema's, which the host reads as the
+ * rank from narrowest to widest. Only the ids live here: the words are in `modes.<id>` of the `chat`
+ * namespace, read when a surface draws one rather than when this module loads.
+ */
+export const RUNTIME_MODES = RuntimeModeSchema.options;
+export function runtimeModeLabel(mode) {
+    return i18next.t(`agent-chat:modes.${mode}.label`);
+}
+export function runtimeModeHint(mode) {
+    return i18next.t(`agent-chat:modes.${mode}.hint`);
+}

package/dist/chat/stash.d.ts

@@ -0,0 +1,24 @@
+import { type ChatDraft } from './drafts.js';
+export declare const STASH_SHORTCUT: import("@adecore/ui").Shortcut;
+export declare const STASH_LIMIT = 20;
+export interface StashedAttachment {
+    name: string;
+    mime: string;
+    size: number;
+}
+export interface StashedPrompt {
+    id: string;
+    text: string;
+    mentions: string[];
+    skills: string[];
+    attachments: StashedAttachment[];
+    createdAt: number;
+}
+export declare function parseStash(raw: string | null): StashedPrompt[];
+export declare function withStashed(prompts: StashedPrompt[], entry: StashedPrompt): StashedPrompt[];
+export declare function stashedFrom(draft: ChatDraft, id: string, now: number): StashedPrompt | null;
+export declare const useStash: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    prompts: StashedPrompt[];
+}>>;
+export declare function stashDraft(draft: ChatDraft): boolean;
+export declare function forgetStashed(id: string): void;

package/dist/chat/stash.js

@@ -0,0 +1,91 @@
+import { chatStorageKey, chatStorageLegacyKeys, createChatStore } from '../storage.js';
+import { uploadBytes } from './attachments.js';
+import { isEmptyDraft } from './drafts.js';
+import { isRecord } from './logic/json.js';
+import { persistedJson } from './persisted-json.js';
+import { withQuote } from './quote.js';
+import { shortcut } from '@adecore/ui';
+/* Puts the draft away, or takes the last one back on an empty box. */
+export const STASH_SHORTCUT = shortcut('Mod+S');
+const storageKey = () => chatStorageKey('stash');
+// Past this the list is an archive nobody reads; the oldest entry makes room for a new one.
+export const STASH_LIMIT = 20;
+function strings(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
+}
+function attachments(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((entry) => ({
+        name: typeof entry.name === 'string' ? entry.name : '',
+        mime: typeof entry.mime === 'string' ? entry.mime : '',
+        size: typeof entry.size === 'number' ? entry.size : 0
+    }));
+}
+/* Only the fields we know today, so anything an older or a broken write left behind falls away here. */
+export function parseStash(raw) {
+    if (raw === null) {
+        return [];
+    }
+    try {
+        const stored = JSON.parse(raw);
+        if (!Array.isArray(stored)) {
+            return [];
+        }
+        return stored
+            .filter(isRecord)
+            .filter((entry) => typeof entry.id === 'string' && typeof entry.text === 'string')
+            .map((entry) => ({
+            id: entry.id,
+            text: entry.text,
+            mentions: strings(entry.mentions),
+            skills: strings(entry.skills),
+            attachments: attachments(entry.attachments),
+            createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
+        }))
+            .slice(0, STASH_LIMIT);
+    }
+    catch {
+        return [];
+    }
+}
+/* Newest first, capped: the entry that has been waiting longest is the one nobody comes back for. */
+export function withStashed(prompts, entry) {
+    return [entry, ...prompts].slice(0, STASH_LIMIT);
+}
+/* What a draft looks like on the shelf, its quote folded into the text; null when there is nothing worth putting there. */
+export function stashedFrom(draft, id, now) {
+    if (isEmptyDraft(draft)) {
+        return null;
+    }
+    return {
+        id,
+        text: withQuote(draft.quote, draft.text),
+        mentions: [...draft.mentions],
+        skills: [...draft.skills],
+        attachments: draft.attachments.map((attachment) => ({ name: attachment.name, mime: attachment.mime, size: uploadBytes(attachment) })),
+        createdAt: now
+    };
+}
+const storage = persistedJson(storageKey, parseStash, [], () => chatStorageLegacyKeys('stash'));
+/*
+ * Prompts put aside for later can move to another chat, so the shelf is shared across chats.
+ */
+export const useStash = createChatStore(() => ({ prompts: [] }), (store) => store.setState({ prompts: storage.read() }));
+function write(prompts) {
+    useStash.setState({ prompts });
+    storage.write(prompts);
+}
+/* Puts a draft on the shelf; false when the composer held nothing to put there. */
+export function stashDraft(draft) {
+    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now());
+    if (!entry) {
+        return false;
+    }
+    write(withStashed(useStash.getState().prompts, entry));
+    return true;
+}
+export function forgetStashed(id) {
+    write(useStash.getState().prompts.filter((entry) => entry.id !== id));
+}

package/dist/chat/subagent-conversation.d.ts

@@ -0,0 +1,41 @@
+import type { ChatItem, ChatSubagentResult } from '@adecore/agent-contracts';
+import { type ChatTransport } from '../transport.js';
+export declare const SUBAGENT_PAGE = 60;
+export interface SubagentConversationState {
+    status: 'loading' | 'ready' | 'failed';
+    items: ChatItem[];
+    source: ChatSubagentResult['source'] | null;
+    context: NonNullable<ChatSubagentResult['context']> | null;
+    cursor: string | null;
+    live: boolean;
+    loadingEarlier: boolean;
+    error: string | null;
+    unsupported: boolean;
+}
+export declare const INITIAL_CONVERSATION: SubagentConversationState;
+export declare function mergeNewest(current: ChatItem[], currentCursor: string | null, page: ChatItem[], pageCursor: string | null): {
+    items: ChatItem[];
+    cursor: string | null;
+};
+export declare class SubagentConversation {
+    private readonly transport;
+    private readonly chatId;
+    private readonly toolUseId;
+    private readonly onChange;
+    private readonly unsubscribe;
+    private state;
+    private disposed;
+    private queue;
+    private refreshWaiting;
+    private earlier;
+    constructor(transport: ChatTransport, chatId: string, toolUseId: string, onChange: (state: SubagentConversationState) => void);
+    get current(): SubagentConversationState;
+    start(): Promise<void>;
+    refresh(): Promise<void>;
+    loadEarlier(): Promise<void>;
+    dispose(): void;
+    private readNewest;
+    private ask;
+    private enqueue;
+    private set;
+}

package/dist/chat/subagent-conversation.js

@@ -0,0 +1,167 @@
+import i18next from 'i18next';
+import { errorCode, isConnectionError } from '../transport.js';
+// What the panel opens on: the newest end of the conversation, which is where an agent that works is.
+export const SUBAGENT_PAGE = 60;
+export const INITIAL_CONVERSATION = {
+    status: 'loading',
+    items: [],
+    source: null,
+    context: null,
+    cursor: null,
+    live: false,
+    loadingEarlier: false,
+    error: null,
+    unsupported: false
+};
+/*
+ * The newest page laid over what is on screen. An item that is already there is replaced where it
+ * stands and a new one goes after them all. A page that shares nothing with what is held means more
+ * happened than one page holds, so what is held is dropped for it rather than shown with a hole.
+ */
+export function mergeNewest(current, currentCursor, page, pageCursor) {
+    const known = new Map(current.map((item, index) => [item.id, index]));
+    if (current.length > 0 && page.length > 0 && !page.some((item) => known.has(item.id))) {
+        return { items: page, cursor: pageCursor };
+    }
+    const items = [...current];
+    for (const item of page) {
+        const index = known.get(item.id);
+        if (index === undefined) {
+            items.push(item);
+        }
+        else {
+            items[index] = item;
+        }
+    }
+    return { items, cursor: current.length === 0 ? pageCursor : currentCursor };
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : i18next.t('agent-chat:subagents.noAnswer');
+}
+/*
+ * One subagent's conversation as a panel follows it. Opening asks for the newest page and holds the
+ * conversation on the machine, which then says whenever it grew; each time, the newest page is asked
+ * again and laid over what is there. A socket that comes back holds it again, and letting go is the
+ * last thing it says.
+ */
+export class SubagentConversation {
+    transport;
+    chatId;
+    toolUseId;
+    onChange;
+    unsubscribe = [];
+    state = INITIAL_CONVERSATION;
+    disposed = false;
+    // One request at a time, so a refresh never lands under an older page that arrived after it.
+    queue = Promise.resolve();
+    refreshWaiting = false;
+    earlier = null;
+    constructor(transport, chatId, toolUseId, onChange) {
+        this.transport = transport;
+        this.chatId = chatId;
+        this.toolUseId = toolUseId;
+        this.onChange = onChange;
+    }
+    get current() {
+        return this.state;
+    }
+    start() {
+        this.unsubscribe.push(this.transport.on('chat.subagentChanged', (event) => {
+            if (event.chatId === this.chatId && event.toolUseId === this.toolUseId) {
+                void this.refresh();
+            }
+        }), this.transport.subscribeStatus((status) => {
+            if (status === 'open') {
+                void this.enqueue(() => this.readNewest(true));
+            }
+        }));
+        return this.enqueue(() => this.readNewest(true));
+    }
+    /* The newest page again; calls that arrive while one waits become that one. */
+    refresh() {
+        if (this.refreshWaiting) {
+            return this.queue;
+        }
+        this.refreshWaiting = true;
+        return this.enqueue(() => {
+            this.refreshWaiting = false;
+            return this.readNewest(false);
+        });
+    }
+    loadEarlier() {
+        // A page on its way answers every call made meanwhile; a scroll asks for one on every frame.
+        this.earlier ??= this.enqueue(async () => {
+            const cursor = this.state.cursor;
+            if (cursor === null) {
+                return;
+            }
+            this.set({ loadingEarlier: true });
+            try {
+                const page = await this.ask({ cursor, limit: SUBAGENT_PAGE });
+                this.set({ items: [...page.items, ...this.state.items], cursor: page.history.cursor, live: page.live, loadingEarlier: false });
+            }
+            catch (error) {
+                if (errorCode(error) === 'history-expired') {
+                    // The record was written again under this panel; what it holds now is the only truth.
+                    this.set({ items: [], cursor: null, loadingEarlier: false });
+                    await this.readNewest(false);
+                    return;
+                }
+                this.set({ loadingEarlier: false, error: messageOf(error) });
+            }
+        }).finally(() => {
+            this.earlier = null;
+        });
+        return this.earlier;
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        for (const off of this.unsubscribe.splice(0)) {
+            off();
+        }
+        if (this.transport.status === 'open') {
+            void this.transport.request('chat.subagent', { chatId: this.chatId, toolUseId: this.toolUseId, limit: 1, watch: false }).catch(() => undefined);
+        }
+    }
+    async readNewest(watch) {
+        try {
+            const page = await this.ask({ limit: SUBAGENT_PAGE, ...(watch ? { watch: true } : {}) });
+            const merged = mergeNewest(this.state.items, this.state.cursor, page.items, page.history.cursor);
+            this.set({
+                status: 'ready',
+                items: merged.items,
+                cursor: merged.cursor,
+                live: page.live,
+                source: page.source,
+                context: page.context ?? null,
+                error: null
+            });
+        }
+        catch (error) {
+            if (this.state.status === 'ready' && isConnectionError(error)) {
+                // What is on screen stays; the socket that comes back asks again.
+                return;
+            }
+            const unsupported = errorCode(error) === 'unknown-request';
+            this.set({ status: 'failed', error: messageOf(error), unsupported });
+        }
+    }
+    ask(extra) {
+        return this.transport.request('chat.subagent', { chatId: this.chatId, toolUseId: this.toolUseId, ...extra });
+    }
+    enqueue(work) {
+        const next = this.queue.then(() => (this.disposed ? undefined : work()));
+        this.queue = next.catch(() => undefined);
+        return next;
+    }
+    set(patch) {
+        if (this.disposed) {
+            return;
+        }
+        this.state = { ...this.state, ...patch };
+        this.onChange(this.state);
+    }
+}

package/dist/chat/subagent-list.d.ts

@@ -0,0 +1,19 @@
+import type { ChatInfo, ChatItem, ChatSubagentItem } from '@adecore/agent-contracts';
+import type { StatusWord } from '../agents/status-look.js';
+import type { SubagentTask } from '../host.js';
+export declare function subagentTitle(item: ChatSubagentItem): string;
+export declare function subagentFacts(item: ChatSubagentItem, modelName: string | null): string[];
+export declare function taskIdOf(item: ChatSubagentItem): string | null;
+export declare function statusWordOf(item: ChatSubagentItem, task: SubagentTask | null): StatusWord;
+export type TaskRowState = StatusWord | 'waiting';
+export declare function taskRowStateOf(item: ChatSubagentItem, task: SubagentTask | null, child: ChatInfo | undefined): TaskRowState;
+export declare function flyoutSubagents(order: readonly string[], structure: Readonly<Record<string, ChatItem>>): ChatSubagentItem[];
+export declare function summaryWordOf(words: readonly StatusWord[]): StatusWord;
+export declare function badgeCountOf(words: readonly StatusWord[]): number;
+export declare function entryTimeOf(item: ChatSubagentItem, task: SubagentTask | null, now: number): string;
+export type SubagentStop = 'task' | 'mark';
+export declare function stopOf(item: ChatSubagentItem, turnRunning: boolean): SubagentStop | null;
+export declare function stopLabel(stop: SubagentStop): string;
+export type ComposerStop = 'turn' | 'turn-and-subagents';
+export declare function composerStopOf(shiftKey: boolean): ComposerStop;
+export declare function composerStopLabel(): string;

package/dist/chat/subagent-list.js

@@ -0,0 +1,106 @@
+import i18next from 'i18next';
+import { formatMoment, formatElapsedShort, formatTokens } from '@adecore/ui/format';
+export function subagentTitle(item) {
+    return item.description || item.summary || item.subagentType || i18next.t('agent-chat:rows.subagent.label');
+}
+/* What the bar over a sub-agent's conversation says of it beside its state and its time; the model is named by the caller, which has the catalog. */
+export function subagentFacts(item, modelName) {
+    return [
+        modelName,
+        item.subagentType,
+        item.background ? i18next.t('agent-chat:rows.subagent.background') : null,
+        item.usage !== null && item.usage.totalTokens > 0
+            ? i18next.t('agent-chat:subagents.info.tokens', { tokens: formatTokens(item.usage.totalTokens) })
+            : null,
+        item.usage !== null && item.usage.toolUses > 0 ? i18next.t('agent-chat:group.toolCalls', { count: item.usage.toolUses }) : null
+    ].filter((fact) => fact !== null && fact !== '');
+}
+/* The task a row stands for, whose id the host wrote into the row's own. */
+export function taskIdOf(item) {
+    return item.origin === 'ruimte' && item.id.startsWith('task-') ? item.id.slice(5) : null;
+}
+/* A cancelled task is a failed row on the wire and a paused one a running row, and only the task itself still says which it is. */
+export function statusWordOf(item, task) {
+    if (item.status === 'failed' && task?.status === 'cancelled') {
+        return 'cancelled';
+    }
+    if (item.status === 'running' && task?.status === 'open' && task.paused !== undefined) {
+        return 'paused';
+    }
+    return item.status;
+}
+export function taskRowStateOf(item, task, child) {
+    const word = statusWordOf(item, task);
+    if (word === 'running' && (child?.status === 'needs-you' || (child?.requests?.length ?? 0) > 0)) {
+        return 'waiting';
+    }
+    return word;
+}
+/*
+ * What the flyout over the composer lists: every sub-agent still at work, and the ones that settled
+ * since the last message, so a finished batch stays until the next message is sent. That includes an
+ * older row a message woke again. A settled one from before that message stays too while a sibling of
+ * its turn still runs. Older ones are only in the thread.
+ */
+export function flyoutSubagents(order, structure) {
+    const lastMessage = order.findLastIndex((id) => structure[id]?.kind === 'user');
+    const lastMessageAt = lastMessage < 0 ? null : (structure[order[lastMessage]]?.createdAt ?? null);
+    const items = order.flatMap((id, index) => {
+        const item = structure[id];
+        return item?.kind === 'subagent' ? [{ item, index }] : [];
+    });
+    const turns = new Set(items.flatMap(({ item }) => (item.status === 'running' && item.turnId !== null ? [item.turnId] : [])));
+    return items
+        .filter(({ item, index }) => item.status === 'running' ||
+        index > lastMessage ||
+        (lastMessageAt !== null && item.finishedAt !== null && item.finishedAt > lastMessageAt) ||
+        (item.turnId !== null && turns.has(item.turnId)))
+        .map(({ item }) => item);
+}
+/* The one state the badge shows for all of them: work in progress first, then work held up, then whatever went wrong. */
+export function summaryWordOf(words) {
+    return ['running', 'paused', 'failed', 'cancelled'].find((word) => words.includes(word)) ?? 'done';
+}
+/* The number on the badge: the ones still at work, a paused one included, and all of them once none is. */
+export function badgeCountOf(words) {
+    const active = words.filter((word) => word === 'running' || word === 'paused').length;
+    return active > 0 ? active : words.length;
+}
+/* The time on the right of an entry: how long it has run so far, or how long it took once it settled. */
+export function entryTimeOf(item, task, now) {
+    // A task's own record says when it was given and settled; the row copies those, but may lag behind it.
+    const startedAt = task?.createdAt ?? item.startedAt;
+    const finishedAt = task === null ? item.finishedAt : (task.settledAt ?? item.finishedAt);
+    const word = statusWordOf(item, task);
+    if (word === 'paused') {
+        const until = task?.paused?.until;
+        return until === undefined
+            ? i18next.t('agent-chat:common.status.paused')
+            : i18next.t('agent-chat:activity.pausedUntil', { time: formatMoment(until, now) });
+    }
+    if (item.status === 'running') {
+        return startedAt > 0 ? formatElapsedShort(now - startedAt) : '';
+    }
+    if (startedAt <= 0 || finishedAt === null || finishedAt < startedAt) {
+        return i18next.t(`agent-chat:common.status.${word}`);
+    }
+    return i18next.t(`agent-chat:activity.took.${word}`, { duration: formatElapsedShort(finishedAt - startedAt) });
+}
+export function stopOf(item, turnRunning) {
+    if (item.status !== 'running') {
+        return null;
+    }
+    if (item.origin === 'ruimte') {
+        return item.childId === undefined ? null : 'task';
+    }
+    return turnRunning ? null : 'mark';
+}
+export function stopLabel(stop) {
+    return stop === 'task' ? i18next.t('agent-chat:subagents.stop.task') : i18next.t('agent-chat:subagents.stop.mark');
+}
+export function composerStopOf(shiftKey) {
+    return shiftKey ? 'turn-and-subagents' : 'turn';
+}
+export function composerStopLabel() {
+    return i18next.t('agent-chat:composer.stop');
+}

package/dist/chat/subagent-support.d.ts

@@ -0,0 +1,6 @@
+interface SubagentSupportStore {
+    unsupported: Record<string, true>;
+    markUnsupported(scopeId: string): void;
+}
+export declare const useSubagentSupport: import("zustand").UseBoundStore<import("zustand").StoreApi<SubagentSupportStore>>;
+export {};

package/dist/chat/subagent-support.js

@@ -0,0 +1,14 @@
+import { create } from 'zustand';
+/*
+ * Whether a host can open a subagent's conversation is learned by asking once rather than from a
+ * version: the first refusal hides the button on that host's rows that carry no pointer of their own.
+ */
+export const useSubagentSupport = create((set, get) => ({
+    unsupported: {},
+    markUnsupported(scopeId) {
+        if (get().unsupported[scopeId]) {
+            return;
+        }
+        set({ unsupported: { ...get().unsupported, [scopeId]: true } });
+    }
+}));

package/dist/chat/subagent-view.d.ts

@@ -0,0 +1,35 @@
+import type { ChatItem, ChatSubagentItem } from '@adecore/agent-contracts';
+export interface SubagentStep {
+    toolUseId: string;
+    description: string;
+}
+export type SubagentTrail = readonly SubagentStep[];
+export interface BreadcrumbStep {
+    label: string;
+    depth: number;
+    current: boolean;
+}
+export declare const MAIN_AGENT: SubagentTrail;
+export declare function crumbOf(item: ChatSubagentItem): SubagentStep;
+export declare function openFromMain(step: SubagentStep): SubagentTrail;
+export declare function openBelow(trail: SubagentTrail, step: SubagentStep): SubagentTrail;
+export declare function trailTo(trail: SubagentTrail, depth: number): SubagentTrail;
+export declare function stepBack(trail: SubagentTrail): SubagentTrail;
+export declare function composerWrites(trail: SubagentTrail): boolean;
+export declare function breadcrumbOf(trail: SubagentTrail): BreadcrumbStep[];
+export declare function canOpenSubagent(item: ChatSubagentItem, machineRefused: boolean): boolean;
+export declare function subagentOf(structure: Readonly<Record<string, ChatItem>>, toolUseId: string): ChatSubagentItem | null;
+export declare function openableSubagents(order: readonly string[], structure: Record<string, ChatItem>, machineRefused: boolean): ChatSubagentItem[];
+interface SubagentViewStore {
+    trails: Record<string, SubagentTrail>;
+    show(key: string, trail: SubagentTrail): void;
+    back(key: string): boolean;
+}
+export declare const useSubagentView: import("zustand").UseBoundStore<import("zustand").StoreApi<SubagentViewStore>>;
+export declare function useSubagentTrail(chatId: string): {
+    trail: SubagentTrail;
+    show(trail: SubagentTrail): void;
+};
+export declare function useOpenableSubagents(chatId: string): ChatSubagentItem[];
+export declare function useSubagentItem(chatId: string, toolUseId: string): ChatSubagentItem | null;
+export {};