@adecore/agents-react 0.31.11 → 0.32.0

package/dist/state/chats.js

@@ -1,252 +1,468 @@
-import { useContext, useMemo } from 'react';
+import { c as _c } from "react/compiler-runtime";
+import { useContext } from 'react';
 import { create } from 'zustand';
 import { appendToolOutput } from '@adecore/agent-contracts/text';
 import { ChatScopeContext, useChatScope } from '../scope.js';
 function isWaiting(item) {
-    return (item?.kind === 'approval' && item.decision === 'pending') || (item?.kind === 'question' && item.state === 'pending');
+  return item?.kind === 'approval' && item.decision === 'pending' || item?.kind === 'question' && item.state === 'pending';
 }
 function stateOf(info, items, page) {
-    const byId = Object.fromEntries(items.map((item) => [item.id, item]));
-    const order = items.map((item) => item.id);
-    if (page === undefined || page.history.cursor === null) {
-        return { info, items: byId, structure: byId, order };
-    }
-    const before = page.pending.filter((item) => !(item.id in byId));
-    const subagents = (page.subagents ?? []).filter((item) => !(item.id in byId));
-    for (const item of [...before, ...subagents]) {
-        byId[item.id] = item;
-    }
+  const byId = Object.fromEntries(items.map(item => [item.id, item]));
+  const order = items.map(item => item.id);
+  if (page === undefined || page.history.cursor === null) {
     return {
-        info,
-        items: byId,
-        structure: byId,
-        order,
-        history: page.history,
-        waitingBefore: before.map((item) => item.id),
-        subagentsBefore: subagents.map((item) => item.id)
+      info,
+      items: byId,
+      structure: byId,
+      order
     };
+  }
+  const before = page.pending.filter(item => !(item.id in byId));
+  const subagents = (page.subagents ?? []).filter(item => !(item.id in byId));
+  for (const item of [...before, ...subagents]) {
+    byId[item.id] = item;
+  }
+  return {
+    info,
+    items: byId,
+    structure: byId,
+    order,
+    history: page.history,
+    waitingBefore: before.map(item => item.id),
+    subagentsBefore: subagents.map(item => item.id)
+  };
 }
 /* An older host names no place in the thread, and it always hands over the whole of it. */
 function isBeforePage(state, historyIndex) {
-    return state.history !== undefined && historyIndex !== undefined && historyIndex < state.history.start;
+  return state.history !== undefined && historyIndex !== undefined && historyIndex < state.history.start;
 }
 /* An item from before the page this client holds matters only as a sub-agent, a request that waits, or one that stopped waiting. */
 function withEarlierItem(state, item) {
-    if (item.kind === 'subagent') {
-        const subagents = state.subagentsBefore ?? [];
-        return { ...withItem(state, item), subagentsBefore: subagents.includes(item.id) ? subagents : [...subagents, item.id] };
-    }
-    const waiting = state.waitingBefore ?? [];
-    const held = waiting.includes(item.id);
-    if (isWaiting(item)) {
-        return { ...withItem(state, item), waitingBefore: held ? waiting : [...waiting, item.id] };
-    }
-    return held ? { ...withItem(state, item), waitingBefore: waiting.filter((id) => id !== item.id) } : state;
+  if (item.kind === 'subagent') {
+    const subagents = state.subagentsBefore ?? [];
+    return {
+      ...withItem(state, item),
+      subagentsBefore: subagents.includes(item.id) ? subagents : [...subagents, item.id]
+    };
+  }
+  const waiting = state.waitingBefore ?? [];
+  const held = waiting.includes(item.id);
+  if (isWaiting(item)) {
+    return {
+      ...withItem(state, item),
+      waitingBefore: held ? waiting : [...waiting, item.id]
+    };
+  }
+  return held ? {
+    ...withItem(state, item),
+    waitingBefore: waiting.filter(id => id !== item.id)
+  } : state;
 }
 /* The page before the one a chat holds, unless the thread was read again since that page was asked for. */
 export function prependPage(state, cursor, page) {
-    if (state.history?.cursor !== cursor) {
-        return state;
-    }
-    const held = new Set(state.order);
-    const older = page.items.filter((item) => !held.has(item.id));
-    const olderIds = new Set(older.map((item) => item.id));
-    const items = { ...state.items };
-    for (const item of older) {
-        // A request from before the page that this client already holds came in live, which is never older than the page.
-        items[item.id] = state.items[item.id] ?? item;
-    }
-    const order = [...olderIds, ...state.order];
-    if (page.history.cursor === null) {
-        const { history: _history, waitingBefore: _waitingBefore, subagentsBefore: _subagentsBefore, ...rest } = state;
-        return { ...rest, items, structure: items, order };
-    }
-    const waitingBefore = (state.waitingBefore ?? []).filter((id) => !olderIds.has(id));
-    const subagentsBefore = (state.subagentsBefore ?? []).filter((id) => !olderIds.has(id));
-    return { ...state, items, structure: items, order, history: page.history, waitingBefore, subagentsBefore };
+  if (state.history?.cursor !== cursor) {
+    return state;
+  }
+  const held = new Set(state.order);
+  const older = page.items.filter(item => !held.has(item.id));
+  const olderIds = new Set(older.map(item => item.id));
+  const items = {
+    ...state.items
+  };
+  for (const item of older) {
+    // A request from before the page that this client already holds came in live, which is never older than the page.
+    items[item.id] = state.items[item.id] ?? item;
+  }
+  const order = [...olderIds, ...state.order];
+  if (page.history.cursor === null) {
+    const {
+      history: _history,
+      waitingBefore: _waitingBefore,
+      subagentsBefore: _subagentsBefore,
+      ...rest
+    } = state;
+    return {
+      ...rest,
+      items,
+      structure: items,
+      order
+    };
+  }
+  const waitingBefore = (state.waitingBefore ?? []).filter(id => !olderIds.has(id));
+  const subagentsBefore = (state.subagentsBefore ?? []).filter(id => !olderIds.has(id));
+  return {
+    ...state,
+    items,
+    structure: items,
+    order,
+    history: page.history,
+    waitingBefore,
+    subagentsBefore
+  };
 }
 /* The requests that still wait, oldest first: those from before the page this client holds, then the thread's own. */
 export function waitingRequestsOf(chat) {
-    return [...(chat?.waitingBefore ?? []), ...(chat?.order ?? [])].map((id) => chat?.structure[id]).filter(isWaiting);
+  return [...(chat?.waitingBefore ?? []), ...(chat?.order ?? [])].map(id => chat?.structure[id]).filter(isWaiting);
 }
 /* The state with one item replaced, in the thread and in the structure the rows come from. */
 function withItem(state, item) {
-    const items = { ...state.items, [item.id]: item };
-    return { ...state, items, structure: items };
+  const items = {
+    ...state.items,
+    [item.id]: item
+  };
+  return {
+    ...state,
+    items,
+    structure: items
+  };
 }
 /* Cheap enough, since a status only arrives when the host saw one change, never on a streamed word. */
 function sameInfo(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+  return JSON.stringify(left) === JSON.stringify(right);
 }
 /* The statuses with this chat's info in them, the same object when that info is already there. */
 function withStatus(statuses, key, info) {
-    return statuses[key]?.info === info ? statuses : { ...statuses, [key]: { info } };
+  return statuses[key]?.info === info ? statuses : {
+    ...statuses,
+    [key]: {
+      info
+    }
+  };
 }
 function without(rows, matches) {
-    return Object.fromEntries(Object.entries(rows).filter(([key]) => !matches(key)));
+  return Object.fromEntries(Object.entries(rows).filter(([key]) => !matches(key)));
 }
 export function applyEvent(state, event) {
-    switch (event.type) {
-        case 'item': {
-            if (isBeforePage(state, event.historyIndex)) {
-                return withEarlierItem(state, event.item);
-            }
-            const known = event.item.id in state.items;
-            return { ...withItem(state, event.item), order: known ? state.order : [...state.order, event.item.id] };
+  switch (event.type) {
+    case 'item':
+      {
+        if (isBeforePage(state, event.historyIndex)) {
+          return withEarlierItem(state, event.item);
         }
-        case 'delta': {
-            const item = state.items[event.itemId];
-            if (event.uiQueries && item?.kind === 'assistant') {
-                // The text first, as the daemon's thread applies it, then the metadata on what it grew into.
-                const { uiQueries, ...text } = event;
-                const grown = event.text === '' ? state : applyEvent(state, text);
-                const reply = grown.items[event.itemId] ?? item;
-                return { ...grown, items: { ...grown.items, [event.itemId]: { ...reply, uiQueries } } };
+        const known = event.item.id in state.items;
+        return {
+          ...withItem(state, event.item),
+          order: known ? state.order : [...state.order, event.item.id]
+        };
+      }
+    case 'delta':
+      {
+        const item = state.items[event.itemId];
+        if (event.uiQueries && item?.kind === 'assistant') {
+          // The text first, as the daemon's thread applies it, then the metadata on what it grew into.
+          const {
+            uiQueries,
+            ...text
+          } = event;
+          const grown = event.text === '' ? state : applyEvent(state, text);
+          const reply = grown.items[event.itemId] ?? item;
+          return {
+            ...grown,
+            items: {
+              ...grown.items,
+              [event.itemId]: {
+                ...reply,
+                uiQueries
+              }
             }
-            if (event.ui !== undefined && event.text === '') {
-                if (item?.kind === 'assistant' && item.streaming && event.textLength === item.text.length) {
-                    return { ...state, items: { ...state.items, [event.itemId]: { ...item, ui: event.ui } } };
+          };
+        }
+        if (event.ui !== undefined && event.text === '') {
+          if (item?.kind === 'assistant' && item.streaming && event.textLength === item.text.length) {
+            return {
+              ...state,
+              items: {
+                ...state.items,
+                [event.itemId]: {
+                  ...item,
+                  ui: event.ui
                 }
-                return state;
+              }
+            };
+          }
+          return state;
+        }
+        if (item?.kind === 'assistant' || item?.kind === 'thinking') {
+          const grown = {
+            ...item,
+            text: item.text + event.text
+          };
+          // The first text is structure after all, since an empty reply that is not streaming has no row.
+          if (item.text === '') {
+            return withItem(state, grown);
+          }
+          return {
+            ...state,
+            items: {
+              ...state.items,
+              [event.itemId]: grown
             }
-            if (item?.kind === 'assistant' || item?.kind === 'thinking') {
-                const grown = { ...item, text: item.text + event.text };
-                // The first text is structure after all, since an empty reply that is not streaming has no row.
-                if (item.text === '') {
-                    return withItem(state, grown);
-                }
-                return { ...state, items: { ...state.items, [event.itemId]: grown } };
+          };
+        }
+        if (item?.kind === 'tool' && item.state === 'running') {
+          const progress = item.progress ?? {
+            startedAt: null,
+            description: null,
+            output: null
+          };
+          const grown = {
+            ...item,
+            progress: {
+              ...progress,
+              output: appendToolOutput(progress.output, event.text)
             }
-            if (item?.kind === 'tool' && item.state === 'running') {
-                const progress = item.progress ?? { startedAt: null, description: null, output: null };
-                const grown = { ...item, progress: { ...progress, output: appendToolOutput(progress.output, event.text) } };
-                return { ...state, items: { ...state.items, [event.itemId]: grown } };
+          };
+          return {
+            ...state,
+            items: {
+              ...state.items,
+              [event.itemId]: grown
             }
-            return state;
+          };
         }
-        case 'info':
-            return { ...state, info: event.info };
-        case 'reset':
-            return stateOf(event.info, event.items);
-    }
+        return state;
+      }
+    case 'info':
+      return {
+        ...state,
+        info: event.info
+      };
+    case 'reset':
+      return stateOf(event.info, event.items);
+  }
 }
 /* Fields of a held chat that are not part of its thread; a chat this client does not hold stays as it is. */
 function withFields(store, key, fields) {
-    const current = store.byKey[key];
-    if (!current) {
-        return {};
-    }
-    return { byKey: { ...store.byKey, [key]: { ...current, ...fields } } };
-}
-export const useChats = create((set) => ({
-    byKey: {},
-    statusByKey: {},
-    reset(key, info, items, page) {
-        set((s) => {
-            // The bookmarks and the visuals are not part of the thread; they come in on their own and outlive a reset of it.
-            const { bookmarks, visuals } = s.byKey[key] ?? {};
-            const next = { ...stateOf(info, items, page), ...(bookmarks === undefined ? {} : { bookmarks }), ...(visuals === undefined ? {} : { visuals }) };
-            return {
-                byKey: { ...s.byKey, [key]: next },
-                statusByKey: withStatus(s.statusByKey, key, info)
-            };
-        });
-    },
-    prepend(key, cursor, page) {
-        set((s) => {
-            const current = s.byKey[key];
-            if (!current) {
-                return {};
-            }
-            const next = prependPage(current, cursor, page);
-            return next === current ? {} : { byKey: { ...s.byKey, [key]: next } };
-        });
-    },
-    apply(key, event) {
-        set((s) => {
-            const current = s.byKey[key];
-            if (!current) {
-                return {};
-            }
-            const next = applyEvent(current, event);
-            return { byKey: { ...s.byKey, [key]: next }, statusByKey: withStatus(s.statusByKey, key, next.info) };
-        });
-    },
-    /*
-     * The status of a chat this window is not reading, which the host sends for every chat it has
-     * loaded. The thread stays empty until somebody attaches, since this is what a header, a list and
-     * the counters need, and they ask the info and never the items.
-     */
-    status(key, info) {
-        set((s) => {
-            const current = s.byKey[key];
-            if (!current) {
-                return { byKey: { ...s.byKey, [key]: stateOf(info, []) }, statusByKey: withStatus(s.statusByKey, key, info) };
-            }
-            // An attached client already had this on `chat.event`; writing it again would redraw the thread.
-            if (sameInfo(current.info, info)) {
-                return {};
-            }
-            return { byKey: { ...s.byKey, [key]: { ...current, info } }, statusByKey: withStatus(s.statusByKey, key, info) };
-        });
-    },
-    bookmarks(key, bookmarks) {
-        set((s) => withFields(s, key, { bookmarks }));
-    },
-    visuals(key, visuals) {
-        set((s) => withFields(s, key, { visuals }));
-    },
-    forget(key) {
-        set((s) => {
-            const next = { ...s.byKey };
-            delete next[key];
-            const statuses = { ...s.statusByKey };
-            delete statuses[key];
-            return { byKey: next, statusByKey: statuses };
-        });
-    },
-    forgetWhere(matches) {
-        set((s) => ({ byKey: without(s.byKey, matches), statusByKey: without(s.statusByKey, matches) }));
+  const current = store.byKey[key];
+  if (!current) {
+    return {};
+  }
+  return {
+    byKey: {
+      ...store.byKey,
+      [key]: {
+        ...current,
+        ...fields
+      }
     }
+  };
+}
+export const useChats = create(set => ({
+  byKey: {},
+  statusByKey: {},
+  reset(key, info, items, page) {
+    set(s => {
+      // The bookmarks and the visuals are not part of the thread; they come in on their own and outlive a reset of it.
+      const {
+        bookmarks,
+        visuals
+      } = s.byKey[key] ?? {};
+      const next = {
+        ...stateOf(info, items, page),
+        ...(bookmarks === undefined ? {} : {
+          bookmarks
+        }),
+        ...(visuals === undefined ? {} : {
+          visuals
+        })
+      };
+      return {
+        byKey: {
+          ...s.byKey,
+          [key]: next
+        },
+        statusByKey: withStatus(s.statusByKey, key, info)
+      };
+    });
+  },
+  prepend(key, cursor, page) {
+    set(s => {
+      const current = s.byKey[key];
+      if (!current) {
+        return {};
+      }
+      const next = prependPage(current, cursor, page);
+      return next === current ? {} : {
+        byKey: {
+          ...s.byKey,
+          [key]: next
+        }
+      };
+    });
+  },
+  apply(key, event) {
+    set(s => {
+      const current = s.byKey[key];
+      if (!current) {
+        return {};
+      }
+      const next = applyEvent(current, event);
+      return {
+        byKey: {
+          ...s.byKey,
+          [key]: next
+        },
+        statusByKey: withStatus(s.statusByKey, key, next.info)
+      };
+    });
+  },
+  /*
+   * The status of a chat this window is not reading, which the host sends for every chat it has
+   * loaded. The thread stays empty until somebody attaches, since this is what a header, a list and
+   * the counters need, and they ask the info and never the items.
+   */
+  status(key, info) {
+    set(s => {
+      const current = s.byKey[key];
+      if (!current) {
+        return {
+          byKey: {
+            ...s.byKey,
+            [key]: stateOf(info, [])
+          },
+          statusByKey: withStatus(s.statusByKey, key, info)
+        };
+      }
+      // An attached client already had this on `chat.event`; writing it again would redraw the thread.
+      if (sameInfo(current.info, info)) {
+        return {};
+      }
+      return {
+        byKey: {
+          ...s.byKey,
+          [key]: {
+            ...current,
+            info
+          }
+        },
+        statusByKey: withStatus(s.statusByKey, key, info)
+      };
+    });
+  },
+  bookmarks(key, bookmarks) {
+    set(s => withFields(s, key, {
+      bookmarks
+    }));
+  },
+  visuals(key, visuals) {
+    set(s => withFields(s, key, {
+      visuals
+    }));
+  },
+  forget(key) {
+    set(s => {
+      const next = {
+        ...s.byKey
+      };
+      delete next[key];
+      const statuses = {
+        ...s.statusByKey
+      };
+      delete statuses[key];
+      return {
+        byKey: next,
+        statusByKey: statuses
+      };
+    });
+  },
+  forgetWhere(matches) {
+    set(s => ({
+      byKey: without(s.byKey, matches),
+      statusByKey: without(s.statusByKey, matches)
+    }));
+  }
 }));
 /* The sink of one host's chat client: it hands over chat ids, this puts them under the keys of its scope. */
 export function chatSink(keyOf) {
-    return {
-        reset: (chatId, info, items, page) => useChats.getState().reset(keyOf(chatId), info, items, page),
-        prepend: (chatId, cursor, page) => useChats.getState().prepend(keyOf(chatId), cursor, page),
-        apply: (chatId, event) => useChats.getState().apply(keyOf(chatId), event),
-        status: (chatId, info) => useChats.getState().status(keyOf(chatId), info),
-        bookmarks: (chatId, bookmarks) => useChats.getState().bookmarks(keyOf(chatId), bookmarks),
-        visuals: (chatId, visuals) => useChats.getState().visuals(keyOf(chatId), visuals),
-        forget: (chatId) => useChats.getState().forget(keyOf(chatId))
-    };
+  return {
+    reset: (chatId, info, items, page) => useChats.getState().reset(keyOf(chatId), info, items, page),
+    prepend: (chatId, cursor, page) => useChats.getState().prepend(keyOf(chatId), cursor, page),
+    apply: (chatId, event) => useChats.getState().apply(keyOf(chatId), event),
+    status: (chatId, info) => useChats.getState().status(keyOf(chatId), info),
+    bookmarks: (chatId, bookmarks) => useChats.getState().bookmarks(keyOf(chatId), bookmarks),
+    visuals: (chatId, visuals) => useChats.getState().visuals(keyOf(chatId), visuals),
+    forget: chatId => useChats.getState().forget(keyOf(chatId))
+  };
 }
 /* One chat's thread in the scope this is rendered in. The selector keeps a render tied to the field it reads. */
 export function useChatRow(chatId, select) {
-    const { keyOf } = useChatScope();
-    return useChats((s) => select(s.byKey[keyOf(chatId)]));
+  const $ = _c(4);
+  const {
+    keyOf
+  } = useChatScope();
+  let t0;
+  if ($[0] !== chatId || $[1] !== keyOf || $[2] !== select) {
+    t0 = s => select(s.byKey[keyOf(chatId)]);
+    $[0] = chatId;
+    $[1] = keyOf;
+    $[2] = select;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  return useChats(t0);
 }
 /*
  * The models the CLI of this provider reported running in the chats this client holds of the host.
  * A model it ran is proof the CLI offers it, whatever the version says. Outside a scope there is none.
  */
 export function useReportedModels(provider) {
-    const scope = useContext(ChatScopeContext);
-    const joined = useChats((s) => {
-        const names = new Set();
-        for (const [key, state] of Object.entries(s.statusByKey)) {
-            if (scope?.owns(key) === true && state.info.provider === provider && state.info.model !== null) {
-                names.add(state.info.model);
-            }
+  const $ = _c(5);
+  const scope = useContext(ChatScopeContext);
+  let t0;
+  if ($[0] !== provider || $[1] !== scope) {
+    t0 = s => {
+      const names = new Set();
+      for (const [key, state] of Object.entries(s.statusByKey)) {
+        if (scope?.owns(key) === true && state.info.provider === provider && state.info.model !== null) {
+          names.add(state.info.model);
         }
-        return [...names].sort().join('\n');
-    });
-    return useMemo(() => new Set(joined === '' ? [] : joined.split('\n')), [joined]);
+      }
+      return [...names].sort().join("\n");
+    };
+    $[0] = provider;
+    $[1] = scope;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  const joined = useChats(t0);
+  let t1;
+  if ($[3] !== joined) {
+    t1 = new Set(joined === "" ? [] : joined.split("\n"));
+    $[3] = joined;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return t1;
+}
+/* Whether a call still waits on the person's answer to an approval of it, when its clock is not running yet. */
+export function useAwaitsApproval(chatId, toolUseId) {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== toolUseId) {
+    t0 = row => waitingRequestsOf(row).some(request => request.kind === "approval" && request.toolUseId === toolUseId);
+    $[0] = toolUseId;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useChatRow(chatId, t0);
 }
 /* The item as the thread holds it now, for a row derived from the structure, which a delta leaves alone. */
 export function useCurrentItem(chatId, derived) {
-    return useChatRow(chatId, (row) => {
-        const item = row?.items[derived.id];
-        return item?.kind === derived.kind ? item : derived;
-    });
-}
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== derived) {
+    t0 = row => {
+      const item = row?.items[derived.id];
+      return item?.kind === derived.kind ? item : derived;
+    };
+    $[0] = derived;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return useChatRow(chatId, t0);
+}

package/dist/state/index.js

@@ -2,4 +2,4 @@
 export { waitingRequestsOf, applyEvent, useChats, chatSink, useChatRow } from './chats.js';
 export { useProviderAccountsStore, useProviderAccounts, providerAccountsOf, knownAccounts, watchProviderAccounts } from './provider-accounts.js';
 export { useProvidersStore, useProviders, providersOf, providerSinkFor } from './providers.js';
-export { USAGE_PREFERENCES_KEY, dayOf, windowFor, reloadUsagePreferences, useUsageStore } from './usage.js';
+export { USAGE_PREFERENCES_KEY, dayOf, windowFor, reloadUsagePreferences, useUsageStore } from './usage.js';