@borgee/agents-host 0.2.74 → 0.2.94

package/dist/providers/claude/foreground-handoff.d.ts

@@ -0,0 +1,4 @@
+export declare const CLAUDE_FOREGROUND_HANDOFF_METHOD = "_borgee/session/foreground_handoff";
+export declare const CLAUDE_FOREGROUND_LIFECYCLE_EVENT = "settled_with_background";
+export declare function readClaudeForegroundSettledTurn(value: unknown): number | undefined;
+export declare function isClaudeUpdateFromIsolatedTurn(value: unknown, isolationFence: number | undefined): boolean;

package/dist/providers/claude/foreground-handoff.js

@@ -0,0 +1,45 @@
+const NAMESPACE = 'claudeCode';
+export const CLAUDE_FOREGROUND_HANDOFF_METHOD = '_borgee/session/foreground_handoff';
+export const CLAUDE_FOREGROUND_LIFECYCLE_EVENT = 'settled_with_background';
+function readClaudeProviderMetadata(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const meta = value._meta;
+    if (typeof meta !== 'object' || meta === null || Array.isArray(meta)) {
+        return undefined;
+    }
+    const provider = meta[NAMESPACE];
+    if (typeof provider !== 'object' || provider === null || Array.isArray(provider)) {
+        return undefined;
+    }
+    return provider;
+}
+export function readClaudeForegroundSettledTurn(value) {
+    const provider = readClaudeProviderMetadata(value);
+    const lifecycle = provider?.foregroundLifecycle;
+    if (typeof lifecycle !== 'object' || lifecycle === null || Array.isArray(lifecycle)) {
+        return undefined;
+    }
+    if (lifecycle.event !== CLAUDE_FOREGROUND_LIFECYCLE_EVENT) {
+        return undefined;
+    }
+    const foregroundTurn = lifecycle.foregroundTurn;
+    return Number.isSafeInteger(foregroundTurn) && foregroundTurn > 0
+        ? foregroundTurn
+        : undefined;
+}
+export function isClaudeUpdateFromIsolatedTurn(value, isolationFence) {
+    if (isolationFence === undefined) {
+        return false;
+    }
+    const provider = readClaudeProviderMetadata(value);
+    if (!provider) {
+        return false;
+    }
+    const foregroundTurn = provider.foregroundTurn;
+    if (Number.isSafeInteger(foregroundTurn) && foregroundTurn > 0) {
+        return foregroundTurn <= isolationFence;
+    }
+    return provider.foregroundLane === 'background';
+}

package/dist/providers/claude/task-cancellation-protocol.d.ts

@@ -0,0 +1,14 @@
+export declare const CLAUDE_TASK_CANCELLATION_METHOD = "_borgee/claude/task/cancel/v1";
+export declare const CLAUDE_TASK_CANCELLATION_VERSION = 1;
+export interface ClaudeTaskCancellationRequest {
+    sessionId: string;
+    taskId: string;
+}
+export type ClaudeTaskCancellationResponse = {
+    outcome: 'accepted';
+} | {
+    outcome: 'not_found';
+} | {
+    outcome: 'unsupported';
+};
+export declare function supportsClaudeTaskCancellation(response: unknown): boolean;

package/dist/providers/claude/task-cancellation-protocol.js

@@ -0,0 +1,21 @@
+export const CLAUDE_TASK_CANCELLATION_METHOD = '_borgee/claude/task/cancel/v1';
+export const CLAUDE_TASK_CANCELLATION_VERSION = 1;
+export function supportsClaudeTaskCancellation(response) {
+    if (typeof response !== 'object' || response === null) {
+        return false;
+    }
+    const meta = response._meta;
+    if (typeof meta !== 'object' || meta === null) {
+        return false;
+    }
+    const borgee = meta.borgee;
+    if (typeof borgee !== 'object' || borgee === null) {
+        return false;
+    }
+    const capability = borgee.claudeTaskCancellation;
+    if (typeof capability !== 'object' || capability === null) {
+        return false;
+    }
+    return (capability.version === CLAUDE_TASK_CANCELLATION_VERSION
+        && capability.method === CLAUDE_TASK_CANCELLATION_METHOD);
+}

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

@@ -7,7 +7,7 @@ export declare class CodexProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
-    constructor(cli: CodexCliClient, turnPreparer: ProviderTurnPreparer);
+    constructor(cli: CodexCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;

package/dist/providers/codex/adapter.js

@@ -7,6 +7,13 @@ export const CODEX_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabiliti
         reason: 'real-media-delivered',
         delivery: ['blob'],
     },
