@borgee/agents-host 0.1.8 → 0.2.0

package/README.md

@@ -26,6 +26,7 @@ Borgee channel message
 - local-config multi-agent startup
 - one isolated `AgentsHost` per effective agent key
 - per-channel conversation memory via each provider's native session mechanism
+- one draft progress message per turn when a provider emits public progress
 - hot reload for host config and agent file add / update / remove
 
 **Out of scope:**

package/dist/agents-host.d.ts

@@ -23,8 +23,12 @@ export declare class AgentsHost {
     private readonly config;
     private readonly provider;
     private readonly borgee;
+    private readonly activeTurns;
+    private readonly progressChannelQueues;
+    private readonly progressDrafts;
     private selfAgentId;
     private started;
+    private controlPlaneClosed;
     constructor(config: AgentsHostConfig, deps?: {
         borgee?: ChatControlPlane;
         provider?: ProviderAdapter;
@@ -32,4 +36,7 @@ export declare class AgentsHost {
     start(): Promise<void>;
     stop(): Promise<void>;
     private handleMessage;
+    private trackActiveTurn;
+    private enqueueProgressChannelTurn;
+    private ensureProgressDraft;
 }

package/dist/agents-host.js

@@ -1,5 +1,107 @@
 import { SdkChatControlPlane } from './chat/sdk-chat-control-plane.js';
 import { createProvider } from './providers/create-provider.js';
+const STREAM_PROGRESS_EDIT_THROTTLE_MS = 150;
+function hasVisibleText(value) {
+    return value.trim().length > 0;
+}
+function providerUsesDraftProgress(provider) {
+    return provider === 'claude' || provider === 'copilot';
+}
+class DraftMessageController {
+    borgee;
+    channelId;
+    canWrite;
+    messageId = null;
+    currentBody = '';
+    pendingBody = null;
+    timer = null;
+    sealed = false;
+    writeChain = Promise.resolve();
+    constructor(borgee, channelId, canWrite) {
+        this.borgee = borgee;
+        this.channelId = channelId;
+        this.canWrite = canWrite;
+    }
+    update(text) {
+        if (this.sealed || !hasVisibleText(text)) {
+            return;
+        }
+        this.pendingBody = text;
+        if (this.timer) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flushPending().catch((error) => {
+                console.error('[agents-host] failed to flush draft progress:', error);
+            });
+        }, STREAM_PROGRESS_EDIT_THROTTLE_MS);
+    }
+    cancelProgress() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.sealed = true;
+    }
+    async finalize(finalText) {
+        this.sealed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (hasVisibleText(finalText)) {
+            this.pendingBody = finalText;
+            await this.flushPending();
+            return;
+        }
+        await this.enqueueWrite(async () => {
+            if (!this.canWrite() || !this.messageId) {
+                return;
+            }
+            await this.borgee.deleteMessage(this.messageId);
+            this.messageId = null;
+            this.currentBody = '';
+            this.pendingBody = null;
+        });
+    }
+    async discard() {
+        this.sealed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.pendingBody = null;
+        await this.enqueueWrite(async () => {
+            if (!this.canWrite() || !this.messageId) {
+                return;
+            }
+            await this.borgee.deleteMessage(this.messageId);
+            this.messageId = null;
+            this.currentBody = '';
+        });
+    }
+    async flushPending() {
+        await this.enqueueWrite(async () => {
+            const body = this.pendingBody;
+            if (!this.canWrite() || !body || body === this.currentBody) {
+                return;
+            }
+            if (this.messageId) {
+                await this.borgee.editMessage(this.messageId, body);
+            }
+            else {
+                const posted = await this.borgee.postMessage(this.channelId, body);
+                this.messageId = posted.messageId;
+            }
+            this.currentBody = body;
+        });
+    }
+    enqueueWrite(operation) {
+        this.writeChain = this.writeChain.then(operation, operation);
+        return this.writeChain;
+    }
+}
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
  * to exactly one Borgee agent over `@borgee/plugin-sdk` (BPP / `/ws/plugin`).
