@adecore/agents-react 0.31.12 → 0.32.0

package/dist/state/provider-accounts.js

@@ -1,67 +1,90 @@
+import { c as _c } from "react/compiler-runtime";
 import { create } from 'zustand';
 import { useChatScope } from '../scope.js';
 /* One object for a host that has not answered yet, so a selector gets a stable snapshot. */
-const NONE = { accounts: null, loaded: false };
+const NONE = {
+  accounts: null,
+  loaded: false
+};
 /* The accounts of every agent CLI on each host, and what each CLI last said about who is signed in there. */
 export const useProviderAccountsStore = create((set, get) => ({
-    byScope: {},
-    set(scopeId, accounts) {
-        set({ byScope: { ...get().byScope, [scopeId]: { accounts, loaded: true } } });
-    },
-    forget(scopeId) {
-        const { [scopeId]: _gone, ...rest } = get().byScope;
-        set({ byScope: rest });
-    }
+  byScope: {},
+  set(scopeId, accounts) {
+    set({
+      byScope: {
+        ...get().byScope,
+        [scopeId]: {
+          accounts,
+          loaded: true
+        }
+      }
+    });
+  },
+  forget(scopeId) {
+    const {
+      [scopeId]: _gone,
+      ...rest
+    } = get().byScope;
+    set({
+      byScope: rest
+    });
+  }
 }));
 /* The accounts of the host in scope, like `useProviders`. */
 export function useProviderAccounts(select) {
-    const { id } = useChatScope();
-    return useProviderAccountsStore((s) => select(s.byScope[id] ?? NONE));
+  const $ = _c(3);
+  const {
+    id
+  } = useChatScope();
+  let t0;
+  if ($[0] !== id || $[1] !== select) {
+    t0 = s => select(s.byScope[id] ?? NONE);
+    $[0] = id;
+    $[1] = select;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useProviderAccountsStore(t0);
 }
 export function providerAccountsOf(scopeId) {
-    return useProviderAccountsStore.getState().byScope[scopeId] ?? NONE;
+  return useProviderAccountsStore.getState().byScope[scopeId] ?? NONE;
 }
 /* The accounts as `accountFor` takes them: undefined until the host answered, null for one that keeps none. */
 export function knownAccounts(row) {
-    return row.loaded ? row.accounts : undefined;
+  return row.loaded ? row.accounts : undefined;
 }
 /*
  * Keeps one host's accounts in the store: the whole list on every fresh link, then every change the
  * host announces. Answers the function that stops it.
  */
 export function watchProviderAccounts(scopeId, transport) {
-    const store = useProviderAccountsStore.getState();
-    // A list asked for before a change arrived is older than that change, so it is dropped.
-    let changes = 0;
-    const load = () => {
-        const asked = changes;
-        transport
-            .request('accounts.list', {})
-            .then((accounts) => {
-            if (changes === asked) {
-                store.set(scopeId, accounts);
-            }
-        })
-            .catch(() => {
-            // A host from before accounts never answers; it has only each CLI's own login.
-            if (changes === asked && !providerAccountsOf(scopeId).loaded) {
-                store.set(scopeId, null);
-            }
-        });
-    };
-    const off = [
-        transport.on('accounts.changed', (accounts) => {
-            changes += 1;
-            store.set(scopeId, accounts);
-        }),
-        transport.subscribeStatus((status) => {
-            if (status === 'open') {
-                load();
-            }
-        })
-    ];
-    if (transport.status === 'open') {
-        load();
+  const store = useProviderAccountsStore.getState();
+  // A list asked for before a change arrived is older than that change, so it is dropped.
+  let changes = 0;
+  const load = () => {
+    const asked = changes;
+    transport.request('accounts.list', {}).then(accounts => {
+      if (changes === asked) {
+        store.set(scopeId, accounts);
+      }
+    }).catch(() => {
+      // A host from before accounts never answers; it has only each CLI's own login.
+      if (changes === asked && !providerAccountsOf(scopeId).loaded) {
+        store.set(scopeId, null);
+      }
+    });
+  };
+  const off = [transport.on('accounts.changed', accounts => {
+    changes += 1;
+    store.set(scopeId, accounts);
+  }), transport.subscribeStatus(status => {
+    if (status === 'open') {
+      load();
     }
-    return () => off.forEach((stop) => stop());
-}
+  })];
+  if (transport.status === 'open') {
+    load();
+  }
+  return () => off.forEach(stop => stop());
+}

package/dist/state/providers.js

@@ -1,33 +1,62 @@
+import { c as _c } from "react/compiler-runtime";
 import { create } from 'zustand';
 import { useChatScope } from '../scope.js';
 /* One object for a host that has not answered yet, so a selector gets a stable snapshot. */
-const NONE = { providers: [], loaded: false };
+const NONE = {
+  providers: [],
+  loaded: false
+};
 /* Which agent CLIs each host reports, and their models; filled once per connection. */
 export const useProvidersStore = create((set, get) => ({
-    byScope: {},
-    setProviders(scopeId, providers) {
-        set({ byScope: { ...get().byScope, [scopeId]: { providers, loaded: true } } });
-    },
-    forget(scopeId) {
-        const { [scopeId]: _gone, ...rest } = get().byScope;
-        set({ byScope: rest });
-    }
+  byScope: {},
+  setProviders(scopeId, providers) {
+    set({
+      byScope: {
+        ...get().byScope,
+        [scopeId]: {
+          providers,
+          loaded: true
+        }
+      }
+    });
+  },
+  forget(scopeId) {
+    const {
+      [scopeId]: _gone,
+      ...rest
+    } = get().byScope;
+    set({
+      byScope: rest
+    });
+  }
 }));
 /*
  * The CLIs of the host in scope. An agent menu has to offer what the host the chat will run on has
  * installed, never what another host answered.
  */
 export function useProviders(select) {
-    const { id } = useChatScope();
-    return useProvidersStore((s) => select(s.byScope[id] ?? NONE));
+  const $ = _c(3);
+  const {
+    id
+  } = useChatScope();
+  let t0;
+  if ($[0] !== id || $[1] !== select) {
+    t0 = s => select(s.byScope[id] ?? NONE);
+    $[0] = id;
+    $[1] = select;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useProvidersStore(t0);
 }
 /* The same answer outside a render. */
 export function providersOf(scopeId) {
-    return useProvidersStore.getState().byScope[scopeId] ?? NONE;
+  return useProvidersStore.getState().byScope[scopeId] ?? NONE;
 }
 /* What one host's chat client fills in; it knows its own host and nothing of the others. */
 export function providerSinkFor(scopeId) {
-    return {
-        setProviders: (providers) => useProvidersStore.getState().setProviders(scopeId, providers)
-    };
-}
+  return {
+    setProviders: providers => useProvidersStore.getState().setProviders(scopeId, providers)
+  };
+}

package/dist/state/usage.js

@@ -1,113 +1,190 @@
+import { c as _c } from "react/compiler-runtime";
 import { chatStorageKey, chatStorageLegacyKeys, createChatStore, onChatStorageConfiguration } from '../storage.js';
 import { persistedJson } from '../chat/persisted-json.js';
 import { localTimeZone } from '@adecore/ui/format';
 import { useChatScope } from '../scope.js';
 /* Only the id and the length. A store has no words, so the page names a period in its own language. */
-export const USAGE_PERIODS = [
-    { id: 'today', days: 1 },
-    { id: '7d', days: 7 },
-    { id: '30d', days: 30 },
-    { id: '90d', days: 90 }
-];
+export const USAGE_PERIODS = [{
+  id: 'today',
+  days: 1
+}, {
+  id: '7d',
+  days: 7
+}, {
+  id: '30d',
+  days: 30
+}, {
+  id: '90d',
+  days: 90
+}];
 const storageKey = () => chatStorageKey('usage');
 export let USAGE_PREFERENCES_KEY = storageKey();
 onChatStorageConfiguration(() => {
-    USAGE_PREFERENCES_KEY = storageKey();
+  USAGE_PREFERENCES_KEY = storageKey();
 });
-const DEFAULTS = { period: '7d', metric: 'cost', currency: 'USD' };
+const DEFAULTS = {
+  period: '7d',
+  metric: 'cost',
+  currency: 'USD'
+};
 function parsePreferences(raw) {
-    try {
-        const stored = JSON.parse(raw ?? '{}');
-        return {
-            period: USAGE_PERIODS.some((period) => period.id === stored.period) ? stored.period : DEFAULTS.period,
-            metric: stored.metric === 'tokens' || stored.metric === 'cost' ? stored.metric : DEFAULTS.metric,
-            currency: stored.currency === 'EUR' ? 'EUR' : DEFAULTS.currency
-        };
-    }
-    catch {
-        return DEFAULTS;
-    }
+  try {
+    const stored = JSON.parse(raw ?? '{}');
+    return {
+      period: USAGE_PERIODS.some(period => period.id === stored.period) ? stored.period : DEFAULTS.period,
+      metric: stored.metric === 'tokens' || stored.metric === 'cost' ? stored.metric : DEFAULTS.metric,
+      currency: stored.currency === 'EUR' ? 'EUR' : DEFAULTS.currency
+    };
+  } catch {
+    return DEFAULTS;
+  }
 }
 const storage = persistedJson(storageKey, parsePreferences, DEFAULTS, () => chatStorageLegacyKeys('usage'));
 /* The three stored choices out of the store, so a setter writes the other two back unchanged. */
 function chosen(state) {
-    return { period: state.period, metric: state.metric, currency: state.currency };
+  return {
+    period: state.period,
+    metric: state.metric,
+    currency: state.currency
+  };
 }
 function pad(value) {
-    return String(value).padStart(2, '0');
+  return String(value).padStart(2, '0');
 }
 /* The viewer's own calendar day; the host may stand in another zone and buckets in this one. */
 export function dayOf(date) {
-    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
 }
 /* What a period asks for: today in hours from local midnight, every other period a bar per calendar day. */
 export function windowFor(period, now = new Date()) {
-    const days = USAGE_PERIODS.find((entry) => entry.id === period)?.days ?? 7;
-    const from = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (days - 1));
-    return {
-        from: dayOf(from),
-        to: dayOf(now),
-        resolution: period === 'today' ? 'hour' : 'day',
-        timeZone: localTimeZone() ?? 'UTC'
-    };
+  const days = USAGE_PERIODS.find(entry => entry.id === period)?.days ?? 7;
+  const from = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (days - 1));
+  return {
+    from: dayOf(from),
+    to: dayOf(now),
+    resolution: period === 'today' ? 'hour' : 'day',
+    timeZone: localTimeZone() ?? 'UTC'
+  };
 }
 /* A period, and only the usage of one account when one is picked; null is every account. */
 export function summaryPayload(period, account, now = new Date()) {
-    return account === null ? windowFor(period, now) : { ...windowFor(period, now), accounts: [account] };
+  return account === null ? windowFor(period, now) : {
+    ...windowFor(period, now),
+    accounts: [account]
+  };
 }
 /* What was asked, so an answer to the question before this one is never drawn over a newer one. */
 export function askedKey(payload) {
-    return `${payload.from}\0${payload.to}\0${payload.resolution}\0${payload.timeZone}\0${payload.accounts?.join(',') ?? ''}`;
+  return `${payload.from}\0${payload.to}\0${payload.resolution}\0${payload.timeZone}\0${payload.accounts?.join(',') ?? ''}`;
 }
 /* One object for a host nothing was read from yet, so a selector gets a stable snapshot. */
