@borgee/agents-host 0.1.5 → 0.1.6

package/README.md

@@ -20,9 +20,8 @@ Borgee channel message
 ```
 
 **In scope:** one agent per process, per-channel conversation memory via each
-CLI's own native session resume
-(Claude `--resume`, Copilot `--session-id`), and dispatching to a local CLI
-provider.
+provider's native session mechanism (Claude CLI resume, Copilot ACP sessions),
+and dispatching to a local CLI provider.
 
 **Out of scope** (see the larger `feat/multi-agent-runtime-host` work for
 these): remote command execution / shell dispatch, node provisioning,
@@ -54,18 +53,20 @@ pnpm --filter @borgee/agents-host dev
 | `BORGEE_AGENT_NAME` | no | `Assistant` | Display name used in prompts |
 | `RUNTIME_PROVIDER` | no | `claude` | `claude` or `copilot` |
 | `CLAUDE_COMMAND` / `CLAUDE_ARGS` | no | `claude` / `--print` | Local Claude CLI command + args |
-| `COPILOT_COMMAND` / `COPILOT_ARGS` | no | `copilot` / `-s --no-color --allow-all-tools --output-format text` | Local Copilot CLI command + args |
+| `COPILOT_COMMAND` / `COPILOT_ARGS` | no | `copilot` / empty | Local Copilot CLI command. `COPILOT_ARGS` is accepted for backward-compatible config/CLI parsing but ignored by the persistent Copilot ACP prototype, which always launches `copilot --acp`. |
 
 ## Conversation memory
 
-Each Borgee channel is mapped 1:1 to a native CLI session, keyed by a
-generated UUID kept in memory for the process's lifetime:
+Each Borgee channel is mapped 1:1 to a provider-native session for the
+process's lifetime:
 
 - **Claude**: first turn for a channel uses `--session-id <uuid>`; every
   turn after uses `-r/--resume <uuid>` (Claude treats these as distinct
   operations).
-- **Copilot**: every turn uses `--session-id=<uuid>` — Copilot's CLI treats
-  that flag as create-or-resume for the same UUID.
+- **Copilot**: one persistent `copilot --acp` subprocess is shared by the
+  host, with one ACP session per Borgee channel. Same-channel turns are
+  serialized so they cannot interleave; different channels keep isolated ACP
+  sessions.
 
 There is no separate history/context store on our side; if the runtime host
 process restarts, each channel starts a fresh CLI session (no session-id

package/dist/agents-host.js

@@ -59,6 +59,7 @@ export class AgentsHost {
             return;
         this.started = false;
         await this.borgee.close();
+        await this.provider.dispose?.();
     }
     async handleMessage(msg) {
         console.log('[agents-host] received message', {

package/dist/cli-args.d.ts

@@ -19,4 +19,4 @@ export declare class CliUsageError extends Error {
  * process, so callers (and tests) can decide how to report it.
  */
 export declare function parseStartArgs(argv: string[]): ParsedStartArgs;
-export declare const USAGE = "Usage: agents-host start <serverUrl> <apiKey> [options]\n\nOptions:\n  --name <name>                 Display name (default: Assistant)\n  --provider <claude|copilot>   Runtime provider (default: claude)\n  --claude-command <cmd>        Local Claude CLI command (default: claude)\n  --claude-args <args>          Local Claude CLI args (default: --print)\n  --copilot-command <cmd>        Local Copilot CLI command (default: copilot)\n  --copilot-args <args>          Local Copilot CLI args\n\nExample:\n  agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot\n";
+export declare const USAGE = "Usage: agents-host start <serverUrl> <apiKey> [options]\n\nOptions:\n  --name <name>                 Display name (default: Assistant)\n  --provider <claude|copilot>   Runtime provider (default: claude)\n  --claude-command <cmd>        Local Claude CLI command (default: claude)\n  --claude-args <args>          Local Claude CLI args (default: --print)\n  --copilot-command <cmd>         Local Copilot CLI command (default: copilot)\n  --copilot-args <args>           Ignored by the Copilot ACP prototype\n\nExample:\n  agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot\n";

package/dist/cli-args.js

@@ -58,8 +58,8 @@ Options:
   --provider <claude|copilot>   Runtime provider (default: claude)
   --claude-command <cmd>        Local Claude CLI command (default: claude)
   --claude-args <args>          Local Claude CLI args (default: --print)
-  --copilot-command <cmd>        Local Copilot CLI command (default: copilot)
-  --copilot-args <args>          Local Copilot CLI args
+  --copilot-command <cmd>         Local Copilot CLI command (default: copilot)
+  --copilot-args <args>           Ignored by the Copilot ACP prototype
 
 Example:
   agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot

package/dist/config.d.ts

@@ -3,5 +3,9 @@ import type { AgentsHostConfig } from './types.js';
  * Loads agents-host configuration from environment variables. This process
  * hosts exactly one Borgee agent (`BORGEE_AGENT_API_KEY`) — to run more
  * agents, run more processes with different env vars.
+ *
+ * The Copilot ACP prototype still parses `COPILOT_ARGS` for CLI/env backward
+ * compatibility, but the persistent ACP backend intentionally ignores them and
+ * always launches `copilot --acp`.
  */
 export declare function loadConfigFromEnv(): AgentsHostConfig;

package/dist/config.js

@@ -22,6 +22,10 @@ function resolveProvider() {
  * Loads agents-host configuration from environment variables. This process
  * hosts exactly one Borgee agent (`BORGEE_AGENT_API_KEY`) — to run more
  * agents, run more processes with different env vars.
+ *
+ * The Copilot ACP prototype still parses `COPILOT_ARGS` for CLI/env backward
+ * compatibility, but the persistent ACP backend intentionally ignores them and
+ * always launches `copilot --acp`.
  */
 export function loadConfigFromEnv() {
     return {

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

@@ -5,4 +5,5 @@ export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
     constructor(cli: CopilotCliClient);
     generateReply(input: ProviderInput): Promise<ProviderReply>;
+    dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -15,4 +15,7 @@ export class CopilotProviderAdapter {
         const text = await this.cli.generateReply(input.channelId, prompt);
         return { text };
     }
+    async dispose() {
+        await this.cli.dispose();
+    }
 }

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

@@ -1,24 +1,58 @@
+import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
+interface CopilotAcpRuntime {
+    spawn: typeof spawn;
+    client: typeof client;
+    ndJsonStream: typeof ndJsonStream;
+    methods: typeof methods;
+    protocolVersion: typeof PROTOCOL_VERSION;
+    cwd: string;
+    shutdownGracePeriodMs: number;
+    shutdownForceKillWaitMs: number;
+}
 /**
- * CLI client for the GitHub Copilot CLI (`copilot`) non-interactive mode,
- * with native per-channel session continuity.
- *
- * Unlike the Claude CLI, Copilot's non-interactive mode takes the prompt as
- * a `-p/--prompt` argument rather than reading it from stdin, so the prompt
- * is appended to the configured base args on every invocation instead of
- * being written to the child process's stdin.
+ * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
- * Verified CLI behavior (`copilot --help` + empirical check): `--session-id
- * <uuid>` both *creates* a new session pinned to that UUID (first call) and
- * *resumes* it (subsequent calls with the same UUID) — one flag covers both
- * cases, unlike Claude's `--session-id`/`--resume` split. No message history
- * is kept on our side — the CLI's own session storage is the single source
- * of truth for conversation memory.
+ * The legacy one-shot `COPILOT_ARGS` / constructor args are intentionally
+ * ignored here: the prototype always launches the child as `copilot --acp`,
+ * performs the ACP initialize handshake once, then reuses one ACP session per
+ * Borgee channel for the process lifetime.
  */
 export declare class CopilotCliClient {
     private readonly command;
-    private readonly args;
-    private readonly sessionIdsByChannel;
-    constructor(command: string, args: string[]);
+    private readonly runtime;
+    private readonly channels;
+    private readonly closingSessions;
+    private readonly pendingSessionStarts;
+    private readonly pendingSessionCloses;
+    private readonly fatalPromise;
+    private rejectFatalPromise;
+    private child?;
+    private connection?;
+    private startPromise?;
+    private shutdownPromise?;
+    private childExitPromise?;
+    private resolveChildExit?;
+    private fatalError;
+    private disposing;
+    private backendClosed;
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>);
     generateReply(channelId: string, prompt: string): Promise<string>;
-    private run;
+    dispose(): Promise<void>;
+    private ensureStarted;
+    private startBackend;
+    private getOrCreateChannelState;
+    private processChannelQueue;
+    private getOrCreateSession;
+    private runTurn;
+    private raceWithFatal;
+    private failAll;
+    private invalidateSession;
+    private closeSession;
+    private rejectQueuedTurnsAfterSessionTaint;
+    private shutdownBackend;
+    private waitForPendingSessionStarts;
+    private waitForPendingSessionCloses;
+    private waitForChildExit;
 }
+export {};

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

@@ -1,65 +1,455 @@
-import { randomUUID } from 'node:crypto';
+import { Readable, Writable } from 'node:stream';
 import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
+const SESSION_TAINTED_ERRORS = new WeakSet();
+const DEFAULT_SHUTDOWN_GRACE_PERIOD_MS = 250;
+const DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS = 250;
+const QUEUED_TURN_DROPPED_MESSAGE = 'Copilot ACP session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
+const DEFAULT_RUNTIME = {
+    spawn,
+    client,
+    ndJsonStream,
+    methods,
+    protocolVersion: PROTOCOL_VERSION,
+    cwd: process.cwd(),
+    shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
+    shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
+};
+function createDeferredTurn(prompt) {
+    let settled = false;
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    return {
+        prompt,
+        promise,
+        resolve(value) {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise(value);
+        },
+        reject(error) {
+            if (settled)
+                return;
+            settled = true;
+            rejectPromise(normalizeError(error));
+        },
+    };
+}
+function normalizeError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function markSessionTainted(error) {
+    const normalized = normalizeError(error);
+    SESSION_TAINTED_ERRORS.add(normalized);
+    return normalized;
+}
+function isSessionTainted(error) {
+    return error instanceof Error && SESSION_TAINTED_ERRORS.has(error);
+}
+function selectPermissionOption(options) {
+    const option = options.find((candidate) => candidate.kind === 'allow_always') ??
+        options.find((candidate) => candidate.kind === 'allow_once');
+    if (!option) {
+        throw new Error('Copilot ACP requested permission but did not offer an allow option');
+    }
+    return option.optionId;
+}
 /**
- * CLI client for the GitHub Copilot CLI (`copilot`) non-interactive mode,
- * with native per-channel session continuity.
- *
- * Unlike the Claude CLI, Copilot's non-interactive mode takes the prompt as
- * a `-p/--prompt` argument rather than reading it from stdin, so the prompt
- * is appended to the configured base args on every invocation instead of
- * being written to the child process's stdin.
+ * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
- * Verified CLI behavior (`copilot --help` + empirical check): `--session-id
- * <uuid>` both *creates* a new session pinned to that UUID (first call) and
- * *resumes* it (subsequent calls with the same UUID) — one flag covers both
- * cases, unlike Claude's `--session-id`/`--resume` split. No message history
- * is kept on our side — the CLI's own session storage is the single source
- * of truth for conversation memory.
+ * The legacy one-shot `COPILOT_ARGS` / constructor args are intentionally
+ * ignored here: the prototype always launches the child as `copilot --acp`,
+ * performs the ACP initialize handshake once, then reuses one ACP session per
+ * Borgee channel for the process lifetime.
  */
 export class CopilotCliClient {
     command;
-    args;
-    sessionIdsByChannel = new Map();
-    constructor(command, args) {
+    runtime;
+    channels = new Map();
+    closingSessions = new WeakSet();
+    pendingSessionStarts = new Set();
+    pendingSessionCloses = new Set();
+    fatalPromise;
+    rejectFatalPromise;
+    child;
+    connection;
+    startPromise;
+    shutdownPromise;
+    childExitPromise;
+    resolveChildExit;
+    fatalError = null;
+    disposing = false;
+    backendClosed = false;
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}) {
         this.command = command;
-        this.args = args;
+        this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
+        this.fatalPromise = new Promise((_, reject) => {
+            this.rejectFatalPromise = reject;
+        });
+        void this.fatalPromise.catch(() => { });
     }
     async generateReply(channelId, prompt) {
-        const sessionId = this.sessionIdsByChannel.get(channelId) ?? randomUUID();
-        const text = await this.run([...this.args, `--session-id=${sessionId}`, '-p', prompt]);
-        this.sessionIdsByChannel.set(channelId, sessionId);
-        return text;
-    }
-    async run(args) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(this.command, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            child.stdout.setEncoding('utf8');
-            child.stderr.setEncoding('utf8');
-            child.stdout.on('data', (chunk) => {
-                stdout += chunk;
-            });
-            child.stderr.on('data', (chunk) => {
-                stderr += chunk;
-            });
-            child.on('error', (error) => {
-                reject(error);
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        const state = this.getOrCreateChannelState(channelId);
+        const turn = createDeferredTurn(prompt);
+        state.queue.push(turn);
+        this.processChannelQueue(channelId, state);
+        return turn.promise;
+    }
+    async dispose() {
+        const error = new Error('Copilot ACP backend stopped');
+        this.disposing = true;
+        const closed = this.connection?.closed ?? Promise.resolve();
+        this.failAll(error);
+        await Promise.all([closed, this.shutdownPromise ?? Promise.resolve()]);
+    }
+    async ensureStarted() {
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        if (!this.startPromise) {
+            this.startPromise = this.startBackend();
+        }
+        await this.startPromise;
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+    }
+    async startBackend() {
+        const child = this.runtime.spawn(this.command, ['--acp'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        child.stderr.resume();
+        child.once('error', (error) => {
+            this.failAll(new Error(`Copilot ACP process error: ${normalizeError(error).message}`));
+        });
+        child.once('exit', (code, signal) => {
+            this.resolveChildExit?.();
+            if (this.disposing)
+                return;
+            const suffix = signal ? `signal ${signal}` : `code ${String(code ?? 'unknown')}`;
+            this.failAll(new Error(`Copilot ACP process exited unexpectedly (${suffix})`));
+        });
+        this.childExitPromise = new Promise((resolve) => {
+            this.resolveChildExit = resolve;
+        });
+        const output = Writable.toWeb(child.stdin);
+        const input = Readable.toWeb(child.stdout);
+        const stream = this.runtime.ndJsonStream(output, input);
+        const app = this.runtime
+            .client({ name: 'borgee-agents-host' })
+            .onRequest(this.runtime.methods.client.session.requestPermission, ({ params }) => ({
+            outcome: {
+                outcome: 'selected',
+                optionId: selectPermissionOption(params.options),
+            },
+        }));
+        const connection = app.connect(stream);
+        this.connection = connection;
+        void connection.closed.then(() => {
+            if (!this.disposing) {
+                this.failAll(new Error('Copilot ACP connection closed unexpectedly'));
+            }
+        });
+        try {
+            await connection.agent.request(this.runtime.methods.agent.initialize, {
+                protocolVersion: this.runtime.protocolVersion,
+                clientCapabilities: {},
+                clientInfo: {
+                    name: '@borgee/agents-host',
+                    version: '0.1.6',
+                },
             });
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Copilot CLI failed with code ${code}: ${stderr.trim()}`));
-                    return;
+        }
+        catch (error) {
+            const normalized = new Error(`Copilot ACP initialize failed: ${normalizeError(error).message}`);
+            this.failAll(normalized);
+            throw normalized;
+        }
+    }
+    getOrCreateChannelState(channelId) {
+        let state = this.channels.get(channelId);
+        if (!state) {
+            state = {
+                processing: false,
+                queue: [],
+            };
+            this.channels.set(channelId, state);
+        }
+        return state;
+    }
+    processChannelQueue(channelId, state) {
+        if (state.processing) {
+            return;
+        }
+        state.processing = true;
+        void (async () => {
+            try {
+                while (!this.fatalError) {
+                    const turn = state.queue.shift();
+                    if (!turn) {
+                        return;
+                    }
+                    state.activeTurn = turn;
+                    try {
+                        await this.ensureStarted();
+                        const session = await this.getOrCreateSession(channelId, state);
+                        let reply;
+                        try {
+                            reply = await this.runTurn(session, turn.prompt);
+                        }
+                        catch (error) {
+                            if (isSessionTainted(error)) {
+                                this.invalidateSession(state, session);
+                                this.rejectQueuedTurnsAfterSessionTaint(state, error);
+                            }
+                            throw error;
+                        }
+                        turn.resolve(reply);
+                    }
+                    catch (error) {
+                        turn.reject(error);
+                    }
+                    finally {
+                        state.activeTurn = undefined;
+                    }
                 }
-                const text = stdout.trim();
-                if (!text) {
-                    reject(new Error('Copilot CLI returned empty output'));
-                    return;
+            }
+            finally {
+                state.processing = false;
+            }
+        })();
+    }
+    async getOrCreateSession(channelId, state) {
+        if (state.session) {
+            return state.session;
+        }
+        if (state.sessionPromise) {
+            return state.sessionPromise;
+        }
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+        const sessionPromise = this.connection.agent.buildSession(this.runtime.cwd).start();
+        this.pendingSessionStarts.add(sessionPromise);
+        state.sessionPromise = sessionPromise;
+        let sessionAdopted = false;
+        void sessionPromise
+            .then((session) => {
+            if (!sessionAdopted &&
+                (this.fatalError !== null || this.disposing || state.sessionPromise !== sessionPromise)) {
+                this.closeSession(session);
+            }
+        })
+            .finally(() => {
+            this.pendingSessionStarts.delete(sessionPromise);
+        })
+            .catch(() => { });
+        try {
+            const session = await this.raceWithFatal(sessionPromise);
+            if (this.fatalError) {
+                this.closeSession(session);
+                throw this.fatalError;
+            }
+            sessionAdopted = true;
+            state.session = session;
+            return session;
+        }
+        catch (error) {
+            state.session = undefined;
+            throw error;
+        }
+        finally {
+            if (state.sessionPromise === sessionPromise) {
+                state.sessionPromise = undefined;
+            }
+            if (!state.session && state.queue.length === 0 && !state.activeTurn) {
+                this.channels.delete(channelId);
+            }
+        }
+    }
+    async runTurn(session, prompt) {
+        const promptPromise = this.raceWithFatal(session.prompt(prompt));
+        const promptFailure = new Promise((_, reject) => {
+            void promptPromise.catch((error) => reject(markSessionTainted(error)));
+        });
+        let text = '';
+        for (;;) {
+            let update;
+            try {
+                update = await this.raceWithFatal(Promise.race([session.nextUpdate(), promptFailure]));
+            }
+            catch (error) {
+                if (this.fatalError && error === this.fatalError) {
+                    throw error;
                 }
-                resolve(text);
-            });
+                throw markSessionTainted(error);
+            }
+            if (update.kind === 'stop') {
+                let response;
+                try {
+                    response = await promptPromise;
+                }
+                catch (error) {
+                    throw markSessionTainted(error);
+                }
+                if (response.stopReason !== 'end_turn') {
+                    throw new Error(`Copilot ACP turn stopped with stopReason "${response.stopReason}"`);
+                }
+                const output = text.trim();
+                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;
+            }
+        }
+    }
+    async raceWithFatal(promise) {
+        if (this.fatalError) {
+            throw this.fatalError;
+        }
+        return Promise.race([promise, this.fatalPromise]);
+    }
+    failAll(error) {
+        if (this.fatalError) {
+            return;
+        }
+        this.fatalError = error;
+        this.rejectFatalPromise(error);
+        for (const [channelId, state] of this.channels.entries()) {
+            state.activeTurn?.reject(error);
+            for (const turn of state.queue) {
+                turn.reject(error);
+            }
+            state.queue.length = 0;
+            if (state.session) {
+                this.closeSession(state.session);
+            }
+            state.session = undefined;
+            state.sessionPromise = undefined;
+            state.activeTurn = undefined;
+            if (!state.processing) {
+                this.channels.delete(channelId);
+            }
+        }
+        this.channels.clear();
+        this.shutdownPromise = this.shutdownBackend(error);
+    }
+    invalidateSession(state, session) {
+        if (state.session === session) {
+            state.session = undefined;
+        }
+        this.closeSession(session);
+    }
+    closeSession(session) {
+        if (this.closingSessions.has(session)) {
+            return;
+        }
+        this.closingSessions.add(session);
+        const agent = this.connection?.agent;
+        const closeMethod = this.runtime.methods.agent.session?.close;
+        const closePromise = typeof agent?.closeSession === 'function'
+            ? agent.closeSession({ sessionId: session.sessionId })
+            : closeMethod
+                ? this.connection?.agent.request(closeMethod, { sessionId: session.sessionId })
+                : undefined;
+        session.dispose();
+        if (!closePromise) {
+            return;
+        }
+        let trackedClosePromise;
+        trackedClosePromise = Promise.resolve(closePromise)
+            .then(() => undefined)
+            .catch(() => { })
+            .finally(() => {
+            this.pendingSessionCloses.delete(trackedClosePromise);
+        });
+        this.pendingSessionCloses.add(trackedClosePromise);
+    }
+    rejectQueuedTurnsAfterSessionTaint(state, error) {
+        if (state.queue.length === 0) {
+            return;
+        }
+        const rejection = new Error(QUEUED_TURN_DROPPED_MESSAGE, {
+            cause: normalizeError(error),
         });
+        for (const turn of state.queue) {
+            turn.reject(rejection);
+        }
+        state.queue.length = 0;
+    }
+    async shutdownBackend(error) {
+        if (this.backendClosed) {
+            return;
+        }
+        this.backendClosed = true;
+        const connection = this.connection;
+        const child = this.child;
+        await this.waitForPendingSessionStarts();
+        await this.waitForPendingSessionCloses();
+        connection?.close(error);
+        this.connection = undefined;
+        if (!child) {
+            this.child = undefined;
+            return;
+        }
+        const childExitPromise = this.childExitPromise ?? Promise.resolve();
+        child.kill('SIGTERM');
+        const exitedAfterTerm = await this.waitForChildExit(childExitPromise, this.runtime.shutdownGracePeriodMs);
+        if (exitedAfterTerm) {
+            this.child = undefined;
+            return;
+        }
+        child.kill('SIGKILL');
+        await this.waitForChildExit(childExitPromise, this.runtime.shutdownForceKillWaitMs);
+        this.child = undefined;
+    }
+    async waitForPendingSessionStarts() {
+        if (this.pendingSessionStarts.size === 0) {
+            return;
+        }
+        await Promise.race([
+            Promise.allSettled([...this.pendingSessionStarts]).then(() => undefined),
+            new Promise((resolve) => {
+                setTimeout(resolve, this.runtime.shutdownGracePeriodMs);
+            }),
+        ]);
+    }
+    async waitForPendingSessionCloses() {
+        if (this.pendingSessionCloses.size === 0) {
+            return;
+        }
+        await Promise.race([
+            Promise.allSettled([...this.pendingSessionCloses]).then(() => undefined),
+            new Promise((resolve) => {
+                setTimeout(resolve, this.runtime.shutdownGracePeriodMs);
+            }),
+        ]);
+    }
+    async waitForChildExit(childExitPromise, timeoutMs) {
+        if (timeoutMs <= 0) {
+            return false;
+        }
+        return Promise.race([
+            childExitPromise.then(() => true),
+            new Promise((resolve) => {
+                setTimeout(() => resolve(false), timeoutMs);
+            }),
+        ]);
     }
 }

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -21,6 +21,7 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@agentclientprotocol/sdk": "^1.2.1",
     "cross-spawn": "^7.0.6",
     "@borgee/plugin-sdk": "0.1.1"
   },