@adecore/agents-react 0.31.11 → 0.32.0

package/dist/chat/account-choice.js

@@ -1,3 +1,4 @@
+import { c as _c } from "react/compiler-runtime";
 import { useMemo } from 'react';
 import { accountName, accountsOfKind, hasAccountChoice, offeredAccounts } from '../agents/accounts.js';
 import { useProviderAccounts } from '../state/provider-accounts.js';
@@ -7,24 +8,93 @@ import { useProviders } from '../state/providers.js';
  * the CLI has fewer than two accounts that are on: with one there is nothing to choose or tell apart.
  */
 export function useAccountChoice(kind, account) {
-    const accounts = useProviderAccounts((row) => row.accounts);
-    const providerName = useProviders((row) => row.providers.find((entry) => entry.kind === kind)?.name) ?? kind ?? '';
-    return useMemo(() => {
-        if (kind === null || accounts === null) {
-            return null;
-        }
-        const entries = accountsOfKind(accounts, kind);
-        if (!hasAccountChoice(entries)) {
-            return null;
-        }
-        const currentId = account ?? kind;
-        return {
-            accounts,
-            offered: offeredAccounts(entries, currentId),
-            currentId,
-            current: entries.find((entry) => entry.id === currentId) ?? null,
-            providerName,
-            nameOf: (entry) => accountName(entry, providerName)
-        };
-    }, [accounts, kind, account, providerName]);
+  const $ = _c(7);
+  const accounts = useProviderAccounts(_temp);
+  const providerName = useProviders(row_0 => row_0.providers.find(entry => entry.kind === kind)?.name) ?? kind ?? "";
+  let t0;
+  if ($[0] !== account || $[1] !== accounts || $[2] !== kind || $[3] !== providerName) {
+    bb0: {
+      if (kind === null || accounts === null) {
+        t0 = null;
+        break bb0;
+      }
+      const entries = accountsOfKind(accounts, kind);
+      if (!hasAccountChoice(entries)) {
+        t0 = null;
+        break bb0;
+      }
+      const currentId = account ?? kind;
+      let t1;
+      if ($[5] !== providerName) {
+        t1 = entry_1 => accountName(entry_1, providerName);
+        $[5] = providerName;
+        $[6] = t1;
+      } else {
+        t1 = $[6];
+      }
+      t0 = {
+        accounts,
+        offered: offeredAccounts(entries, currentId),
+        currentId,
+        current: entries.find(entry_0 => entry_0.id === currentId) ?? null,
+        providerName,
+        nameOf: t1
+      };
+    }
+    $[0] = account;
+    $[1] = accounts;
+    $[2] = kind;
+    $[3] = providerName;
+    $[4] = t0;
+  } else {
+    t0 = $[4];
+  }
+  return t0;
 }
