@adecore/agents 0.23.1 → 0.24.0

package/dist/chat/chat-process.js

@@ -12,7 +12,9 @@ export function spawnChatProcess(options) {
         env: options.env,
         stdio: ['pipe', 'pipe', 'pipe'],
         // A group of its own, so ending the chat also ends what its agent started (a dev server, a watcher).
-        detached: true
+        // On Windows that would open a console window of its own instead; `taskkill` reaches the tree there.
+        detached: process.platform !== 'win32',
+        windowsHide: true
     });
     // Node reports a missing executable as an event after the call; a start that failed says so on the spot.
     child.on('error', () => undefined);
@@ -44,16 +46,31 @@ export function spawnChatProcess(options) {
         },
         stdout: Readable.toWeb(child.stdout),
         stderr: Readable.toWeb(child.stderr),
-        kill: (signal) => {
-            try {
-                process.kill(-pid, signal);
-            }
-            catch {
-                // Nothing of the group is left to signal.
-            }
-        }
+        kill: (signal) => killProcessTree(pid, signal)
     };
 }
+/* Signals a process and everything it started. Windows has no process groups and no SIGTERM, so there the tree is ended at once. */
+export function killProcessTree(pid, signal, options = {}) {
+    const { platform = process.platform, kill = process.kill, run = runQuietly } = options;
+    if (platform === 'win32') {
+        run(['taskkill', '/pid', String(pid), '/t', '/f']);
+        return;
+    }
+    try {
+        kill(-pid, signal);
+    }
+    catch {
+        // Nothing of the group is left to signal.
+    }
+}
+function runQuietly([command, ...args]) {
+    if (command === undefined) {
+        return;
+    }
+    const child = spawn(command, args, { stdio: 'ignore', windowsHide: true });
+    // A tree that already ended makes taskkill fail, which is what the caller wanted anyway.
+    child.on('error', () => undefined);
+}
 // After stdin closed, a CLI that is still around is not going to say more.
 const EXIT_GRACE_MS = 3000;
 // What a CLI and everything it started get between the SIGTERM and the SIGKILL.
@@ -99,6 +116,89 @@ export class StreamTail {
         }
     }
 }