+    progressUpdates: {
+        support: 'supported',
+    },
+    backgroundRuns: {
+        lifecycle: 'not-supported',
+        targetedCancellation: 'not-supported',
+    },
 });
 export class CodexProviderAdapter {
     cli;

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

@@ -9,7 +9,7 @@ import { AcpProgressCollector } from '../acp-progress-collector.js';
 import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { assertCodexProjectDocumentSize, buildCodexProjectDocument } from './project-doc.js';
 import { isGatewayCredentialSidecarBasename } from '../../context/injection.js';
-import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
+import { isDiscussionOnlyResolvedWorkingFolder } from '../../context/resolved-working-folder.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();
@@ -488,7 +488,7 @@ export class CodexCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
-                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkingFolder(turn.preparedTurn.promptContext)
                             ? 'deny-all'
                             : 'default';
                         const projectedPromptContext = await this.refreshProjectedPromptContextBestEffort(turn.channelId, turn.preparedTurn.promptContext);
@@ -658,7 +658,7 @@ export class CodexCliClient {
         }
     }
     async resolveSessionCwd(promptContext) {
-        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkingFolder?.rootPath ?? this.runtime.cwd;
     }
     async recycleSessionIfInjectionScopeChanged(channelId, state) {
         const session = state.session;
@@ -969,7 +969,9 @@ export class CodexCliClient {
             policyMode: 'enforce',
             params,
             logger: this.logger,
+            agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
             channelId: state?.channelId,
+            sessionBound: state !== undefined,
             toolPermissionMode: state?.toolPermissionMode ?? 'default',
         });
     }
@@ -1136,6 +1138,7 @@ export class CodexCliClient {
             this.closeSession(session);
         }
         this.channels.delete(channelId);