+// One object each, so a render that changes nothing hands back the same answer.
+function _temp(row) {
+  return row.accounts;
+}
+const LOADING = {
+  status: 'loading'
+};
+const UNSUPPORTED = {
+  status: 'unsupported'
+};
+/* `useNewAccountChoice` without React, for its tests. */
+export function newAccountChoiceOf(row, kind, providerName) {
+  if (kind === null || !row.loaded) {
+    return LOADING;
+  }
+  const entries = accountsOfKind(row.accounts, kind);
+  // An older machine lists no accounts at all, or none of a CLI it does not know.
+  if (entries.length === 0) {
+    return UNSUPPORTED;
+  }
+  return {
+    status: 'ready',
+    offered: offeredAccounts(entries, undefined),
+    providerName,
+    nameOf: entry => accountName(entry, providerName)
+  };
+}
+/* The accounts a new chat or agent of this CLI may start under on the machine in scope. */
+export function useNewAccountChoice(kind) {
+  const $ = _c(4);
+  const row = useProviderAccounts(_temp2);
+  const providerName = useProviders(entry_0 => entry_0.providers.find(provider => provider.kind === kind)?.name) ?? kind ?? "";
+  let t0;
+  if ($[0] !== kind || $[1] !== providerName || $[2] !== row) {
+    t0 = newAccountChoiceOf(row, kind, providerName);
+    $[0] = kind;
+    $[1] = providerName;
+    $[2] = row;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  return t0;
+}
+function _temp2(entry) {
+  return entry;
+}

package/dist/chat/actions.js

@@ -1,71 +1,138 @@
+import { c as _c } from "react/compiler-runtime";
 import i18next from 'i18next';
 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. */
 export function transportActions(transport) {
-    return {
-        clear: async (chatId, force) => {
-            await transport.request('chat.clear', { chatId, ...(force ? { force: true } : {}) });
-        },
-        stopTurn: async (chatId, subagents) => {
-            await transport.request('chat.cancel', { chatId, ...(subagents ? { subagents: true } : {}) });
-        },
-        unqueue: async (chatId, messageId) => {
-            const { message } = await transport.request('chat.unqueue', { chatId, messageId });
-            // A host answers without the message once it went out, which is what the composer tells a person.
-            if (message === undefined) {
-                throw new ChatTransportError('request-not-found', i18next.t('agent-chat:composer.queue.alreadySent'));
-            }
-        },
-        sendNow: async (chatId, messageId) => {
-            await transport.request('chat.sendNow', { chatId, messageId });
-        },
-        compact: async (chatId) => {
-            await transport.request('chat.compact', { chatId });
-        },
-        configure: async (chatId, patch) => {
-            await transport.request('chat.configure', { chatId, ...patch });
-        },
-        continueOn: async (chatId, account) => {
-            await transport.request('chat.continueOn', { chatId, account });
-        },
-        turnDiff: async (chatId, turnId) => (await transport.request('chat.turnDiff', { chatId, turnId })).diff,
-        stopSubagent: async (chatId, toolUseId) => {
-            await transport.request('chat.stopSubagent', { chatId, toolUseId });
-        },
-        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 }) });
-        },
-        answer: async (chatId, requestId, answers) => {
-            await transport.request('chat.answer', { chatId, requestId, answers });
-        },
-        dismiss: async (chatId, itemId) => {
-            await transport.request('chat.dismiss', { chatId, itemId });
-        }
-    };
+  return {
+    clear: async (chatId, force) => {
+      await transport.request('chat.clear', {
+        chatId,
+        ...(force ? {
+          force: true
+        } : {})
+      });
+    },
+    stopTurn: async (chatId, subagents) => {
+      await transport.request('chat.cancel', {
+        chatId,
+        ...(subagents ? {
+          subagents: true
+        } : {})
+      });
+    },
+    unqueue: async (chatId, messageId) => {
+      const {
+        message
+      } = await transport.request('chat.unqueue', {
+        chatId,
+        messageId
+      });
+      // A host answers without the message once it went out, which is what the composer tells a person.
+      if (message === undefined) {
+        throw new ChatTransportError('request-not-found', i18next.t('agent-chat:composer.queue.alreadySent'));
+      }
+    },
+    sendNow: async (chatId, messageId) => {
+      await transport.request('chat.sendNow', {
+        chatId,
+        messageId
+      });
+    },
+    compact: async chatId => {
+      await transport.request('chat.compact', {
+        chatId
+      });
+    },
+    configure: async (chatId, patch) => {
+      await transport.request('chat.configure', {
+        chatId,
+        ...patch
+      });
+    },
+    continueOn: async (chatId, account) => {
+      await transport.request('chat.continueOn', {
+        chatId,
+        account
+      });
+    },
+    turnDiff: async (chatId, turnId) => (await transport.request('chat.turnDiff', {
+      chatId,
+      turnId
+    })).diff,
+    stopSubagent: async (chatId, toolUseId) => {
+      await transport.request('chat.stopSubagent', {
+        chatId,
+        toolUseId
+      });
+    },
+    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
+        })
+      });
+    },
+    answer: async (chatId, requestId, answers) => {
+      await transport.request('chat.answer', {
+        chatId,
+        requestId,
+        answers
+      });
+    },
+    dismiss: async (chatId, itemId) => {
+      await transport.request('chat.dismiss', {
+        chatId,
+        itemId
+      });
+    }
+  };
 }
 const byTransport = new WeakMap();
 /* 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;
-    }
-    const { transport } = scope;
-    let actions = byTransport.get(transport);
-    if (actions === undefined) {
-        actions = transportActions(transport);
-        byTransport.set(transport, actions);
-    }
-    return actions;
+  const own = host.actions;
+  if (own !== null) {
+    return own;
+  }
+  const {
+    transport
+  } = scope;
+  let actions = byTransport.get(transport);
+  if (actions === undefined) {
+    actions = transportActions(transport);
+    byTransport.set(transport, actions);
+  }
+  return actions;
 }
 export function useChatActions() {
-    return actionsOf(useChatScope(), useChatHost());
-}
+  const $ = _c(3);
+  const t0 = useChatScope();
+  const t1 = useChatHost();
+  let t2;
+  if ($[0] !== t0 || $[1] !== t1) {
+    t2 = actionsOf(t0, t1);
+    $[0] = t0;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+}

package/dist/chat/activity.js

@@ -1,6 +1,6 @@
 export function backgroundCounts(tasks) {
-    return {
-        shells: tasks.filter((task) => task.kind === 'shell').length,
-        monitors: tasks.filter((task) => task.kind === 'monitor').length
-    };
-}
+  return {
+    shells: tasks.filter(task => task.kind === 'shell').length,
+    monitors: tasks.filter(task => task.kind === 'monitor').length
+  };
+}

package/dist/chat/attachments.js

@@ -2,85 +2,106 @@ import i18next from 'i18next';
 import { attachmentBytes, attachmentImageMime, CHAT_ATTACHMENTS_MAX_BYTES, CHAT_ATTACHMENTS_MAX_COUNT, CHAT_ATTACHMENT_MAX_BYTES } from '@adecore/agent-contracts';
 import { formatBytes as bytesOf } from '@adecore/ui/format';
 export function isImageAttachment(mime) {
-    return mime.startsWith('image/');
+  return mime.startsWith('image/');
 }
 /* The type on a file card: the extension, as long as it is short enough to read as one. */
 export function fileBadge(name) {
-    const dot = name.lastIndexOf('.');
-    if (dot <= 0 || dot === name.length - 1) {
-        return null;
-    }
-    const extension = name.slice(dot + 1);
-    return extension.length <= 5 ? extension.toUpperCase() : null;
+  const dot = name.lastIndexOf('.');
+  if (dot <= 0 || dot === name.length - 1) {
+    return null;
+  }
+  const extension = name.slice(dot + 1);
+  return extension.length <= 5 ? extension.toUpperCase() : null;
 }
 /* Whole kilobytes, which is all a row under a file name has room for, and a decimal once it runs into megabytes. */
 export function formatBytes(bytes) {
-    return bytesOf(bytes, bytes < 1024 * 1024);
+  return bytesOf(bytes, bytes < 1024 * 1024);
 }
 /* Which of the incoming files fit next to what the composer already holds, and why the rest do not. */
 export function checkAttachmentLimits(current, incoming, currentBytes = 0) {
-    const accepted = [];
-    const rejected = [];
-    let bytes = currentBytes;
-    for (const file of incoming) {
-        if (file.bytes === 0) {
-            rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.empty') });
-        }
-        else if (file.bytes > CHAT_ATTACHMENT_MAX_BYTES) {
-            rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.tooLarge', { size: formatBytes(CHAT_ATTACHMENT_MAX_BYTES) }) });
-        }
-        else if (current + accepted.length >= CHAT_ATTACHMENTS_MAX_COUNT) {
-            rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.tooMany', { count: CHAT_ATTACHMENTS_MAX_COUNT }) });
-        }
-        else if (bytes + file.bytes > CHAT_ATTACHMENTS_MAX_BYTES) {
-            rejected.push({
-                name: file.name,
-                reason: i18next.t('agent-chat:attachments.rejected.tooHeavy', { size: formatBytes(CHAT_ATTACHMENTS_MAX_BYTES) })
-            });
-        }
-        else {
-            accepted.push(file);
-            bytes += file.bytes;
-        }
+  const accepted = [];
+  const rejected = [];
+  let bytes = currentBytes;
+  for (const file of incoming) {
+    if (file.bytes === 0) {
+      rejected.push({
+        name: file.name,
+        reason: i18next.t('agent-chat:attachments.rejected.empty')
+      });
+    } else if (file.bytes > CHAT_ATTACHMENT_MAX_BYTES) {
+      rejected.push({
+        name: file.name,
+        reason: i18next.t('agent-chat:attachments.rejected.tooLarge', {
+          size: formatBytes(CHAT_ATTACHMENT_MAX_BYTES)
+        })
+      });
+    } else if (current + accepted.length >= CHAT_ATTACHMENTS_MAX_COUNT) {
+      rejected.push({
+        name: file.name,
+        reason: i18next.t('agent-chat:attachments.rejected.tooMany', {
+          count: CHAT_ATTACHMENTS_MAX_COUNT
+        })
+      });
+    } else if (bytes + file.bytes > CHAT_ATTACHMENTS_MAX_BYTES) {
+      rejected.push({
+        name: file.name,
+        reason: i18next.t('agent-chat:attachments.rejected.tooHeavy', {
+          size: formatBytes(CHAT_ATTACHMENTS_MAX_BYTES)
+        })
+      });
+    } else {
+      accepted.push(file);
+      bytes += file.bytes;
     }
-    return { accepted, rejected };
+  }
+  return {
+    accepted,
+    rejected
+  };
 }
 /* The files in a paste or a drop; a paste of plain text gives none. */
 export function filesOf(transfer) {
-    return transfer ? [...transfer.files] : [];
+  return transfer ? [...transfer.files] : [];
 }
 function readAsBase64(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onerror = () => reject(reader.error ?? new Error(i18next.t('agent-chat:attachments.unreadable', { name: file.name })));
-        reader.onload = () => {
-            const url = String(reader.result);
-            resolve(url.slice(url.indexOf(',') + 1));
-        };
-        reader.readAsDataURL(file);
-    });
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error(i18next.t('agent-chat:attachments.unreadable', {
+      name: file.name
+    })));
+    reader.onload = () => {
+      const url = String(reader.result);
+      resolve(url.slice(url.indexOf(',') + 1));
+    };
+    reader.readAsDataURL(file);
+  });
 }
 // A pasted screenshot has no name; the clock gives it one so the row and the agent can tell them apart.
 function nameFor(file, index) {
-    return file.name || `pasted-${Date.now()}-${index + 1}.${file.type.split('/')[1] ?? 'bin'}`;
+  return file.name || `pasted-${Date.now()}-${index + 1}.${file.type.split('/')[1] ?? 'bin'}`;
 }
 export async function readAttachments(files) {
-    return Promise.all(files.map(async (file, index) => ({
-        name: nameFor(file, index),
-        mime: attachmentImageMime({ name: file.name, mime: file.type }) ?? (file.type || 'application/octet-stream'),
-        data: await readAsBase64(file)
-    })));
+  return Promise.all(files.map(async (file, index) => ({
+    name: nameFor(file, index),
+    mime: attachmentImageMime({
+      name: file.name,
+      mime: file.type
+    }) ?? (file.type || 'application/octet-stream'),
+    data: await readAsBase64(file)
+  })));
 }
 /* Files the host already stored for a chat, back as uploads the composer can hold again. */
 export async function readStoredAttachments(read, stored) {
-    const files = await Promise.all(stored.map(async (attachment) => new File([await read(attachment)], attachment.name, { type: attachment.mime })));
-    return readAttachments(files);
+  const files = await Promise.all(stored.map(async attachment => new File([await read(attachment)], attachment.name, {
+    type: attachment.mime
+  })));
+  return readAttachments(files);
 }
 /* A preview of a file the composer still holds; the bytes have not reached the host yet. */
 export function uploadPreviewUrl(upload) {
-    return `data:${upload.mime};base64,${upload.data}`;
+  return `data:${upload.mime};base64,${upload.data}`;
 }
 /* What the file weighs, from the base64 the composer is holding: three bytes per four characters. */
 export function uploadBytes(upload) {
-    return attachmentBytes(upload.data);
-}
+  return attachmentBytes(upload.data);
+}

