@adecore/agents-react 0.37.1 → 0.37.3

package/dist/chat/ui/thread-references.js

@@ -0,0 +1,78 @@
+import { c as _c } from "react/compiler-runtime";
+import { useChatHost } from '../../host.js';
+import { useHostReferables } from '../../host-hooks.js';
+import { useChatScope } from '../../scope.js';
+import { useChatRow } from '../../state/chats.js';
+const referencedOf = new WeakMap();
+/*
+ * The ids a person pointed at with `#` in a thread, one per line. A string, so the selector that reads
+ * it answers the same value until a message with another one comes; the structure a streamed word
+ * leaves alone is what it is cached on.
+ */
+export function threadReferencedKey(structure) {
+  if (structure === undefined) {
+    return '';
+  }
+  const cached = referencedOf.get(structure);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const ids = new Set();
+  for (const item of Object.values(structure)) {
+    if (item.kind === 'user') {
+      for (const id of [...(item.chats ?? []), ...(item.references ?? [])]) {
+        ids.add(id);
+      }
+    }
+  }
+  const key = [...ids].join('\n');
+  referencedOf.set(structure, key);
+  return key;
+}
+/* What the views, nodes and chats of a thread stand for now, and how one opens, for the rows that draw chips. */
+export function useReferenceLookup(chatId) {
+  const $ = _c(9);
+  const {
+    id: scopeId
+  } = useChatScope();
+  const {
+    openReference
+  } = useChatHost();
+  const referables = useHostReferables(scopeId, chatId);
+  const key = useChatRow(chatId, _temp);
+  let t0;
+  if ($[0] !== openReference || $[1] !== scopeId) {
+    t0 = openReference ? id => openReference(scopeId, id) : null;
+    $[0] = openReference;
+    $[1] = scopeId;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== key) {
+    t1 = key === "" ? [] : key.split("\n");
+    $[3] = key;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== referables.items || $[6] !== t0 || $[7] !== t1) {
+    t2 = {
+      items: referables.items,
+      open: t0,
+      referenced: t1
+    };
+    $[5] = referables.items;
+    $[6] = t0;
+    $[7] = t1;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  return t2;
+}
+function _temp(chat) {
+  return threadReferencedKey(chat?.structure);
+}

package/dist/host-hooks.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderPlatform } from '@adecore/agent-contracts';
+import { type Referables } from './chat/chat-references.js';
 import { type ChatHost, type CommandLook } from './host.js';
 export declare function useHostCodeMode(): 'light' | 'dark';
 export declare function useHostCodeThemes(): {
@@ -13,6 +14,7 @@ export declare function useHostStreaming(): ReturnType<ChatHost['useStreaming']>
 export declare function useHostSendDelivery(): ReturnType<ChatHost['useSendDelivery']>;
 export declare function useHostTimelineFind(...args: Parameters<ChatHost['useTimelineFind']>): ReturnType<ChatHost['useTimelineFind']>;
 export declare function useHostReferableChats(): ReturnType<ChatHost['useReferableChats']>;
+export declare function useHostReferables(scopeId: string, chatId: string): Referables;
 export declare function useHostLoginBlocked(...args: Parameters<ChatHost['useLoginBlocked']>): ReturnType<ChatHost['useLoginBlocked']>;
 export declare function useHostMachinePlatform(scopeId: string): ProviderPlatform | null;
 export declare function useHostProjectLook(...args: Parameters<ChatHost['useProjectLook']>): ReturnType<ChatHost['useProjectLook']>;

package/dist/host-hooks.js

@@ -1,5 +1,6 @@
 'use no memo';
 
+import { referablesOfChats } from './chat/chat-references.js';
 import { useChatHost } from './host.js';
 export function useHostCodeMode() {
   return useChatHost().code.useMode();
@@ -31,6 +32,12 @@ export function useHostTimelineFind(...args) {
 export function useHostReferableChats() {
   return useChatHost().useReferableChats();
 }
+const useReferablesFromChats = (_scopeId, _chatId) => referablesOfChats(useHostReferableChats());
+/* A host without views of its own offers its chats. */
+export function useHostReferables(scopeId, chatId) {
+  const useReferables = useChatHost().useReferables ?? useReferablesFromChats;
+  return useReferables(scopeId, chatId);
+}
 export function useHostLoginBlocked(...args) {
   return useChatHost().useLoginBlocked(...args);
 }

package/dist/host.d.ts

@@ -4,6 +4,7 @@ import type { EditorView } from '@codemirror/view';
 import type { Highlighter, ThemeRegistration } from 'shiki';
 import type { EditorEngine } from '@adecore/editor';
 import type { AgentKind, ChatCheckpointDiff, ChatConfigurePayload, ChatGoalAction, ChatItem, ChatSubagentItem, ChatUiChoicePayload, ChatUiQueryPayload, ChatUiQueryReading, ChatUiLinkPayload, ChatUiLinkReading, ProviderPlatform } from '@adecore/agent-contracts';
+import type { Referables } from './chat/chat-references.js';
 import type { TimelineRow } from './chat/logic/timeline.js';
 import type { FindReveal } from './chat/ui/find-reveal.js';
 import type { PromptAction } from './prompts/logic/prompts.js';
@@ -247,6 +248,8 @@ export interface ChatHost {
         id: string;
         title: string;
     }>;
+    useReferables?(scopeId: string, chatId: string): Referables;
+    openReference?(scopeId: string, id: string): void;
     openLogin: ((scopeId: string, kind: AgentKind, accountId: string, name: string) => Promise<void>) | null;
     useLoginBlocked(scopeId: string): string | null;
     runProviderCommand?(scopeId: string, kind: AgentKind, command: string): void;

package/dist/locales/en/agent-chat.d.ts

@@ -16,10 +16,9 @@ declare const _default: {
         unreadable: string;
         unreadableThumbnail: string;
     };
-    chatReference: {
+    references: {
         gone: string;
         untitled: string;
-        remove: string;
     };
     fork: {
         refusal: {
@@ -305,6 +304,7 @@ declare const _default: {
             commands: string;
             skills: string;
             mentions: string;
+            references: string;
         };
         held: {
             question: string;
@@ -349,10 +349,27 @@ declare const _default: {
         mentions: {
             here: string;
             files: string;
-            chats: string;
             noMatch: string;
             empty: string;
         };
+        references: {
+            canvas: string;
+            views: string;
+            noMatch: string;
+            kinds: {
+                canvas: string;
+                chat: string;
+                terminal: string;
+                note: string;
+                text: string;
+                drawing: string;
+                diagram: string;
+                browser: string;
+                device: string;
+                file: string;
+                database: string;
+            };
+        };
         queue: {
             attachments_one: string;
             attachments_other: string;

package/dist/locales/en/agent-chat.js

@@ -16,10 +16,9 @@ export default {
     unreadable: 'Could not read {{name}}',
     unreadableThumbnail: 'Could not read the thumbnail'
   },
-  chatReference: {
-    gone: 'Chat not in this project',
-    untitled: 'Untitled chat',
-    remove: 'Remove {{title}}'
+  references: {
+    gone: 'Not in this project',
+    untitled: 'Untitled'
   },
   fork: {
     refusal: {
@@ -304,7 +303,8 @@ export default {
     menu: {
       commands: 'Commands',
       skills: 'Skills',
-      mentions: 'Mentions'
+      mentions: 'Mentions',
+      references: 'Views and nodes'
     },
     held: {
       question: 'Question waiting. Opens when you pause typing.',
@@ -349,10 +349,27 @@ export default {
     mentions: {
       here: 'Files in this folder',
       files: 'Files',
-      chats: 'Chats in this project',
-      noMatch: 'No files or chats match',
+      noMatch: 'No files match',
       empty: 'No files here'
     },
+    references: {
+      canvas: 'On this canvas',
+      views: 'Views',
+      noMatch: 'No view or node matches',
+      kinds: {
+        canvas: 'canvas',
+        chat: 'chat',
+        terminal: 'terminal',
+        note: 'note',
+        text: 'text',
+        drawing: 'drawing',
+        diagram: 'diagram',
+        browser: 'browser',
+        device: 'device',
+        file: 'file',
+        database: 'table'
+      }
+    },
     queue: {
       attachments_one: '{{count}} attachment',
       attachments_other: '{{count}} attachments',

package/dist/locales/nl/agent-chat.d.ts

@@ -16,10 +16,9 @@ declare const _default: {
         unreadable: string;
         unreadableThumbnail: string;
     };
-    chatReference: {
+    references: {
         gone: string;
         untitled: string;
-        remove: string;
     };
     fork: {
         refusal: {
@@ -305,6 +304,7 @@ declare const _default: {
             commands: string;
             skills: string;
             mentions: string;
+            references: string;
         };
         held: {
             question: string;
@@ -349,10 +349,27 @@ declare const _default: {
         mentions: {
             here: string;
             files: string;
-            chats: string;
             noMatch: string;
             empty: string;
         };
+        references: {
+            canvas: string;
+            views: string;
+            noMatch: string;
+            kinds: {
+                canvas: string;
+                chat: string;
+                terminal: string;
+                note: string;
+                text: string;
+                drawing: string;
+                diagram: string;
+                browser: string;
+                device: string;
+                file: string;
+                database: string;
+            };
+        };
         queue: {
             attachments_one: string;
             attachments_other: string;

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

@@ -16,10 +16,9 @@ export default {
     unreadable: 'Kon {{name}} niet lezen',
     unreadableThumbnail: 'Kon de miniatuur niet lezen'
   },
-  chatReference: {
-    gone: 'Chat niet in dit project',
-    untitled: 'Naamloze chat',
-    remove: '{{title}} verwijderen'
+  references: {
+    gone: 'Niet in dit project',
+    untitled: 'Naamloos'
   },
   fork: {
     refusal: {
@@ -304,7 +303,8 @@ export default {
     menu: {
       commands: "Commando's",
       skills: 'Skills',
-      mentions: 'Vermeldingen'
+      mentions: 'Vermeldingen',
+      references: 'Views en nodes'
     },
     held: {
       question: 'Er wacht een vraag. Opent zodra je stopt met typen.',
@@ -349,10 +349,27 @@ export default {
     mentions: {
       here: 'Bestanden in deze map',
       files: 'Bestanden',
-      chats: 'Chats in dit project',
-      noMatch: 'Geen bestanden of chats gevonden',
+      noMatch: 'Geen bestanden gevonden',
       empty: 'Hier staan geen bestanden'
     },
+    references: {
+      canvas: 'Op dit canvas',
+      views: 'Views',
+      noMatch: 'Geen view of node gevonden',
+      kinds: {
+        canvas: 'canvas',
+        chat: 'chat',
+        terminal: 'terminal',
+        note: 'notitie',
+        text: 'tekst',
+        drawing: 'tekening',
+        diagram: 'diagram',
+        browser: 'browser',
+        device: 'apparaat',
+        file: 'bestand',
+        database: 'tabel'
+      }
+    },
     queue: {
       attachments_one: '{{count}} bijlage',
       attachments_other: '{{count}} bijlagen',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents-react",
-  "version": "0.37.1",
+  "version": "0.37.3",
   "description": "React agent chat threads, composers, approvals, provider accounts and usage views.",
   "type": "module",
   "exports": {
@@ -67,11 +67,11 @@
     "test:visuals": "bun --config=integration.bunfig.toml --conditions=source test ./src/chat/visual-viewport.integration.test.ts"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.37.1",
-    "@adecore/editor": "0.37.1",
-    "@adecore/editor-react": "0.37.1",
-    "@adecore/intelligent-ui": "0.37.1",
-    "@adecore/merge": "0.37.1",
+    "@adecore/agent-contracts": "0.37.3",
+    "@adecore/editor": "0.37.3",
+    "@adecore/editor-react": "0.37.3",
+    "@adecore/intelligent-ui": "0.37.3",
+    "@adecore/merge": "0.37.3",
     "@codemirror/commands": "^6.11.1",
     "@codemirror/language": "^6.12.4",
     "@codemirror/state": "^6.7.6",
@@ -94,14 +94,14 @@
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
-    "@adecore/ui": "^0.37.1",
+    "@adecore/ui": "^0.37.3",
     "i18next": "^26.4.2",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
     "react-i18next": "^17.0.15"
   },
   "devDependencies": {
-    "@adecore/ui": "0.37.1",
+    "@adecore/ui": "0.37.3",
     "@types/bun": "^1.4.2",
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",

package/src/chat/chat-client.ts

@@ -39,6 +39,8 @@ export interface ChatSendExtras {
     /* The reply a quote at the head of the text was taken from. */
     quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachmentUpload[];
+    /* Views and nodes picked with `#`; a machine that does not know the field drops it. */
+    references?: string[];
 }
 
 interface Mounted extends ChatOpenOptions, MountedEntry {
@@ -211,7 +213,8 @@ export class ChatClient {
             skills: extras.skills,
             chats: extras.chats,
             quoteSource: extras.quoteSource,
-            attachments: extras.attachments
+            attachments: extras.attachments,
+            references: extras.references
         });
     }
 

package/src/chat/chat-references.ts

@@ -1,11 +1,52 @@
+import type { ReferenceToken } from './mentions';
+
 /* Another chat a message may point at, under the name it has right now. */
 export interface ProjectChat {
     id: string;
     title: string;
 }
 
-/* The chats an `@query` offers: never the chat typing it or one already attached. */
-export function chatSuggestions(chats: readonly ProjectChat[], query: string, exclude: readonly string[], limit: number): ProjectChat[] {
+export type ReferableKind = 'canvas' | 'chat' | 'terminal' | 'note' | 'text' | 'drawing' | 'diagram' | 'browser' | 'device' | 'file' | 'database';
+
+/* What a message may point at with `#`, under the name it has right now. */
+export interface Referable {
+    id: string;
+    name: string;
+    kind: ReferableKind;
+    /* What tells it apart from another of the same name, such as the canvas it stands on; absent when its kind does. */
+    detail?: string;
+    /* `canvas` for what stands on the canvas the chat is a node of, `views` for a view of the project. */
+    group: 'canvas' | 'views';
+}
+
+export interface Referables {
+    /* The canvas group first, then the views; never the chat that asks. */
+    items: readonly Referable[];
+    /* The machine only resolves chats, so nothing else is offered. */
+    chatsOnly: boolean;
+}
+
+/* What a host without views offers: its chats, which every machine takes. */
+export function referablesOfChats(chats: readonly ProjectChat[]): Referables {
+    return { items: chats.map((chat) => ({ id: chat.id, name: chat.title, kind: 'chat', group: 'views' })), chatsOnly: true };
+}
+
+/*
+ * How each id is spelled in a text: under the name it was picked with where `spelled` knows it, else
+ * under the name it has now. An id with neither has no token.
+ */
+export function referenceTokens(ids: readonly string[], items: readonly Referable[], spelled: Readonly<Record<string, string>> = {}): ReferenceToken[] {
+    return [...new Set(ids)].flatMap((id) => {
+        const name = spelled[id] ?? items.find((item) => item.id === id)?.name;
+        return name === undefined || name === '' ? [] : [{ id, name }];
+    });
+}
+
+/* What a `#query` offers, the canvas first: never an id in `exclude`, and only chats where the machine takes no more. */
+export function referenceSuggestions(referables: Referables, query: string, exclude: readonly string[], limit: number): Referable[] {
     const needle = query.toLowerCase();
-    return chats.filter((chat) => !exclude.includes(chat.id) && chat.title.toLowerCase().includes(needle)).slice(0, limit);
+    const matches = referables.items.filter(
+        (item) => item.name !== '' && (!referables.chatsOnly || item.kind === 'chat') && !exclude.includes(item.id) && item.name.toLowerCase().includes(needle)
+    );
+    return [...matches.filter((item) => item.group === 'canvas'), ...matches.filter((item) => item.group === 'views')].slice(0, limit);
 }

package/src/chat/drafts.ts

@@ -9,16 +9,20 @@ export interface ChatDraft {
     text: string;
     mentions: string[];
     skills: string[];
-    /* Chats of the project picked with `@`, drawn beside the text rather than in it. */
+    /* Chats of the project picked with `#`, by id; apart from `references`, since every machine takes a chat. */
     chats: string[];
     attachments: ChatAttachmentUpload[];
     /* A piece of an answer that goes above the text as a blockquote; empty for none. */
     quote: string;
     /* The reply the quote was taken from; null when the quote names none. */
     quoteSource: string | null;
+    /* Views and nodes of the project picked with `#`, by id. */
+    references: string[];
+    /* The name each pick was spelled with in the text, by id, so a chip outlives a rename; a pick without one takes the name it has now. */
+    referenceNames?: Record<string, string>;
 }
 
-export const EMPTY_DRAFT: ChatDraft = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '', quoteSource: null };
+export const EMPTY_DRAFT: ChatDraft = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '', quoteSource: null, references: [] };
 
 // Older records only had text; the rest is filled in on read.
 type DraftRecord = {
@@ -29,6 +33,8 @@ type DraftRecord = {
     attachments?: ChatAttachmentUpload[];
     quote?: string;
     quoteSource?: string;
+    references?: string[];
+    referenceNames?: Record<string, string>;
 };
 
 const storage = persistedJson<Record<string, DraftRecord>>(
@@ -74,7 +80,9 @@ export function readDraft(chatId: string): ChatDraft {
               chats: record.chats ?? [],
               attachments: record.attachments ?? [],
               quote: record.quote ?? '',
-              quoteSource: record.quoteSource ?? null
+              quoteSource: record.quoteSource ?? null,
+              references: record.references ?? [],
+              ...(record.referenceNames === undefined ? {} : { referenceNames: record.referenceNames })
           }
         : EMPTY_DRAFT;
 }
@@ -94,7 +102,9 @@ export function writeDraft(chatId: string, draft: ChatDraft): void {
         chats: draft.chats,
         attachments: draft.attachments,
         quote: draft.quote,
-        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource })
+        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource }),
+        references: draft.references,
+        ...namesOf(draft)
     };
     if (storage.write(drafts)) {
         return;
@@ -106,11 +116,17 @@ export function writeDraft(chatId: string, draft: ChatDraft): void {
         skills: draft.skills,
         chats: draft.chats,
         quote: draft.quote,
-        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource })
+        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource }),
+        references: draft.references,
+        ...namesOf(draft)
     };
     storage.write(drafts);
 }
 
+function namesOf(draft: ChatDraft): Pick<DraftRecord, 'referenceNames'> {
+    return draft.referenceNames === undefined ? {} : { referenceNames: draft.referenceNames };
+}
+
 /* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
 export function joinDraftText(current: string, added: string): string {
     return current.trim() === '' ? added : `${current.replace(/\s+$/, '')}\n\n${added}`;
@@ -142,7 +158,9 @@ export function takeBackIntoDraft(
             chats: union(taken.chats, current.chats),
             attachments: [...checked.accepted.map((entry) => entry.upload), ...current.attachments],
             quote: current.quote,
-            quoteSource: current.quoteSource
+            quoteSource: current.quoteSource,
+            references: union(taken.references, current.references),
+            ...namesOf(current)
         },
         rejected: checked.rejected
     };

package/src/chat/index.ts

@@ -2,7 +2,7 @@
 export { type AccountChoice, useAccountChoice, type NewAccountChoice, useNewAccountChoice } from './account-choice';
 export { transportActions, actionsOf, useChatActions } from './actions';
 export { type ChatSendExtras, ChatClient } from './chat-client';
-export type { ProjectChat } from './chat-references';
+export type { ProjectChat, Referable, ReferableKind, Referables } from './chat-references';
 export { sendFromComposer, type ComposerSend } from './composer-send';
 export { stepEffortFromComposer } from './composer-effort';
 export type { EffortStep } from './logic/effort';

package/src/chat/logic/picker-entries.ts

@@ -1,6 +1,17 @@
-import type { AgentKind, ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+import { pickerGroupsOf, providerGroupOf, type AgentKind, type ModelInfo, type ProviderInfo } from '@adecore/agent-contracts';
 import { nameCollator } from '@adecore/ui/format';
 
+/* The providers in the order a picker lists them: the frontier labs, the rest, then the API providers, each by name. */
+export function inPickerOrder<T extends { kind: AgentKind; name: string }>(providers: readonly T[]): T[] {
+    const groups = pickerGroupsOf(providers);
+    return [...groups.frontier, ...groups.others, ...groups.api];
+}
+
+/* Whether a separator goes between two providers next to each other in that order: where one group ends. */
+export function separatesGroups(previous: AgentKind | undefined, kind: AgentKind): boolean {
+    return previous !== undefined && providerGroupOf(previous) !== providerGroupOf(kind);
+}
+
 /*
  * 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.