@borgee/agents-host 0.1.8 → 0.2.1

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

@@ -1,5 +1,7 @@
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
+import type { ProviderGenerateOptions } from '../../types.js';
+import type { CopilotChannelSessionStore } from './session-store.js';
 interface CopilotAcpRuntime {
     spawn: typeof spawn;
     client: typeof client;
@@ -21,8 +23,11 @@ interface CopilotAcpRuntime {
  */
 export declare class CopilotCliClient {
     private readonly command;
+    private readonly sessionStore?;
+    private readonly resolveSessionStoreAgentId;
     private readonly runtime;
     private readonly channels;
+    private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
     private readonly pendingSessionCloses;
@@ -37,14 +42,22 @@ export declare class CopilotCliClient {
     private fatalError;
     private disposing;
     private backendClosed;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>);
-    generateReply(channelId: string, prompt: string): Promise<string>;
+    private loadedSessionStoreAgentId;
+    private sessionStoreLoadPromise;
+    private sessionStoreWriteQueue;
+    private sessionCapabilities;
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined);
+    generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
     private ensureStarted;
     private startBackend;
     private getOrCreateChannelState;
     private processChannelQueue;
     private getOrCreateSession;
+    private startFreshSession;
+    private restoreOrCreateSession;
+    private restoreSession;
+    private clearBufferedSessionReplay;
     private runTurn;
     private raceWithFatal;
     private failAll;
@@ -53,6 +66,12 @@ export declare class CopilotCliClient {
     private rejectQueuedTurnsAfterSessionTaint;
     private clearIdleTimer;
     private reconcileIdleChannelState;
+    private ensureSessionStoreLoaded;
+    private persistSession;
+    private persistSessionBestEffort;
+    private clearPersistedSession;
+    private clearPersistedSessionBestEffort;
+    private flushSessionStore;
     private evictIdleChannel;
     private shutdownBackend;
     private waitForPendingSessionStarts;

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

@@ -17,7 +17,92 @@ const DEFAULT_RUNTIME = {
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
 };
-function createDeferredTurn(prompt) {
+const DEFAULT_SESSION_CAPABILITIES = {
+    loadSession: false,
+    resumeSession: false,
+};
+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 +112,7 @@ function createDeferredTurn(prompt) {
     });
     return {
         prompt,
+        options,
         promise,
         resolve(value) {
             if (settled)
@@ -45,6 +131,24 @@ function createDeferredTurn(prompt) {
 function normalizeError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
+function asObject(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+function isStaleRestoreFailure(error) {
+    const message = normalizeError(error).message.toLowerCase();
+    return message.includes('session not found')
+        || message.includes('unknown session')
+        || message.includes('cannot resume')
+        || message.includes('not found');
+}
+function readSessionCapabilities(response) {
+    const agentCapabilities = asObject(asObject(response)?.agentCapabilities);
+    const sessionCapabilities = asObject(agentCapabilities?.sessionCapabilities ?? agentCapabilities?.session);
+    return {
+        loadSession: agentCapabilities?.loadSession === true,
+        resumeSession: asObject(sessionCapabilities?.resume) !== null,
+    };
+}
 function markSessionTainted(error) {
     const normalized = normalizeError(error);
     SESSION_TAINTED_ERRORS.add(normalized);
@@ -71,8 +175,11 @@ function selectPermissionOption(options) {
  */
 export class CopilotCliClient {
     command;
+    sessionStore;
+    resolveSessionStoreAgentId;
     runtime;
     channels = new Map();
+    persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
     pendingSessionCloses = new Set();
@@ -87,21 +194,27 @@ export class CopilotCliClient {
     fatalError = null;
     disposing = false;
     backendClosed = false;
-    constructor(command, _ignoredArgs = [], runtimeOverrides = {}) {
+    loadedSessionStoreAgentId = null;
+    sessionStoreLoadPromise = null;
+    sessionStoreWriteQueue = Promise.resolve();
+    sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined) {
         this.command = command;
+        this.sessionStore = sessionStore;
+        this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
         this.fatalPromise = new Promise((_, reject) => {
             this.rejectFatalPromise = reject;
         });
         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;
@@ -166,7 +279,7 @@ export class CopilotCliClient {
             }
         });
         try {
-            await connection.agent.request(this.runtime.methods.agent.initialize, {
+            const initializeResponse = await connection.agent.request(this.runtime.methods.agent.initialize, {
                 protocolVersion: this.runtime.protocolVersion,
                 clientCapabilities: {},
                 clientInfo: {
@@ -174,6 +287,7 @@ export class CopilotCliClient {
                     version: '0.1.6',
                 },
             });
+            this.sessionCapabilities = readSessionCapabilities(initializeResponse);
         }
         catch (error) {
             const normalized = new Error(`Copilot ACP initialize failed: ${normalizeError(error).message}`);
@@ -211,7 +325,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)) {
@@ -246,7 +360,11 @@ export class CopilotCliClient {
         if (!this.connection) {
             throw new Error('Copilot ACP connection is not available');
         }
-        const sessionPromise = this.connection.agent.buildSession(this.runtime.cwd).start();
+        await this.ensureSessionStoreLoaded();
+        const persistedSessionId = this.persistedSessions.get(channelId);
+        const sessionPromise = persistedSessionId
+            ? this.restoreOrCreateSession(channelId, persistedSessionId)
+            : this.startFreshSession(channelId);
         this.pendingSessionStarts.add(sessionPromise);
         state.sessionPromise = sessionPromise;
         let sessionAdopted = false;
@@ -281,12 +399,75 @@ export class CopilotCliClient {
             }
         }
     }
-    async runTurn(session, prompt) {
+    async startFreshSession(channelId) {
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+        const session = await this.connection.agent.buildSession(this.runtime.cwd).start();
+        await this.persistSessionBestEffort(channelId, session.sessionId);
+        return session;
+    }
+    async restoreOrCreateSession(channelId, sessionId) {
+        if (!this.sessionCapabilities.resumeSession && !this.sessionCapabilities.loadSession) {
+            return this.startFreshSession(channelId);
+        }
+        try {
+            return await this.restoreSession(sessionId);
+        }
+        catch (error) {
+            if (!isStaleRestoreFailure(error)) {
+                throw normalizeError(error);
+            }
+            await this.clearPersistedSessionBestEffort(channelId);
+            return this.startFreshSession(channelId);
+        }
+    }
+    async restoreSession(sessionId) {
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+        const agent = this.connection.agent;
+        if (typeof agent.attachSession !== 'function') {
+            throw new Error('Copilot ACP SDK does not expose session attachment helpers');
+        }
+        const session = agent.attachSession({ sessionId });
+        try {
+            if (this.sessionCapabilities.resumeSession) {
+                await this.connection.agent.request(this.runtime.methods.agent.session.resume, {
+                    sessionId,
+                    cwd: this.runtime.cwd,
+                    mcpServers: [],
+                });
+                return session;
+            }
+            if (this.sessionCapabilities.loadSession) {
+                await this.connection.agent.request(this.runtime.methods.agent.session.load, {
+                    sessionId,
+                    cwd: this.runtime.cwd,
+                    mcpServers: [],
+                });
+                this.clearBufferedSessionReplay(session);
+                return session;
+            }
+            throw new Error('Copilot ACP agent does not advertise session restore capabilities');
+        }
+        catch (error) {
+            session.dispose();
+            throw normalizeError(error);
+        }
+    }
+    clearBufferedSessionReplay(session) {
+        const updates = session.updates;
+        if (updates && Array.isArray(updates.values)) {
+            updates.values = [];
+        }
+    }
+    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 +490,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) {
@@ -359,6 +537,12 @@ export class CopilotCliClient {
             state.session = undefined;
         }
         this.closeSession(session);
+        for (const [channelId, candidate] of this.channels.entries()) {
+            if (candidate === state) {
+                void this.clearPersistedSessionBestEffort(channelId);
+                break;
+            }
+        }
     }
     closeSession(session) {
         if (this.closingSessions.has(session)) {
@@ -428,6 +612,78 @@ export class CopilotCliClient {
             this.evictIdleChannel(channelId, state, generation);
         }, this.runtime.idleSessionTtlMs);
     }
+    async ensureSessionStoreLoaded() {
+        if (!this.sessionStore) {
+            return;
+        }
+        const agentId = this.resolveSessionStoreAgentId()?.trim();
+        if (!agentId) {
+            return;
+        }
+        if (this.loadedSessionStoreAgentId === agentId) {
+            return;
+        }
+        if (!this.sessionStoreLoadPromise) {
+            this.sessionStoreLoadPromise = (async () => {
+                const loaded = await this.sessionStore.load(agentId);
+                this.persistedSessions.clear();
+                for (const [channelId, sessionId] of Object.entries(loaded)) {
+                    this.persistedSessions.set(channelId, sessionId);
+                }
+                this.loadedSessionStoreAgentId = agentId;
+            })().finally(() => {
+                this.sessionStoreLoadPromise = null;
+            });
+        }
+        await this.sessionStoreLoadPromise;
+    }
+    async persistSession(channelId, sessionId) {
+        await this.ensureSessionStoreLoaded();
+        this.persistedSessions.set(channelId, sessionId);
+        await this.flushSessionStore();
+    }
+    async persistSessionBestEffort(channelId, sessionId) {
+        try {
+            await this.persistSession(channelId, sessionId);
+        }
+        catch (error) {
+            console.error('[agents-host] failed to persist Copilot session map; keeping reply delivery', {
+                agentId: this.loadedSessionStoreAgentId,
+                channelId,
+                sessionId,
+                error,
+            });
+        }
+    }
+    async clearPersistedSession(channelId) {
+        await this.ensureSessionStoreLoaded();
+        if (!this.persistedSessions.delete(channelId)) {
+            return;
+        }
+        await this.flushSessionStore();
+    }
+    async clearPersistedSessionBestEffort(channelId) {
+        try {
+            await this.clearPersistedSession(channelId);
+        }
+        catch (error) {
+            console.error('[agents-host] failed to clear Copilot session map; retrying in-memory only', {
+                agentId: this.loadedSessionStoreAgentId,
+                channelId,
+                error,
+            });
+        }
+    }
+    async flushSessionStore() {
+        if (!this.sessionStore || !this.loadedSessionStoreAgentId) {
+            return;
+        }
+        const agentId = this.loadedSessionStoreAgentId;
+        const snapshot = Object.fromEntries(this.persistedSessions.entries());
+        const write = this.sessionStoreWriteQueue.then(() => this.sessionStore.save(agentId, snapshot));
+        this.sessionStoreWriteQueue = write.catch(() => { });
+        await write;
+    }
     evictIdleChannel(channelId, state, generation) {
         if (this.disposing || this.fatalError || this.backendClosed) {
             return;

package/dist/providers/copilot/session-store.d.ts

@@ -0,0 +1,14 @@
+export interface CopilotChannelSessionStore {
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}
+export interface FileCopilotChannelSessionStoreOptions {
+    resolvePath(agentId: string): string;
+}
+export declare class FileCopilotChannelSessionStore implements CopilotChannelSessionStore {
+    private readonly options;
+    constructor(options: FileCopilotChannelSessionStoreOptions);
+    private loadFromPath;
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}

package/dist/providers/copilot/session-store.js

@@ -0,0 +1,97 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+async function syncDirectory(path) {
+    const directoryHandle = await open(path, 'r');
+    try {
+        await directoryHandle.sync();
+    }
+    finally {
+        await directoryHandle.close();
+    }
+}
+function normalizePersistedSessions(raw, filePath) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new Error(`invalid Copilot session file: ${filePath}`);
+    }
+    const entries = Object.entries(raw);
+    const sessions = {};
+    for (const [channelId, sessionId] of entries) {
+        if (typeof sessionId !== 'string' || sessionId.trim().length === 0) {
+            throw new Error(`invalid Copilot session file: ${filePath}`);
+        }
+        sessions[channelId] = sessionId;
+    }
+    return sessions;
+}
+export class FileCopilotChannelSessionStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async loadFromPath(filePath) {
+        const raw = await readFile(filePath, 'utf8');
+        return normalizePersistedSessions(JSON.parse(raw), filePath);
+    }
+    async load(agentId) {
+        const filePath = this.options.resolvePath(agentId);
+        try {
+            return await this.loadFromPath(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            return {};
+        }
+    }
+    async save(agentId, sessions) {
+        const filePath = this.options.resolvePath(agentId);
+        const parentPath = dirname(filePath);
+        await mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0) {
+            try {
+                await unlink(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                return;
+            }
+            await syncDirectory(parentPath);
+            return;
+        }
+        const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryHandle;
+        try {
+            temporaryHandle = await open(temporaryPath, 'wx', 0o600);
+            await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
+                encoding: 'utf8',
+            });
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            await rename(temporaryPath, filePath);
+            await syncDirectory(parentPath);
+        }
+        catch (error) {
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                }
+                catch {
+                    // Preserve the original durability failure.
+                }
+            }
+            try {
+                await unlink(temporaryPath);
+            }
+            catch {
+                // Cleanup is best effort.
+            }
+            throw error;
+        }
+    }
+}

package/dist/providers/create-provider.js

@@ -1,17 +1,24 @@
 import { ClaudeCliClient } from './claude/cli-client.js';
 import { ClaudeProviderAdapter } from './claude/adapter.js';
+import { FileClaudeChannelSessionStore } from './claude/session-store.js';
 import { CopilotCliClient } from './copilot/cli-client.js';
 import { CopilotProviderAdapter } from './copilot/adapter.js';
+import { FileCopilotChannelSessionStore } from './copilot/session-store.js';
+import { resolveClaudeSessionMapPath, resolveCopilotSessionMapPath } from '../state-paths.js';
 export function createProvider(config) {
     switch (config.provider) {
         case 'claude': {
-            const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs);
+            const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs, {}, new FileClaudeChannelSessionStore({
+                resolvePath: (agentId) => resolveClaudeSessionMapPath(config.stateRootDir, agentId),
+            }), config.resolveStableAgentId);
             return new ClaudeProviderAdapter(cli);
         }
         case 'copilot': {
             const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
                 idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
-            });
+            }, new FileCopilotChannelSessionStore({
+                resolvePath: (agentId) => resolveCopilotSessionMapPath(config.stateRootDir, agentId),
+            }), config.resolveStableAgentId);
             return new CopilotProviderAdapter(cli);
         }
         default:

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/state-paths.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveSingleAgentStateRoot(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
+export declare function resolveManagedStateRoot(rootPath: string): string;
+export declare function resolveLocalConfigAgentStateRoot(rootPath: string, agentKey: string): string;
+export declare function resolveAgentCursorPath(stateRootDir: string, agentId: string): string;
+export declare function resolveClaudeSessionMapPath(stateRootDir: string, agentId: string): string;
+export declare function resolveCopilotSessionMapPath(stateRootDir: string, agentId: string): string;

package/dist/state-paths.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+const SINGLE_AGENT_HOME_ROOT = '.borgee';
+const AGENTS_HOST_ROOT = 'agents-host';
+const SINGLE_AGENT_NAMESPACE = 'single-agent';
+const MANAGED_STATE_DIRNAME = '.state';
+const STATE_ROOT_LABEL_MAX_LENGTH = 48;
+function encodeSegment(value) {
+    return encodeURIComponent(value);
+}
+function sanitizeStateRootLabel(agentKey) {
+    const sanitized = encodeSegment(agentKey)
+        .toLowerCase()
+        .replace(/%/g, '-')
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, STATE_ROOT_LABEL_MAX_LENGTH);
+    return sanitized.length > 0 ? sanitized : 'agent';
+}
+function hashStateRootKey(agentKey) {
+    return createHash('sha256').update(agentKey).digest('hex').slice(0, 12);
+}
+export function resolveSingleAgentStateRoot(env = process.env, resolvedHomeDir = homedir()) {
+    const home = env.HOME?.trim() || resolvedHomeDir.trim();
+    if (!home) {
+        throw new Error('Unable to resolve a user home directory for agents-host state');
+    }
+    return join(home, SINGLE_AGENT_HOME_ROOT, AGENTS_HOST_ROOT, SINGLE_AGENT_NAMESPACE);
+}
+export function resolveManagedStateRoot(rootPath) {
+    return join(resolve(rootPath), MANAGED_STATE_DIRNAME);
+}
+export function resolveLocalConfigAgentStateRoot(rootPath, agentKey) {
+    return join(resolveManagedStateRoot(rootPath), `${sanitizeStateRootLabel(agentKey)}-${hashStateRootKey(agentKey)}`);
+}
+export function resolveAgentCursorPath(stateRootDir, agentId) {
+    return join(stateRootDir, `bpp-cursor-${encodeSegment(agentId)}.json`);
+}
+export function resolveClaudeSessionMapPath(stateRootDir, agentId) {
+    return join(stateRootDir, `claude-channel-sessions-${encodeSegment(agentId)}.json`);
+}
+export function resolveCopilotSessionMapPath(stateRootDir, agentId) {
+    return join(stateRootDir, `copilot-channel-sessions-${encodeSegment(agentId)}.json`);
+}

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface ProviderCommandConfig {
 }
 export interface ProviderRuntimeConfig extends ProviderCommandConfig {
     provider: ProviderKind;
+    stateRootDir: string;
+    resolveStableAgentId?: () => string | undefined;
 }
 export interface HostedAgentConfig {
     agentApiKey: string;
@@ -16,6 +18,7 @@ export interface HostedAgentConfig {
 }
 export interface AgentsHostConfig extends ProviderCommandConfig {
     borgeeBaseUrl: string;
+    stateRootDir: string;
     agent: HostedAgentConfig;
 }
 export interface LocalHostConfigFile {
@@ -106,3 +109,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;
+}