@adecore/agents-react 0.31.12 → 0.33.0

package/dist/chat/subagent-list.js

@@ -2,104 +2,102 @@ import i18next from 'i18next';
 import { activeSubagents } from '@adecore/agent-contracts';
 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');
+  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 !== '');
+  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;
+  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;
+  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;
+  const word = statusWordOf(item, task);
+  if (word === 'running' && (child?.status === 'needs-you' || (child?.requests?.length ?? 0) > 0)) {
+    return 'waiting';
+  }
+  return word;
 }
 /* How far delegated work is: what settled as done, what still runs or waits, and how many of those wait on a person. */
 export function progressOf(states) {
-    return {
-        done: states.filter((state) => state === 'done').length,
-        total: states.length,
-        waiting: states.filter((state) => state === 'waiting').length,
-        active: states.filter((state) => state === 'running' || state === 'paused' || state === 'waiting').length
-    };
+  return {
+    done: states.filter(state => state === 'done').length,
+    total: states.length,
+    waiting: states.filter(state => state === 'waiting').length,
+    active: states.filter(state => state === 'running' || state === 'paused' || state === 'waiting').length
+  };
 }
 /* What the flyout over the composer lists (`activeSubagents`); `order` puts the rows from before the page first. */
 export function flyoutSubagents(order, structure) {
-    return activeSubagents(order.flatMap((id) => {
-        const item = structure[id];
-        return item === undefined ? [] : [item];
-    }));
+  return activeSubagents(order.flatMap(id => {
+    const item = structure[id];
+    return item === undefined ? [] : [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';
+  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;
+  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) });
+  // 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';
-    }
-    if (item.native?.agentId) {
-        return 'native';
-    }
-    return turnRunning ? null : 'mark';
+  if (item.status !== 'running') {
+    return null;
+  }
+  if (item.origin === 'ruimte') {
+    return item.childId === undefined ? null : 'task';
+  }
+  if (item.native?.agentId) {
+    return 'native';
+  }
+  return turnRunning ? null : 'mark';
 }
 export function stopLabel(stop) {
-    return i18next.t(`agent-chat:subagents.stop.${stop}`);
+  return i18next.t(`agent-chat:subagents.stop.${stop}`);
 }
 export function composerStopOf(shiftKey) {
-    return shiftKey ? 'turn-and-subagents' : 'turn';
+  return shiftKey ? 'turn-and-subagents' : 'turn';
 }
 export function composerStopLabel() {
-    return i18next.t('agent-chat:composer.stop');
-}
+  return i18next.t('agent-chat:composer.stop');
+}

package/dist/chat/subagent-support.js

@@ -4,11 +4,16 @@ import { create } from 'zustand';
  * 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 } });
+  unsupported: {},
+  markUnsupported(scopeId) {
+    if (get().unsupported[scopeId]) {
+      return;
     }
-}));
+    set({
+      unsupported: {
+        ...get().unsupported,
+        [scopeId]: true
+      }
+    });
+  }
+}));

package/dist/chat/subagent-view.js

@@ -1,5 +1,5 @@
+import { c as _c } from "react/compiler-runtime";
 import i18next from 'i18next';
-import { useMemo } from 'react';
 import { create } from 'zustand';
 import { useChatScope } from '../scope.js';
 import { useChatRow } from '../state/chats.js';