+        this.idleBackendShutdown.reconcile();
     }
     async shutdownBackend(error) {
         if (this.backendClosed) {
@@ -1194,10 +1197,8 @@ export class CodexCliClient {
         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;
-            }
+        if (this.channels.size > 0) {
+            return false;
         }
         return true;
     }

package/dist/providers/codex/project-doc.js

@@ -2,12 +2,12 @@ import { buildAttentionSummaryLines } from '../../context/attention.js';
 import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from '../../context/collaboration-capabilities-diagnostics.js';
 import { buildCollaborationOutcomeSummaryLines } from '../../context/collaboration-outcome.js';
 import { MAIN_SESSION_DELEGATION_LINES } from '../../context/main-session-delegation.js';
-import { buildResolvedWorkspaceGuidanceLines } from '../../context/resolved-workspace.js';
+import { buildResolvedWorkingFolderGuidanceLines } from '../../context/resolved-working-folder.js';
 import { buildSkillManualLines, buildSkillManualReadLine } from '../../context/skill-manual.js';
 import { buildTaskThreadCollaborationSummaryLines } from '../../context/task-thread-collaboration.js';
 const PROJECT_DOC_MAX_BYTES = 32 * 1024;
 // Every command the CLI carries needs the gateway credential file, so the capability is only
-// worth naming in a workspace that also names one; otherwise the model is handed an invocation
+// worth naming in a project document that also names one; otherwise the model is handed an invocation
 // template it cannot fill.
 function buildSkillRuntimeLines(context) {
     if (!context?.skillRuntime) {
@@ -29,15 +29,15 @@ function buildGatewayCredentialLines(context) {
 export function buildCodexProjectDocument(context) {
     const sessionDelegationLines = context?.skillRuntime ? [] : MAIN_SESSION_DELEGATION_LINES;
     const lines = [
-        '# Borgee channel workspace',
+        '# Borgee channel session',
         '',
-        'This workspace belongs to one Borgee channel session hosted by agents-host.',
+        'This directory belongs to one Borgee channel session hosted by agents-host.',
         'Keep visible replies concise, do not claim actions you did not perform, and prefer the per-turn prompt when it provides newer turn-local details.',
         '',
         ...sessionDelegationLines,
         ...(() => {
-            const workspaceLines = buildResolvedWorkspaceGuidanceLines(context);
-            return workspaceLines.length > 0 ? ['', ...workspaceLines] : [];
+            const workingFolderLines = buildResolvedWorkingFolderGuidanceLines(context);
+            return workingFolderLines.length > 0 ? ['', ...workingFolderLines] : [];
         })(),
         ...(() => {
             const collaborationOutcomeLines = buildCollaborationOutcomeSummaryLines(context?.collaborationOutcome);

package/dist/providers/copilot/activity-metadata.d.ts

@@ -0,0 +1,3 @@
+import type { ProgressActivity, ProviderBackgroundRunProgress } from '../../types.js';
+/** Registry state describes background work, never a wait on the foreground turn. */
+export declare function toCopilotBackgroundActivity(sessionId: string, run: ProviderBackgroundRunProgress): ProgressActivity;

package/dist/providers/copilot/activity-metadata.js

@@ -0,0 +1,19 @@
+/** Registry state describes background work, never a wait on the foreground turn. */
+export function toCopilotBackgroundActivity(sessionId, run) {
+    const active = run.state === 'running' || run.state === 'waiting';
+    return {
+        id: `copilot-background:${sessionId}:${run.providerRunId}:${run.startedAt ?? 0}`,
+        label: run.label,
+        kind: 'other',
+        status: run.state === 'waiting' ? 'waiting'
+            : active ? 'in_progress'
+                : run.state === 'completed' ? 'completed' : 'failed',
+        subagent: true,
+        background: true,
+        backgroundState: run.state === 'cancelled' || run.state === 'unknown' ? 'failed' : run.state,
+        followUpControl: run.state === 'cancelled' || run.state === 'unknown'
+            ? 'unavailable' : 'same-session-required',
+        reason: run.reason ?? (run.state === 'cancelled' ? 'Cancelled'
+            : run.state === 'unknown' ? 'Final background state unavailable' : undefined),
+    };
+}

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

@@ -1,5 +1,5 @@
 import { type ProviderAdapter } from '../provider-adapter.js';
-import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
+import type { ProviderAutonomousReply, ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
 import { CopilotCliClient } from './cli-client.js';
 export declare const COPILOT_HOSTED_PROVIDER_CAPABILITIES: import("../provider-adapter.js").ProviderCapabilities;
@@ -7,8 +7,12 @@ export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
-    constructor(cli: CopilotCliClient, turnPreparer: ProviderTurnPreparer);
+    constructor(cli: CopilotCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    onAutonomousReply(handler: ((reply: ProviderAutonomousReply) => void) | undefined): void;
     cancelTurn(channelId: string): Promise<boolean>;
+    interruptTurn(channelId: string): Promise<boolean>;
+    cancelSession(channelId: string): Promise<boolean>;
+    cancelBackgroundRun(channelId: string, providerRunId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -7,6 +7,13 @@ export const COPILOT_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabili
         reason: 'real-media-delivered',
         delivery: ['blob'],
     },
+    progressUpdates: {
+        support: 'supported',
+    },
+    backgroundRuns: {
+        lifecycle: 'supported',
+        targetedCancellation: 'supported',
+    },
 });
 export class CopilotProviderAdapter {
     cli;
@@ -25,8 +32,27 @@ export class CopilotProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    onAutonomousReply(handler) {
+        this.cli.onAutonomousReply(handler
+            ? (reply) => {
+                const parsed = parseProviderReply(reply.text);
+                if (parsed.text.trim()) {
+                    handler({ ...reply, text: parsed.text });
+                }
+            }
+            : undefined);
+    }
     async cancelTurn(channelId) {
-        return this.cli.cancelTurn(channelId);
+        return this.cli.cancelSession(channelId);
+    }
+    async interruptTurn(channelId) {
+        return this.cli.interruptTurn(channelId);
+    }
+    async cancelSession(channelId) {
+        return this.cli.cancelSession(channelId);
+    }
+    async cancelBackgroundRun(channelId, providerRunId) {
+        return this.cli.cancelBackgroundRun(channelId, providerRunId);
     }
     async dispose() {
         await this.cli.dispose();

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

@@ -3,9 +3,12 @@ import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientpro
 import { type DebugLogger } from '../../debug.js';
 import type { InternalPolicyMode } from '../../compatibility-gates.js';
 import type { AuthorizationAuditSinkLike } from '../../policy/authorization-audit.js';
-import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
+import type { PreparedProviderTurnInput, ProviderAutonomousReply, ProviderGenerateOptions } from '../../types.js';
 import type { CopilotChannelSessionStore } from './session-store.js';
-interface CopilotAcpRuntime {
+import { type CopilotSdkClientFactory } from './sdk-session.js';
+interface CopilotRuntime {
+    transport: 'sdk' | 'acp';
+    createSdkClient: CopilotSdkClientFactory;
     spawn: typeof spawn;
     client: typeof client;
     ndJsonStream: typeof ndJsonStream;
@@ -15,6 +18,7 @@ interface CopilotAcpRuntime {
     idleSessionTtlMs: number;
     idleBackendShutdownMs: number;
     idleShutdownGracePeriodMs: number;
+    sessionCloseTimeoutMs: number;
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
     fetch(input: string | URL, init?: RequestInit): Promise<Response>;
@@ -29,12 +33,12 @@ interface CopilotHostedImageInputConfig {
     agentApiKey?: string;
 }
 /**
- * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
+ * Persistent session client for the GitHub Copilot CLI.
  *
- * 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.
+ * Production uses the Copilot SDK headless JSON-RPC transport. The ACP runtime
+ * remains injectable for compatibility tests. Both paths reuse one provider
+ * session per Borgee channel because the background-agent registry belongs to
+ * that session and later read_agent/write_agent turns must keep that identity.
  */
 export declare class CopilotCliClient {
     private readonly command;
@@ -45,15 +49,21 @@ export declare class CopilotCliClient {
     private readonly imageInputConfig;
     private readonly runtime;
     private readonly channels;
+    private readonly channelWorkerRoutes;
+    private readonly sessionAuthorizationLeases;
     /**
      * 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;
+    interruptTurn(channelId: string): Promise<boolean>;
+    cancelSession(channelId: string): Promise<boolean>;
     cancelTurn(channelId: string): Promise<boolean>;
+    cancelBackgroundRun(channelId: string, providerRunId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
+    private readonly orphanedSessions;
     private readonly pendingSessionStarts;
     private readonly pendingSessionCloses;
     private readonly pendingSessionStoreOperations;
@@ -61,6 +71,7 @@ export declare class CopilotCliClient {
     private rejectFatalPromise;
     private child?;
     private connection?;
+    private sdkClient?;
     private startPromise?;
     private shutdownPromise?;
     private childExitPromise?;
@@ -71,6 +82,7 @@ export declare class CopilotCliClient {
      */
     private backendGeneration;
     private idleShutdownPromise?;
+    private backendShutdownInProgress;
     private fatalError;
     private disposing;
     private backendClosed;
@@ -78,19 +90,25 @@ export declare class CopilotCliClient {
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
     private sessionCapabilities;
+    private backendRecycleRequired;
+    private autonomousReplyHandler?;
     private readonly idleBackendShutdown;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions, imageInputConfig?: CopilotHostedImageInputConfig);
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotRuntime>, 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>;
+    onAutonomousReply(handler: ((reply: ProviderAutonomousReply) => void) | undefined): void;
     dispose(): Promise<void>;
     private ensureStarted;
     private startBackend;
+    private startSdkBackend;
     private getOrCreateChannelState;
+    private resolveChannelState;
     private processChannelQueue;
     private getOrCreateSession;
     private startFreshSession;
     private restoreOrCreateSession;
     private restoreSession;
+    private createSdkSessionAdapter;
     private clearBufferedSessionReplay;
     private resolveSessionCwd;
     private buildPromptInput;
@@ -99,15 +117,21 @@ export declare class CopilotCliClient {
     private runTurn;
     private raceWithFatal;
     private handlePermissionRequest;
+    private handleSdkPermissionRequest;
     private failAll;
     private invalidateSession;
     private closeSession;
+    private markSessionOrphaned;
     private rejectQueuedTurnsAfterSessionTaint;
     private clearIdleTimer;
-    private findChannelStateBySessionId;
+    private bindSessionAuthorization;
+    private promoteWorkerRoute;
+    private releaseWorkerRoute;
+    private releaseInactiveWorkerRoute;
     private reconcileIdleChannelState;
     private ensureSessionStoreLoaded;
     private readPersistedSessionId;
+    private isPersistentRouteOwner;
     private persistSession;
     private persistSessionBestEffort;
     private clearPersistedSession;
@@ -119,14 +143,17 @@ export declare class CopilotCliClient {
     /**
      * 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
+     * while `isBackendIdle()` holds, because every channel's live session is
      * dropped here and no turn is ever replayed onto its successor.
      */
     private shutdownIdleBackend;
     private isBackendIdle;
+    private reconcileBackendLifecycle;
+    private releaseBackendAuthorizationLeases;
     private closeBackendProcess;
     private waitForPendingSessionStarts;
     private waitForPendingSessionCloses;
+    private waitForSessionClose;
     private waitForChildExit;
 }
 export {};