package/dist/chat/bookmarks.js

@@ -1,72 +1,82 @@
 import i18next from 'i18next';
 import { create } from 'zustand';
 import { jumpToTimelineItem } from './timeline-scroll.js';
-export const useBookmarkNaming = create((set) => ({
+export const useBookmarkNaming = create(set => ({
+  chatKey: null,
+  itemId: null,
+  open: (chatKey, itemId) => set({
+    chatKey,
+    itemId
+  }),
+  close: () => set({
     chatKey: null,
-    itemId: null,
-    open: (chatKey, itemId) => set({ chatKey, itemId }),
-    close: () => set({ chatKey: null, itemId: null })
+    itemId: null
+  })
 }));
 function failed(host, title, e) {
-    host.notify({ title, description: e instanceof Error ? e.message : String(e), kind: 'error' });
+  host.notify({
+    title,
+    description: e instanceof Error ? e.message : String(e),
+    kind: 'error'
+  });
 }
 async function add(scope, host, chatId, itemId, name) {
-    try {
-        await scope.chats.addBookmark(chatId, itemId, name);
-        return true;
-    }
-    catch (e) {
-        failed(host, i18next.t('agent-chat:bookmarks.addFailed'), e);
-        return false;
-    }
+  try {
+    await scope.chats.addBookmark(chatId, itemId, name);
+    return true;
+  } catch (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, host, chatId, itemId) {
-    useBookmarkNaming.getState().open(scope.keyOf(chatId), itemId);
-    if (!(await add(scope, host, chatId, itemId))) {
-        useBookmarkNaming.getState().close();
-    }
+  useBookmarkNaming.getState().open(scope.keyOf(chatId), itemId);
+  if (!(await add(scope, host, chatId, itemId))) {
+    useBookmarkNaming.getState().close();
+  }
 }
 /*
  * 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, host, chatId, itemId, name, previous) {
-    const next = name.trim();
-    if (next === (previous ?? '')) {
-        return;
-    }
-    if (next !== '') {
-        await add(scope, host, chatId, itemId, next);
-        return;
-    }
-    try {
-        await scope.chats.renameBookmark(chatId, itemId, '');
-    }
-    catch (e) {
-        failed(host, i18next.t('agent-chat:bookmarks.renameFailed'), e);
-    }
+  const next = name.trim();
+  if (next === (previous ?? '')) {
+    return;
+  }
+  if (next !== '') {
+    await add(scope, host, chatId, itemId, next);
+    return;
+  }
+  try {
+    await scope.chats.renameBookmark(chatId, itemId, '');
+  } catch (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, host, chatId, bookmark) {
-    try {
-        await scope.chats.removeBookmark(chatId, bookmark.itemId);
-    }
-    catch (e) {
-        failed(host, i18next.t('agent-chat:bookmarks.removeFailed'), e);
-        return;
+  try {
+    await scope.chats.removeBookmark(chatId, bookmark.itemId);
+  } catch (e) {
+    failed(host, i18next.t('agent-chat:bookmarks.removeFailed'), e);
+    return;
+  }
+  host.notify({
+    title: i18next.t('agent-chat:bookmarks.removed'),
+    kind: 'deleted',
+    action: {
+      label: i18next.t('agent-chat:common.action.undo'),
+      run: () => void add(scope, host, chatId, bookmark.itemId, bookmark.name)
     }
-    host.notify({
-        title: i18next.t('agent-chat:bookmarks.removed'),
-        kind: 'deleted',
-        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. */
 export function goToBookmark(scope, chatId, itemId, rename = false) {
-    const key = scope.keyOf(chatId);
-    if (rename) {
-        useBookmarkNaming.getState().open(key, itemId);
-    }
-    return jumpToTimelineItem(key, itemId);
-}
+  const key = scope.keyOf(chatId);
+  if (rename) {
+    useBookmarkNaming.getState().open(key, itemId);
+  }
+  return jumpToTimelineItem(key, itemId);
+}