@adecore/agents-react 0.31.12 → 0.32.0

package/dist/chat/logic/picker-entries.js

@@ -3,69 +3,109 @@
  * with the rest behind one row that opens all of them. A list of three hundred models is not one to scroll.
  */
 export const COMPACT_MODEL_LIMIT = 8;
+const NO_FAVORITES = () => new Set();
 function matches(model, query) {
-    return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query) || (model.vendor?.toLowerCase().includes(query) ?? false);
+  return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query) || (model.vendor?.toLowerCase().includes(query) ?? false);
 }
 /*
  * By maker, then by name, when the provider says who made its models; a list with no makers keeps the order
  * it came in. A model with no maker goes last, so the ones that have one read as groups.
  */
 export function modelsByVendor(models) {
-    if (!models.some((model) => model.vendor !== undefined)) {
-        return models;
+  if (!models.some(model => model.vendor !== undefined)) {
+    return models;
+  }
+  return [...models].sort((a, b) => {
+    if (a.vendor === undefined || b.vendor === undefined) {
+      return a.vendor === b.vendor ? 0 : a.vendor === undefined ? 1 : -1;
     }
-    return [...models].sort((a, b) => {
-        if (a.vendor === undefined || b.vendor === undefined) {
-            return a.vendor === b.vendor ? 0 : a.vendor === undefined ? 1 : -1;
-        }
-        return (a.vendor.localeCompare(b.vendor, undefined, { sensitivity: 'base' }) ||
-            a.name.localeCompare(b.name, undefined, { sensitivity: 'base', numeric: true }));
+    return a.vendor.localeCompare(b.vendor, undefined, {
+      sensitivity: 'base'
+    }) || a.name.localeCompare(b.name, undefined, {
+      sensitivity: 'base',
+      numeric: true
     });
+  });
 }
-/* The models a long list shows before it is opened: the default and the one that is picked. Null when the list is short enough to show whole. */
-export function shortlistOf(kind, models, current) {
-    if (models.length <= COMPACT_MODEL_LIMIT) {
-        return null;
-    }
-    return modelsByVendor(models.filter((model) => model.isDefault || (current?.provider === kind && current.model === model.slug)));
+/* The starred models first, in the order they came, then the rest by maker. */
+export function favoritesFirst(models, favorites) {
+  if (favorites.size === 0) {
+    return modelsByVendor(models);
+  }
+  return [...models.filter(model => favorites.has(model.slug)), ...modelsByVendor(models.filter(model => !favorites.has(model.slug)))];
+}
+/*
+ * The models a long list shows before it is opened: the starred ones, the default and the one that is picked.
+ * Null when the list is short enough to show whole.
+ */
+export function shortlistOf(kind, models, current, favorites = new Set()) {
+  if (models.length <= COMPACT_MODEL_LIMIT) {
+    return null;
+  }
+  return favoritesFirst(models.filter(model => model.isDefault || favorites.has(model.slug) || current?.provider === kind && current.model === model.slug), favorites);
 }
 /* Whether the providers offer enough models together that a search is quicker than reading the list. */
 export function wantsModelSearch(providers) {
-    return providers.reduce((count, entry) => count + entry.models.length, 0) > COMPACT_MODEL_LIMIT;
+  return providers.reduce((count, entry) => count + entry.models.length, 0) > COMPACT_MODEL_LIMIT;
 }
-/* Every model of every provider that a search finds, legacy ones included, by maker; a provider with none is left out. */
-export function searchModels(providers, query) {
-    const needle = query.trim().toLowerCase();
-    return providers
-        .map((entry) => ({ entry, models: modelsByVendor(entry.models.filter((model) => matches(model, needle))) }))
-        .filter((group) => group.models.length > 0);
+/* Every model of every provider that a search finds, legacy ones included, starred first and then by maker; a provider with none is left out. */
+export function searchModels(providers, query, favoritesOf = NO_FAVORITES) {
+  const needle = query.trim().toLowerCase();
+  return providers.map(entry => ({
+    entry,
+    models: favoritesFirst(entry.models.filter(model => matches(model, needle)), favoritesOf(entry.kind))
+  })).filter(group => group.models.length > 0);
 }
 const NONE = new Set();
 /*
  * The rows of the model list. A model an old CLI cannot run is a row like any other, so a search for
  * only that model still finds the row that explains why it cannot be picked. A search looks through
  * every model of every provider; without one, a provider with many models shows a short list and a row
- * that opens the rest, grouped by maker.
+ * that opens the rest, grouped by maker. A provider's starred models come first wherever it lists them.
  */
-export function pickerEntriesOf(providers, query, legacyOpen, expanded = NONE, current = null) {
-    const rowsOf = (entry, models) => modelsByVendor(models).map((model) => ({ kind: 'model', provider: entry, model }));
-    if (query !== '') {
-        return providers.flatMap((entry) => rowsOf(entry, entry.models.filter((model) => matches(model, query))));
+export function pickerEntriesOf(providers, query, legacyOpen, expanded = NONE, current = null, favoritesOf = NO_FAVORITES) {
+  const rowsOf = (entry, models) => favoritesFirst(models, favoritesOf(entry.kind)).map(model => ({
+    kind: 'model',
+    provider: entry,
+    model
+  }));
+  if (query !== '') {
+    return providers.flatMap(entry => rowsOf(entry, entry.models.filter(model => matches(model, query))));
+  }
+  const legacy = providers.flatMap(entry => entry.models.filter(model => model.legacy).map(model => ({
+    kind: 'model',
+    provider: entry,
+    model
+  })));
+  const live = providers.flatMap(entry => {
+    const models = entry.models.filter(model => !model.legacy);
+    const shortlist = shortlistOf(entry.kind, models, current, favoritesOf(entry.kind));
+    if (shortlist === null) {
+      return rowsOf(entry, models);
     }
-    const legacy = providers.flatMap((entry) => entry.models.filter((model) => model.legacy).map((model) => ({ kind: 'model', provider: entry, model })));
-    const live = providers.flatMap((entry) => {
-        const models = entry.models.filter((model) => !model.legacy);
-        const shortlist = shortlistOf(entry.kind, models, current);
-        if (shortlist === null) {
-            return rowsOf(entry, models);
-        }
-        if (expanded.has(entry.kind)) {
-            return [{ kind: 'all', provider: entry, count: models.length, open: true }, ...rowsOf(entry, models)];
-        }
-        return [...rowsOf(entry, shortlist), { kind: 'all', provider: entry, count: models.length, open: false }];
-    });
-    if (legacy.length === 0) {
-        return live;
+    if (expanded.has(entry.kind)) {
+      return [{
+        kind: 'all',
+        provider: entry,
+        count: models.length,
+        open: true
+      }, ...rowsOf(entry, models)];
     }
-    return legacyOpen ? [...live, { kind: 'legacy', count: legacy.length }, ...legacy] : [...live, { kind: 'legacy', count: legacy.length }];
-}
+    return [...rowsOf(entry, shortlist), {
+      kind: 'all',
+      provider: entry,
+      count: models.length,
+      open: false
+    }];
+  });
+  if (legacy.length === 0) {
+    return live;
+  }
+  return legacyOpen ? [...live, {
+    kind: 'legacy',
+    count: legacy.length
+  }, ...legacy] : [...live, {
+    kind: 'legacy',
+    count: legacy.length
+  }];
+}

package/dist/chat/logic/resume-compaction.d.ts

@@ -1,14 +1,27 @@
 import type { ChatInfo, ChatItem, ProviderCapabilities } from '@adecore/agent-contracts';
 export declare const RESUME_COMPACTION_TOKENS = 100000;
 export declare const RESUME_COMPACTION_IDLE_MS: number;
+export type ResumeCompactionReason = 'cache-expired' | 'idle';
 export interface ResumeCompactionOffer {
     turnId: string;
     tokens: number;
+    reason: ResumeCompactionReason;
 }
-export declare function resumeCompactionOffer({ info, compaction, items, dismissedTurnId, now }: {
+interface OfferInput {
     info: ChatInfo;
     compaction: ProviderCapabilities['compaction'] | undefined;
     items: readonly ChatItem[];
     dismissedTurnId: string | null;
+}
+export declare function resumeCompactionDueAt(input: OfferInput): number | null;
+export declare function resumeCompactionOffer(input: OfferInput & {
     now: number;
 }): ResumeCompactionOffer | null;
+export interface DueClock {
+    now(): number;
+    setTimer(run: () => void, ms: number): unknown;
+    clearTimer(timer: unknown): void;
+    onWake(wake: () => void): () => void;
+}
+export declare function watchDueAt(dueAt: number, due: (now: number) => void, clock: DueClock): () => void;
+export {};

package/dist/chat/logic/resume-compaction.js

@@ -5,34 +5,103 @@
 export const RESUME_COMPACTION_TOKENS = 100_000;
 /* The longest prompt cache Claude keeps is an hour, so past this the whole thread is read again anyway. */
 export const RESUME_COMPACTION_IDLE_MS = 70 * 60_000;
+/* The newest turn by when it started, so a thread that arrives out of order still names the turn that ran last. */
 function lastTurn(items) {
-    return items.findLast((item) => item.kind === 'turn') ?? null;
+  let last = null;
+  for (const item of items) {
+    if (item.kind === 'turn' && (last === null || item.createdAt >= last.createdAt)) {
+      last = item;
+    }
+  }
+  return last;
+}
+/* The turn an offer would be about, or null while nothing could be offered whatever the time. */
+function offerableTurn({
+  info,
+  compaction,
+  items,
+  dismissedTurnId
+}) {
+  if (compaction === undefined || compaction === 'none') {
+    return null;
+  }
+  if (info.activeTurnId !== null || (info.queue ?? []).length > 0) {
+    return null;
+  }
+  if (info.usage.contextTokens < RESUME_COMPACTION_TOKENS) {
+    return null;
+  }
+  const turn = lastTurn(items);
+  if (turn === null || turn.endedAt === null || turn.id === dismissedTurnId) {
+    return null;
+  }
+  /*
+   * `contextTokens` keeps the old number until the next request, so without this the offer would
+   * come straight back after a compaction. A native compaction is a turn without a message of the
+   * person, which is why this looks at the turn and not at the last thing that was said.
+   */
+  if (items.some(item => item.kind === 'compaction' && item.turnId === turn.id)) {
+    return null;
+  }
+  return turn;
+}
+/* A silence longer than any cache lives stands in for an expiry from a CLI that names none. */
+function dueAtOf(info, endedAt) {
+  return info.usage.cacheExpiresAt ?? endedAt + RESUME_COMPACTION_IDLE_MS;
+}
+/*
+ * When the next message would pay for the whole thread again, or null while nothing could be offered,
+ * so a surface knows whether to keep a timer.
+ */
+export function resumeCompactionDueAt(input) {
+  const endedAt = offerableTurn(input)?.endedAt ?? null;
+  return endedAt === null ? null : dueAtOf(input.info, endedAt);
 }
 /* Whether to offer compacting before the next message. */
-export function resumeCompactionOffer({ info, compaction, items, dismissedTurnId, now }) {
-    if (compaction === undefined || compaction === 'none') {
-        return null;
-    }
-    if (info.activeTurnId !== null || (info.queue ?? []).length > 0) {
-        return null;
-    }
-    if (info.usage.contextTokens < RESUME_COMPACTION_TOKENS) {
-        return null;
+export function resumeCompactionOffer(input) {
+  const turn = offerableTurn(input);
+  if (turn === null || turn.endedAt === null || input.now < dueAtOf(input.info, turn.endedAt)) {
+    return null;
+  }
+  return {
+    turnId: turn.id,
+    tokens: input.info.usage.contextTokens,
+    reason: input.info.usage.cacheExpiresAt === undefined ? 'idle' : 'cache-expired'
+  };
+}
+/*
+ * Calls `due` with the time once `dueAt` passed. A timer can fire a few milliseconds early, and one that runs on a
+ * monotonic clock fires late after the system slept, so an early timer is armed again and a wake looks at once.
+ */
+export function watchDueAt(dueAt, due, clock) {
+  let timer = null;
+  let done = false;
+  const check = () => {
+    if (timer !== null) {
+      clock.clearTimer(timer);
+      timer = null;
     }
-    const turn = lastTurn(items);
-    if (turn === null || turn.endedAt === null || turn.id === dismissedTurnId) {
-        return null;
+    if (done) {
+      return;
     }
-    if (now - turn.endedAt < RESUME_COMPACTION_IDLE_MS) {
-        return null;
+    const now = clock.now();
+    if (now >= dueAt) {
+      done = true;
+      due(now);
+      return;
     }
-    /*
-     * `contextTokens` keeps the old number until the next request, so without this the offer would
-     * come straight back after a compaction. A native compaction is a turn without a message of the
-     * person, which is why this looks at the turn and not at the last thing that was said.
-     */
-    if (items.some((item) => item.kind === 'compaction' && item.turnId === turn.id)) {
-        return null;
+    timer = clock.setTimer(() => {
+      timer = null;
+      check();
+    }, dueAt - now);
+  };
+  const stopWake = clock.onWake(check);
+  check();
+  return () => {
+    done = true;
+    stopWake();
+    if (timer !== null) {
+      clock.clearTimer(timer);
     }
-    return { turnId: turn.id, tokens: info.usage.contextTokens };
-}
+  };
+}