@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/stash.js

@@ -11,80 +11,91 @@ 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') : [];
+  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
-    }));
+  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
+  }));
 }
 function stashedQuote(value) {
-    if (!isRecord(value) || typeof value.text !== 'string' || typeof value.chatId !== 'string' || typeof value.itemId !== 'string') {
-        return undefined;
-    }
-    return { text: value.text, chatId: value.chatId, itemId: value.itemId };
+  if (!isRecord(value) || typeof value.text !== 'string' || typeof value.chatId !== 'string' || typeof value.itemId !== 'string') {
+    return undefined;
+  }
+  return {
+    text: value.text,
+    chatId: value.chatId,
+    itemId: value.itemId
+  };
 }
 function stashedQuoteField(value) {
-    const quote = stashedQuote(value);
-    return quote === undefined ? {} : { quote };
+  const quote = stashedQuote(value);
+  return quote === undefined ? {} : {
+    quote
+  };
 }
 /* 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),
-            chats: strings(entry.chats),
-            attachments: attachments(entry.attachments),
-            ...stashedQuoteField(entry.quote),
-            createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
-        }))
-            .slice(0, STASH_LIMIT);
-    }
-    catch {
-        return [];
+  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),
+      chats: strings(entry.chats),
+      attachments: attachments(entry.attachments),
+      ...stashedQuoteField(entry.quote),
+      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);
+  return [entry, ...prompts].slice(0, STASH_LIMIT);
 }
 /*
  * What a draft looks like on the shelf; null when there is nothing worth putting there. A quote that
  * knows its reply stays apart, since it leads back to that reply in `chatId`; any other is folded into the text.
  */
 export function stashedFrom(draft, id, now, chatId) {
-    if (isEmptyDraft(draft)) {
-        return null;
-    }
-    const kept = draft.quote !== '' && draft.quoteSource !== null;
-    return {
-        id,
-        text: kept ? draft.text : withQuote(draft.quote, draft.text),
-        ...(kept ? { quote: { text: draft.quote, chatId, itemId: draft.quoteSource } } : {}),
-        mentions: [...draft.mentions],
-        skills: [...draft.skills],
-        chats: [...draft.chats],
-        attachments: draft.attachments.map((attachment) => ({ name: attachment.name, mime: attachment.mime, size: uploadBytes(attachment) })),
-        createdAt: now
-    };
+  if (isEmptyDraft(draft)) {
+    return null;
+  }
+  const kept = draft.quote !== '' && draft.quoteSource !== null;
+  return {
+    id,
+    text: kept ? draft.text : withQuote(draft.quote, draft.text),
+    ...(kept ? {
+      quote: {
+        text: draft.quote,
+        chatId,
+        itemId: draft.quoteSource
+      }
+    } : {}),
+    mentions: [...draft.mentions],
+    skills: [...draft.skills],
+    chats: [...draft.chats],
+    attachments: draft.attachments.map(attachment => ({
+      name: attachment.name,
+      mime: attachment.mime,
+      size: uploadBytes(attachment)
+    })),
+    createdAt: now
+  };
 }
 /* The limit of `chats` in a send. */
 export const STASH_CHATS_LIMIT = 16;
@@ -93,26 +104,35 @@ export const STASH_CHATS_LIMIT = 16;
  * order they were picked. `dropped` counts the chats left out because the project no longer has them.
  */
 export function restorableChats(stashed, referable, chatId) {
-    const others = stashed.filter((id) => id !== chatId);
-    const chats = others.filter((id) => referable.has(id));
-    return { chats: chats.slice(0, STASH_CHATS_LIMIT), dropped: others.length - chats.length };
+  const others = stashed.filter(id => id !== chatId);
+  const chats = others.filter(id => referable.has(id));
+  return {
+    chats: chats.slice(0, STASH_CHATS_LIMIT),
+    dropped: others.length - chats.length
+  };
 }
 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() }));
+export const useStash = createChatStore(() => ({
+  prompts: []
+}), store => store.setState({
+  prompts: storage.read()
+}));
 function write(prompts) {
-    useStash.setState({ prompts });
-    storage.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, chatId) {
-    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now(), chatId);
-    if (!entry) {
-        return false;
-    }
-    write(withStashed(useStash.getState().prompts, entry));
-    return true;
+  const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now(), chatId);
+  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));
-}
+  write(useStash.getState().prompts.filter(entry => entry.id !== id));
+}

package/dist/chat/subagent-conversation.js

@@ -3,16 +3,16 @@ 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: [],
-    pending: [],
-    source: null,
-    context: null,
-    cursor: null,
-    live: false,
-    loadingEarlier: false,
-    error: null,
-    unsupported: false
+  status: 'loading',
+  items: [],
+  pending: [],
+  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
@@ -20,27 +20,32 @@ export const INITIAL_CONVERSATION = {
  * 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 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;
     }
-    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 };
+  }
+  return {
+    items,
+    cursor: current.length === 0 ? pageCursor : currentCursor
+  };
 }
 function pendingOf(items) {
-    return items.filter((item) => (item.kind === 'approval' && item.decision === 'pending') || (item.kind === 'question' && item.state === 'pending'));
+  return items.filter(item => item.kind === 'approval' && item.decision === 'pending' || item.kind === 'question' && item.state === 'pending');
 }
 function messageOf(error) {
-    return error instanceof Error ? error.message : i18next.t('agent-chat:subagents.noAnswer');
+  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
@@ -49,125 +54,162 @@ function messageOf(error) {
  * 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;
+  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;
     }
-    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);
+    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
         });
-    }
-    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 });
-                const items = [...page.items, ...this.state.items];
-                this.set({ items, pending: page.pending ?? pendingOf(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;
+        const items = [...page.items, ...this.state.items];
+        this.set({
+          items,
+          pending: page.pending ?? pendingOf(items),
+          cursor: page.history.cursor,
+          live: page.live,
+          loadingEarlier: false
         });
-        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);
+      } 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;
     }
-    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,
-                pending: page.pending ?? pendingOf(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 });
-        }
+    this.disposed = true;
+    for (const off of this.unsubscribe.splice(0)) {
+      off();
     }
-    ask(extra) {
-        return this.transport.request('chat.subagent', { chatId: this.chatId, toolUseId: this.toolUseId, ...extra });
+    if (this.transport.status === 'open') {
+      void this.transport.request('chat.subagent', {
+        chatId: this.chatId,
+        toolUseId: this.toolUseId,
+        limit: 1,
+        watch: false
+      }).catch(() => undefined);
     }
-    enqueue(work) {
-        const next = this.queue.then(() => (this.disposed ? undefined : work()));
-        this.queue = next.catch(() => undefined);
-        return next;
+  }
+  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,
+        pending: page.pending ?? pendingOf(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
+      });
     }
-    set(patch) {
-        if (this.disposed) {
-            return;
-        }
-        this.state = { ...this.state, ...patch };
-        this.onChange(this.state);
+  }
+  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);
+  }
+}