-const EMPTY = { asked: null, summary: null, loading: false, failed: false, limits: null };
+const EMPTY = {
+  asked: null,
+  summary: null,
+  loading: false,
+  failed: false,
+  limits: null
+};
 /* Reads the period, metric and currency again, once another window of the same origin wrote them. */
 export function reloadUsagePreferences() {
-    useUsageStore.setState(storage.read());
+  useUsageStore.setState(storage.read());
 }
 export const useUsageStore = createChatStore((set, get) => {
-    const choosePreference = (change) => {
-        storage.write({ ...chosen(get()), ...change });
-        set(change);
-    };
-    const patchRow = (scopeId, change) => {
-        set({ byScope: { ...get().byScope, [scopeId]: { ...(get().byScope[scopeId] ?? EMPTY), ...change } } });
-    };
-    return {
-        ...DEFAULTS,
-        byScope: {},
-        chosen: null,
-        choose(scopeId) {
-            set({ chosen: scopeId });
-        },
-        setPeriod(period) {
-            choosePreference({ period });
-        },
-        setMetric(metric) {
-            choosePreference({ metric });
-        },
-        setCurrency(currency) {
-            choosePreference({ currency });
-        },
-        setLoading(scopeId, loading) {
-            patchRow(scopeId, { loading });
-        },
-        receive(scopeId, asked, summary) {
-            patchRow(scopeId, { asked, summary, loading: false, failed: false });
-        },
-        fail(scopeId) {
-            patchRow(scopeId, { loading: false, failed: true });
-        },
-        setLimits(scopeId, limits) {
-            patchRow(scopeId, { limits });
-        },
-        forget(scopeId) {
-            const { [scopeId]: _gone, ...rest } = get().byScope;
-            set({ byScope: rest });
+  const choosePreference = change => {
+    storage.write({
+      ...chosen(get()),
+      ...change
+    });
+    set(change);
+  };
+  const patchRow = (scopeId, change) => {
+    set({
+      byScope: {
+        ...get().byScope,
+        [scopeId]: {
+          ...(get().byScope[scopeId] ?? EMPTY),
+          ...change
         }
-    };
-}, (store) => store.setState(storage.read()));
+      }
+    });
+  };
+  return {
+    ...DEFAULTS,
+    byScope: {},
+    chosen: null,
+    choose(scopeId) {
+      set({
+        chosen: scopeId
+      });
+    },
+    setPeriod(period) {
+      choosePreference({
+        period
+      });
+    },
+    setMetric(metric) {
+      choosePreference({
+        metric
+      });
+    },
+    setCurrency(currency) {
+      choosePreference({
+        currency
+      });
+    },
+    setLoading(scopeId, loading) {
+      patchRow(scopeId, {
+        loading
+      });
+    },
+    receive(scopeId, asked, summary) {
+      patchRow(scopeId, {
+        asked,
+        summary,
+        loading: false,
+        failed: false
+      });
+    },
+    fail(scopeId) {
+      patchRow(scopeId, {
+        loading: false,
+        failed: true
+      });
+    },
+    setLimits(scopeId, limits) {
+      patchRow(scopeId, {
+        limits
+      });
+    },
+    forget(scopeId) {
+      const {
+        [scopeId]: _gone,
+        ...rest
+      } = get().byScope;
+      set({
+        byScope: rest
+      });
+    }
+  };
+}, store => store.setState(storage.read()));
 export function useUsage(select) {
-    const { id } = useChatScope();
-    return useUsageStore((s) => select({ period: s.period, metric: s.metric, currency: s.currency, ...(s.byScope[id] ?? EMPTY) }));
-}
+  const $ = _c(3);
+  const {
+    id
+  } = useChatScope();
+  let t0;
+  if ($[0] !== id || $[1] !== select) {
+    t0 = s => select({
+      period: s.period,
+      metric: s.metric,
+      currency: s.currency,
+      ...(s.byScope[id] ?? EMPTY)
+    });
+    $[0] = id;
+    $[1] = select;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return useUsageStore(t0);
+}