@@ -7,90 +7,178 @@ import { useSubagentSupport } from './subagent-support.js';
 export const MAIN_AGENT = [];
 const NO_ITEMS = [];
 export function crumbOf(item) {
-    return { toolUseId: item.toolUseId, description: item.description };
+  return {
+    toolUseId: item.toolUseId,
+    description: item.description
+  };
 }
 function stepLabel(step) {
-    return step.description || i18next.t('agent-chat:rows.subagent.label');
+  return step.description || i18next.t('agent-chat:rows.subagent.label');
 }
 /* A row in the main agent's thread or an entry of the flyout opens its conversation straight away. */
 export function openFromMain(step) {
-    return [step];
+  return [step];
 }
 export function openBelow(trail, step) {
-    return [...trail, step];
+  return [...trail, step];
 }
 export function trailTo(trail, depth) {
-    return depth <= 0 ? MAIN_AGENT : trail.slice(0, depth);
+  return depth <= 0 ? MAIN_AGENT : trail.slice(0, depth);
 }
 export function stepBack(trail) {
-    return trailTo(trail, trail.length - 1);
+  return trailTo(trail, trail.length - 1);
 }
 /*
  * A sub-agent's conversation is read back, so there is nobody to write to. The composer stays, since
  * the chat's own approvals and questions are answered there.
  */
 export function composerWrites(trail) {
-    return trail.length === 0;
+  return trail.length === 0;
 }
 /* The crumbs after the chat's own title, which the bar draws as the first crumb and the way back. */
 export function breadcrumbOf(trail) {
-    return trail.map((step, index) => ({ label: stepLabel(step), depth: index + 1, current: index === trail.length - 1 }));
+  return trail.map((step, index) => ({
+    label: stepLabel(step),
+    depth: index + 1,
+    current: index === trail.length - 1
+  }));
 }
 /* A row without a pointer of its own can only be opened by a machine that answers `chat.subagent` for it. */
 export function canOpenSubagent(item, machineRefused) {
-    return item.native !== undefined || !machineRefused;
+  return item.native !== undefined || !machineRefused;
 }
 /* The row of the call that opened a conversation, a nested one included, since its row is in the thread too. */
 export function subagentOf(structure, toolUseId) {
-    return Object.values(structure).find((item) => item.kind === 'subagent' && item.toolUseId === toolUseId) ?? null;
+  return Object.values(structure).find(item => item.kind === 'subagent' && item.toolUseId === toolUseId) ?? null;
 }
 /* The subagents a chat can open, in the order the thread has them. */
 export function openableSubagents(order, structure, machineRefused) {
-    return order.flatMap((id) => {
-        const item = structure[id];
-        return item?.kind === 'subagent' && canOpenSubagent(item, machineRefused) ? [item] : [];
-    });
+  return order.flatMap(id => {
+    const item = structure[id];
+    return item?.kind === 'subagent' && canOpenSubagent(item, machineRefused) ? [item] : [];
+  });
 }
 /*
  * What a chat shows in its place, for this page's life only: a look into a subagent is a moment
  * rather than a place, so it is never written to the project or to the host.
  */
 export const useSubagentView = create((set, get) => ({
-    trails: {},
-    show(key, trail) {
-        const trails = { ...get().trails };
-        if (trail.length === 0) {
-            delete trails[key];
-        }
-        else {
-            trails[key] = trail;
-        }
-        set({ trails });
-    },
-    back(key) {
-        const trail = get().trails[key];
-        if (trail === undefined || trail.length === 0) {
-            return false;
-        }
-        get().show(key, stepBack(trail));
-        return true;
+  trails: {},
+  show(key, trail) {
+    const trails = {
+      ...get().trails
+    };
+    if (trail.length === 0) {
+      delete trails[key];
+    } else {
+      trails[key] = trail;
+    }
+    set({
+      trails
+    });
+  },
+  back(key) {
+    const trail = get().trails[key];
+    if (trail === undefined || trail.length === 0) {
+      return false;
     }
+    get().show(key, stepBack(trail));
+    return true;
+  }
 }));
 /* The trail of a chat in the scope this is rendered in, and a way to set it. */
 export function useSubagentTrail(chatId) {
-    const key = useChatScope().keyOf(chatId);
-    const trail = useSubagentView((s) => s.trails[key] ?? MAIN_AGENT);
-    return { trail, show: (next) => useSubagentView.getState().show(key, next) };
+  const $ = _c(10);
+  const t0 = useChatScope();
+  let t1;
+  if ($[0] !== chatId || $[1] !== t0) {
+    t1 = t0.keyOf(chatId);
+    $[0] = chatId;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const key = t1;
+  let t2;
+  if ($[3] !== key) {
+    t2 = s => s.trails[key] ?? MAIN_AGENT;
+    $[3] = key;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  const trail = useSubagentView(t2);
+  let t3;
+  if ($[5] !== key) {
+    t3 = next => useSubagentView.getState().show(key, next);
+    $[5] = key;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t3 || $[8] !== trail) {
+    t4 = {
+      trail,
+      show: t3
+    };
+    $[7] = t3;
+    $[8] = trail;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  return t4;
 }
 export function useOpenableSubagents(chatId) {
-    const { id } = useChatScope();
-    const refused = useSubagentSupport((s) => s.unsupported[id] === true);
-    // The structure and not the items, so a delta growing a reply does not walk the thread again.
-    const order = useChatRow(chatId, (row) => row?.order);
-    const structure = useChatRow(chatId, (row) => row?.structure);
-    return useMemo(() => (structure === undefined ? [] : openableSubagents(order ?? NO_ITEMS, structure, refused)), [order, structure, refused]);
+  const $ = _c(6);
+  const {
+    id
+  } = useChatScope();
+  let t0;
+  if ($[0] !== id) {
+    t0 = s => s.unsupported[id] === true;
+    $[0] = id;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const refused = useSubagentSupport(t0);
+  const order = useChatRow(chatId, _temp);
+  const structure = useChatRow(chatId, _temp2);
+  let t1;
+  if ($[2] !== order || $[3] !== refused || $[4] !== structure) {
+    t1 = structure === undefined ? [] : openableSubagents(order ?? NO_ITEMS, structure, refused);
+    $[2] = order;
+    $[3] = refused;
+    $[4] = structure;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  return t1;
+}
+function _temp2(row_0) {
+  return row_0?.structure;
+}
+function _temp(row) {
+  return row?.order;
 }
 export function useSubagentItem(chatId, toolUseId) {
-    const structure = useChatRow(chatId, (row) => row?.structure);
-    return useMemo(() => (structure === undefined ? null : subagentOf(structure, toolUseId)), [structure, toolUseId]);
+  const $ = _c(3);
+  const structure = useChatRow(chatId, _temp3);
+  let t0;
+  if ($[0] !== structure || $[1] !== toolUseId) {
+    t0 = structure === undefined ? null : subagentOf(structure, toolUseId);
+    $[0] = structure;
+    $[1] = toolUseId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
 }
+function _temp3(row) {
+  return row?.structure;
+}

package/dist/chat/thumbnails.js

@@ -1,3 +1,4 @@
+import { c as _c } from "react/compiler-runtime";
 import i18next from 'i18next';
 import { useEffect, useState } from 'react';
 import { uploadPreviewUrl } from './attachments.js';
@@ -5,29 +6,29 @@ import { uploadPreviewUrl } from './attachments.js';
 export const THUMBNAIL_PX = 256;
 /* The square in the middle of an image that a thumbnail shows, the same part `object-cover` would. */
 export function thumbnailCrop(width, height, max = THUMBNAIL_PX) {
-    const size = Math.max(1, Math.min(width, height));
-    return {
-        sx: Math.max(0, Math.floor((width - size) / 2)),
-        sy: Math.max(0, Math.floor((height - size) / 2)),
-        size,
-        out: Math.min(max, size)
-    };
+  const size = Math.max(1, Math.min(width, height));
+  return {
+    sx: Math.max(0, Math.floor((width - size) / 2)),
+    sy: Math.max(0, Math.floor((height - size) / 2)),
+    size,
+    out: Math.min(max, size)
+  };
 }
 function bytesOf(base64) {
-    const binary = atob(base64);
-    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
+  const binary = atob(base64);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
 }
 function dataUrlOf(blob) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onerror = () => reject(reader.error ?? new Error(i18next.t('agent-chat:attachments.unreadableThumbnail')));
-        reader.onload = () => resolve(String(reader.result));
-        reader.readAsDataURL(blob);
-    });
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error(i18next.t('agent-chat:attachments.unreadableThumbnail')));
+    reader.onload = () => resolve(String(reader.result));
+    reader.readAsDataURL(blob);
+  });
 }
 /*
  * A still of the middle of an image, decoded once: a browser decodes a full data URL again on every
@@ -35,54 +36,81 @@ function dataUrlOf(blob) {
  * cannot be decoded this way (an SVG, a browser without `OffscreenCanvas`) falls back to the image.
  */
 async function makeThumbnail(upload) {
-    try {
-        const bitmap = await createImageBitmap(new Blob([bytesOf(upload.data)], { type: upload.mime }));
-        const crop = thumbnailCrop(bitmap.width, bitmap.height);
-        const canvas = new OffscreenCanvas(crop.out, crop.out);
-        const context = canvas.getContext('2d');
-        if (!context) {
-            bitmap.close();
-            return uploadPreviewUrl(upload);
-        }
-        context.drawImage(bitmap, crop.sx, crop.sy, crop.size, crop.size, 0, 0, crop.out, crop.out);
-        bitmap.close();
-        return await dataUrlOf(await canvas.convertToBlob({ type: 'image/png' }));
-    }
-    catch {
-        return uploadPreviewUrl(upload);
+  try {
+    const bitmap = await createImageBitmap(new Blob([bytesOf(upload.data)], {
+      type: upload.mime
+    }));
+    const crop = thumbnailCrop(bitmap.width, bitmap.height);
+    const canvas = new OffscreenCanvas(crop.out, crop.out);
+    const context = canvas.getContext('2d');
+    if (!context) {
+      bitmap.close();
+      return uploadPreviewUrl(upload);
     }
+    context.drawImage(bitmap, crop.sx, crop.sy, crop.size, crop.size, 0, 0, crop.out, crop.out);
+    bitmap.close();
+    return await dataUrlOf(await canvas.convertToBlob({
+      type: 'image/png'
+    }));
+  } catch {
+    return uploadPreviewUrl(upload);
+  }
 }
 // Keyed by the upload itself, so a composer that mounts again finds it and a removed file lets it go.
 const made = new WeakMap();
 const making = new WeakMap();
 function thumbnailOf(upload) {
-    let promise = making.get(upload);
-    if (!promise) {
-        promise = makeThumbnail(upload).then((url) => {
-            made.set(upload, url);
-            return url;
-        });
-        making.set(upload, promise);
-    }
-    return promise;
+  let promise = making.get(upload);
+  if (!promise) {
+    promise = makeThumbnail(upload).then(url => {
+      made.set(upload, url);
+      return url;
+    });
+    making.set(upload, promise);
+  }
+  return promise;
 }
 /* The thumbnail of an image the composer holds, or null while it is being made. */
 export function useUploadThumbnail(upload) {
-    const [ready, setReady] = useState(null);
-    const cached = made.get(upload);
-    useEffect(() => {
-        if (made.has(upload)) {
-            return;
+  const $ = _c(5);
+  const [ready, setReady] = useState(null);
+  let t0;
+  if ($[0] !== upload) {
+    t0 = made.get(upload);
+    $[0] = upload;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const cached = t0;
+  let t1;
+  let t2;
+  if ($[2] !== upload) {
+    t1 = () => {
+      if (made.has(upload)) {
+        return;
+      }
+      let cancelled = false;
+      thumbnailOf(upload).then(url => {
+        if (!cancelled) {
+          setReady({
+            upload,
+            url
+          });
         }
-        let cancelled = false;
-        void thumbnailOf(upload).then((url) => {
-            if (!cancelled) {
-                setReady({ upload, url });
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [upload]);
-    return cached ?? (ready?.upload === upload ? ready.url : null);
-}
+      });
+      return () => {
+        cancelled = true;
+      };
+    };
+    t2 = [upload];
+    $[2] = upload;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useEffect(t1, t2);
+  return cached ?? (ready?.upload === upload ? ready.url : null);
+}

package/dist/chat/timeline-flash.js

@@ -2,15 +2,27 @@ import { create } from 'zustand';
 /* A little longer than the animation of `.chat-flash`, so a row that scrolls into view again later is neither lit nor opened a second time. */
 const FLASH_MS = 2000;
 export const useTimelineFlash = create((set, get) => ({
-    target: null,
-    flash(key, rowId, opens, block) {
-        const nonce = (get().target?.nonce ?? 0) + 1;
-        set({ target: { key, rowId, opens, nonce, ...(block ? { block } : {}) } });
-        const timer = setTimeout(() => {
-            if (get().target?.nonce === nonce) {
-                set({ target: null });
-            }
-        }, FLASH_MS);
-        timer.unref?.();
-    }
-}));
+  target: null,
+  flash(key, rowId, opens, block) {
+    const nonce = (get().target?.nonce ?? 0) + 1;
+    set({
+      target: {
+        key,
+        rowId,
+        opens,
+        nonce,
+        ...(block ? {
+          block
+        } : {})
+      }
+    });
+    const timer = setTimeout(() => {
+      if (get().target?.nonce === nonce) {
+        set({
+          target: null
+        });
+      }
+    }, FLASH_MS);
+    timer.unref?.();
+  }
+}));