@borgee/agents-host 0.2.33 → 0.2.44

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

@@ -13,14 +13,21 @@ interface CopilotAcpRuntime {
     protocolVersion: typeof PROTOCOL_VERSION;
     cwd: string;
     idleSessionTtlMs: number;
+    idleBackendShutdownMs: number;
+    idleShutdownGracePeriodMs: number;
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
+    fetch(input: string | URL, init?: RequestInit): Promise<Response>;
 }
 interface CopilotPermissionPolicyOptions {
     gateEnabled?: boolean;
     policyMode?: InternalPolicyMode;
     auditSink?: AuthorizationAuditSinkLike;
 }
+interface CopilotHostedImageInputConfig {
+    borgeeBaseUrl?: string;
+    agentApiKey?: string;
+}
 /**
  * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
@@ -35,8 +42,15 @@ export declare class CopilotCliClient {
     private readonly resolveSessionStoreAgentId;
     private readonly logger;
     private readonly permissionPolicy;
+    private readonly imageInputConfig;
     private readonly runtime;
     private readonly channels;
+    /**
+     * The provider session currently bound to channelId, or undefined before a
+     * turn has opened one. Surfaced so agents-host can record which session
+     * worked a task without the agent being asked to report its own id.
+     */
+    sessionIdForChannel(channelId: string): string | undefined;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
@@ -49,7 +63,13 @@ export declare class CopilotCliClient {
     private startPromise?;
     private shutdownPromise?;
     private childExitPromise?;
-    private resolveChildExit?;
+    /**
+     * Bumped on every spawn so the `exit` / `connection.closed` handlers of a
+     * backend we deliberately recycled stay silent instead of latching a fatal
+     * error onto the client that already owns its successor.
+     */
+    private backendGeneration;
+    private idleShutdownPromise?;
     private fatalError;
     private disposing;
     private backendClosed;
@@ -57,7 +77,8 @@ export declare class CopilotCliClient {
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
     private sessionCapabilities;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions);
+    private readonly idleBackendShutdown;
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions, imageInputConfig?: CopilotHostedImageInputConfig);
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
@@ -71,6 +92,8 @@ export declare class CopilotCliClient {
     private restoreSession;
     private clearBufferedSessionReplay;
     private resolveSessionCwd;
+    private buildPromptInput;
+    private fetchImageBlock;
     private recycleSessionIfCwdChanged;
     private runTurn;
     private raceWithFatal;
@@ -92,6 +115,15 @@ export declare class CopilotCliClient {
     private trackSessionStoreOperation;
     private evictIdleChannel;
     private shutdownBackend;
+    /**
+     * Backend teardown without the fatal latch: the client stays usable and
+     * `ensureStarted()` spawns a replacement process on the next turn. Only safe
+     * while `isBackendIdle()` holds, because every channel's live ACP session is
+     * dropped here and no turn is ever replayed onto its successor.
+     */
+    private shutdownIdleBackend;
+    private isBackendIdle;
+    private closeBackendProcess;
     private waitForPendingSessionStarts;
     private waitForPendingSessionCloses;
     private waitForChildExit;

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

@@ -3,8 +3,18 @@ import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
+import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const DEFAULT_IDLE_SESSION_TTL_MS = 2 * 24 * 60 * 60 * 1000;
+const IDLE_BACKEND_STOPPED_MESSAGE = 'Copilot ACP backend stopped after idle timeout';
+/**
+ * A fatal teardown has callers waiting on it, so it force-kills quickly. An
+ * idle recycle has nobody waiting, and the CLIs unlink their on-disk session
+ * locks during SIGTERM cleanup — a lock left behind by SIGKILL makes the next
+ * restore believe the session is still in use (github/copilot-cli#3255). So the
+ * idle path trades latency nobody observes for a clean exit.
+ */
+const DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS = 5_000;
 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';
@@ -16,8 +26,11 @@ const DEFAULT_RUNTIME = {
     protocolVersion: PROTOCOL_VERSION,
     cwd: process.cwd(),
     idleSessionTtlMs: DEFAULT_IDLE_SESSION_TTL_MS,
+    idleBackendShutdownMs: IDLE_BACKEND_SHUTDOWN_DISABLED_MS,
+    idleShutdownGracePeriodMs: DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
+    fetch: async (input, init) => fetch(input, init),
 };
 const DEFAULT_SESSION_CAPABILITIES = {
     loadSession: false,
@@ -26,6 +39,28 @@ const DEFAULT_SESSION_CAPABILITIES = {
 function hasVisibleText(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
+function isAbsoluteHttpUrl(value) {
+    return value.startsWith('http://') || value.startsWith('https://');
+}
+function resolveHostedAttachmentUrl(rawUrl, borgeeBaseUrl) {
+    if (isAbsoluteHttpUrl(rawUrl)) {
+        return rawUrl;
+    }
+    const base = borgeeBaseUrl.replace(/\/$/, '');
+    const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;
+    return `${base}${path}`;
+}
+function isSameOrigin(left, right) {
+    try {
+        return new URL(left).origin === new URL(right).origin;
+    }
+    catch {
+        return false;
+    }
+}
+function asImagePart(part) {
+    return part.type === 'image' ? part : null;
+}
 function formatToolProgress(title, status) {
     const normalizedTitle = hasVisibleText(title) ? title.trim() : null;
     switch (status) {
@@ -104,7 +139,7 @@ class CopilotProgressCollector {
         this.onProgress({ text });
     }
 }
-function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext, options) {
+function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options) {
     let settled = false;
     let resolvePromise;
     let rejectPromise;
@@ -114,9 +149,8 @@ function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext
     });
     return {
         channelId,
-        prompt,
+        preparedTurn,
         sessionPersistence,
-        promptContext,
         options,
         promise,
         resolve(value) {
@@ -204,8 +238,17 @@ export class CopilotCliClient {
     resolveSessionStoreAgentId;
     logger;
     permissionPolicy;
+    imageInputConfig;
     runtime;
     channels = new Map();
+    /**
+     * The provider session currently bound to channelId, or undefined before a
+     * turn has opened one. Surfaced so agents-host can record which session
+     * worked a task without the agent being asked to report its own id.
+     */
+    sessionIdForChannel(channelId) {
+        return this.channels.get(channelId)?.session?.sessionId;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -218,7 +261,13 @@ export class CopilotCliClient {
     startPromise;
     shutdownPromise;
     childExitPromise;
-    resolveChildExit;
+    /**
+     * Bumped on every spawn so the `exit` / `connection.closed` handlers of a
+     * backend we deliberately recycled stay silent instead of latching a fatal
+     * error onto the client that already owns its successor.
+     */
+    backendGeneration = 0;
+    idleShutdownPromise;
     fatalError = null;
     disposing = false;
     backendClosed = false;
@@ -226,13 +275,25 @@ export class CopilotCliClient {
     sessionStoreLoadPromise = null;
     sessionStoreWriteQueue = Promise.resolve();
     sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
-    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}) {
+    idleBackendShutdown;
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}, imageInputConfig = {}) {
         this.command = command;
         this.sessionStore = sessionStore;
         this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.logger = logger;
         this.permissionPolicy = permissionPolicy;
+        this.imageInputConfig = imageInputConfig;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
+        this.idleBackendShutdown = new IdleBackendShutdownScheduler({
+            idleShutdownMs: this.runtime.idleBackendShutdownMs,
+            isIdle: () => this.isBackendIdle(),
+            shutdown: () => this.shutdownIdleBackend(),
+            onShutdownFailed: (error) => {
+                this.logger.error('failed to stop the idle Copilot ACP backend', {
+                    error: summarizeError(error),
+                });
+            },
+        });
         this.fatalPromise = new Promise((_, reject) => {
             this.rejectFatalPromise = reject;
         });
@@ -242,19 +303,27 @@ export class CopilotCliClient {
         if (this.fatalError) {
             throw this.fatalError;
         }
-        const preparedTurn = typeof channelIdOrTurn === 'string'
+        const preparedTurnBase = typeof channelIdOrTurn === 'string'
             ? {
                 channelId: channelIdOrTurn,
+                incomingContent: '',
+                incomingParts: [],
                 prompt: typeof promptOrOptions === 'string' ? promptOrOptions : '',
             }
             : channelIdOrTurn;
+        const preparedTurn = {
+            ...preparedTurnBase,
+            incomingContent: preparedTurnBase.incomingContent ?? '',
+            incomingParts: preparedTurnBase.incomingParts ?? [],
+        };
         const options = typeof channelIdOrTurn === 'string'
             ? maybeOptions
             : promptOrOptions;
         const sessionRouting = resolveSessionRouting(preparedTurn);
         const state = this.getOrCreateChannelState(sessionRouting.key, preparedTurn.channelId, sessionRouting.persistence);
         this.clearIdleTimer(state);
-        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn.prompt, sessionRouting.persistence, preparedTurn.promptContext, options);
+        this.idleBackendShutdown.cancel();
+        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn, sessionRouting.persistence, options);
         state.queue.push(turn);
         this.processChannelQueue(sessionRouting.key, state);
         return turn.promise;
@@ -262,12 +331,17 @@ export class CopilotCliClient {
     async dispose() {
         const error = new Error('Copilot ACP backend stopped');
         this.disposing = true;
+        this.idleBackendShutdown.cancel();
         this.logger?.debug('stopping Copilot ACP backend');
         const closed = this.connection?.closed ?? Promise.resolve();
         this.failAll(error);
         let thrown;
         try {
-            await Promise.all([closed, this.shutdownPromise ?? Promise.resolve()]);
+            await Promise.all([
+                closed,
+                this.idleShutdownPromise ?? Promise.resolve(),
+                this.shutdownPromise ?? Promise.resolve(),
+            ]);
         }
         catch (disposeError) {
             thrown = disposeError;
@@ -288,6 +362,12 @@ export class CopilotCliClient {
         if (this.fatalError) {
             throw this.fatalError;
         }
+        if (this.idleShutdownPromise) {
+            await this.idleShutdownPromise;
+            if (this.fatalError) {
+                throw this.fatalError;
+            }
+        }
         if (!this.startPromise) {
             this.startPromise = this.startBackend();
         }
@@ -300,6 +380,8 @@ export class CopilotCliClient {
         }
     }
     async startBackend() {
+        const generation = ++this.backendGeneration;
+        const ownsCurrentBackend = () => (this.backendGeneration === generation && !this.disposing);
         this.logger?.debug('starting Copilot ACP process', {
             command: this.command,
             args: ['--acp'],
@@ -315,13 +397,20 @@ export class CopilotCliClient {
         });
         child.stderr.resume();
         this.logger?.debug('spawned Copilot ACP process', { pid: child.pid });
+        let resolveChildExit;
+        this.childExitPromise = new Promise((resolve) => {
+            resolveChildExit = resolve;
+        });
         child.once('error', (error) => {
             this.logger?.debugError('Copilot ACP process error', error);
+            if (!ownsCurrentBackend()) {
+                return;
+            }
             this.failAll(new Error(`Copilot ACP process error: ${normalizeError(error).message}`));
         });
         child.once('exit', (code, signal) => {
-            this.resolveChildExit?.();
-            if (this.disposing) {
+            resolveChildExit();
+            if (!ownsCurrentBackend()) {
                 this.logger?.debug('Copilot ACP process exited during shutdown', { code, signal });
                 return;
             }
@@ -329,9 +418,6 @@ export class CopilotCliClient {
             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);
@@ -341,7 +427,7 @@ export class CopilotCliClient {
         const connection = app.connect(stream);
         this.connection = connection;
         void connection.closed.then(() => {
-            if (!this.disposing) {
+            if (ownsCurrentBackend()) {
                 this.logger?.debugError('Copilot ACP connection closed unexpectedly');
                 this.failAll(new Error('Copilot ACP connection closed unexpectedly'));
             }
@@ -400,13 +486,14 @@ export class CopilotCliClient {
                     }
                     state.activeTurn = turn;
                     try {
-                        state.cwd = await this.resolveSessionCwd(turn.promptContext);
+                        state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
                         await this.ensureStarted();
                         await this.recycleSessionIfCwdChanged(channelId, state);
                         const session = await this.getOrCreateSession(channelId, state);
                         let reply;
                         try {
-                            reply = await this.runTurn(session, turn.prompt, turn.options);
+                            const promptInput = await this.buildPromptInput(turn.preparedTurn);
+                            reply = await this.runTurn(session, promptInput, turn.options);
                         }
                         catch (error) {
                             if (isSessionTainted(error)) {
@@ -428,6 +515,7 @@ export class CopilotCliClient {
             finally {
                 state.processing = false;
                 this.reconcileIdleChannelState(channelId, state);
+                this.idleBackendShutdown.reconcile();
             }
         })();
     }
@@ -561,6 +649,37 @@ export class CopilotCliClient {
     async resolveSessionCwd(promptContext) {
         return promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd;
     }
+    async buildPromptInput(turn) {
+        const imageParts = turn.incomingParts.map(asImagePart).filter((part) => part !== null);
+        if (imageParts.length === 0) {
+            return turn.prompt;
+        }
+        const imageBlocks = await Promise.all(imageParts.map(async (part) => this.fetchImageBlock(part.attachment.url, part.attachment.contentType)));
+        return [{ type: 'text', text: turn.prompt }, ...imageBlocks];
+    }
+    async fetchImageBlock(rawUrl, contentType) {
+        const baseUrl = this.imageInputConfig.borgeeBaseUrl?.trim();
+        const agentApiKey = this.imageInputConfig.agentApiKey?.trim();
+        if (!baseUrl || !agentApiKey) {
+            throw new Error('Copilot image input requires Borgee base URL and agent API key');
+        }
+        const resolvedUrl = resolveHostedAttachmentUrl(rawUrl, baseUrl);
+        if (!isSameOrigin(resolvedUrl, baseUrl)) {
+            throw new Error(`Copilot image input only supports Borgee-origin attachments: ${resolvedUrl}`);
+        }
+        const response = await this.runtime.fetch(resolvedUrl, {
+            headers: { Authorization: `Bearer ${agentApiKey}` },
+        });
+        if (!response.ok) {
+            throw new Error(`Copilot image fetch failed with ${response.status} ${response.statusText}`.trim());
+        }
+        return {
+            type: 'image',
+            mimeType: contentType,
+            data: Buffer.from(await response.arrayBuffer()).toString('base64'),
+            uri: response.url || resolvedUrl,
+        };
+    }
     async recycleSessionIfCwdChanged(channelId, state) {
         const session = state.session;
         if (!session) {
@@ -643,6 +762,7 @@ export class CopilotCliClient {
         }
         this.fatalError = error;
         this.rejectFatalPromise(error);
+        this.idleBackendShutdown.cancel();
         for (const [channelId, state] of this.channels.entries()) {
             this.clearIdleTimer(state);
             state.activeTurn?.reject(error);
@@ -884,6 +1004,64 @@ export class CopilotCliClient {
             return;
         }
         this.backendClosed = true;
+        await this.closeBackendProcess(error, this.runtime.shutdownGracePeriodMs);
+    }
+    /**
+     * Backend teardown without the fatal latch: the client stays usable and
+     * `ensureStarted()` spawns a replacement process on the next turn. Only safe
+     * while `isBackendIdle()` holds, because every channel's live ACP session is
+     * dropped here and no turn is ever replayed onto its successor.
+     */
+    async shutdownIdleBackend() {
+        // Detach the running backend before any signal reaches it, so its own exit
+        // and connection-closed handlers read this teardown as deliberate instead
+        // of latching a fatal error on a client that stays usable.
+        this.backendGeneration += 1;
+        const error = new Error(IDLE_BACKEND_STOPPED_MESSAGE);
+        const sessions = [];
+        for (const [channelId, state] of [...this.channels.entries()]) {
+            this.clearIdleTimer(state);
+            if (state.session) {
+                sessions.push(state.session);
+            }
+            state.session = undefined;
+            state.sessionCwd = undefined;
+            this.channels.delete(channelId);
+        }
+        this.logger?.debug('stopping idle Copilot ACP backend', {
+            channels: sessions.length,
+            idleShutdownMs: this.runtime.idleBackendShutdownMs,
+        });
+        for (const session of sessions) {
+            this.closeSession(session);
+        }
+        const idleShutdownPromise = this.closeBackendProcess(error, this.runtime.idleShutdownGracePeriodMs).finally(() => {
+            this.startPromise = undefined;
+            this.childExitPromise = undefined;
+            this.sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
+            this.idleShutdownPromise = undefined;
+        });
+        this.idleShutdownPromise = idleShutdownPromise;
+        await idleShutdownPromise;
+    }
+    isBackendIdle() {
+        if (this.disposing || this.fatalError || this.backendClosed || this.idleShutdownPromise) {
+            return false;
+        }
+        if (!this.child) {
+            return false;
+        }
+        if (this.pendingSessionStarts.size > 0) {
+            return false;
+        }
+        for (const state of this.channels.values()) {
+            if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async closeBackendProcess(error, gracePeriodMs) {
         const connection = this.connection;
         const child = this.child;
         await this.waitForPendingSessionStarts();
@@ -895,9 +1073,9 @@ export class CopilotCliClient {
             return;
         }
         const childExitPromise = this.childExitPromise ?? Promise.resolve();
-        this.logger?.debug('sending SIGTERM to Copilot ACP process');
+        this.logger?.debug('sending SIGTERM to Copilot ACP process', { gracePeriodMs });
         child.kill('SIGTERM');
-        const exitedAfterTerm = await this.waitForChildExit(childExitPromise, this.runtime.shutdownGracePeriodMs);
+        const exitedAfterTerm = await this.waitForChildExit(childExitPromise, gracePeriodMs);
         if (exitedAfterTerm) {
             this.logger?.debug('Copilot ACP process exited after SIGTERM');
             this.child = undefined;

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

@@ -1,6 +1,6 @@
 import type { DebugLogger } from '../debug.js';
 import type { ProviderRuntimeConfig } from '../types.js';
-import type { ProviderAdapter } from './provider-adapter.js';
+import { type ProviderAdapter } from './provider-adapter.js';
 import type { LocalhostGatewayContextPublisher } from '../context/injection.js';
 import type { AuthorizationAuditSinkLike } from '../policy/authorization-audit.js';
 interface CreateProviderOptions {

package/dist/providers/create-provider.js

@@ -2,6 +2,7 @@ import { FileChannelContextStore } from '../context/injection.js';
 import { createProviderConnectionsSessionStore } from '../connections-state-store.js';
 import { ProviderTurnPreparer } from '../context/turn-preparation.js';
 import { CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, CODEX_PROVIDER_COMPATIBILITY_GATE, COPILOT_PROVIDER_V2_COMPATIBILITY_GATE, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, parseInternalProviderImplementationOverrides, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, SKILL_RUNTIME_COMPATIBILITY_GATE, } from '../compatibility-gates.js';
+import { resolveIdleBackendShutdownMs } from './idle-backend-shutdown.js';
 import { ClaudeCliClient } from './claude/cli-client.js';
 import { ClaudeProviderAdapter } from './claude/adapter.js';
 import { FileClaudeChannelSessionStore } from './claude/session-store.js';
@@ -9,16 +10,18 @@ import { CodexCliClient } from './codex/cli-client.js';
 import { CodexProviderAdapter } from './codex/adapter.js';
 import { FileCodexChannelSessionStore } from './codex/session-store.js';
 import { CopilotCliClient } from './copilot/cli-client.js';
-import { CopilotProviderAdapter } from './copilot/adapter.js';
+import { COPILOT_HOSTED_PROVIDER_CAPABILITIES, CopilotProviderAdapter } from './copilot/adapter.js';
 import { FileCopilotChannelSessionStore } from './copilot/session-store.js';
 import { resolveClaudeSessionMapPath, resolveCodexSessionMapPath, resolveCopilotSessionMapPath, } from '../state-paths.js';
 import { createAwaitingUserProgressHandler, parseProviderReply } from './awaiting-user.js';
 class ProviderV2CompatibilityAdapter {
     provider;
     turnPreparer;
-    constructor(provider, turnPreparer) {
+    capabilities;
+    constructor(provider, turnPreparer, capabilities) {
         this.provider = provider;
         this.turnPreparer = turnPreparer;
+        this.capabilities = capabilities;
     }
     async generateReply(input, options) {
         const preparedTurn = await this.turnPreparer.prepare(input);
@@ -39,7 +42,9 @@ class CliBackedProviderV2 {
         const text = await this.cli.generateReply(input.turn, {
             onProgress: createAwaitingUserProgressHandler(options?.onProgress),
         });
-        return parseProviderReply(text);
+        // Read the session AFTER the turn: a first turn on a channel opens the
+        // session as it runs, so before this point there is nothing to report.
+        return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.turn.channelId) };
     }
     async shutdown() {
         await this.cli.dispose();
@@ -57,8 +62,8 @@ function resolveCopilotImplementation(routingConfig) {
     }
     return routingConfig.implementationOverrides.copilot ?? 'v2';
 }
-function createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer) {
-    const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs, {}, createProviderConnectionsSessionStore({
+function createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs) {
+    const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs, { idleBackendShutdownMs }, createProviderConnectionsSessionStore({
         provider: 'claude',
         legacyStore: new FileClaudeChannelSessionStore({
             resolvePath: (agentId) => resolveClaudeSessionMapPath(config.stateRootDir, agentId),
@@ -66,13 +71,17 @@ function createClaudeProvider(config, debugLogger, connectionsStateGateEnabled,
         stateRootDir: config.stateRootDir,
         gateEnabled: connectionsStateGateEnabled,
         logger: debugLogger,
-    }), config.resolveStableAgentId, debugLogger);
+    }), config.resolveStableAgentId, debugLogger, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+    });
     return new ClaudeProviderAdapter(cli, turnPreparer);
 }
-function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, implementation, turnPreparer, policyAuditGateEnabled, authorizationAuditSink) {
+function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, implementation, turnPreparer, policyAuditGateEnabled, authorizationAuditSink, idleBackendShutdownMs) {
     const policyMode = resolveInternalPolicyMode(policyAuditGateEnabled);
     const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
         idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
+        idleBackendShutdownMs,
     }, createProviderConnectionsSessionStore({
         provider: 'copilot',
         legacyStore: new FileCopilotChannelSessionStore({
@@ -85,13 +94,16 @@ function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled,
         gateEnabled: policyAuditGateEnabled,
         policyMode,
         auditSink: authorizationAuditSink,
+    }, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
     });
     return implementation === 'v2'
-        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer)
+        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer, COPILOT_HOSTED_PROVIDER_CAPABILITIES)
         : new CopilotProviderAdapter(cli, turnPreparer);
 }
-function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer) {
-    const cli = new CodexCliClient(config.codexCommand, config.codexArgs, {}, createProviderConnectionsSessionStore({
+function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs) {
+    const cli = new CodexCliClient(config.codexCommand, config.codexArgs, { idleBackendShutdownMs }, createProviderConnectionsSessionStore({
         provider: 'codex',
         legacyStore: new FileCodexChannelSessionStore({
             resolvePath: (agentId) => resolveCodexSessionMapPath(config.stateRootDir, agentId),
@@ -99,7 +111,10 @@ function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, t
         stateRootDir: config.stateRootDir,
         gateEnabled: connectionsStateGateEnabled,
         logger: debugLogger,
-    }), config.resolveStableAgentId, debugLogger);
+    }), config.resolveStableAgentId, debugLogger, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+    });
     return new CodexProviderAdapter(cli, turnPreparer);
 }
 export function createProvider(config, debugLogger, options = {}) {
@@ -112,6 +127,7 @@ export function createProvider(config, debugLogger, options = {}) {
     const skillRuntimeGateEnabled = routingConfig.compatibilityGates.has(SKILL_RUNTIME_COMPATIBILITY_GATE);
     const localhostGatewayGateEnabled = routingConfig.compatibilityGates.has(LOCALHOST_GATEWAY_COMPATIBILITY_GATE);
     const policyAuditGateEnabled = routingConfig.compatibilityGates.has(POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE);
+    const idleBackendShutdownMs = resolveIdleBackendShutdownMs(config.providerIdleShutdownMinutes, routingConfig.compatibilityGates);
     const channelContextStore = contextInjectionGateEnabled
         ? new FileChannelContextStore(config.stateRootDir, {
             skillRuntimeEnabled: skillRuntimeGateEnabled,
@@ -124,16 +140,16 @@ export function createProvider(config, debugLogger, options = {}) {
     const turnPreparer = new ProviderTurnPreparer(channelContextStore, debugLogger);
     switch (config.provider) {
         case 'claude': {
-            return createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer);
+            return createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs);
         }
         case 'codex': {
             if (!routingConfig.compatibilityGates.has(CODEX_PROVIDER_COMPATIBILITY_GATE)) {
                 throw new Error(`Unsupported provider: ${String(config.provider)} (enable ${CODEX_PROVIDER_COMPATIBILITY_GATE})`);
             }
-            return createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer);
+            return createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs);
         }
         case 'copilot': {
-            return createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, resolveCopilotImplementation(routingConfig), turnPreparer, policyAuditGateEnabled, options.authorizationAuditSink);
+            return createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, resolveCopilotImplementation(routingConfig), turnPreparer, policyAuditGateEnabled, options.authorizationAuditSink, idleBackendShutdownMs);
         }
         default:
             throw new Error(`Unsupported provider: ${String(config.provider)}`);

package/dist/providers/idle-backend-shutdown.d.ts

@@ -0,0 +1,16 @@
+export declare const IDLE_BACKEND_SHUTDOWN_DISABLED_MS = 0;
+export declare function resolveIdleBackendShutdownMs(idleShutdownMinutes: number, compatibilityGates: ReadonlySet<string>): number;
+export interface IdleBackendShutdownSchedulerOptions {
+    idleShutdownMs: number;
+    isIdle: () => boolean;
+    shutdown: () => Promise<void>;
+    onShutdownFailed: (error: unknown) => void;
+}
+export declare class IdleBackendShutdownScheduler {
+    private readonly options;
+    private timer?;
+    constructor(options: IdleBackendShutdownSchedulerOptions);
+    get enabled(): boolean;
+    cancel(): void;
+    reconcile(): void;
+}