package/dist/storage.js

@@ -1,89 +1,90 @@
 import { create } from 'zustand';
 const SUFFIXES = {
-    drafts: 'chat.drafts',
-    preferences: 'chat.preferences',
-    stash: 'chat.stash',
-    usage: 'usage'
+  drafts: 'chat.drafts',
+  preferences: 'chat.preferences',
+  stash: 'chat.stash',
+  usage: 'usage'
 };
 let options = {};
 let hydrated = false;
 const hydrators = [];
 const configurationListeners = [];
 export function onChatStorageConfiguration(listener) {
-    configurationListeners.push(listener);
+  configurationListeners.push(listener);
 }
 /* Configure once before using a store, so an imported component cannot read another host's records. */
 export function configureChatStorage(configuration) {
-    if (hydrated) {
-        throw new Error('Configure chat storage before using chat stores');
-    }
-    options = {
-        ...configuration,
-        keys: { ...configuration.keys },
-        legacyNamespaces: [...(configuration.legacyNamespaces ?? [])],
-        legacyKeys: Object.fromEntries(Object.entries(configuration.legacyKeys ?? {}).map(([key, values]) => [key, [...values]]))
-    };
-    for (const listener of configurationListeners) {
-        listener();
-    }
+  if (hydrated) {
+    throw new Error('Configure chat storage before using chat stores');
+  }
+  options = {
+    ...configuration,
+    keys: {
+      ...configuration.keys
+    },
+    legacyNamespaces: [...(configuration.legacyNamespaces ?? [])],
+    legacyKeys: Object.fromEntries(Object.entries(configuration.legacyKeys ?? {}).map(([key, values]) => [key, [...values]]))
+  };
+  for (const listener of configurationListeners) {
+    listener();
+  }
 }
 export function chatStorageKey(record) {
-    return options.keys?.[record] ?? `${options.namespace ?? 'adecore'}.${SUFFIXES[record]}`;
+  return options.keys?.[record] ?? `${options.namespace ?? 'adecore'}.${SUFFIXES[record]}`;
 }
 export function chatStorageLegacyKeys(record) {
-    return [...(options.legacyKeys?.[record] ?? []), ...(options.legacyNamespaces ?? []).map((namespace) => `${namespace}.${SUFFIXES[record]}`)];
+  return [...(options.legacyKeys?.[record] ?? []), ...(options.legacyNamespaces ?? []).map(namespace => `${namespace}.${SUFFIXES[record]}`)];
 }
 export function chatStorageAdapter() {
-    if (options.storage !== undefined) {
-        return options.storage;
-    }
-    try {
-        return globalThis.localStorage;
-    }
-    catch {
-        return null;
-    }
+  if (options.storage !== undefined) {
+    return options.storage;
+  }
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return null;
+  }
 }
 export function hydrateChatStorage() {
-    if (hydrated) {
-        return;
-    }
-    hydrated = true;
-    for (const hydrate of hydrators) {
-        hydrate();
-    }
+  if (hydrated) {
+    return;
+  }
+  hydrated = true;
+  for (const hydrate of hydrators) {
+    hydrate();
+  }
 }
 export function createChatStore(initial, hydrate) {
-    const store = create(initial);
-    let initialized = false;
-    const hydrateOnce = () => {
-        if (initialized) {
-            return;
-        }
-        initialized = true;
-        hydrate(store);
-    };
-    hydrators.push(hydrateOnce);
-    const ready = () => {
-        hydrateChatStorage();
-        hydrateOnce();
-    };
-    const useStore = ((...args) => {
-        ready();
-        return store(...args);
-    });
-    Object.assign(useStore, store);
-    useStore.getState = () => {
-        ready();
-        return store.getState();
-    };
-    useStore.subscribe = (...args) => {
-        ready();
-        return store.subscribe(...args);
-    };
-    useStore.setState = ((...args) => {
-        ready();
-        store.setState(...args);
-    });
-    return useStore;
-}
+  const store = create(initial);
+  let initialized = false;
+  const hydrateOnce = () => {
+    if (initialized) {
+      return;
+    }
+    initialized = true;
+    hydrate(store);
+  };
+  hydrators.push(hydrateOnce);
+  const ready = () => {
+    hydrateChatStorage();
+    hydrateOnce();
+  };
+  const useStore = (...args) => {
+    ready();
+    return store(...args);
+  };
+  Object.assign(useStore, store);
+  useStore.getState = () => {
+    ready();
+    return store.getState();
+  };
+  useStore.subscribe = (...args) => {
+    ready();
+    return store.subscribe(...args);
+  };
+  useStore.setState = (...args) => {
+    ready();
+    store.setState(...args);
+  };
+  return useStore;
+}

package/dist/testing/index.js

@@ -1,2 +1,2 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { PROMPT_SAMPLES } from './prompts.js';
+export { PROMPT_SAMPLES } from './prompts.js';