@adecore/agents 0.38.0 → 0.40.0

package/src/chat/ui-replies.ts

@@ -50,18 +50,22 @@ export class UiReplies {
     /* The preview of every reply still streaming, as deltas, for a client that attached in the middle of one. */
     previews(): ChatEvent[] {
         const events: ChatEvent[] = [];
+
         for (const [itemId, preview] of this.compiled) {
             const item = this.options.thread.get(itemId);
+
             if (item?.kind === 'assistant' && item.streaming && item.text.length === preview.textLength) {
                 events.push({ type: 'delta', itemId, text: '', ui: preview.blocks, textLength: preview.textLength });
             }
         }
+
         return events;
     }
 
     previewItems(items: ChatItem[]): ChatItem[] {
         return items.map((item) => {
             const preview = this.compiled.get(item.id);
+
             return item.kind === 'assistant' && preview?.textLength === item.text.length ? { ...item, ui: preview.blocks } : item;
         });
     }
@@ -69,27 +73,38 @@ export class UiReplies {
     /* Hands one event of the chat on, with the blocks of a reply it finished in place of its fences. */
     pass(event: ChatEvent): void {
         const { thread, emit } = this.options;
+
         if (event.type === 'reset') {
             this.clear();
         }
+
         if (event.type === 'item' && event.item.kind === 'tool') {
             this.attachments.delete(event.item.turnId);
         }
+
         const item = event.type === 'item' ? event.item : event.type === 'delta' ? thread.get(event.itemId) : null;
+
         if (item?.kind !== 'assistant' || item.parentToolUseId) {
             emit(event);
+
             return;
         }
+
         const tail = this.unscannedText(item, event.type === 'item');
+
         if (uiMayReferenceHost(tail)) {
             this.referencing.add(item.id);
         }
+
         let stream = this.streams.get(item.id);
+
         if (!stream && !uiHasFence(tail, this.options.fenceLanguage)) {
             this.forgetScan(item);
             emit(event);
+
             return;
         }
+
         if (!stream) {
             stream = new UiStream({
                 querySchemas: this.options.host?.schemas,
@@ -101,21 +116,28 @@ export class UiReplies {
                     emit({ type: 'delta', itemId: item.id, text: '', ui: preview.blocks, textLength: preview.textLength });
                 }
             });
+
             this.streams.set(item.id, stream);
         }
+
         if (this.referencing.has(item.id)) {
             this.options.host?.observe(item, false);
         }
+
         this.forgetScan(item);
         const latestAttachment = this.latestAttachment(item.turnId);
+
         if (event.type !== 'item' || item.streaming) {
             emit(event);
             stream.update(item.text, latestAttachment);
+
             return;
         }
+
         const ui = stream
             .finish(item.text, latestAttachment)
             .map((block) => ({ ...block, revision: createHash('sha256').update(JSON.stringify(block)).digest('hex') }));
+
         this.streams.delete(item.id);
         this.compiled.delete(item.id);
         this.repair(ui.flatMap((block) => block.diagnostics));
@@ -128,6 +150,7 @@ export class UiReplies {
     private repair(diagnostics: UiDiagnostic[]): void {
         const say = (found: UiDiagnostic[], audience: 'person' | 'agent') => {
             const messages = [...new Set(found.map((diagnostic) => diagnostic.message))].slice(0, 6);
+
             if (messages.length > 0) {
                 this.options.repair(
                     `Your last ${this.options.fenceLanguage} block had these diagnostics: ${messages.join(' ')} Use the catalog's supported props and components.`.slice(
@@ -138,10 +161,12 @@ export class UiReplies {
                 );
             }
         };
+
         say(
             diagnostics.filter((diagnostic) => diagnostic.severity !== 'warning'),
             'person'
         );
+
         say(
             diagnostics.filter((diagnostic) => diagnostic.severity === 'warning'),
             'agent'
@@ -152,6 +177,7 @@ export class UiReplies {
         for (const stream of this.streams.values()) {
             stream.dispose();
         }
+
         this.streams.clear();
         this.compiled.clear();
         this.scanned.clear();
@@ -166,11 +192,14 @@ export class UiReplies {
     private unscannedText(item: ChatAssistantItem, whole: boolean): string {
         const scanned = whole ? 0 : (this.scanned.get(item.id) ?? 0);
         this.scanned.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)}`;
     }
 
@@ -186,8 +215,10 @@ export class UiReplies {
         if (this.attachments.has(turnId)) {
             return this.attachments.get(turnId);
         }
+
         const attachment = this.findAttachment(turnId);
         this.attachments.set(turnId, attachment);
+
         return attachment;
     }
 
@@ -196,11 +227,14 @@ export class UiReplies {
             if (item.kind !== 'tool' || item.turnId !== turnId || item.name !== 'ImageGeneration' || item.state !== 'done') {
                 continue;
             }
+
             const input = GeneratedImageInputSchema.safeParse(item.input);
+
             if (input.success && input.data.attachment?.mime.startsWith('image/')) {
                 return input.data.attachment.id;
             }
         }
+
         return undefined;
     }
 }

package/src/chat/visual-store.ts

@@ -72,26 +72,34 @@ function checked(input: VisualInput): {
     heights: VisualHeight[] | undefined;
 } {
     const title = typeof input.title === 'string' ? input.title.trim() : '';
+
     if (title === '') {
         refuse('visual-invalid', 'A visual needs a title; give it a short one that says what the page shows');
     }
+
     if (title.length > VISUAL_LIMITS.title) {
         refuse('visual-invalid', `The title has ${title.length} characters; keep it to ${VISUAL_LIMITS.title} or fewer`);
     }
+
     if (typeof input.html !== 'string' || input.html.trim() === '') {
         refuse('visual-invalid', 'The page is empty; pass one self-contained HTML document');
     }
+
     const maxHeight = input.maxHeight ?? VISUAL_LIMITS.maxHeight;
+
     if (!isSize(maxHeight) || maxHeight < VISUAL_LIMITS.minHeight || maxHeight > VISUAL_LIMITS.maxHeight) {
         refuse(
             'visual-invalid',
             `The maximum height must be from ${VISUAL_LIMITS.minHeight} to ${VISUAL_LIMITS.maxHeight} CSS pixels; leave it out for ${VISUAL_LIMITS.maxHeight}`
         );
     }
+
     if (input.layout !== undefined && !VisualLayoutSchema.safeParse(input.layout).success) {
         refuse('visual-invalid', 'The layout must be inline or wide; leave it out for the reply column');
     }
+
     const heights = input.heights ?? [];
+
     if (
         !Array.isArray(heights) ||
         heights.length > VISUAL_LIMITS.heights ||
@@ -99,9 +107,11 @@ function checked(input: VisualInput): {
     ) {
         refuse('visual-invalid', `Measured heights are at most ${VISUAL_LIMITS.heights} pairs of [width, height] in CSS pixels, with a positive width`);
     }
+
     // One measurement per width, the last one given, ascending as `visualFrameHeight` reads them.
     const byWidth = new Map(heights.map((pair): [number, number] => [Math.max(1, Math.round(pair[0])), Math.ceil(pair[1])]));
     const sorted = [...byWidth].sort((a, b) => a[0] - b[0]);
+
     return { title, html: input.html, maxHeight: Math.round(maxHeight), layout: input.layout, heights: sorted.length === 0 ? undefined : sorted };
 }
 
@@ -115,6 +125,7 @@ function tooLarge(bytes: number): never {
 
 function refuseOversized(html: string): void {
     const bytes = Buffer.byteLength(html, 'utf8');
+
     if (bytes > VISUAL_LIMITS.bytes) {
         tooLarge(bytes);
     }
@@ -143,6 +154,7 @@ export class VisualStore {
 
     listen(listener: VisualListener): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };
@@ -160,6 +172,7 @@ export class VisualStore {
     async prepareWorkspace(chatId: string): Promise<string> {
         const path = this.workspacePath(chatId);
         await mkdir(path, { recursive: true, mode: 0o700 });
+
         return path;
     }
 
@@ -168,10 +181,13 @@ export class VisualStore {
         if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,119}\.html$/.test(name)) {
             refuse('visual-invalid', 'Use an HTML filename such as chart.html, with letters, numbers, dots, hyphens or underscores and no directory');
         }
+
         if (html.trim() === '') {
             refuse('visual-invalid', 'The page is empty; pass one self-contained HTML document');
         }
+
         refuseOversized(html);
+
         return this.writeWorkspaceFile(chatId, name, html);
     }
 
@@ -185,12 +201,16 @@ export class VisualStore {
         // Before the bootstrap is added, so a page far too large is never copied first.
         refuseOversized(html);
         const page = Buffer.from(injectVisualBootstrap(html), 'utf8');
+
         if (page.byteLength > VISUAL_LIMITS.bytes) {
             tooLarge(page.byteLength);
         }
+
         const turnId = typeof input.turnId === 'string' && input.turnId !== '' ? input.turnId : undefined;
+
         return this.writes.run(chatId, async () => {
             const visuals = await this.readFile(chatId);
+
             const visual: ChatVisual = {
                 id: randomBytes(8).toString('hex'),
                 title,
@@ -201,16 +221,21 @@ export class VisualStore {
                 size: page.byteLength,
                 ...(turnId === undefined ? {} : { turnId })
             };
+
             await mkdir(this.attachments.folderOf(chatId), { recursive: true, mode: 0o700 });
             await writeAtomic(this.pagePath(chatId, visual.id), page);
             const next = [...visuals, visual];
+
             try {
                 await this.writeFile(chatId, next);
             } catch (e) {
                 await rm(this.pagePath(chatId, visual.id), { force: true });
+
                 throw e;
             }
+
             this.tell(chatId, next);
+
             return visual;
         });
     }
@@ -219,13 +244,16 @@ export class VisualStore {
     remove(chatId: string, visualId: string): Promise<ChatVisual[]> {
         return this.writes.run(chatId, async () => {
             const visuals = await this.readFile(chatId);
+
             if (!visuals.some((visual) => visual.id === visualId)) {
                 return visuals;
             }
+
             const next = visuals.filter((visual) => visual.id !== visualId);
             await this.writeFile(chatId, next);
             await rm(this.pagePath(chatId, visualId), { force: true });
             this.tell(chatId, next);
+
             return next;
         });
     }
@@ -238,6 +266,7 @@ export class VisualStore {
             await rm(this.workspacePath(chatId), { recursive: true, force: true });
             await Promise.all((visuals ?? []).map((visual) => rm(this.pagePath(chatId, visual.id), { force: true })));
             this.known.delete(chatId);
+
             if (visuals === null || visuals.length > 0) {
                 this.tell(chatId, []);
             }
@@ -250,29 +279,36 @@ export class VisualStore {
      */
     async copyChat(fromChatId: string, toChatId: string, keep: (visual: ChatVisual) => boolean = () => true): Promise<ChatVisual[]> {
         const kept = (await this.list(fromChatId)).filter(keep);
+
         if (kept.length === 0) {
             return this.list(toChatId);
         }
+
         return this.writes.run(toChatId, async () => {
             const copied: ChatVisual[] = [];
             await mkdir(this.attachments.folderOf(toChatId), { recursive: true, mode: 0o700 });
+
             for (const visual of kept) {
                 const page = await readFile(this.pagePath(fromChatId, visual.id)).catch((e: unknown) => {
                     if (isNotFound(e)) {
                         return null;
                     }
+
                     throw e;
                 });
+
                 if (page !== null) {
                     await writeAtomic(this.pagePath(toChatId, visual.id), page);
                     copied.push(visual);
                 }
             }
+
             const existing = await this.readFile(toChatId);
             const ids = new Set(existing.map((visual) => visual.id));
             const next = [...existing, ...copied.filter((visual) => !ids.has(visual.id))];
             await this.writeFile(toChatId, next);
             this.tell(toChatId, next);
+
             return next;
         });
     }
@@ -280,9 +316,11 @@ export class VisualStore {
     /* A page as an attachment of its chat, from the lists this store has seen; null for one it does not know. */
     attachment(chatId: string, visualId: string): ChatAttachment | null {
         const visual = this.known.get(chatId)?.find((candidate) => candidate.id === visualId);
+
         if (!visual) {
             return null;
         }
+
         return { id: visual.id, name: `${visual.title}.html`, mime: 'text/html', size: visual.size, path: this.pagePath(chatId, visual.id) };
     }
 
@@ -294,6 +332,7 @@ export class VisualStore {
         return this.writes.run(chatId, async () => {
             const path = join(await this.prepareWorkspace(chatId), name);
             await writeAtomic(path, content);
+
             return path;
         });
     }
@@ -306,31 +345,41 @@ export class VisualStore {
 
     private async readFile(chatId: string): Promise<ChatVisual[]> {
         let raw: string;
+
         try {
             raw = await readFile(join(this.dir, visualFileName(chatId)), 'utf8');
         } catch (e) {
             if (isNotFound(e)) {
                 this.known.delete(chatId);
+
                 return [];
             }
+
             throw e;
         }
+
         // A file that does not parse is refused rather than read as empty, which the next write would make true.
         const parsed = VisualFileSchema.safeParse(JSON.parse(raw));
+
         if (!parsed.success) {
             throw new Error(`The visuals file of chat ${chatId} is not valid: ${parsed.error.issues[0]?.message ?? 'unknown problem'}`);
         }
+
         this.known.set(chatId, parsed.data.visuals);
+
         return parsed.data.visuals;
     }
 
     private async writeFile(chatId: string, visuals: readonly ChatVisual[]): Promise<void> {
         const path = join(this.dir, visualFileName(chatId));
+
         if (visuals.length === 0) {
             await rm(path, { force: true });
             this.known.delete(chatId);
+
             return;
         }
+
         await mkdir(this.dir, { recursive: true, mode: 0o700 });
         await writeAtomic(path, JSON.stringify({ version: 1, visuals }));
         this.known.set(chatId, [...visuals]);

package/src/chat/wake-chat.ts

@@ -29,8 +29,10 @@ export async function loadChat(deps: ChatOpenerDeps, chatId: string): Promise<Ch
         if (!deps.placed(chatId) || !(await deps.chats.hasStored(chatId))) {
             return null;
         }
+
         await deps.chats.create({ chatId });
     }
+
     return deps.chats.get(chatId) ?? null;
 }
 
@@ -38,6 +40,7 @@ export async function loadChat(deps: ChatOpenerDeps, chatId: string): Promise<Ch
 export function chatOpener(deps: ChatOpenerDeps) {
     return async (chatId: string): Promise<WakeChat | null> => {
         const session = await loadChat(deps, chatId);
+
         return session
             ? {
                   items: () => session.thread.list(),

package/src/client-sinks.ts

@@ -13,11 +13,13 @@ export class ClientSinks<TEvent> {
 
     subscribe(clientId: string, sink: (event: TEvent) => void): () => void {
         this.sinks.set(clientId, sink);
+
         return () => {
             // A client that subscribes again before it unsubscribes keeps its newer sink.
             if (this.sinks.get(clientId) !== sink) {
                 return;
             }
+
             this.sinks.delete(clientId);
             this.onRelease?.(clientId);
         };

package/src/coded-error.ts

@@ -1,8 +1,4 @@
-/*
- * The shape every failure on the wire has: a code a client can branch on and a message a person reads.
- * A domain gives it a union of its own codes, so a typo in a code is a compile error instead of a
- * string the other end never matches.
- */
+/* The shape every failure on the wire has: a code a client can branch on and a message a person reads. */
 export class CodedError<TCode extends string = string> extends Error {
     readonly code: TCode;
     /* What the actor can do instead. Only a refusal fills this; the rest carry an empty list. */

package/src/context/argv.ts

@@ -6,22 +6,26 @@ export type ParsedArgv =
  * Splits the words after a verb into positionals, `--flag value` pairs (`--flag=value` too, for a
  * value that itself starts with `--`) and the switches the verb declared. Anything not declared a
  * switch takes a value, so a flag that lost its argument is refused instead of swallowing the next
- * word, and a flag given twice is refused rather than one of the two silently winning. A name that is
- * both a switch and a flag is on when written bare and takes a value only after `=` (`--state=full`).
+ * word. A name that is both a switch and a flag takes a value only after `=` (`--state=full`).
  */
 export function parseArgv(argv: readonly string[], known: readonly string[], switches: readonly string[] = []): ParsedArgv {
     const positionals: string[] = [];
     const flags: Record<string, string> = {};
     const given = new Set<string>();
     const all = [...new Set([...known, ...switches])];
+
     for (let i = 0; i < argv.length; i++) {
         const word = argv[i]!;
+
         if (!word.startsWith('--')) {
             positionals.push(word);
+
             continue;
         }
+
         const equals = word.indexOf('=');
         const name = word.slice(2, equals === -1 ? undefined : equals);
+
         if (!all.includes(name)) {
             return {
                 ok: false,
@@ -29,33 +33,45 @@ export function parseArgv(argv: readonly string[], known: readonly string[], swi
                 message: all.length === 0 ? `--${name} is not a flag here; this verb takes none` : `--${name} is not one of --${all.join(', --')}`
             };
         }
+
         if (Object.hasOwn(flags, name) || given.has(name)) {
             return { ok: false, code: 'duplicate-flag', message: `--${name} is given twice` };
         }
+
         if (switches.includes(name)) {
             if (equals !== -1 && known.includes(name)) {
                 flags[name] = word.slice(equals + 1);
                 given.add(name);
+
                 continue;
             }
+
             if (equals !== -1) {
                 return { ok: false, code: 'unexpected-value', message: `--${name} takes no value; it is on when you write it and off when you do not` };
             }
+
             given.add(name);
+
             continue;
         }
+
         let value: string;
+
         if (equals !== -1) {
             value = word.slice(equals + 1);
         } else {
             const next = argv[i + 1];
+
             if (next === undefined || next.startsWith('--')) {
                 return { ok: false, code: 'missing-value', message: `--${name} needs a value (write --${name}=<value> for one that starts with --)` };
             }
+
             value = next;
             i++;
         }
+
         flags[name] = value;
     }
+
     return { ok: true, positionals, flags, switches: given };
 }

package/src/context/index.ts

@@ -1,5 +1,6 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
 export { field, refusalBody, refusalRows, type ParsedRefusal, parseRefusalBody } from './refusal.ts';
+
 export {
     VerbRefusal,
     type VerbCallBase,

package/src/context/refusal.ts

@@ -20,6 +20,7 @@ function rows(code: string, message: string, lines: readonly string[]): string[]
 /* What a verb is refused with, whole: the `refused` row and what to do instead under it. */
 export function refusalBody(code: string, message: string, lines: readonly string[] = []): string {
     const [first, ...rest] = rows(code, message, lines);
+
     return [`refused\t${first}`, ...rest].join('\n');
 }
 
@@ -39,8 +40,10 @@ export function parseRefusalBody(text: string): ParsedRefusal | null {
     const [first = '', ...lines] = text.split('\n').filter((line) => line.trim() !== '');
     const parts = first.split('\t');
     const [code, message] = parts[0] === 'refused' ? parts.slice(1) : parts;
+
     if (!code || !message) {
         return null;
     }
+
     return { code, message, lines };
 }