@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/chat-client.js

@@ -9,286 +9,367 @@ const HISTORY_PAGE = 90;
  * reattach stays on the host these chats run on.
  */
 export class ChatClient {
-    transport;
-    sink;
-    providers;
-    mounted = new MountedRegistry();
-    unsubscribe = [];
-    earlier = new Map();
-    inspections = new Map();
-    preferences = null;
-    constructor(transport, sink, providers = null) {
-        this.transport = transport;
-        this.sink = sink;
-        this.providers = providers;
-        this.unsubscribe.push(transport.on('chat.event', ({ chatId, event, seq }) => {
-            this.sink.apply(chatId, event);
-            const entry = this.mounted.get(chatId);
-            if (entry && seq !== undefined) {
-                entry.seq = seq;
-            }
-        }), 
-        // Every chat on the machine, attached or not, so a node waiting on a person says so on a view nobody has open.
-        transport.on('chat.status', ({ chatId, info }) => this.sink.status(chatId, info)), transport.on('chat.bookmarks', ({ chatId, bookmarks }) => this.sink.bookmarks(chatId, bookmarks)), transport.on('chat.visuals', ({ chatId, visuals }) => this.sink.visuals(chatId, visuals)), transport.subscribeStatus((status) => this.onStatus(status)));
-        if (transport.status === 'open') {
-            void this.loadProviders();
-            void this.loadStatuses();
-        }
+  transport;
+  sink;
+  providers;
+  mounted = new MountedRegistry();
+  unsubscribe = [];
+  earlier = new Map();
+  inspections = new Map();
+  preferences = null;
+  constructor(transport, sink, providers = null) {
+    this.transport = transport;
+    this.sink = sink;
+    this.providers = providers;
+    this.unsubscribe.push(transport.on('chat.event', ({
+      chatId,
+      event,
+      seq
+    }) => {
+      this.sink.apply(chatId, event);
+      const entry = this.mounted.get(chatId);
+      if (entry && seq !== undefined) {
+        entry.seq = seq;
+      }
+    }),
+    // Every chat on the machine, attached or not, so a node waiting on a person says so on a view nobody has open.
+    transport.on('chat.status', ({
+      chatId,
+      info
+    }) => this.sink.status(chatId, info)), transport.on('chat.bookmarks', ({
+      chatId,
+      bookmarks
+    }) => this.sink.bookmarks(chatId, bookmarks)), transport.on('chat.visuals', ({
+      chatId,
+      visuals
+    }) => this.sink.visuals(chatId, visuals)), transport.subscribeStatus(status => this.onStatus(status)));
+    if (transport.status === 'open') {
+      void this.loadProviders();
+      void this.loadStatuses();
     }
-    inspect(chatId) {
-        const pending = this.inspections.get(chatId);
-        if (pending) {
-            return pending;
-        }
-        const read = this.transport.request('chat.attach', { chatId, historyLimit: 100 }).finally(async () => {
-            this.inspections.delete(chatId);
-            // A visible chat owns its attachment; an inspection must never release it.
-            if (!this.mounted.get(chatId)) {
-                await this.transport.request('chat.detach', { chatId }).catch(() => undefined);
-            }
-        });
-        this.inspections.set(chatId, read);
-        return read;
+  }
+  inspect(chatId) {
+    const pending = this.inspections.get(chatId);
+    if (pending) {
+      return pending;
     }
-    /* Answers false when the transport is not connected; the chat opens once it is. */
-    async open(chatId, options) {
-        this.mounted.set(chatId, { ...options, attached: false });
-        try {
-            await this.attach(chatId);
-            return true;
-        }
-        catch (e) {
-            if (isConnectionError(e)) {
-                return false;
-            }
-            throw e;
-        }
+    const read = this.transport.request('chat.attach', {
+      chatId,
+      historyLimit: 100
+    }).finally(async () => {
+      this.inspections.delete(chatId);
+      // A visible chat owns its attachment; an inspection must never release it.
+      if (!this.mounted.get(chatId)) {
+        await this.transport.request('chat.detach', {
+          chatId
+        }).catch(() => undefined);
+      }
+    });
+    this.inspections.set(chatId, read);
+    return read;
+  }
+  /* Answers false when the transport is not connected; the chat opens once it is. */
+  async open(chatId, options) {
+    this.mounted.set(chatId, {
+      ...options,
+      attached: false
+    });
+    try {
+      await this.attach(chatId);
+      return true;
+    } catch (e) {
+      if (isConnectionError(e)) {
+        return false;
+      }
+      throw e;
     }
-    /*
-     * Points a chat that has not spoken yet at another CLI. The host fixes a chat's provider when
-     * it registers the chat, so the only way over is to drop the empty one and register it again.
-     * The row stays until the attach of the new one replaces it, so a view keeps what it drew.
-     */
-    async retarget(chatId, provider, selection) {
-        const entry = this.mounted.get(chatId);
-        if (!entry) {
-            return;
-        }
-        // The account belonged to the CLI the chat leaves, and the seq to its stream: the new chat's
-        // stream starts over, so offering it the old seq would read as nothing missed and reset nothing.
-        const { attached: _attached, account: _account, seq: _seq, ...options } = entry;
-        this.mounted.delete(chatId);
-        await this.transport.request('chat.kill', { chatId });
-        try {
-            await this.open(chatId, { ...options, provider, selection });
-        }
-        catch (e) {
-            this.sink.forget(chatId);
-            throw e;
-        }
+  }
+  /*
+   * Points a chat that has not spoken yet at another CLI. The host fixes a chat's provider when
+   * it registers the chat, so the only way over is to drop the empty one and register it again.
+   * The row stays until the attach of the new one replaces it, so a view keeps what it drew.
+   */
+  async retarget(chatId, provider, selection) {
+    const entry = this.mounted.get(chatId);
+    if (!entry) {
+      return;
     }
-    /*
-     * Tells the host what a chat it starts on its own is made with while this socket is connected,
-     * since no client mounting that chat sends a composer preference. Said again on every fresh socket.
-     */
-    setPreferences(preferences) {
-        this.preferences = preferences;
-        this.sendPreferences();
+    // The account belonged to the CLI the chat leaves, and the seq to its stream: the new chat's
+    // stream starts over, so offering it the old seq would read as nothing missed and reset nothing.
+    const {
+      attached: _attached,
+      account: _account,
+      seq: _seq,
+      ...options
+    } = entry;
+    this.mounted.delete(chatId);
+    await this.transport.request('chat.kill', {
+      chatId
+    });
+    try {
+      await this.open(chatId, {
+        ...options,
+        provider,
+        selection
+      });
+    } catch (e) {
+      this.sink.forget(chatId);
+      throw e;
     }
-    async detach(chatId) {
-        const entry = this.mounted.get(chatId);
-        this.mounted.delete(chatId);
-        if (!entry?.attached) {
-            return;
-        }
-        try {
-            await this.transport.request('chat.detach', { chatId });
-        }
-        catch {
-            // The socket closing detaches every chat server-side anyway.
-        }
+  }
+  /*
+   * Tells the host what a chat it starts on its own is made with while this socket is connected,
+   * since no client mounting that chat sends a composer preference. Said again on every fresh socket.
+   */
+  setPreferences(preferences) {
+    this.preferences = preferences;
+    this.sendPreferences();
+  }
+  async detach(chatId) {
+    const entry = this.mounted.get(chatId);
+    this.mounted.delete(chatId);
+    if (!entry?.attached) {
+      return;
     }
-    /* Current hosts return the stable turn id; older compatible ones only report whether the message queued. */
-    async send(chatId, text, extras = {}) {
-        return this.transport.request('chat.send', {
-            chatId,
-            text,
-            delivery: extras.delivery,
-            mentions: extras.mentions,
-            skills: extras.skills,
-            chats: extras.chats,
-            quoteSource: extras.quoteSource,
-            attachments: extras.attachments
-        });
+    try {
+      await this.transport.request('chat.detach', {
+        chatId
+      });
+    } catch {
+      // The socket closing detaches every chat server-side anyway.
     }
-    /* Marks a message; the list every client of the chat holds comes back as `chat.bookmarks`. */
-    async addBookmark(chatId, itemId, name) {
-        const { bookmarks } = await this.transport.request('chat.addBookmark', { chatId, itemId, ...(name === undefined ? {} : { name }) });
-        return bookmarks;
+  }
+  /* Current hosts return the stable turn id; older compatible ones only report whether the message queued. */
+  async send(chatId, text, extras = {}) {
+    return this.transport.request('chat.send', {
+      chatId,
+      text,
+      delivery: extras.delivery,
+      mentions: extras.mentions,
+      skills: extras.skills,
+      chats: extras.chats,
+      quoteSource: extras.quoteSource,
+      attachments: extras.attachments
+    });
+  }
+  /* Marks a message; the list every client of the chat holds comes back as `chat.bookmarks`. */
+  async addBookmark(chatId, itemId, name) {
+    const {
+      bookmarks
+    } = await this.transport.request('chat.addBookmark', {
+      chatId,
+      itemId,
+      ...(name === undefined ? {} : {
+        name
+      })
+    });
+    return bookmarks;
+  }
+  /* An empty name takes the name away. */
+  async renameBookmark(chatId, itemId, name) {
+    const {
+      bookmarks
+    } = await this.transport.request('chat.renameBookmark', {
+      chatId,
+      itemId,
+      name
+    });
+    return bookmarks;
+  }
+  async removeBookmark(chatId, itemId) {
+    const {
+      bookmarks
+    } = await this.transport.request('chat.removeBookmark', {
+      chatId,
+      itemId
+    });
+    return bookmarks;
+  }
+  /* Takes a visual and its page out of the chat for good; the list every client of the chat holds comes back as `chat.visuals`. */
+  async removeVisual(chatId, visualId) {
+    const {
+      visuals
+    } = await this.transport.request('chat.removeVisual', {
+      chatId,
+      visualId
+    });
+    return visuals;
+  }
+  /* What this chat's CLI would run as a skill, for the composer's `$` picker. */
+  async listSkills(chatId) {
+    const {
+      skills
+    } = await this.transport.request('skills.list', {
+      chatId
+    });
+    return skills;
+  }
+  /* Starts the chat over; refused with `chat-busy` while a turn runs, unless `force` stops that turn. */
+  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);
+    await this.transport.request('chat.kill', {
+      chatId
+    });
+  }
+  /*
+   * What every chat on this machine is doing right now. `chat.status` only carries a change, so a
+   * window that just opened or came back from a lost socket asks for the standing answer.
+   */
+  async loadStatuses() {
+    try {
+      const {
+        chats
+      } = await this.transport.request('chat.list', {});
+      for (const info of chats) {
+        this.sink.status(info.chatId, info);
+      }
+    } catch {
+      // The next status event says it instead; an older host never answers this at all.
     }
-    /* An empty name takes the name away. */
-    async renameBookmark(chatId, itemId, name) {
-        const { bookmarks } = await this.transport.request('chat.renameBookmark', { chatId, itemId, name });
-        return bookmarks;
+  }
+  async loadProviders() {
+    if (!this.providers) {
+      return;
     }
-    async removeBookmark(chatId, itemId) {
-        const { bookmarks } = await this.transport.request('chat.removeBookmark', { chatId, itemId });
-        return bookmarks;
+    try {
+      const {
+        providers
+      } = await this.transport.request('provider.list', {});
+      this.providers.setProviders(providers);
+    } catch {
+      // The list comes with the next connection; pickers show what they had.
     }
-    /* Takes a visual and its page out of the chat for good; the list every client of the chat holds comes back as `chat.visuals`. */
-    async removeVisual(chatId, visualId) {
-        const { visuals } = await this.transport.request('chat.removeVisual', { chatId, visualId });
-        return visuals;
+  }
+  /*
+   * The page before the oldest one this chat holds, one request per chat at a time. A cursor the
+   * host no longer knows means the thread changed under it, so the chat is read again from its end.
+   */
+  loadEarlier(chatId, cursor) {
+    const running = this.earlier.get(chatId);
+    if (running) {
+      return running;
     }
-    /* What this chat's CLI would run as a skill, for the composer's `$` picker. */
-    async listSkills(chatId) {
-        const { skills } = await this.transport.request('skills.list', { chatId });
-        return skills;
+    const read = this.transport.request('chat.history', {
+      chatId,
+      cursor,
+      limit: HISTORY_PAGE
+    }).then(page => this.sink.prepend(chatId, cursor, page)).catch(async e => {
+      const entry = this.mounted.get(chatId);
+      if (errorCode(e) !== 'history-expired' || !entry) {
+        throw e;
+      }
+      delete entry.seq;
+      await this.attach(chatId);
+    }).finally(() => this.earlier.delete(chatId));
+    this.earlier.set(chatId, read);
+    return read;
+  }
+  isMounted(chatId) {
+    return this.mounted.has(chatId);
+  }
+  /* Lets go of the machine; the chats keep running there, the host only stops streaming them here. */
+  dispose() {
+    for (const off of this.unsubscribe) {
+      off();
     }
-    /* Starts the chat over; refused with `chat-busy` while a turn runs, unless `force` stops that turn. */
-    async clear(chatId, force = false) {
-        await this.transport.request('chat.clear', { chatId, ...(force ? { force: true } : {}) });
+    this.unsubscribe.length = 0;
+    for (const chatId of [...this.mounted.keys()]) {
+      void this.detach(chatId);
     }
-    /*
-     * 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 });
+  }
+  /*
+   * A reattach offers the last seq the store holds. The host answers only what came after it when
+   * it still has all of that, and the newest page of the thread otherwise, so a short drop costs a
+   * few events.
+   */
+  async attach(chatId) {
+    const entry = this.mounted.get(chatId);
+    if (!entry) {
+      return;
     }
-    async kill(chatId) {
-        this.mounted.delete(chatId);
-        this.sink.forget(chatId);
-        await this.transport.request('chat.kill', { chatId });
+    await this.transport.request('chat.create', {
+      chatId,
+      provider: entry.provider,
+      account: entry.account,
+      cwd: entry.cwd,
+      resume: entry.resume,
+      selection: entry.selection,
+      runtimeMode: entry.runtimeMode
+    });
+    // Closed or opened again in the meantime: an opening that is still there attaches itself.
+    if (this.mounted.get(chatId) !== entry) {
+      return;
     }
-    /*
-     * What every chat on this machine is doing right now. `chat.status` only carries a change, so a
-     * window that just opened or came back from a lost socket asks for the standing answer.
-     */
-    async loadStatuses() {
-        try {
-            const { chats } = await this.transport.request('chat.list', {});
-            for (const info of chats) {
-                this.sink.status(info.chatId, info);
-            }
-        }
-        catch {
-            // The next status event says it instead; an older host never answers this at all.
-        }
+    const since = entry.seq;
+    const result = await this.transport.request('chat.attach', {
+      chatId,
+      historyLimit: HISTORY_PAGE,
+      ...(since === undefined ? {} : {
+        since
+      })
+    });
+    const current = this.mounted.get(chatId);
+    if (current !== entry) {
+      // Its detach found nothing attached yet, and the host would stream this chat here until the socket closes.
+      if (!current) {
+        await this.transport.request('chat.detach', {
+          chatId
+        }).catch(() => undefined);
+      }
+      return;
     }
-    async loadProviders() {
-        if (!this.providers) {
-            return;
-        }
-        try {
-            const { providers } = await this.transport.request('provider.list', {});
-            this.providers.setProviders(providers);
-        }
-        catch {
-            // The list comes with the next connection; pickers show what they had.
-        }
+    entry.attached = true;
+    if (result.seq !== undefined) {
+      entry.seq = result.seq;
     }
-    /*
-     * The page before the oldest one this chat holds, one request per chat at a time. A cursor the
-     * host no longer knows means the thread changed under it, so the chat is read again from its end.
-     */
-    loadEarlier(chatId, cursor) {
-        const running = this.earlier.get(chatId);
-        if (running) {
-            return running;
-        }
-        const read = this.transport
-            .request('chat.history', { chatId, cursor, limit: HISTORY_PAGE })
-            .then((page) => this.sink.prepend(chatId, cursor, page))
-            .catch(async (e) => {
-            const entry = this.mounted.get(chatId);
-            if (errorCode(e) !== 'history-expired' || !entry) {
-                throw e;
-            }
-            delete entry.seq;
-            await this.attach(chatId);
-        })
-            .finally(() => this.earlier.delete(chatId));
-        this.earlier.set(chatId, read);
-        return read;
+    if (result.events && since !== undefined) {
+      for (const event of result.events) {
+        this.sink.apply(chatId, event);
+      }
+    } else {
+      const page = result.history === undefined ? undefined : {
+        history: result.history,
+        pending: result.pending ?? [],
+        subagents: result.subagents ?? []
+      };
+      this.sink.reset(chatId, result.info, result.items, page);
     }
-    isMounted(chatId) {
-        return this.mounted.has(chatId);
+    // A host without bookmarks or visuals sends none, and then this chat has none.
+    this.sink.bookmarks(chatId, result.bookmarks ?? []);
+    this.sink.visuals(chatId, result.visuals ?? []);
+  }
+  sendPreferences() {
+    if (this.preferences === null) {
+      return;
     }
-    /* Lets go of the machine; the chats keep running there, the host only stops streaming them here. */
-    dispose() {
-        for (const off of this.unsubscribe) {
-            off();
-        }
-        this.unsubscribe.length = 0;
-        for (const chatId of [...this.mounted.keys()]) {
-            void this.detach(chatId);
-        }
+    void this.transport.request('chat.setPreferences', this.preferences).catch(() => undefined);
+  }
+  onStatus(status) {
+    if (status === 'open') {
+      this.sendPreferences();
+      void this.loadProviders();
+      void this.loadStatuses();
+      void this.mounted.reattachAll(chatId => this.attach(chatId));
+      return;
     }
-    /*
-     * A reattach offers the last seq the store holds. The host answers only what came after it when
-     * it still has all of that, and the newest page of the thread otherwise, so a short drop costs a
-     * few events.
-     */
-    async attach(chatId) {
-        const entry = this.mounted.get(chatId);
-        if (!entry) {
-            return;
-        }
-        await this.transport.request('chat.create', {
-            chatId,
-            provider: entry.provider,
-            account: entry.account,
-            cwd: entry.cwd,
-            resume: entry.resume,
-            selection: entry.selection,
-            runtimeMode: entry.runtimeMode
-        });
-        // Closed or opened again in the meantime: an opening that is still there attaches itself.
-        if (this.mounted.get(chatId) !== entry) {
-            return;
-        }
-        const since = entry.seq;
-        const result = await this.transport.request('chat.attach', { chatId, historyLimit: HISTORY_PAGE, ...(since === undefined ? {} : { since }) });
-        const current = this.mounted.get(chatId);
-        if (current !== entry) {
-            // Its detach found nothing attached yet, and the host would stream this chat here until the socket closes.
-            if (!current) {
-                await this.transport.request('chat.detach', { chatId }).catch(() => undefined);
-            }
-            return;
-        }
-        entry.attached = true;
-        if (result.seq !== undefined) {
-            entry.seq = result.seq;
-        }
-        if (result.events && since !== undefined) {
-            for (const event of result.events) {
-                this.sink.apply(chatId, event);
-            }
-        }
-        else {
-            const page = result.history === undefined ? undefined : { history: result.history, pending: result.pending ?? [], subagents: result.subagents ?? [] };
-            this.sink.reset(chatId, result.info, result.items, page);
-        }
-        // A host without bookmarks or visuals sends none, and then this chat has none.
-        this.sink.bookmarks(chatId, result.bookmarks ?? []);
-        this.sink.visuals(chatId, result.visuals ?? []);
-    }
-    sendPreferences() {
-        if (this.preferences === null) {
-            return;
-        }
-        void this.transport.request('chat.setPreferences', this.preferences).catch(() => undefined);
-    }
-    onStatus(status) {
-        if (status === 'open') {
-            this.sendPreferences();
-            void this.loadProviders();
-            void this.loadStatuses();
-            void this.mounted.reattachAll((chatId) => this.attach(chatId));
-            return;
-        }
-        this.mounted.detachAll();
-    }
-}
+    this.mounted.detachAll();
+  }
+}

package/dist/chat/chat-references.js

@@ -1,5 +1,5 @@
 /* The chats an `@query` offers: never the chat typing it or one already attached. */
 export function chatSuggestions(chats, query, exclude, limit) {
-    const needle = query.toLowerCase();
-    return chats.filter((chat) => !exclude.includes(chat.id) && chat.title.toLowerCase().includes(needle)).slice(0, limit);
-}
+  const needle = query.toLowerCase();
+  return chats.filter(chat => !exclude.includes(chat.id) && chat.title.toLowerCase().includes(needle)).slice(0, limit);
+}

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

@@ -0,0 +1,5 @@
+import type { EffortStep } from './logic/effort.js';
+type Stepper = (step: EffortStep) => void;
+export declare function registerEffortStepper(key: string, stepper: Stepper): () => void;
+export declare function stepEffortFromComposer(key: string, step: EffortStep): boolean;
+export {};