@adecore/agents-react 0.36.0 → 0.37.0

package/dist/chat/chat-client.d.ts

@@ -27,10 +27,13 @@ export declare class ChatClient {
     private readonly mounted;
     private readonly unsubscribe;
     private readonly earlier;
+    private readonly observers;
     private readonly inspections;
     private preferences;
+    private checkpoints;
     constructor(transport: ChatTransport, sink: ChatSink, providers?: ProviderSink | null);
     inspect(chatId: string): Promise<ChatAttachResult>;
+    observe(chatId: string): () => void;
     open(chatId: string, options: ChatOpenOptions): Promise<boolean>;
     retarget(chatId: string, provider: AgentKind, selection: ModelSelection): Promise<void>;
     setPreferences(preferences: ChatPreferencesPayload): void;
@@ -53,6 +56,8 @@ export declare class ChatClient {
     isMounted(chatId: string): boolean;
     dispose(): void;
     private attach;
+    private sequence;
+    private rememberSequence;
     private sendPreferences;
     private onStatus;
 }

package/dist/chat/chat-client.js

@@ -15,8 +15,10 @@ export class ChatClient {
   mounted = new MountedRegistry();
   unsubscribe = [];
   earlier = new Map();
+  observers = new Map();
   inspections = new Map();
   preferences = null;
+  checkpoints = new WeakMap();
   constructor(transport, sink, providers = null) {
     this.transport = transport;
     this.sink = sink;
@@ -26,10 +28,10 @@ export class ChatClient {
       event,
       seq
     }) => {
+      const previous = this.sequence(chatId);
       this.sink.apply(chatId, event);
-      const entry = this.mounted.get(chatId);
-      if (entry && seq !== undefined) {
-        entry.seq = seq;
+      if (previous !== undefined || !this.sink.historyIdentity && this.mounted.get(chatId)?.attached) {
+        this.rememberSequence(chatId, seq);
       }
     }),
     // Every chat on the machine, attached or not, so a node waiting on a person says so on a view nobody has open.
@@ -68,6 +70,33 @@ export class ChatClient {
     this.inspections.set(chatId, read);
     return read;
   }
+  /* Shares a live attachment without creating a chat; a visible composer and several ancestors may hold it together. */
+  observe(chatId) {
+    this.observers.set(chatId, (this.observers.get(chatId) ?? 0) + 1);
+    if (!this.mounted.has(chatId)) {
+      this.mounted.set(chatId, {
+        attached: false,
+        observerOnly: true
+      });
+      void this.attach(chatId).catch(() => undefined);
+    }
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      const remaining = (this.observers.get(chatId) ?? 1) - 1;
+      if (remaining > 0) {
+        this.observers.set(chatId, remaining);
+        return;
+      }
+      this.observers.delete(chatId);
+      if (this.mounted.get(chatId)?.observerOnly) {
+        void this.detach(chatId);
+      }
+    };
+  }
   /* Answers false when the transport is not connected; the chat opens once it is. */
   async open(chatId, options) {
     this.mounted.set(chatId, {
@@ -100,8 +129,10 @@ export class ChatClient {
       attached: _attached,
       account: _account,
       seq: _seq,
+      observerOnly: _observerOnly,
       ...options
     } = entry;
+    this.rememberSequence(chatId, undefined);
     this.mounted.delete(chatId);
     await this.transport.request('chat.kill', {
       chatId
@@ -127,6 +158,10 @@ export class ChatClient {
   }
   async detach(chatId) {
     const entry = this.mounted.get(chatId);
+    if (entry && this.observers.has(chatId)) {
+      entry.observerOnly = true;
+      return;
+    }
     this.mounted.delete(chatId);
     if (!entry?.attached) {
       return;
@@ -271,12 +306,16 @@ export class ChatClient {
       chatId,
       cursor,
       limit: HISTORY_PAGE
-    }).then(page => this.sink.prepend(chatId, cursor, page)).catch(async e => {
+    }).then(page => {
+      const seq = this.sequence(chatId);
+      this.sink.prepend(chatId, cursor, page);
+      this.rememberSequence(chatId, seq);
+    }).catch(async e => {
       const entry = this.mounted.get(chatId);
       if (errorCode(e) !== 'history-expired' || !entry) {
         throw e;
       }
-      delete entry.seq;
+      this.rememberSequence(chatId, undefined);
       await this.attach(chatId);
     }).finally(() => this.earlier.delete(chatId));
     this.earlier.set(chatId, read);
@@ -291,6 +330,8 @@ export class ChatClient {
       off();
     }
     this.unsubscribe.length = 0;
+    this.observers.clear();
+    this.checkpoints = new WeakMap();
     for (const chatId of [...this.mounted.keys()]) {
       void this.detach(chatId);
     }
@@ -305,20 +346,22 @@ export class ChatClient {
     if (!entry) {
       return;
     }
-    await this.transport.request('chat.create', {
-      chatId,
-      provider: entry.provider,
-      account: entry.account,
-      cwd: entry.cwd,
-      resume: entry.resume,
-      selection: entry.selection,
-      runtimeMode: entry.runtimeMode
-    });
+    if (!entry.observerOnly) {
+      await this.transport.request('chat.create', {
+        chatId,
+        provider: entry.provider,
+        account: entry.account,
+        cwd: entry.cwd,
+        resume: entry.resume,
+        selection: entry.selection,
+        runtimeMode: entry.runtimeMode
+      });
+    }
     // Closed or opened again in the meantime: an opening that is still there attaches itself.
     if (this.mounted.get(chatId) !== entry) {
       return;
     }
-    const since = entry.seq;
+    const since = this.sequence(chatId);
     const result = await this.transport.request('chat.attach', {
       chatId,
       historyLimit: HISTORY_PAGE,
@@ -336,13 +379,19 @@ export class ChatClient {
       }
       return;
     }
-    entry.attached = true;
-    if (result.seq !== undefined) {
-      entry.seq = result.seq;
+    // A cache eviction while the request was in flight also invalidates its replay base.
+    if (result.events && since !== undefined && this.sequence(chatId) === undefined) {
+      await this.attach(chatId);
+      return;
     }
+    entry.attached = true;
     if (result.events && since !== undefined) {
-      for (const event of result.events) {
-        this.sink.apply(chatId, event);
+      if (this.sink.replay) {
+        this.sink.replay(chatId, result.events);
+      } else {
+        for (const event of result.events) {
+          this.sink.apply(chatId, event);
+        }
       }
     } else {
       const page = result.history === undefined ? undefined : {
@@ -352,10 +401,32 @@ export class ChatClient {
       };
       this.sink.reset(chatId, result.info, result.items, page);
     }
+    this.rememberSequence(chatId, result.seq);
     // A host without bookmarks or visuals sends none, and then this chat has none.
     this.sink.bookmarks(chatId, result.bookmarks ?? []);
     this.sink.visuals(chatId, result.visuals ?? []);
   }
+  sequence(chatId) {
+    if (!this.sink.historyIdentity) {
+      return this.mounted.get(chatId)?.seq;
+    }
+    const identity = this.sink.historyIdentity(chatId);
+    return identity === undefined ? undefined : this.checkpoints.get(identity);
+  }
+  rememberSequence(chatId, seq) {
+    const entry = this.mounted.get(chatId);
+    if (entry) {
+      entry.seq = seq;
+    }
+    const identity = this.sink.historyIdentity?.(chatId);
+    if (identity !== undefined) {
+      if (seq === undefined) {
+        this.checkpoints.delete(identity);
+      } else {
+        this.checkpoints.set(identity, seq);
+      }
+    }
+  }
   sendPreferences() {
     if (this.preferences === null) {
       return;

package/dist/chat/index.d.ts

@@ -29,3 +29,4 @@ export { useSubagentSupport } from './subagent-support.js';
 export { crumbOf, openFromMain, composerWrites, canOpenSubagent, useSubagentView, useSubagentTrail, useSubagentItem, type SubagentStep, type SubagentTrail } from './subagent-view.js';
 export { stepTimelineMessage, jumpToTimelineItem, type TurnTarget, registerTurnJumper, jumpToTimelineTurn, type ItemJumpOptions } from './timeline-scroll.js';
 export { type StatusWord, statusLookOf, taskStatusWord, type StatusLook, type TaskState } from '../agents/status-look.js';
+export { ChatPromptFeed } from './pending-prompts.js';

package/dist/chat/index.js

@@ -24,4 +24,5 @@ export { subagentTitle, summaryWordOf, stopOf } from './subagent-list.js';
 export { useSubagentSupport } from './subagent-support.js';
 export { crumbOf, openFromMain, composerWrites, canOpenSubagent, useSubagentView, useSubagentTrail, useSubagentItem } from './subagent-view.js';
 export { stepTimelineMessage, jumpToTimelineItem, registerTurnJumper, jumpToTimelineTurn } from './timeline-scroll.js';
-export { statusLookOf, taskStatusWord } from '../agents/status-look.js';
+export { statusLookOf, taskStatusWord } from '../agents/status-look.js';
+export { ChatPromptFeed } from './pending-prompts.js';

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

@@ -1,9 +1,17 @@
+import { nameCollator } from '@adecore/ui/format';
 /*
  * A provider with more live models than this keeps the list short: the model that is picked and the default,
  * 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();
+const VENDOR_ORDER = {
+  sensitivity: 'base'
+};
+const MODEL_ORDER = {
+  sensitivity: 'base',
+  numeric: true
+};
 function matches(model, query) {
   return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query) || (model.vendor?.toLowerCase().includes(query) ?? false);
 }
@@ -15,16 +23,13 @@ export function modelsByVendor(models) {
   if (!models.some(model => model.vendor !== undefined)) {
     return models;
   }
+  const vendorOrder = nameCollator(VENDOR_ORDER).compare;
+  const modelOrder = nameCollator(MODEL_ORDER).compare;
   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 vendorOrder(a.vendor, b.vendor) || modelOrder(a.name, b.name);
   });
 }
 /* The starred models first, in the order they came, then the rest by maker. */

package/dist/chat/logic/scrubber.d.ts

@@ -36,8 +36,9 @@ export declare function ticksWithHits(ticks: readonly ScrubberTick[], hitRows: r
 export declare function messageAt(layout: ScrubberLayout, y: number): number | null;
 export declare function slotOf(layout: ScrubberLayout, message: number): number | null;
 export declare function tickWidth(kind: TickKind, distanceFromPointer: number | null): number;
+type MessageStarts = Pick<readonly number[], 'length' | 'at'>;
 export interface ReadingPosition {
-    starts: readonly number[];
+    starts: MessageStarts;
     scrollTop: number;
     visibleHeight: number;
 }
@@ -47,5 +48,6 @@ export interface MessageRange {
 }
 export declare function messagesInView({ starts, scrollTop, visibleHeight }: ReadingPosition): MessageRange | null;
 export declare function slotInView(slot: TickSlot, range: MessageRange | null): boolean;
-export declare function stepMessage(starts: readonly number[], eligible: (index: number) => boolean, scrollTop: number, direction: -1 | 1): number | null;
+export declare function stepMessage(starts: MessageStarts, eligible: (index: number) => boolean, scrollTop: number, direction: -1 | 1): number | null;
 export declare function threadPaddingLeft(width: number, strip: boolean, measure?: number): number;
+export {};

package/dist/chat/logic/scrubber.js

@@ -197,7 +197,7 @@ function lastIndexAtOrBelow(length, valueAt, limit) {
 }
 /* The last index whose start lies at or above a line, or -1. */
 function lastAtOrAbove(starts, line) {
-  return lastIndexAtOrBelow(starts.length, index => starts[index], line);
+  return lastIndexAtOrBelow(starts.length, index => starts.at(index), line);
 }
 /*
  * The messages on screen. A message counts from its own start to the start of the next one, so the
@@ -209,13 +209,13 @@ export function messagesInView({
   visibleHeight
 }) {
   const bottom = scrollTop + visibleHeight;
-  if (starts.length === 0 || visibleHeight <= 0 || starts[0] >= bottom) {
+  if (starts.length === 0 || visibleHeight <= 0 || starts.at(0) >= bottom) {
     return null;
   }
   const first = Math.max(0, lastAtOrAbove(starts, scrollTop));
   let last = lastAtOrAbove(starts, bottom);
   // A row that starts on the very last line has not a pixel on screen yet.
-  if (starts[last] >= bottom) {
+  if (starts.at(last) >= bottom) {
     last--;
   }
   return {

package/dist/chat/pending-prompts.d.ts

@@ -0,0 +1,15 @@
+import type { PromptSubject } from '../prompts/logic/subjects.js';
+import type { ChatScope } from '../scope.js';
+export declare class ChatPromptFeed {
+    private readonly scope;
+    private readonly chatId;
+    private readonly changed;
+    private readonly children;
+    private unsubscribe;
+    private current;
+    private disposed;
+    constructor(scope: ChatScope, chatId: string, changed: (subjects: PromptSubject[]) => void);
+    start(): void;
+    dispose(): void;
+    private update;
+}

package/dist/chat/pending-prompts.js

@@ -0,0 +1,93 @@
+import { CHAT_REQUEST_LIMITS } from '@adecore/agent-contracts';
+import { useChats, waitingRequestsOf } from '../state/chats.js';
+import { subagentTitle } from './subagent-list.js';
+function stillWaiting(item, info) {
+  return info.status === 'needs-you' && (info.requests === undefined || info.requests.length >= CHAT_REQUEST_LIMITS.perChat || info.requests.some(request => request.requestId === item.requestId));
+}
+/* Follows descendant requests while the main chat is open, including children discovered in later events or older history pages. */
+export class ChatPromptFeed {
+  scope;
+  chatId;
+  changed;
+  children = new Map();
+  unsubscribe;
+  current = null;
+  disposed = false;
+  constructor(scope, chatId, changed) {
+    this.scope = scope;
+    this.chatId = chatId;
+    this.changed = changed;
+  }
+  start() {
+    this.unsubscribe = useChats.subscribe(() => this.update());
+    this.update();
+  }
+  dispose() {
+    this.disposed = true;
+    this.unsubscribe?.();
+    for (const release of this.children.values()) {
+      release();
+    }
+    this.children.clear();
+  }
+  update() {
+    if (this.disposed) {
+      return;
+    }
+    const store = useChats.getState();
+    const subjects = new Map();
+    const seen = new Set();
+    const visit = (chatId, source) => {
+      if (seen.has(chatId)) {
+        return;
+      }
+      seen.add(chatId);
+      const key = this.scope.keyOf(chatId);
+      const row = store.byKey[key];
+      const info = store.statusByKey[key]?.info ?? row?.info;
+      for (const item of waitingRequestsOf(row)) {
+        if (info !== undefined && (chatId === this.chatId || stillWaiting(item, info))) {
+          subjects.set(`${chatId}:${item.requestId}`, {
+            kind: 'chat',
+            nodeId: chatId,
+            item,
+            ...(source === undefined ? {} : {
+              source
+            })
+          });
+        }
+      }
+      for (const item of Object.values(row?.structure ?? {})) {
+        if (item.kind !== 'subagent' || item.childId === undefined || seen.has(item.childId)) {
+          continue;
+        }
+        const childInfo = store.statusByKey[this.scope.keyOf(item.childId)]?.info;
+        if (item.status !== 'running' && childInfo?.status !== 'needs-you') {
+          continue;
+        }
+        if (!this.children.has(item.childId)) {
+          this.children.set(item.childId, this.scope.chats.observe(item.childId));
+        }
+        visit(item.childId, {
+          label: subagentTitle(item),
+          provider: childInfo?.provider
+        });
+      }
+    };
+    visit(this.chatId);
+    for (const [chatId, release] of this.children) {
+      if (!seen.has(chatId)) {
+        this.children.delete(chatId);
+        release();
+      }
+    }
+    const next = [...subjects.values()];
+    if (this.current === null || next.length !== this.current.length || next.some((subject, index) => {
+      const previous = this.current?.[index];
+      return subject.nodeId !== previous?.nodeId || subject.item !== previous.item || subject.source?.label !== previous.source?.label || subject.source?.provider !== previous.source?.provider;
+    })) {
+      this.current = next;
+      this.changed(next);
+    }
+  }
+}

package/dist/chat/reading-width.js

@@ -14,11 +14,15 @@ export function isChatReadingWidth(value) {
 export function readingMeasure(width) {
   return MEASURES[width];
 }
-/* What `.chat-column-content` and `.chat-composer-content` read their width from. */
+/* A wide visual outgrows the reading column, but only a full-width chat lets it run past this. */
+const WIDE_MEASURE = 1200;
+/* What `.chat-column-content`, `.chat-wide-content` and `.chat-composer-content` read their width from. */
 export function readingWidthStyle(width) {
   const measure = MEASURES[width];
+  const bounded = Number.isFinite(measure);
   return {
-    '--chat-measure': Number.isFinite(measure) ? `${measure}px` : '100%'
+    '--chat-measure': bounded ? `${measure}px` : '100%',
+    '--chat-wide-measure': bounded ? `${WIDE_MEASURE}px` : '100%'
   };
 }
 export function readingWidthLabel(width) {

package/dist/chat/ui/PromptComposer.d.ts

@@ -1,6 +1,6 @@
 import { type ReactNode } from 'react';
 import type { HoldRelease } from '../prompt-hold.js';
-import { type PendingPrompt } from '../../prompts/logic/prompts.js';
+import { type PromptSubject } from '../../prompts/logic/subjects.js';
 export interface PromptHold {
     held: boolean;
     releasedBy: HoldRelease | null;
@@ -8,7 +8,7 @@ export interface PromptHold {
 }
 export declare function PromptComposer({ chatId, pending, focused, onShowElsewhere, disabled, hasDraft, denyReason, onAllAnswered, hold, children }: {
     chatId: string;
-    pending: PendingPrompt[];
+    pending: PromptSubject[];
     focused: boolean;
     onShowElsewhere?: () => void;
     disabled: boolean;