@adecore/agents-react 0.31.12 → 0.32.0

package/dist/locales/nl/agent-usage.js

@@ -1,131 +1,137 @@
 export default {
-    limits: {
-        title: 'Limieten',
-        explain: 'Het streepje op een balk laat zien hoeveel van het venster voorbij is. Een balk voorbij dat streepje verbruikt sneller dan het venster teruggeeft.',
-        loading: 'Limieten laden…',
-        used: '{{percent}}% gebruikt',
-        bar: '{{window}}, {{percent}}% gebruikt',
-        windowPassed: '{{percent}}% van het venster voorbij',
-        faster: 'Verbruikt sneller dan het venster teruggeeft.',
-        slower: 'Verbruikt langzamer dan het venster teruggeeft.',
-        resets: 'Reset {{at}}',
-        none: 'Nog geen limieten gemeld.',
-        notInstalled: 'Niet geïnstalleerd op deze machine.',
-        noSubscription: 'Dit account gebruikt een API-sleutel en kent geen abonnementslimieten.',
-        unreachable: 'De CLI was niet bereikbaar.',
-        filter: 'Accounts waarvan je de limieten ziet',
-        signedOut: 'Niet ingelogd',
-        signedOutDetail: 'Niet ingelogd. Log in om de limieten te zien.',
-        logIn: 'Inloggen',
-        nextReset: '{{window}} reset {{at}}',
-        checked: {
-            now: 'nu',
-            ago: '{{duration}} geleden',
-            fromTurn: 'Uit een turn · {{when}}'
-        }
+  limits: {
+    title: 'Limieten',
+    explain: 'De markering toont waar het verbruik bij een gelijk tempo zou staan. Voorbij de markering verbruik je sneller dan het weer vrijkomt.',
+    loading: 'Limieten laden…',
+    used: '{{percent}}% gebruikt',
+    bar: '{{window}}, {{percent}}% gebruikt',
+    windowPassed: '{{percent}}% van het venster voorbij',
+    faster: 'Sneller verbruikt dan het weer vrijkomt.',
+    slower: 'Langzamer verbruikt dan het weer vrijkomt.',
+    pace: {
+      ahead: '{{percent}}% gebruikt, voor op een gelijkmatig tempo van {{pace}}%',
+      behind: '{{percent}}% gebruikt, achter op een gelijkmatig tempo van {{pace}}%',
+      even: '{{percent}}% gebruikt, op een gelijkmatig tempo'
     },
-    settings: {
-        currency: {
-            label: 'Valuta',
-            dollars: 'Prijzen zoals gepubliceerd, in dollars.',
-            noRate: 'Nog geen wisselkoers. De pagina toont dollars zolang die er niet is.',
-            converted: 'Omgerekend met de ECB-referentiekoers van {{date}}.',
-            options: {
-                USD: 'Dollars',
-                EUR: "Euro's"
-            }
-        },
-        page: {
-            label: 'Verbruikspagina',
-            description: 'Kosten, tokens en planlimieten, per account.',
-            open: 'Verbruik openen'
-        }
-    },
-    section: {
-        label: 'Verbruik',
-        description: 'De valuta van de verbruikspagina.'
-    },
-    dialog: {
-        title: 'Verbruik',
-        description: 'Kosten, tokens en limieten van je abonnement',
-        close: 'Verbruik sluiten',
-        rescan: 'Opnieuw scannen',
-        period: 'Periode',
-        metric: 'Eenheid',
-        failed: 'Verbruik kon niet worden getekend',
-        periods: {
-            today: 'Vandaag',
-            '7d': '7 dagen',
-            '30d': '30 dagen',
-            '90d': '90 dagen'
-        },
-        metrics: {
-            cost: 'Kosten',
-            tokens: 'Tokens'
-        },
-        accounts: {
-            label: 'Account',
-            all: 'Alle accounts'
-        }
-    },
-    empty: {
-        noTranscripts: 'Geen transcripts van Claude of Codex gevonden. De machine leest ~/.claude/projects en ~/.codex/sessions.',
-        noUsage: 'Nog geen verbruik op deze machine.'
-    },
-    agents: {
-        none: 'Op deze machine staat geen agent-CLI.',
-        installed: 'Deze machine heeft {{list}}.',
-        settings: 'Agent-instellingen'
+    even: 'Even snel verbruikt als het vrijkomt.',
+    resets: 'Reset {{at}}',
+    none: 'Nog geen limieten gemeld.',
+    notInstalled: 'Niet geïnstalleerd op deze machine.',
+    noSubscription: 'API-sleutel, geen abonnementslimieten.',
+    unreachable: 'Kon de limieten niet ophalen.',
+    filter: 'Getoonde accounts',
+    signedOut: 'Niet ingelogd',
+    signedOutDetail: 'Niet ingelogd. Log in om limieten te zien.',
+    logIn: 'Inloggen',
+    nextReset: '{{window}} reset {{at}}',
+    checked: {
+      now: 'nu',
+      ago: '{{duration}} geleden',
+      fromTurn: 'Uit een turn · {{when}}'
+    }
+  },
+  settings: {
+    currency: {
+      label: 'Valuta',
+      dollars: 'Prijzen zoals gepubliceerd, in dollars.',
+      noRate: 'Nog geen wisselkoers. Bedragen in dollars.',
+      converted: 'Omgerekend met de ECB-koers van {{date}}.',
+      options: {
+        USD: 'Dollars',
+        EUR: "Euro's"
+      }
     },
-    provenance: {
-        failed: 'Kon de transcripts niet lezen. Dit is de laatste scan die wel lukte.',
-        scanned_one: 'Gescand om {{time}}, {{files}} bestand',
-        scanned_other: 'Gescand om {{time}}, {{files}} bestanden',
-        bundledPrices: 'Prijzen uit de meegeleverde tabel',
-        fetchedPrices: 'Prijzen van LiteLLM, {{date}}',
-        rate: '{{currency}} tegen de ECB-koers van {{date}}'
+    page: {
+      label: 'Verbruikspagina',
+      description: 'Kosten, tokens en planlimieten, per account.',
+      open: 'Verbruik openen'
+    }
+  },
+  section: {
+    label: 'Verbruik',
+    description: 'Valuta van de verbruikspagina.'
+  },
+  dialog: {
+    title: 'Verbruik',
+    description: 'Kosten, tokens en limieten van je abonnement',
+    close: 'Verbruik sluiten',
+    rescan: 'Opnieuw scannen',
+    period: 'Periode',
+    metric: 'Eenheid',
+    failed: 'Kon het verbruik niet tonen',
+    periods: {
+      today: 'Vandaag',
+      '7d': '7 dagen',
+      '30d': '30 dagen',
+      '90d': '90 dagen'
     },
-    summary: {
-        sessions_one: '{{sessions}} sessie',
-        sessions_other: '{{sessions}} sessies',
-        calls_one: '{{calls}} aanroep',
-        calls_other: '{{calls}} aanroepen',
-        apiRates: 'tegen API-tarieven'
+    metrics: {
+      cost: 'Kosten',
+      tokens: 'Tokens'
     },
-    tiles: {
-        processed: 'Verwerkt',
-        uncachedInput: 'Input zonder cache',
-        cachedInput: 'Input uit cache',
-        cacheWrites: 'Naar cache geschreven',
-        output: 'Output',
-        cacheSavings: 'Bespaard met cache'
+    accounts: {
+      label: 'Account',
+      all: 'Alle accounts'
+    }
+  },
+  empty: {
+    noTranscripts: 'Nog geen chats van Claude of Codex gevonden op deze machine.',
+    noUsage: 'Nog geen verbruik.'
+  },
+  agents: {
+    none: 'Geen agent-CLI geïnstalleerd.',
+    installed: 'Geïnstalleerd: {{list}}.',
+    settings: 'Agent-instellingen'
+  },
+  provenance: {
+    failed: 'Kon het laatste verbruik niet lezen. Dit zijn de vorige resultaten.',
+    scanned_one: 'Gescand om {{time}}, {{files}} bestand',
+    scanned_other: 'Gescand om {{time}}, {{files}} bestanden',
+    bundledPrices: 'Ingebouwde prijzen',
+    fetchedPrices: 'Prijzen van {{date}}',
+    rate: '{{currency}} tegen de ECB-koers van {{date}}'
+  },
+  summary: {
+    sessions_one: '{{sessions}} sessie',
+    sessions_other: '{{sessions}} sessies',
+    calls_one: '{{calls}} aanroep',
+    calls_other: '{{calls}} aanroepen',
+    apiRates: 'tegen API-tarieven'
+  },
+  tiles: {
+    processed: 'Verwerkt',
+    uncachedInput: 'Input zonder cache',
+    cachedInput: 'Input uit cache',
+    cacheWrites: 'Naar cache geschreven',
+    output: 'Output',
+    cacheSavings: 'Bespaard met cache'
+  },
+  chart: {
+    total: 'Totaal'
+  },
+  breakdown: {
+    title: 'Uitsplitsing',
+    tabs: {
+      models: 'Modellen',
+      projects: 'Projecten',
+      day: 'Dag'
     },
-    chart: {
-        total: 'Totaal'
+    models: {
+      model: 'Model',
+      calls: 'Aanroepen',
+      input: 'Input',
+      output: 'Output',
+      cache: 'Cache R/W',
+      cost: 'Kosten',
+      share: 'Aandeel',
+      pricedAs: 'Geprijsd als {{model}}',
+      noPrice: 'Geen prijs bekend'
     },
-    breakdown: {
-        title: 'Uitsplitsing',
-        tabs: {
-            models: 'Modellen',
-            projects: 'Projecten',
-            day: 'Dag'
-        },
-        models: {
-            model: 'Model',
-            calls: 'Aanroepen',
-            input: 'Input',
-            output: 'Output',
-            cache: 'Cache R/W',
-            cost: 'Kosten',
-            share: 'Aandeel',
-            pricedAs: 'Geprijsd als {{model}}',
-            noPrice: 'Geen prijs bekend voor dit model'
-        },
-        days: {
-            day: 'Dag',
-            total: 'Totaal',
-            tokens: 'Tokens',
-            empty: 'Geen activiteit in deze periode.'
-        }
+    days: {
+      day: 'Dag',
+      total: 'Totaal',
+      tokens: 'Tokens',
+      empty: 'Geen activiteit in deze periode.'
     }
-};
+  }
+};

package/dist/locales.js

@@ -1,21 +1,21 @@
 /* The words of this package, a namespace per surface, which the app adds to its i18next beside its own namespaces. */
 export const AGENTS_NAMESPACES = ['agent-chat', 'agent-prompts', 'agent-providers', 'agent-usage'];
 async function open(files) {
-    return Object.fromEntries(await Promise.all(Object.entries(files).map(async ([namespace, file]) => [namespace, (await file()).default])));
+  return Object.fromEntries(await Promise.all(Object.entries(files).map(async ([namespace, file]) => [namespace, (await file()).default])));
 }
 /* The words are modules, not JSON: Node needs `with { type: 'json' }` on a JSON import, and a browser refuses it on the JavaScript Vite serves. */
 /* One loader per language that answers every namespace of it, so a bundler splits them and a window only downloads the language it shows. */
 export const AGENTS_LOCALES = {
-    en: () => open({
-        'agent-chat': () => import('./locales/en/agent-chat.js'),
-        'agent-prompts': () => import('./locales/en/agent-prompts.js'),
-        'agent-providers': () => import('./locales/en/agent-providers.js'),
-        'agent-usage': () => import('./locales/en/agent-usage.js')
-    }),
-    nl: () => open({
-        'agent-chat': () => import('./locales/nl/agent-chat.js'),
-        'agent-prompts': () => import('./locales/nl/agent-prompts.js'),
-        'agent-providers': () => import('./locales/nl/agent-providers.js'),
-        'agent-usage': () => import('./locales/nl/agent-usage.js')
-    })
-};
+  en: () => open({
+    'agent-chat': () => import('./locales/en/agent-chat.js'),
+    'agent-prompts': () => import('./locales/en/agent-prompts.js'),
+    'agent-providers': () => import('./locales/en/agent-providers.js'),
+    'agent-usage': () => import('./locales/en/agent-usage.js')
+  }),
+  nl: () => open({
+    'agent-chat': () => import('./locales/nl/agent-chat.js'),
+    'agent-prompts': () => import('./locales/nl/agent-prompts.js'),
+    'agent-providers': () => import('./locales/nl/agent-providers.js'),
+    'agent-usage': () => import('./locales/nl/agent-usage.js')
+  })
+};

package/dist/mounted-registry.js

@@ -6,34 +6,35 @@ const REATTACH_CONCURRENCY = 4;
  * The host on the other side is a fresh one as far as this client knows, so nothing is assumed.
  */
 export class MountedRegistry extends Map {
-    /* Nothing is attached over a link that is gone; `report` is how a store hears about it. */
-    detachAll(report) {
-        for (const [id, entry] of this) {
-            entry.attached = false;
-            report?.(id, entry);
-        }
-    }
-    /*
-     * One pass over what is mounted but not attached, in mount order, a few at a time. It works on a
-     * copy, because attaching mounts and unmounts as it goes. An entry that left in the meantime is
-     * skipped, since a node may leave the canvas while its attach is on the wire.
-     */
-    async reattachAll(reattach) {
-        const queue = [...this];
-        const work = async () => {
-            for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
-                const [id, entry] = next;
-                if (entry.attached || this.get(id) !== entry) {
-                    continue;
-                }
-                try {
-                    await reattach(id, entry);
-                }
-                catch {
-                    // A socket that dropped again brings the next pass; anything else surfaces on the next mount.
-                }
-            }
-        };
-        await Promise.all(Array.from({ length: REATTACH_CONCURRENCY }, work));
+  /* Nothing is attached over a link that is gone; `report` is how a store hears about it. */
+  detachAll(report) {
+    for (const [id, entry] of this) {
+      entry.attached = false;
+      report?.(id, entry);
     }
-}
+  }
+  /*
+   * One pass over what is mounted but not attached, in mount order, a few at a time. It works on a
+   * copy, because attaching mounts and unmounts as it goes. An entry that left in the meantime is
+   * skipped, since a node may leave the canvas while its attach is on the wire.
+   */
+  async reattachAll(reattach) {
+    const queue = [...this];
+    const work = async () => {
+      for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
+        const [id, entry] = next;
+        if (entry.attached || this.get(id) !== entry) {
+          continue;
+        }
+        try {
+          await reattach(id, entry);
+        } catch {
+          // A socket that dropped again brings the next pass; anything else surfaces on the next mount.
+        }
+      }
+    };
+    await Promise.all(Array.from({
+      length: REATTACH_CONCURRENCY
+    }, work));
+  }
+}

package/dist/port-transport.js

@@ -3,7 +3,7 @@ import { parseServerFrame } from '@adecore/agent-contracts/envelope';
 import { AGENT_EVENT_SCHEMAS, AGENT_REQUEST_SCHEMAS } from '@adecore/agent-contracts/protocol';
 import { ChatTransportError } from './transport.js';
 function isEventType(event) {
-    return Object.hasOwn(AGENT_EVENT_SCHEMAS, event);
+  return Object.hasOwn(AGENT_EVENT_SCHEMAS, event);
 }
 /*
  * A chat host at the other end of a port, such as a process that runs the chats beside the window.
@@ -12,114 +12,125 @@ function isEventType(event) {
  * with a warning, the way the socket transport of an app drops one.
  */
 export function portTransport(port) {
-    let status = 'open';
-    let nextId = 1;
-    const pending = new Map();
-    const eventHandlers = new Map();
-    const statusHandlers = new Set();
-    const answer = (id, frame) => {
-        const entry = pending.get(id);
-        if (!entry) {
-            return;
-        }
+  let status = 'open';
+  let nextId = 1;
+  const pending = new Map();
+  const eventHandlers = new Map();
+  const statusHandlers = new Set();
+  const answer = (id, frame) => {
+    const entry = pending.get(id);
+    if (!entry) {
+      return;
+    }
+    pending.delete(id);
+    if (!frame.ok) {
+      entry.reject(new ChatTransportError(frame.error.code, frame.error.message));
+      return;
+    }
+    const result = AGENT_REQUEST_SCHEMAS[entry.type].result.safeParse(frame.result);
+    if (!result.success) {
+      entry.reject(new ChatTransportError('bad-reply', i18next.t('agent-chat:transport.badReply', {
+        type: entry.type
+      })));
+      return;
+    }
+    entry.resolve(result.data);
+  };
+  const dispatch = (event, payload) => {
+    if (!isEventType(event)) {
+      console.warn('Dropped an unknown event', event);
+      return;
+    }
+    const parsed = AGENT_EVENT_SCHEMAS[event].safeParse(payload);
+    if (!parsed.success) {
+      console.warn(`Dropped a malformed ${event} event`);
+      return;
+    }
+    // A copy, so a handler that unsubscribes while it runs does not change the set being walked.
+    for (const handler of [...(eventHandlers.get(event) ?? [])]) {
+      handler(parsed.data);
+    }
+  };
+  const stopListening = port.onFrame(raw => {
+    if (status === 'closed') {
+      return;
+    }
+    const parsed = parseServerFrame(raw);
+    if (!parsed.ok) {
+      console.warn('Dropped a malformed frame', parsed.message);
+      return;
+    }
+    const frame = parsed.value;
+    if ('event' in frame) {
+      dispatch(frame.event, frame.payload);
+      return;
+    }
+    if (frame.id === null) {
+      // An answer without an id is about a frame the host could not read; nothing waits for it.
+      console.warn('The chat host refused a frame', frame);
+      return;
+    }
+    answer(frame.id, frame);
+  });
+  return {
+    get status() {
+      return status;
+    },
+    request(type, payload) {
+      if (status !== 'open') {
+        return Promise.reject(new ChatTransportError('not-connected', i18next.t('agent-chat:transport.notConnected')));
+      }
+      const id = String(nextId++);
+      const promise = new Promise((resolve, reject) => {
+        pending.set(id, {
+          type,
+          resolve: resolve,
+          reject
+        });
+      });
+      try {
+        port.send({
+          id,
+          type,
+          payload
+        });
+      } catch {
+        // A payload the port cannot clone throws here, and the caller only listens to the promise.
         pending.delete(id);
-        if (!frame.ok) {
-            entry.reject(new ChatTransportError(frame.error.code, frame.error.message));
-            return;
-        }
-        const result = AGENT_REQUEST_SCHEMAS[entry.type].result.safeParse(frame.result);
-        if (!result.success) {
-            entry.reject(new ChatTransportError('bad-reply', i18next.t('agent-chat:transport.badReply', { type: entry.type })));
-            return;
-        }
-        entry.resolve(result.data);
-    };
-    const dispatch = (event, payload) => {
-        if (!isEventType(event)) {
-            console.warn('Dropped an unknown event', event);
-            return;
-        }
-        const parsed = AGENT_EVENT_SCHEMAS[event].safeParse(payload);
-        if (!parsed.success) {
-            console.warn(`Dropped a malformed ${event} event`);
-            return;
-        }
-        // A copy, so a handler that unsubscribes while it runs does not change the set being walked.
-        for (const handler of [...(eventHandlers.get(event) ?? [])]) {
-            handler(parsed.data);
-        }
-    };
-    const stopListening = port.onFrame((raw) => {
-        if (status === 'closed') {
-            return;
-        }
-        const parsed = parseServerFrame(raw);
-        if (!parsed.ok) {
-            console.warn('Dropped a malformed frame', parsed.message);
-            return;
-        }
-        const frame = parsed.value;
-        if ('event' in frame) {
-            dispatch(frame.event, frame.payload);
-            return;
-        }
-        if (frame.id === null) {
-            // An answer without an id is about a frame the host could not read; nothing waits for it.
-            console.warn('The chat host refused a frame', frame);
-            return;
-        }
-        answer(frame.id, frame);
-    });
-    return {
-        get status() {
-            return status;
-        },
-        request(type, payload) {
-            if (status !== 'open') {
-                return Promise.reject(new ChatTransportError('not-connected', i18next.t('agent-chat:transport.notConnected')));
-            }
-            const id = String(nextId++);
-            const promise = new Promise((resolve, reject) => {
-                pending.set(id, { type, resolve: resolve, reject });
-            });
-            try {
-                port.send({ id, type, payload });
-            }
-            catch {
-                // A payload the port cannot clone throws here, and the caller only listens to the promise.
-                pending.delete(id);
-                return Promise.reject(new ChatTransportError('not-sent', i18next.t('agent-chat:transport.notSent', { type })));
-            }
-            return promise;
-        },
-        on(event, handler) {
-            const handlers = eventHandlers.get(event) ?? new Set();
-            eventHandlers.set(event, handlers);
-            handlers.add(handler);
-            return () => {
-                handlers.delete(handler);
-            };
-        },
-        subscribeStatus(handler) {
-            statusHandlers.add(handler);
-            return () => {
-                statusHandlers.delete(handler);
-            };
-        },
-        close() {
-            if (status === 'closed') {
-                return;
-            }
-            status = 'closed';
-            stopListening();
-            const waiting = [...pending.values()];
-            pending.clear();
-            for (const entry of waiting) {
-                entry.reject(new ChatTransportError('disconnected', i18next.t('agent-chat:transport.closedBeforeAnswer')));
-            }
-            for (const handler of [...statusHandlers]) {
-                handler(status);
-            }
-        }
-    };
-}
+        return Promise.reject(new ChatTransportError('not-sent', i18next.t('agent-chat:transport.notSent', {
+          type
+        })));
+      }
+      return promise;
+    },
+    on(event, handler) {
+      const handlers = eventHandlers.get(event) ?? new Set();
+      eventHandlers.set(event, handlers);
+      handlers.add(handler);
+      return () => {
+        handlers.delete(handler);
+      };
+    },
+    subscribeStatus(handler) {
+      statusHandlers.add(handler);
+      return () => {
+        statusHandlers.delete(handler);
+      };
+    },
+    close() {
+      if (status === 'closed') {
+        return;
+      }
+      status = 'closed';
+      stopListening();
+      const waiting = [...pending.values()];
+      pending.clear();
+      for (const entry of waiting) {
+        entry.reject(new ChatTransportError('disconnected', i18next.t('agent-chat:transport.closedBeforeAnswer')));
+      }
+      for (const handler of [...statusHandlers]) {
+        handler(status);
+      }
+    }
+  };
+}

package/dist/prompts/index.js

@@ -7,4 +7,4 @@ export { useFocusAfterAnswer } from './logic/useFocusAfterAnswer.js';
 export { usePromptSession } from './logic/usePromptSession.js';
 export { PromptPrimary, ApprovalActions } from './ui/PromptActions.js';
 export { PROMPT_SURFACE, PromptCard } from './ui/PromptCard.js';
-export { PromptView } from './ui/PromptView.js';
+export { PromptView } from './ui/PromptView.js';

package/dist/prompts/logic/focus.js

@@ -4,20 +4,21 @@
  * keyboard when it stands alone, and a stray Enter never grants anything. False when `root` holds no card.
  */
 export function focusPromptStart(root) {
-    const card = root?.querySelector('.prompt-card');
-    if (!card) {
-        return false;
-    }
-    const start = card.querySelector('[data-prompt-entry]:not(:disabled)') ??
-        card.querySelector('[role="toolbar"] button:not(:disabled):not([data-prompt-primary]):not([data-prompt-lasting])') ??
-        card.querySelector('[data-prompt-primary]:not(:disabled)') ??
-        card.querySelector('.prompt-heading');
-    start?.focus({ preventScroll: true });
-    return start !== null;
+  const card = root?.querySelector('.prompt-card');
+  if (!card) {
+    return false;
+  }
+  const start = card.querySelector('[data-prompt-entry]:not(:disabled)') ?? card.querySelector('[role="toolbar"] button:not(:disabled):not([data-prompt-primary]):not([data-prompt-lasting])') ?? card.querySelector('[data-prompt-primary]:not(:disabled)') ?? card.querySelector('.prompt-heading');
+  start?.focus({
+    preventScroll: true
+  });
+  return start !== null;
 }
 /* Puts the keyboard on a card's heading, where keys typed for something else answer nothing. False when `root` holds no card. */
 export function focusPromptHeading(root) {
-    const heading = root?.querySelector('.prompt-card .prompt-heading');
-    heading?.focus({ preventScroll: true });
-    return !!heading;
-}
+  const heading = root?.querySelector('.prompt-card .prompt-heading');
+  heading?.focus({
+    preventScroll: true
+  });
+  return !!heading;
+}