@@ -22,8 +124,12 @@ export class AgentsHost {
     config;
     provider;
     borgee;
+    activeTurns = new Set();
+    progressChannelQueues = new Map();
+    progressDrafts = new Map();
     selfAgentId = null;
     started = false;
+    controlPlaneClosed = false;
     constructor(config, deps) {
         this.config = config;
         this.provider = deps?.provider ?? createProvider({
@@ -44,8 +150,15 @@ export class AgentsHost {
         if (this.started)
             return;
         this.started = true;
+        this.controlPlaneClosed = false;
         await this.borgee.connect((message) => {
-            void this.handleMessage(message);
+            if (!this.started) {
+                return;
+            }
+            const task = providerUsesDraftProgress(this.config.agent.provider)
+                ? this.enqueueProgressChannelTurn(message.channel_id, () => this.handleMessage(message))
+                : this.handleMessage(message);
+            this.trackActiveTurn(task);
         });
         const me = await this.borgee.getMe();
         this.selfAgentId = me.id;
@@ -59,8 +172,13 @@ export class AgentsHost {
         if (!this.started)
             return;
         this.started = false;
+        for (const draft of this.progressDrafts.values()) {
+            draft.cancelProgress();
+        }
+        this.controlPlaneClosed = true;
         await this.borgee.close();
         await this.provider.dispose?.();
+        await Promise.allSettled([...this.activeTurns]);
     }
     async handleMessage(msg) {
         console.log('[agents-host] received message', {
@@ -80,6 +198,8 @@ export class AgentsHost {
         // messages an agent receives (per-agent + per-channel require_mention is
         // enforced at BPP fan-out via AgentReceivesChannelMessage). If a channel
         // message reaches this host at all, the agent is meant to handle it.
+        const stopTyping = this.borgee.startTyping(msg.channel_id);
+        const useDraftProgress = providerUsesDraftProgress(this.config.agent.provider);
         try {
             const reply = await this.provider.generateReply({
                 agentName: this.config.agent.agentName,
@@ -87,15 +207,73 @@ export class AgentsHost {
                 channelId: msg.channel_id,
                 incomingAuthorId: authorId,
                 incomingContent: content,
-            });
-            await this.borgee.postMessage(msg.channel_id, reply.text);
+            }, useDraftProgress
+                ? {
+                    onProgress: (update) => {
+                        if (!this.started || this.controlPlaneClosed) {
+                            return;
+                        }
+                        this.ensureProgressDraft(msg.channel_id).update(update.text);
+                    },
+                }
+                : undefined);
+            if (useDraftProgress) {
+                const draft = this.progressDrafts.get(msg.channel_id);
+                if (!this.started) {
+                    await draft?.discard().catch(() => { });
+                    this.progressDrafts.delete(msg.channel_id);
+                    return;
+                }
+                await (draft ?? this.ensureProgressDraft(msg.channel_id)).finalize(reply.text);
+                this.progressDrafts.delete(msg.channel_id);
+            }
+            else if (this.started && !this.controlPlaneClosed) {
+                await this.borgee.postMessage(msg.channel_id, reply.text);
+            }
         }
         catch (error) {
+            if (useDraftProgress) {
+                const draft = this.progressDrafts.get(msg.channel_id);
+                if (draft) {
+                    await draft.discard().catch(() => { });
+                    this.progressDrafts.delete(msg.channel_id);
+                }
+            }
             console.error('[agents-host] failed to generate or send reply:', {
                 provider: this.config.agent.provider,
                 agentName: this.config.agent.agentName,
                 error,
             });
         }
+        finally {
+            stopTyping();
+        }
+    }
+    trackActiveTurn(task) {
+        this.activeTurns.add(task);
+        void task.finally(() => {
+            this.activeTurns.delete(task);
+        });
+    }
+    enqueueProgressChannelTurn(channelId, task) {
+        const previous = this.progressChannelQueues.get(channelId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => { })
+            .then(task)
+            .finally(() => {
+            if (this.progressChannelQueues.get(channelId) === next) {
+                this.progressChannelQueues.delete(channelId);
+            }
+        });
+        this.progressChannelQueues.set(channelId, next);
+        return next;
+    }
+    ensureProgressDraft(channelId) {
+        let draft = this.progressDrafts.get(channelId);
+        if (!draft) {
+            draft = new DraftMessageController(this.borgee, channelId, () => !this.controlPlaneClosed);
+            this.progressDrafts.set(channelId, draft);
+        }
+        return draft;
     }
 }

package/dist/chat/chat-control-plane.d.ts

@@ -1,7 +1,10 @@
-import type { ChannelMessageEvent, MeResponseUser } from '../types.js';
+import type { ChannelMessageEvent, MeResponseUser, PostedMessage } from '../types.js';
 export interface ChatControlPlane {
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
-    postMessage(channelId: string, content: string): Promise<void>;
+    postMessage(channelId: string, content: string): Promise<PostedMessage>;
+    editMessage(messageId: string, content: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    startTyping(channelId: string): () => void;
     getMe(): Promise<MeResponseUser>;
 }

package/dist/chat/sdk-chat-control-plane.d.ts

@@ -1,7 +1,7 @@
 import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent } from '@borgee/plugin-sdk';
-import type { ChannelMessageEvent, MeResponseUser } from '../types.js';
+import type { ChannelMessageEvent, MeResponseUser, PostedMessage } from '../types.js';
 import type { ChatControlPlane } from './chat-control-plane.js';
-type PluginClientLike = Pick<BorgeePluginClient, 'close' | 'connect' | 'getMe' | 'on' | 'sendMessage'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'deleteMessage' | 'editMessage' | 'getMe' | 'on' | 'sendMessage' | 'startTyping'>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
 /**
  * Thin adapter over `@borgee/plugin-sdk` (the same BPP/`/ws/plugin` SDK used by
@@ -13,10 +13,14 @@ export declare class SdkChatControlPlane implements ChatControlPlane {
     private pendingMessages;
     private unsubscribe;
     private connected;
+    private me;
     constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, pluginId?: string);
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
-    postMessage(channelId: string, content: string): Promise<void>;
+    postMessage(channelId: string, content: string): Promise<PostedMessage>;
+    editMessage(messageId: string, content: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    startTyping(channelId: string): () => void;
     getMe(): Promise<MeResponseUser>;
 }
 export declare function mapInboundToChannelMessage(event: InboundMessageEvent): ChannelMessageEvent;

package/dist/chat/sdk-chat-control-plane.js

@@ -9,6 +9,7 @@ export class SdkChatControlPlane {
     pendingMessages = [];
     unsubscribe = null;
     connected = false;
+    me = null;
     constructor(baseUrl, apiKey, createClient = createBorgeePlugin, pluginId) {
         this.client = createClient({ baseUrl, apiKey, pluginId });
     }
@@ -24,6 +25,9 @@ export class SdkChatControlPlane {
         try {
             await this.client.connect();
             this.connected = true;
+            if (this.client.agentId) {
+                this.me = { id: this.client.agentId };
+            }
             for (const message of this.pendingMessages) {
                 onMessage(message);
             }
@@ -44,15 +48,29 @@ export class SdkChatControlPlane {
         await this.client.close();
     }
     async postMessage(channelId, content) {
-        await this.client.sendMessage({ channelId, body: content });
+        const sent = await this.client.sendMessage({ channelId, body: content });
+        return { messageId: sent.messageId };
+    }
+    async editMessage(messageId, content) {
+        await this.client.editMessage({ messageId, body: content });
+    }
+    async deleteMessage(messageId) {
+        await this.client.deleteMessage({ messageId });
+    }
+    startTyping(channelId) {
+        return this.client.startTyping(channelId);
     }
     async getMe() {
+        if (this.me) {
+            return this.me;
+        }
         const me = await this.client.getMe();
-        return {
+        this.me = {
             id: me.id,
             display_name: me.displayName,
             role: me.kind,
         };
+        return this.me;
     }
 }
 export function mapInboundToChannelMessage(event) {

package/dist/providers/claude/adapter.d.ts

@@ -1,8 +1,9 @@
 import type { ProviderAdapter } from '../provider-adapter.js';
-import type { ProviderInput, ProviderReply } from '../../types.js';
+import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { ClaudeCliClient } from './cli-client.js';
 export declare class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
     constructor(cli: ClaudeCliClient);
-    generateReply(input: ProviderInput): Promise<ProviderReply>;
+    generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -4,7 +4,7 @@ export class ClaudeProviderAdapter {
     constructor(cli) {
         this.cli = cli;
     }
-    async generateReply(input) {
+    async generateReply(input, options) {
         const prompt = buildPrompt({
             agentName: input.agentName,
             provider: input.provider,
@@ -12,7 +12,12 @@ export class ClaudeProviderAdapter {
             incomingAuthorId: input.incomingAuthorId,
             incomingContent: input.incomingContent,
         });
-        const text = await this.cli.generateReply(input.channelId, prompt);
+        const text = await this.cli.generateReply(input.channelId, prompt, {
+            onProgress: options?.onProgress,
+        });
         return { text };
     }
+    async dispose() {
+        await this.cli.dispose();
+    }
 }

package/dist/providers/claude/cli-client.d.ts

@@ -1,21 +1,28 @@
+import spawn from 'cross-spawn';
+import type { ProviderGenerateOptions } from '../../types.js';
+interface ClaudeCliRuntime {
+    spawn: typeof spawn;
+}
 /**
  * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
  * native per-channel session continuity.
  *
- * Verified CLI behavior (`claude --help`):
- * - `--session-id <uuid>` starts a *new* conversation pinned to that UUID.
- * - `-r/--resume <uuid>` resumes an *existing* conversation by session ID.
- * These are documented as distinct operations, so this client tracks which
- * channels have already started a session and switches from `--session-id`
- * (first turn) to `--resume` (every turn after) accordingly. No message
- * history is kept on our side — the CLI's own session storage is the single
- * source of truth for conversation memory.
+ * Claude session memory remains entirely inside the Claude CLI. This client
+ * only pins one native session id per Borgee channel and serializes turns per
+ * channel so `--resume` is never called concurrently for the same session.
  */
 export declare class ClaudeCliClient {
     private readonly command;
     private readonly args;
-    private readonly sessionIdsByChannel;
-    constructor(command: string, args: string[]);
-    generateReply(channelId: string, prompt: string): Promise<string>;
+    private readonly runtime;
+    private readonly channels;
+    private stopped;
+    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>);
+    generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
+    dispose(): Promise<void>;
+    private getOrCreateChannelState;
+    private processChannelQueue;
+    private runTurn;
     private run;
 }
+export {};

package/dist/providers/claude/cli-client.js

@@ -1,68 +1,321 @@
 import { randomUUID } from 'node:crypto';
 import spawn from 'cross-spawn';
+const DEFAULT_RUNTIME = {
+    spawn,
+};
+const STREAM_JSON_ARGS = ['--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
+function normalizeError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function createDeferredTurn(prompt, options) {
+    let settled = false;
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    return {
+        prompt,
+        options,
+        promise,
+        resolve(value) {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise(value);
+        },
+        reject(error) {
+            if (settled)
+                return;
+            settled = true;
+            rejectPromise(normalizeError(error));
+        },
+    };
+}
+function asObject(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function hasVisibleText(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function readTextBlocks(blocks) {
+    if (!Array.isArray(blocks)) {
+        return [];
+    }
+    const segments = [];
+    for (const entry of blocks) {
+        const block = asObject(entry);
+        if (!block)
+            continue;
+        if (block.type === 'text' && hasVisibleText(asString(block.text))) {
+            segments.push(asString(block.text));
+        }
+    }
+    return segments;
+}
+function extractTextDelta(event) {
+    if (event.type === 'content_block_delta') {
+        const delta = asObject(event.delta);
+        if (!delta)
+            return null;
+        const deltaType = asString(delta.type);
+        if (deltaType !== undefined && deltaType !== 'text_delta') {
+            return null;
+        }
+        return asString(delta.text) ?? null;
+    }
+    if (event.type === 'content_block_start') {
+        const block = asObject(event.content_block) ?? asObject(event.block);
+        if (!block || block.type !== 'text') {
+            return null;
+        }
+        return asString(block.text) ?? null;
+    }
+    return null;
+}
+function extractToolSummary(event) {
+    if (event.type === 'tool_use') {
+        const toolName = asString(event.name) ?? asString(event.tool_name);
+        return hasVisibleText(toolName) ? `Running ${toolName}…` : 'Running tool…';
+    }
+    if (event.type === 'content_block_start') {
+        const block = asObject(event.content_block) ?? asObject(event.block);
+        if (!block || block.type !== 'tool_use') {
+            return null;
+        }
+        const toolName = asString(block.name);
+        return hasVisibleText(toolName) ? `Running ${toolName}…` : 'Running tool…';
+    }
+    return null;
+}
+function extractFinalText(event) {
+    if (event.type === 'result') {
+        const result = asString(event.result);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    if (event.type === 'message' || event.type === 'assistant') {
+        const message = asObject(event.message) ?? event;
+        const joined = readTextBlocks(message.content).join('');
+        if (joined.length > 0) {
+            return joined;
+        }
+    }
+    return null;
+}
+class ClaudeStreamCollector {
+    onProgress;
+    publicText = '';
+    finalText = null;
+    lastPublished = null;
+    constructor(onProgress) {
+        this.onProgress = onProgress;
+    }
+    consume(event) {
+        const payload = event.type === 'stream_event' ? asObject(event.event) ?? event : event;
+        const textDelta = extractTextDelta(payload);
+        if (textDelta !== null) {
+            this.publicText += textDelta;
+            this.publish(this.publicText);
+        }
+        if (!hasVisibleText(this.publicText)) {
+            const toolSummary = extractToolSummary(payload);
+            if (toolSummary) {
+                this.publish(toolSummary);
+            }
+        }
+        const finalText = extractFinalText(event) ?? extractFinalText(payload);
+        if (finalText !== null) {
+            this.finalText = finalText;
+        }
+    }
+    getFinalText() {
+        const text = this.finalText ?? this.publicText;
+        return hasVisibleText(text) ? text : '';
+    }
+    publish(text) {
+        if (!this.onProgress || !hasVisibleText(text) || text === this.lastPublished) {
+            return;
+        }
+        this.lastPublished = text;
+        this.onProgress({ text });
+    }
+}
 /**
  * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
  * native per-channel session continuity.
  *
- * Verified CLI behavior (`claude --help`):
- * - `--session-id <uuid>` starts a *new* conversation pinned to that UUID.
- * - `-r/--resume <uuid>` resumes an *existing* conversation by session ID.
- * These are documented as distinct operations, so this client tracks which
- * channels have already started a session and switches from `--session-id`
- * (first turn) to `--resume` (every turn after) accordingly. No message
- * history is kept on our side — the CLI's own session storage is the single
- * source of truth for conversation memory.
+ * Claude session memory remains entirely inside the Claude CLI. This client
+ * only pins one native session id per Borgee channel and serializes turns per
+ * channel so `--resume` is never called concurrently for the same session.
  */
 export class ClaudeCliClient {
     command;
     args;
-    sessionIdsByChannel = new Map();
-    constructor(command, args) {
+    runtime;
+    channels = new Map();
+    stopped = false;
+    constructor(command, args, runtimeOverrides = {}) {
         this.command = command;
         this.args = args;
+        this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
+    }
+    async generateReply(channelId, prompt, options) {
+        if (this.stopped) {
+            throw new Error('Claude CLI backend stopped');
+        }
+        const state = this.getOrCreateChannelState(channelId);
+        const turn = createDeferredTurn(prompt, options);
+        state.queue.push(turn);
+        this.processChannelQueue(channelId, state);
+        return turn.promise;
     }
-    async generateReply(channelId, prompt) {
-        const existingSessionId = this.sessionIdsByChannel.get(channelId);
-        const sessionId = existingSessionId ?? randomUUID();
-        const sessionArgs = existingSessionId
-            ? ['--resume', sessionId]
-            : ['--session-id', sessionId];
-        const text = await this.run([...this.args, ...sessionArgs], prompt);
-        // Only remember the session once the CLI call actually succeeds, so a
-        // failed first turn doesn't leave us permanently trying to `--resume`
-        // a session that was never created.
-        this.sessionIdsByChannel.set(channelId, sessionId);
+    async dispose() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        const stoppedError = new Error('Claude CLI backend stopped');
+        for (const state of this.channels.values()) {
+            state.activeTurn?.reject(stoppedError);
+            for (const queuedTurn of state.queue) {
+                queuedTurn.reject(stoppedError);
+            }
+            state.queue = [];
+            state.activeChild?.kill('SIGTERM');
+        }
+    }
+    getOrCreateChannelState(channelId) {
+        let state = this.channels.get(channelId);
+        if (!state) {
+            state = {
+                processing: false,
+                queue: [],
+                sessionEstablished: false,
+            };
+            this.channels.set(channelId, state);
+        }
+        return state;
+    }
+    processChannelQueue(channelId, state) {
+        if (state.processing) {
+            return;
+        }
+        state.processing = true;
+        void (async () => {
+            try {
+                while (!this.stopped) {
+                    const turn = state.queue.shift();
+                    if (!turn) {
+                        return;
+                    }
+                    state.activeTurn = turn;
+                    try {
+                        const text = await this.runTurn(state, turn);
+                        turn.resolve(text);
+                    }
+                    catch (error) {
+                        turn.reject(error);
+                    }
+                    finally {
+                        state.activeTurn = undefined;
+                    }
+                }
+            }
+            finally {
+                state.processing = false;
+                if (state.queue.length > 0 && !this.stopped) {
+                    this.processChannelQueue(channelId, state);
+                }
+            }
+        })();
+    }
+    async runTurn(state, turn) {
+        if (this.stopped) {
+            throw new Error('Claude CLI backend stopped');
+        }
+        const sessionId = state.sessionEstablished ? state.sessionId : randomUUID();
+        const sessionArgs = state.sessionEstablished ? ['--resume', sessionId] : ['--session-id', sessionId];
+        const text = await this.run(state, [...this.args, ...sessionArgs, ...STREAM_JSON_ARGS], turn.prompt, turn.options);
+        state.sessionId = sessionId;
+        state.sessionEstablished = true;
         return text;
     }
-    async run(args, prompt) {
+    async run(state, args, prompt, options) {
         return new Promise((resolve, reject) => {
-            const child = spawn(this.command, args, {
+            const child = this.runtime.spawn(this.command, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
-            let stdout = '';
+            state.activeChild = child;
+            const collector = new ClaudeStreamCollector(options?.onProgress);
             let stderr = '';
+            let lineBuffer = '';
+            let settled = false;
+            const settleReject = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(normalizeError(error));
+            };
+            const settleResolve = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
             child.stdout.setEncoding('utf8');
             child.stderr.setEncoding('utf8');
             child.stdout.on('data', (chunk) => {
-                stdout += chunk;
+                lineBuffer += chunk;
+                while (true) {
+                    const newlineIndex = lineBuffer.indexOf('\n');
+                    if (newlineIndex === -1) {
+                        break;
+                    }
+                    const line = lineBuffer.slice(0, newlineIndex).trim();
+                    lineBuffer = lineBuffer.slice(newlineIndex + 1);
+                    if (!line)
+                        continue;
+                    try {
+                        const event = JSON.parse(line);
+                        collector.consume(event);
+                    }
+                    catch (error) {
+                        settleReject(new Error(`Claude stream-json parse failed: ${normalizeError(error).message}`));
+                        child.kill('SIGTERM');
+                        return;
+                    }
+                }
             });
             child.stderr.on('data', (chunk) => {
                 stderr += chunk;
             });
-            child.on('error', (error) => {
-                reject(error);
+            child.once('error', (error) => {
+                settleReject(error);
             });
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Claude CLI failed with code ${code}: ${stderr.trim()}`));
-                    return;
+            child.once('close', (code) => {
+                if (state.activeChild === child) {
+                    state.activeChild = undefined;
                 }
-                const text = stdout.trim();
-                if (!text) {
-                    reject(new Error('Claude CLI returned empty output'));
+                if (lineBuffer.trim().length > 0 && !settled) {
+                    try {
+                        collector.consume(JSON.parse(lineBuffer.trim()));
+                        lineBuffer = '';
+                    }
+                    catch (error) {
+                        settleReject(new Error(`Claude stream-json parse failed: ${normalizeError(error).message}`));
+                        return;
+                    }
+                }
+                if (code !== 0) {
+                    settleReject(new Error(`Claude CLI failed with code ${code}: ${stderr.trim()}`));
                     return;
                 }
-                resolve(text);
+                settleResolve(collector.getFinalText());
             });
             child.stdin.write(prompt);
             child.stdin.end();

package/dist/providers/copilot/adapter.d.ts

@@ -1,9 +1,9 @@
 import type { ProviderAdapter } from '../provider-adapter.js';
-import type { ProviderInput, ProviderReply } from '../../types.js';
+import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { CopilotCliClient } from './cli-client.js';
 export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
     constructor(cli: CopilotCliClient);
-    generateReply(input: ProviderInput): Promise<ProviderReply>;
+    generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -4,7 +4,7 @@ export class CopilotProviderAdapter {
     constructor(cli) {
         this.cli = cli;
     }
-    async generateReply(input) {
+    async generateReply(input, options) {
         const prompt = buildPrompt({
             agentName: input.agentName,
             provider: input.provider,
@@ -12,7 +12,9 @@ export class CopilotProviderAdapter {
             incomingAuthorId: input.incomingAuthorId,
             incomingContent: input.incomingContent,
         });
-        const text = await this.cli.generateReply(input.channelId, prompt);
+        const text = await this.cli.generateReply(input.channelId, prompt, {
+            onProgress: options?.onProgress,
+        });
         return { text };
     }
     async dispose() {

package/dist/providers/copilot/cli-client.d.ts

@@ -1,5 +1,6 @@
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
+import type { ProviderGenerateOptions } from '../../types.js';
 interface CopilotAcpRuntime {
     spawn: typeof spawn;
     client: typeof client;
@@ -38,7 +39,7 @@ export declare class CopilotCliClient {
     private disposing;
     private backendClosed;
     constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>);
-    generateReply(channelId: string, prompt: string): Promise<string>;
+    generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
     private ensureStarted;
     private startBackend;

package/dist/providers/copilot/cli-client.js

@@ -17,7 +17,88 @@ const DEFAULT_RUNTIME = {
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
 };
-function createDeferredTurn(prompt) {
+function hasVisibleText(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function formatToolProgress(title, status) {
+    const normalizedTitle = hasVisibleText(title) ? title.trim() : null;
+    switch (status) {
+        case 'completed':
+            return normalizedTitle ? `Completed ${normalizedTitle}` : 'Completed tool call';
+        case 'failed':
+            return normalizedTitle ? `Failed ${normalizedTitle}` : 'Tool call failed';
+        case 'pending':
+        case 'in_progress':
+        case undefined:
+        case null:
+            return normalizedTitle ? `Running ${normalizedTitle}…` : 'Running tool…';
+        default:
+            return normalizedTitle ? `${status} ${normalizedTitle}` : status;
+    }
+}
+function formatPlanProgress(entries) {
+    const current = entries.find((entry) => entry.status === 'in_progress') ??
+        entries.find((entry) => entry.status === 'pending') ??
+        entries[0];
+    return hasVisibleText(current?.content) ? `Plan: ${current.content.trim()}` : null;
+}
+class CopilotProgressCollector {
+    onProgress;
+    publicText = '';
+    lastPublished = null;
+    toolTitles = new Map();
+    constructor(onProgress) {
+        this.onProgress = onProgress;
+    }
+    consume(update) {
+        switch (update.update.sessionUpdate) {
+            case 'agent_message_chunk':
+                if (update.update.content.type !== 'text') {
+                    return;
+                }
+                this.publicText += update.update.content.text;
+                this.publish(this.publicText);
+                return;
+            case 'tool_call':
+                this.toolTitles.set(update.update.toolCallId, update.update.title);
+                this.publishFallback(formatToolProgress(update.update.title, update.update.status));
+                return;
+            case 'tool_call_update': {
+                const nextTitle = update.update.title ?? this.toolTitles.get(update.update.toolCallId);
+                if (hasVisibleText(nextTitle)) {
+                    this.toolTitles.set(update.update.toolCallId, nextTitle);
+                }
+                this.publishFallback(formatToolProgress(nextTitle, update.update.status));
+                return;
+            }
+            case 'plan':
+                this.publishFallback(formatPlanProgress(update.update.entries.map((entry) => ({
+                    content: entry.content,
+                    status: entry.status,
+                }))));
+                return;
+            default:
+                return;
+        }
+    }
+    getFinalText() {
+        return this.publicText.trim();
+    }
+    publishFallback(text) {
+        if (hasVisibleText(this.publicText)) {
+            return;
+        }
+        this.publish(text);
+    }
+    publish(text) {
+        if (!this.onProgress || !hasVisibleText(text) || text === this.lastPublished) {
+            return;
+        }
+        this.lastPublished = text;
+        this.onProgress({ text });
+    }
+}
+function createDeferredTurn(prompt, options) {
     let settled = false;
     let resolvePromise;
     let rejectPromise;
@@ -27,6 +108,7 @@ function createDeferredTurn(prompt) {
     });
     return {
         prompt,
+        options,
         promise,
         resolve(value) {
             if (settled)
@@ -95,13 +177,13 @@ export class CopilotCliClient {
         });
         void this.fatalPromise.catch(() => { });
     }
-    async generateReply(channelId, prompt) {
+    async generateReply(channelId, prompt, options) {
         if (this.fatalError) {
             throw this.fatalError;
         }
         const state = this.getOrCreateChannelState(channelId);
         this.clearIdleTimer(state);
-        const turn = createDeferredTurn(prompt);
+        const turn = createDeferredTurn(prompt, options);
         state.queue.push(turn);
         this.processChannelQueue(channelId, state);
         return turn.promise;
@@ -211,7 +293,7 @@ export class CopilotCliClient {
                         const session = await this.getOrCreateSession(channelId, state);
                         let reply;
                         try {
-                            reply = await this.runTurn(session, turn.prompt);
+                            reply = await this.runTurn(session, turn.prompt, turn.options);
                         }
                         catch (error) {
                             if (isSessionTainted(error)) {
@@ -281,12 +363,12 @@ export class CopilotCliClient {
             }
         }
     }
-    async runTurn(session, prompt) {
+    async runTurn(session, prompt, options) {
         const promptPromise = this.raceWithFatal(session.prompt(prompt));
         const promptFailure = new Promise((_, reject) => {
             void promptPromise.catch((error) => reject(markSessionTainted(error)));
         });
-        let text = '';
+        const collector = new CopilotProgressCollector(options?.onProgress);
         for (;;) {
             let update;
             try {
@@ -309,16 +391,13 @@ export class CopilotCliClient {
                 if (response.stopReason !== 'end_turn') {
                     throw new Error(`Copilot ACP turn stopped with stopReason "${response.stopReason}"`);
                 }
-                const output = text.trim();
+                const output = collector.getFinalText();
                 if (!output) {
                     throw new Error('Copilot ACP returned empty output');
                 }
                 return output;
             }
-            if (update.update.sessionUpdate === 'agent_message_chunk' &&
-                update.update.content.type === 'text') {
-                text += update.update.content.text;
-            }
+            collector.consume(update);
         }
     }
     async raceWithFatal(promise) {

package/dist/providers/provider-adapter.d.ts

@@ -1,5 +1,5 @@
-import type { ProviderInput, ProviderReply } from '../types.js';
+import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../types.js';
 export interface ProviderAdapter {
-    generateReply(input: ProviderInput): Promise<ProviderReply>;
+    generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose?(): Promise<void>;
 }

package/dist/types.d.ts

@@ -106,3 +106,12 @@ export interface ProviderInput {
 export interface ProviderReply {
     text: string;
 }
+export interface PostedMessage {
+    messageId: string;
+}
+export interface ProviderProgressUpdate {
+    text: string;
+}
+export interface ProviderGenerateOptions {
+    onProgress?: (update: ProviderProgressUpdate) => void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -24,7 +24,7 @@
     "@agentclientprotocol/sdk": "^1.2.1",
     "cross-spawn": "^7.0.6",
     "yaml": "^2.8.1",
-    "@borgee/plugin-sdk": "0.1.1"
+    "@borgee/plugin-sdk": "0.1.2"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",