@adecore/agents 0.21.0 → 0.21.1

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

@@ -27,6 +27,7 @@ export interface InterruptedRun {
 }
 export interface ChatCoreOptions {
     intelligentUi?: ChatUiHost;
+    uiFenceLanguage?: string;
     providers: ProviderRegistry;
     store?: ChatStore;
     checkpoints?: TurnCheckpoints;
@@ -190,6 +191,7 @@ export declare class ChatCore {
     readonly claudeProjectsDir: string;
     readonly composerPreferences: ComposerPreferences;
     private readonly uiQueries;
+    private readonly uiFenceLanguage;
     private readonly checkpoints;
     private readonly instructions;
     private readonly skillIndex;
@@ -290,6 +292,7 @@ export declare class ChatCore {
         conflicted?: boolean | undefined;
         relativePath?: string | undefined;
         label?: string | undefined;
+        code?: string | undefined;
         reason?: string | undefined;
     }>;
     queryUi(payload: ChatUiQueryPayload, clientId: string): Promise<{
@@ -297,9 +300,10 @@ export declare class ChatCore {
         value?: unknown;
         readId?: string | undefined;
         readAt: number;
+        code?: string | undefined;
         reason?: string | undefined;
     }>;
-    choose(payload: ChatUiChoicePayload): Promise<{
+    choose(payload: ChatUiChoicePayload, clientId: string): Promise<{
         queued: boolean;
         turnId: string;
     }>;

package/dist/chat/chat-core.js

@@ -11,6 +11,7 @@ import { ChatLog, COMPACT_ABOVE_BYTES } from './chat-log.js';
 import { ChatSession } from './chat-session.js';
 import { ComposerPreferences } from './composer-preferences.js';
 import { DeltaCoalescer } from './delta-coalescer.js';
+import { readableAssistantText } from './readable-text.js';
 import { ChatError } from './errors.js';
 import { commandLabel, isBackgroundWork, runsInBackground } from './background-work.js';
 import { SubagentReader } from './subagent-reader.js';
@@ -25,7 +26,8 @@ function isBookmarkable(item) {
 /* The start of a message on one line; a message of only attachments is its file names. */
 function excerptOf(item) {
     const files = item.kind === 'user' ? (item.attachments ?? []).map((attachment) => attachment.name).join(', ') : '';
-    return (item.text.trim() === '' ? files : item.text).replace(/\s+/g, ' ').trim();
+    const text = item.kind === 'assistant' ? readableAssistantText(item) : item.text;
+    return (text.trim() === '' ? files : text).replace(/\s+/g, ' ').trim();
 }
 // One process worked on the turn and one more may take it up after a restart; a loop of resumes could redo a command forever.
 const MAX_ATTEMPTS = 2;
@@ -61,6 +63,7 @@ export class ChatCore {
     claudeProjectsDir;
     composerPreferences = new ComposerPreferences();
     uiQueries;
+    uiFenceLanguage;
     checkpoints;
     instructions;
     skillIndex;
@@ -74,7 +77,7 @@ export class ChatCore {
     // How big each record was the last time it went to disk, and the writes waiting for a big one.
     sizes = new Map();
     waiting = new Map();
-    // What the last record held that no event carries (preambles, the host's extras), as its JSON.
+    // What the last record held that no event carries (preambles, the host's extras, captured UI access), as its JSON.
     unlogged = new Map();
     // The write in flight per chat, so the next one queues behind it instead of racing it.
     writes = new Map();
@@ -87,6 +90,7 @@ export class ChatCore {
     limitResume;
     constructor(options) {
         this.uiQueries = options.intelligentUi ? new ChatUiQueries(options.intelligentUi) : null;
+        this.uiFenceLanguage = options.uiFenceLanguage;
         this.providers = options.providers;
         this.store = options.store ?? null;
         this.bookmarks = options.bookmarks ?? null;
@@ -272,9 +276,11 @@ export class ChatCore {
         const references = this.referencesFor(payload.chatId);
         const session = new ChatSession({
             info,
+            ...(this.uiFenceLanguage ? { uiFenceLanguage: this.uiFenceLanguage } : {}),
             ...(this.uiQueries ? { ui: { schemas: this.uiQueries.schemas, observe: (item, final) => this.uiQueries.observe(session, item, final) } } : {}),
             items: stored?.items ?? [],
             preambles: stored?.preambles ?? [],
+            uiAccess: stored?.uiAccess ?? {},
             provider,
             command: this.commands[kind] ?? provider.command,
             ...(this.spawn ? { spawn: this.spawn } : {}),
@@ -573,7 +579,10 @@ export class ChatCore {
         }
         return this.uiQueries.query(this.require(payload.chatId), payload);
     }
-    async choose(payload) {
+    async choose(payload, clientId) {
+        if (!this.attached.get(payload.chatId)?.has(clientId)) {
+            throw new ChatError('refused-query', 'Attach to the chat before answering its UI.');
+        }
         const session = this.require(payload.chatId);
         const queries = await this.uiQueries?.choiceValues(session, payload);
         const result = session.choose(payload, queries);
@@ -837,7 +846,7 @@ export class ChatCore {
             const log = this.logs.get(chatId);
             // Not folded here: an older write still in flight may land after this one, and the log is what covers for it.
             try {
-                this.store.writeSync(chatId, info, items, { seq: log?.seq ?? 0, resetSeq: log?.resetSeq ?? 0 }, session.preambles, this.recordExtras(chatId));
+                this.store.writeSync(chatId, info, items, { seq: log?.seq ?? 0, resetSeq: log?.resetSeq ?? 0 }, session.preambles, this.recordExtras(chatId), session.uiAccessRecord);
             }
             catch (e) {
                 console.error(`Chat record for ${chatId} failed:`, errorText(e));
@@ -970,7 +979,8 @@ export class ChatCore {
             // A delta held back is already in the thread, so it gets its seq before the snapshot says where it ends.
             this.coalescers.get(chatId)?.flush();
             const extras = this.recordExtras(chatId);
-            const unlogged = JSON.stringify([session.preambles, extras]);
+            const uiAccess = session.uiAccessRecord;
+            const unlogged = JSON.stringify([session.preambles, extras, uiAccess]);
             const folds = fold || log.size > COMPACT_ABOVE_BYTES || !log.onDisk;
             // The log already holds every change to the thread, so the whole record is rewritten only to fold
             // the log, on a chat's first write, or for what no event carries.
@@ -979,7 +989,7 @@ export class ChatCore {
             }
             const { info, items } = session.thread.snapshot();
             const at = { seq: log.seq, resetSeq: log.resetSeq };
-            this.sizes.set(chatId, await this.store.write(chatId, info, items, at, session.preambles, extras));
+            this.sizes.set(chatId, await this.store.write(chatId, info, items, at, session.preambles, extras, uiAccess));
             this.unlogged.set(chatId, unlogged);
             // A chat killed while the write was out has no log left to fold.
             if (this.logs.get(chatId) === log && folds) {

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

@@ -32,6 +32,7 @@ export interface ChatSessionOptions {
     clock?: OutboxClock;
     items?: ChatItem[];
     preambles?: string[];
+    uiAccess?: Readonly<Record<string, unknown>>;
     provider: ChatProvider;
     command: string[];
     env(account: string | undefined): Record<string, string>;
@@ -43,6 +44,7 @@ export interface ChatSessionOptions {
     promptNotes?: PromptNotes;
     references?: ChatReferences;
     checkpoints?: TurnCheckpoints;
+    uiFenceLanguage?: string;
     ui?: {
         schemas: UiCompileOptions['querySchemas'];
         observe(item: ChatAssistantItem, final: boolean): void;
@@ -105,6 +107,11 @@ export declare class ChatSession {
     private readonly steering;
     private readonly uiStreams;
     private readonly uiCompiled;
+    private readonly capturedUiAccess;
+    private readonly uiScanned;
+    private readonly uiReferencing;
+    private readonly uiAttachments;
+    private readonly uiFenceLanguage;
     constructor(options: ChatSessionOptions);
     get uiPreviews(): ChatEvent[];
     previewItems(items: ChatItem[]): ChatItem[];
@@ -124,6 +131,9 @@ export declare class ChatSession {
         queued: boolean;
         turnId: string;
     };
+    uiAccess(itemId: string): unknown;
+    setUiAccess(itemId: string, access: unknown): void;
+    get uiAccessRecord(): Record<string, unknown>;
     updateUiQueries(itemId: string, uiQueries: ChatUiQueryState): void;
     choose(payload: ChatUiChoicePayload, queries?: Readonly<Record<string, unknown>>): {
         queued: boolean;
@@ -226,7 +236,10 @@ export declare class ChatSession {
     private settleFromTranscripts;
     private settleRows;
     private emit;
+    private unscannedUiText;
+    private forgetUiScan;
     private latestUiAttachment;
+    private findUiAttachment;
     private clearUi;
     private delegatingChange;
 }

package/dist/chat/chat-session.js

@@ -1,16 +1,19 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { GeneratedImageInputSchema, notResumedNote } from '@adecore/agent-contracts';
-import { resolveUiChoice, UiFailure } from '@adecore/intelligent-ui';
+import { resolveUiChoice, UI_FENCE_LANGUAGE, UiFailure, uiHasFence, uiMayReferenceHost } from '@adecore/intelligent-ui';
 import { UiStream } from '@adecore/intelligent-ui/stream';
 import { commandLabel, isBackgroundWork, reportsOnBackgroundWork, runningInBackground } from './background-work.js';
 import { ChatError } from './errors.js';
 import { limitedTurn, limitResumeAt, limitResumeWake } from './limit-resume.js';
 import { isMainAgentOutput, ThreadProjector } from './projector.js';
+import { readableAssistantText } from './readable-text.js';
 import { ChatThread } from './thread.js';
 import { errorText } from '../error-text.js';
 import { systemClock } from '../outbox/outbox-worker.js';
 // Claude Code names a session about six seconds after its first prompt, and a first turn can run for minutes.
 const TITLE_RECHECK_MS = 10_000;
+// Longer than any fence line or the name of a tag a scan looks for, so a match never falls between two deltas.
+const UI_SCAN_OVERLAP = 64;
 /* One per limited turn, so a second fork of the same turn writes no second note. */
 function continuedNoteId(turnId) {
     return `continued-${turnId}`;
@@ -74,9 +77,17 @@ export class ChatSession {
     steering = new Set();
     uiStreams = new Map();
     uiCompiled = new Map();
+    capturedUiAccess;
+    // How much of a streaming reply's text the fence and host scans already covered, so a delta scans only its tail.
+    uiScanned = new Map();
+    uiReferencing = new Set();
+    uiAttachments = new Map();
+    uiFenceLanguage;
     constructor(options) {
         this.options = options;
+        this.uiFenceLanguage = options.uiFenceLanguage ?? UI_FENCE_LANGUAGE;
         this.pendingPreambles = options.preambles ?? [];
+        this.capturedUiAccess = new Map(Object.entries(options.uiAccess ?? {}));
         this.thread = new ChatThread(options.info, options.items);
         this.projector = new ThreadProjector(this.thread, { providerName: options.provider.name });
     }
@@ -182,6 +193,21 @@ export class ChatSession {
         this.dispatch(text, extras, turnId);
         return { queued: false, turnId };
     }
+    /* What a UI host captured for a reply; null where the capture was denied or is still out, undefined where none started. */
+    uiAccess(itemId) {
+        return this.capturedUiAccess.get(itemId);
+    }
+    setUiAccess(itemId, access) {
+        if (this.frozen) {
+            return;
+        }
+        this.capturedUiAccess.set(itemId, access);
+        this.options.persistSoon();
+    }
+    /* The captured access of the replies still in the thread, for the record. */
+    get uiAccessRecord() {
+        return Object.fromEntries([...this.capturedUiAccess].filter(([itemId]) => this.thread.get(itemId) !== undefined));
+    }
     updateUiQueries(itemId, uiQueries) {
         const item = this.thread.get(itemId);
         if (this.frozen || item?.kind !== 'assistant' || item.parentToolUseId) {
@@ -1598,7 +1624,7 @@ export class ChatSession {
         this.naming = true;
         const turnId = done[0].id;
         const answer = items
-            .map((item) => (item.kind === 'assistant' && item.turnId === turnId ? item.text : ''))
+            .map((item) => (item.kind === 'assistant' && item.turnId === turnId ? readableAssistantText(item) : ''))
             .filter((text) => text !== '')
             .join('\n\n');
         const agentSessionId = this.thread.info.agentSessionId;
@@ -1652,19 +1678,28 @@ export class ChatSession {
             if (event.type === 'reset') {
                 this.clearUi();
             }
+            if (event.type === 'item' && event.item.kind === 'tool') {
+                this.uiAttachments.delete(event.item.turnId);
+            }
             const item = event.type === 'item' ? event.item : event.type === 'delta' ? this.thread.get(event.itemId) : null;
             if (item?.kind !== 'assistant' || item.parentToolUseId) {
                 this.options.emit(event);
                 continue;
             }
+            const tail = this.unscannedUiText(item, event.type === 'item');
+            if (uiMayReferenceHost(tail)) {
+                this.uiReferencing.add(item.id);
+            }
             let stream = this.uiStreams.get(item.id);
-            if (!stream && !item.text.includes('ruimte-ui')) {
+            if (!stream && !uiHasFence(tail, this.uiFenceLanguage)) {
+                this.forgetUiScan(item);
                 this.options.emit(event);
                 continue;
             }
             if (!stream) {
                 stream = new UiStream({
                     querySchemas: this.options.ui?.schemas,
+                    fenceLanguage: this.uiFenceLanguage,
                     id: item.id,
                     clock: this.options.clock ?? systemClock,
                     emit: (preview) => {
@@ -1674,7 +1709,10 @@ export class ChatSession {
                 });
                 this.uiStreams.set(item.id, stream);
             }
-            this.options.ui?.observe(item, false);
+            if (this.uiReferencing.has(item.id)) {
+                this.options.ui?.observe(item, false);
+            }
+            this.forgetUiScan(item);
             const latestAttachment = this.latestUiAttachment(item.turnId);
             if (event.type === 'item' && !item.streaming) {
                 const ui = stream
@@ -1684,7 +1722,7 @@ export class ChatSession {
                 this.uiCompiled.delete(item.id);
                 const diagnostics = [...new Set(ui.flatMap((block) => block.diagnostics.map((diagnostic) => diagnostic.message)))].slice(0, 6);
                 if (diagnostics.length > 0) {
-                    const repair = `Your last ruimte-ui block had these diagnostics: ${diagnostics.join(' ')} Use the catalog's supported props and components.`.slice(0, 1200);
+                    const repair = `Your last ${this.uiFenceLanguage} block had these diagnostics: ${diagnostics.join(' ')} Use the catalog's supported props and components.`.slice(0, 1200);
                     if (!this.pendingPreambles.includes(repair)) {
                         this.pendingPreambles = [...this.pendingPreambles, repair];
                     }
@@ -1701,7 +1739,36 @@ export class ChatSession {
             }
         }
     }
+    /*
+     * The text a scan has not covered yet, from the start of the line the last scan ended in, since a fence
+     * is one line; a long line is cut short, behind a character no fence or tag can follow.
+     */
+    unscannedUiText(item, whole) {
+        const scanned = whole ? 0 : (this.uiScanned.get(item.id) ?? 0);
+        this.uiScanned.set(item.id, item.text.length);
+        if (scanned === 0 || scanned > item.text.length) {
+            return item.text;
+        }
+        const line = item.text.lastIndexOf('\n', scanned - 1) + 1;
+        const from = Math.max(line, scanned - UI_SCAN_OVERLAP);
+        return from === line ? item.text.slice(from) : `\0${item.text.slice(from)}`;
+    }
+    forgetUiScan(item) {
+        if (!item.streaming) {
+            this.uiScanned.delete(item.id);
+            this.uiReferencing.delete(item.id);
+        }
+    }
+    /* Looked up once per turn, and again only after one of its tool calls changed. */
     latestUiAttachment(turnId) {
+        if (this.uiAttachments.has(turnId)) {
+            return this.uiAttachments.get(turnId);
+        }
+        const attachment = this.findUiAttachment(turnId);
+        this.uiAttachments.set(turnId, attachment);
+        return attachment;
+    }
+    findUiAttachment(turnId) {
         for (const item of this.thread.list().toReversed()) {
             if (item.kind !== 'tool' || item.turnId !== turnId || item.name !== 'ImageGeneration' || item.state !== 'done') {
                 continue;
@@ -1719,6 +1786,9 @@ export class ChatSession {
         }
         this.uiStreams.clear();
         this.uiCompiled.clear();
+        this.uiScanned.clear();
+        this.uiReferencing.clear();
+        this.uiAttachments.clear();
     }
     /* Said on the info as well as by the rows, since a client with the thread closed sees only the info. */
     delegatingChange(events) {

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

@@ -8,6 +8,7 @@ export interface ChatRecord {
     seq: number;
     resetSeq: number;
     preambles: string[];
+    uiAccess: Record<string, unknown>;
     extras: ChatRecordExtras;
     lines: ChatLogLine[];
 }
@@ -28,8 +29,8 @@ export declare class ChatStore {
     list(): Promise<string[]>;
     has(chatId: string): Promise<boolean>;
     discardLog(chatId: string): Promise<number>;
-    write(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras): Promise<number>;
-    writeSync(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras): void;
+    write(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): Promise<number>;
+    writeSync(chatId: string, info: ChatInfo, items: ChatItem[], at?: ChatSeq, preambles?: readonly string[], extras?: ChatRecordExtras, uiAccess?: Readonly<Record<string, unknown>>): void;
     read(chatId: string): Promise<ChatRecord | null>;
     unreadable(chatId: string): Promise<boolean>;
     private readSnapshot;

package/dist/chat/chat-store.js

@@ -19,17 +19,40 @@ const RecordSchema = z.looseObject({
     seq: z.number().int().nonnegative().optional(),
     resetSeq: z.number().int().nonnegative().optional(),
     // Never on the wire: what goes in front of the next real prompt, once (a fork's note for its agent).
-    preambles: z.array(z.string()).optional()
+    preambles: z.array(z.string()).optional(),
+    // Never on the wire: the access a UI host captured for each reply that reads it, by item id.
+    uiAccess: z.record(z.string(), z.unknown()).optional()
 });
-const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles']);
+const OWN_KEYS = new Set(['info', 'items', 'seq', 'resetSeq', 'preambles', 'uiAccess']);
 function extrasOf(record) {
     return Object.fromEntries(Object.entries(record).filter(([key]) => !OWN_KEYS.has(key)));
 }
 function logName(chatId) {
     return `${encodeURIComponent(chatId)}.log`;
 }
-function recordBody(info, items, at, preambles, extras) {
-    return JSON.stringify({ info, items, ...at, ...(preambles.length === 0 ? {} : { preambles }), ...withoutOwnKeys(extras) });
+function recordBody(info, items, at, preambles, extras, uiAccess) {
+    return JSON.stringify({
+        info,
+        items,
+        ...at,
+        ...(preambles.length === 0 ? {} : { preambles }),
+        ...(Object.keys(uiAccess).length === 0 ? {} : { uiAccess }),
+        ...withoutOwnKeys(extras)
+    });
+}
+/* A record from before `uiAccess` kept the access inside each reply's `uiQueries`, which the item schema now drops. */
+function liftUiAccess(record) {
+    if (typeof record !== 'object' || record === null || 'uiAccess' in record || !Array.isArray(record.items)) {
+        return record;
+    }
+    const uiAccess = {};
+    for (const item of record.items) {
+        const queries = item?.uiQueries;
+        if (typeof queries === 'object' && queries !== null && 'access' in queries) {
+            uiAccess[String(item.id)] = queries.access;
+        }
+    }
+    return Object.keys(uiAccess).length === 0 ? record : { ...record, uiAccess };
 }
 function withoutOwnKeys(extras) {
     return Object.fromEntries(Object.entries(extras).filter(([key]) => !OWN_KEYS.has(key)));
@@ -80,8 +103,8 @@ export class ChatStore {
         return lines.at(-1)?.seq ?? 0;
     }
     /* Answers how many bytes the record took, which is what tells a caller whether writing it is cheap. */
-    async write(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}) {
-        const body = recordBody(info, items, at, preambles, extras);
+    async write(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}, uiAccess = {}) {
+        const body = recordBody(info, items, at, preambles, extras, uiAccess);
         await mkdir(this.dir, { recursive: true, mode: 0o700 });
         await writeAtomic(join(this.dir, recordFileName(chatId)), body);
         return body.length;
@@ -90,9 +113,9 @@ export class ChatStore {
      * The same write without a turn of the event loop. A `bun --watch` reload restarts the module
      * before an awaited write comes back, so a shutdown has to put the threads down synchronously.
      */
-    writeSync(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}) {
+    writeSync(chatId, info, items, at = { seq: 0, resetSeq: 0 }, preambles = [], extras = {}, uiAccess = {}) {
         mkdirSync(this.dir, { recursive: true, mode: 0o700 });
-        writeAtomicSync(join(this.dir, recordFileName(chatId)), recordBody(info, items, at, preambles, extras));
+        writeAtomicSync(join(this.dir, recordFileName(chatId)), recordBody(info, items, at, preambles, extras, uiAccess));
     }
     /* Null for a chat with nothing on disk to make it of, and for one whose record does not parse (see `unreadable`). */
     async read(chatId) {
@@ -117,7 +140,15 @@ export class ChatStore {
                 resetSeq = line.seq;
             }
         }
-        return { ...thread.snapshot(), seq, resetSeq, preambles: snapshot.preambles ?? [], extras: extrasOf(snapshot), lines };
+        return {
+            ...thread.snapshot(),
+            seq,
+            resetSeq,
+            preambles: snapshot.preambles ?? [],
+            uiAccess: snapshot.uiAccess ?? {},
+            extras: extrasOf(snapshot),
+            lines
+        };
     }
     /*
      * Whether a record is on disk that this host cannot read: one a newer version wrote, one cut short,
@@ -146,7 +177,7 @@ export class ChatStore {
                 await writeAtomic(join(this.dir, recordFileName(chatId)), JSON.stringify(migrated));
             }
         }
-        const parsed = RecordSchema.safeParse(record);
+        const parsed = RecordSchema.safeParse(liftUiAccess(record));
         return parsed.success ? parsed.data : UNREADABLE;
     }
     async delete(chatId) {
@@ -199,5 +230,5 @@ function fromLogAlone(lines) {
             resetSeq = line.seq;
         }
     }
-    return { ...thread.snapshot(), seq: 0, resetSeq, preambles: [], extras: {}, lines };
+    return { ...thread.snapshot(), seq: 0, resetSeq, preambles: [], uiAccess: {}, extras: {}, lines };
 }

package/dist/chat/readable-text.d.ts

@@ -0,0 +1,2 @@
+import type { ChatAssistantItem } from '@adecore/agent-contracts';
+export declare function readableAssistantText(item: Pick<ChatAssistantItem, 'text' | 'ui' | 'uiQueries'>): string;

package/dist/chat/readable-text.js

@@ -0,0 +1,16 @@
+import { uiFallbackText } from '@adecore/intelligent-ui/text';
+/*
+ * An assistant's words as another agent or a person outside the thread reads them: each UI block becomes
+ * its text fallback, with the first query values when they were frozen for the block as stored. It works
+ * from the stored block ranges, so it holds whatever fence language the host compiled.
+ */
+export function readableAssistantText(item) {
+    if (!item.ui?.length) {
+        return item.text;
+    }
+    const blocks = item.ui.map((block) => {
+        const frozen = item.uiQueries?.blocks[block.id];
+        return frozen && frozen.revision === block.revision ? { ...block, fallback: frozen.fallback } : block;
+    });
+    return uiFallbackText(item.text, blocks);
+}

package/dist/chat/ui-queries.d.ts

@@ -3,6 +3,7 @@ import type { ChatUiLinkPayload, ChatUiLinkReading, ChatAssistantItem, ChatInfo,
 import { type UiValue } from '@adecore/intelligent-ui';
 import { type UiLinkTarget } from '@adecore/intelligent-ui/links';
 import type { ChatSession } from './chat-session.ts';
+import { ChatError } from './errors.ts';
 export interface ChatUiSource {
     args: z.ZodType;
     result: z.ZodType;
@@ -14,11 +15,19 @@ export interface ChatUiHost {
     sources: Readonly<Record<string, ChatUiSource>>;
     link?(info: ChatInfo, access: unknown, target: UiLinkTarget): Promise<ChatUiLinkReading>;
 }
+declare class UiQueryError extends ChatError<string> {
+    readonly reason: string;
+    constructor(code: string, reason: string, message: string);
+}
+export declare class ChatUiRefusal extends UiQueryError {
+    constructor(code: string, reason: string);
+}
 export declare class ChatUiQueries {
     readonly schemas: Record<string, z.ZodType>;
     private readonly captures;
     private readonly freezing;
     private readonly cache;
+    private readonly latest;
     private readonly reading;
     private readonly attempts;
     private readonly active;
@@ -33,6 +42,8 @@ export declare class ChatUiQueries {
     choiceValues(session: ChatSession, payload: ChatUiChoicePayload | ChatUiLinkPayload): Promise<Record<string, unknown>>;
     link(session: ChatSession, payload: ChatUiLinkPayload): Promise<ChatUiLinkReading>;
     forget(chatId: string): void;
+    private evict;
     private linkReading;
-    private reason;
+    private failure;
 }
+export {};