+// Far above any frame either CLI writes, a base64 document in a tool result included; it only bounds a CLI that stopped breaking lines.
+export const MAX_LINE_LENGTH = 64_000_000;
+/*
+ * Cuts decoded output into lines. A chunk is searched only for itself and a partial line is joined
+ * once, when its line break comes, so a long line costs its length once. A line longer than `max`
+ * UTF-16 units is dropped whole, with `onOverflow` called once for it, and the next line reads as usual.
+ */
+export class LineSplitter {
+    onLine;
+    onOverflow;
+    max;
+    parts = [];
+    length = 0;
+    dropping = false;
+    constructor(onLine, onOverflow, max = MAX_LINE_LENGTH) {
+        this.onLine = onLine;
+        this.onOverflow = onOverflow;
+        this.max = max;
+    }
+    push(text) {
+        let start = 0;
+        let newline = text.indexOf('\n');
+        while (newline >= 0) {
+            this.add(text.slice(start, newline));
+            const line = this.take();
+            if (line !== null) {
+                this.onLine(line);
+            }
+            start = newline + 1;
+            newline = text.indexOf('\n', start);
+        }
+        this.add(text.slice(start));
+    }
+    /* Hands on what came after the last line break, for a stream that ended without one. */
+    end() {
+        const line = this.take();
+        if (line !== null && line !== '') {
+            this.onLine(line);
+        }
+    }
+    add(piece) {
+        if (this.dropping || piece === '') {
+            return;
+        }
+        this.length += piece.length;
+        if (this.length > this.max) {
+            this.parts = [];
+            this.dropping = true;
+            this.onOverflow();
+            return;
+        }
+        this.parts.push(piece);
+    }
+    take() {
+        const line = this.dropping ? null : this.parts.join('');
+        this.parts = [];
+        this.length = 0;
+        this.dropping = false;
+        return line;
+    }
+}
+/*
+ * Hands every line of a CLI's output to `onLine` until the stream ends, through a `LineSplitter`.
+ * A read that fails rejects, after every line that came before it was handed on.
+ */
+export async function readStreamLines(stream, onLine, onOverflow, max = MAX_LINE_LENGTH) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    const lines = new LineSplitter(onLine, onOverflow, max);
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            lines.push(decoder.decode(value, { stream: true }));
+        }
+        lines.end();
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
 /*
  * A spawned CLI and how it ends. Every signal goes to its process group, SIGTERM first and SIGKILL
  * after a grace, and only ever because a person stopped, removed or restarted something.

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

@@ -1,5 +1,4 @@
-import type { ChatAttachment, ChatAssistantItem, ChatCheckpointDiff, ChatEvent, ChatInfo, ChatItem, ChatQueuedMessage, ChatQuoteSource, ChatSkill, ChatUiChoiceOrigin, ChatUiChoicePayload, ChatUiQueryState, ModelSelection, RuntimeMode } from '@adecore/agent-contracts';
-import type { UiCompileOptions } from '@adecore/intelligent-ui/compiler';
+import type { ChatAttachment, ChatCheckpointDiff, ChatEvent, ChatGoalAction, ChatInfo, ChatItem, ChatQueuedMessage, ChatQuoteSource, ChatSkill, ChatUiChoiceOrigin, ChatUiChoicePayload, ChatUiQueryState, ModelSelection, RuntimeMode } from '@adecore/agent-contracts';
 import type { ChatProvider } from '../providers/provider.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
 import type { BackendLaunch } from './backend.ts';
@@ -7,6 +6,7 @@ import type { SpawnChatProcess } from './chat-process.ts';
 import type { ChatTitleInput } from './chat-title.ts';
 import type { SubagentSettlement } from './subagent-settlement.ts';
 import { ChatThread } from './thread.ts';
+import { type UiReplyHost } from './ui-replies.ts';
 import { type OutboxClock } from '../outbox/outbox-worker.ts';
 export interface TurnCheckpoints {
     take(cwd: string): Promise<string | null>;
@@ -46,10 +46,7 @@ export interface ChatSessionOptions {
     references?: ChatReferences;
     checkpoints?: TurnCheckpoints;
     uiFenceLanguage?: string;
-    ui?: {
-        schemas: UiCompileOptions['querySchemas'];
-        observe(item: ChatAssistantItem, final: boolean): void;
-    };
+    ui?: UiReplyHost;
     emit(event: ChatEvent): void;
     onLimits?(update: LimitsUpdate): void;
     persist(): void;
@@ -109,13 +106,8 @@ export declare class ChatSession {
     private pendingPreambles;
     private submission;
     private readonly steering;
-    private readonly uiStreams;
-    private readonly uiCompiled;
     private readonly capturedUiAccess;
-    private readonly uiScanned;
-    private readonly uiReferencing;
-    private readonly uiAttachments;
-    private readonly uiFenceLanguage;
+    private readonly uiReplies;
     constructor(options: ChatSessionOptions);
     get uiPreviews(): ChatEvent[];
     previewItems(items: ChatItem[]): ChatItem[];
@@ -125,6 +117,8 @@ export declare class ChatSession {
     get preambles(): readonly string[];
     get pid(): number | null;
     get busy(): boolean;
+    private goalWorks;
+    goal(action: ChatGoalAction): Promise<void>;
     configure(patch: {
         selection?: ModelSelection;
         runtimeMode?: RuntimeMode;
@@ -162,6 +156,8 @@ export declare class ChatSession {
     approve(requestId: string, decision: 'allow' | 'allow-always' | 'deny', message?: string): boolean;
     answer(requestId: string, answers: Record<string, string>): boolean;
     dismiss(itemId: string): boolean;
+    holdForPerson(key: string): void;
+    releaseHold(key: string): void;
     clear(force: boolean): Promise<void>;
     settleStored(selection: ModelSelection, resume: ResumeDecision): void;
     resume(turnId: string, attempt: number, words: ResumeWords): Promise<void>;
@@ -193,6 +189,7 @@ export declare class ChatSession {
     upsertItems(items: readonly ChatItem[]): void;
     addNote(level: 'info' | 'warning' | 'error', text: string): void;
     end(reason: string): void;
+    restart(): Promise<void>;
     freeze(): void;
     dispose(): Promise<void>;
     turnDiff(turnId: string): Promise<ChatCheckpointDiff | null>;
@@ -237,6 +234,7 @@ export declare class ChatSession {
     private pauseQueue;
     private clearWorkflowWarnings;
     private watchWorkflows;
+    private watchWorkflow;
     private reportsCurrentWindow;
     private refreshTitle;
     private applyTitle;
@@ -245,11 +243,6 @@ export declare class ChatSession {
     private settleFromTranscripts;
     private settleRows;
     private emit;
-    private unscannedUiText;
-    private forgetUiScan;
-    private latestUiAttachment;
-    private findUiAttachment;
-    private clearUi;
     private delegatingChange;
 }
 export interface ResumeDecision {