@borgee/agents-host 0.2.62 → 0.2.65

package/dist/agents-host.d.ts

@@ -1,6 +1,6 @@
 import type { ChatControlPlane } from './chat/chat-control-plane.js';
 import { type AgentsHostRuntimeOptions } from './debug.js';
-import type { ProviderAdapter } from './providers/provider-adapter.js';
+import { type ProviderAdapter } from './providers/provider-adapter.js';
 import type { AgentsHostConfig } from './types.js';
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
@@ -160,6 +160,8 @@ export declare class AgentsHost {
     private readCollaborationDraft;
     private supersedeActiveTurn;
     private invalidateChannelTurn;
+    private stopTurn;
+    private responseStateForExecuted;
     private rememberRecentTurn;
     private resolveAuthorizedCollaborationTurn;
     private updateAwaitingUserState;

package/dist/agents-host.js

@@ -12,6 +12,7 @@ import { createLocalhostGatewayController, LOCALHOST_GATEWAY_COLLABORATION_TARGE
 import { extractTaskIdFromTaskAssignmentContent, resolveTaskAssignmentStatePath, } from './context/injection.js';
 import { AuthorizationAuditSink, } from './policy/authorization-audit.js';
 import { createProvider } from './providers/create-provider.js';
+import { ProviderTurnCancelledError } from './providers/provider-adapter.js';
 import { resolveAttentionStatePath, resolveCompactionStatePath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
 import { appendVisibleMention as appendVisibleBodyMention, extractVisibleMentionIds as extractCanonicalMentionIds, } from './visible-mentions.js';
 import { buildHostedIncomingContentText, buildHostedTurnContentParts, extractHostedMessageAttachments, normalizeHostedMessageAttachment, } from './hosted-turn-content.js';
@@ -24,6 +25,9 @@ const PROTOCOL_KICKOFF_DECISION_POLL_INTERVAL_MS = 50;
 const PROTOCOL_KICKOFF_ROUND_LIMIT = 20;
 const COLLABORATION_LATE_SEND_GRACE_MS = 5_000;
 const ORDINARY_HUMAN_EVENT_KINDS = new Set(['', 'message']);
+const TASK_EXECUTION_LOCAL_DIRECTORY_PROPERTY_KEY = 'execution.local_directory';
+const TASK_EXECUTION_LOCAL_DIRECTORY_REMINDER = 'This task has no Execution Local Directory yet. Set it before asking me to work in a real local project directory.';
+const TASK_EXECUTION_LOCAL_DIRECTORY_IN_USE_PREFIX = 'Using Execution Local Directory:';
 async function ensurePrivateStateRoot(path) {
     await mkdir(path, { recursive: true, mode: PRIVATE_STATE_ROOT_MODE });
     await chmod(path, PRIVATE_STATE_ROOT_MODE);
@@ -145,13 +149,15 @@ class DefaultHostRuntime {
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
     }
-    async start(onMessage) {
+    async start(onMessage, onStopTurn) {
         await this.ensureStateRoot(this.config.stateRootDir);
         await this.gateway.start();
         try {
+            this.controlPlane.onStopTurn?.(onStopTurn);
             await this.controlPlane.connect(onMessage);
         }
         catch (error) {
+            this.controlPlane.onStopTurn?.(undefined);
             await this.gateway.stop().catch(() => { });
             throw error;
         }
@@ -159,6 +165,7 @@ class DefaultHostRuntime {
     async stop() {
         let thrown;
         try {
+            this.controlPlane.onStopTurn?.(undefined);
             await this.controlPlane.close();
         }
         catch (error) {
@@ -366,7 +373,7 @@ export class AgentsHost {
                     return;
                 }
                 this.dispatchMessage(message);
-            });
+            }, async (channelId) => this.stopTurn(channelId));
             const agentId = await this.ensureSelfAgentId();
             bufferingMessages = false;
             while (bufferedMessages.length > 0) {
@@ -675,7 +682,7 @@ export class AgentsHost {
             return null;
         }
         this.recordCollaborationOutcome(msg.channel_id, {
-            responseState: executed.completed ? 'responded' : 'failed',
+            responseState: this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
         });
         this.updateMissedCollaborationDiagnostic(msg.channel_id, priorMissedCollaborationDiagnostic);
@@ -1110,7 +1117,7 @@ export class AgentsHost {
         channelState.blocked = undefined;
         this.awaitingUserByChannel.delete(channelId);
         this.recordCollaborationOutcome(channelId, {
-            responseState: executed.completed ? 'responded' : 'failed',
+            responseState: this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
             ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
             turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1174,7 +1181,7 @@ export class AgentsHost {
         const visibleMessageId = deliveredMessageId ?? protocolState.lastProtocolMessageId;
         if (executed.reply?.controlMalformed) {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1184,7 +1191,7 @@ export class AgentsHost {
         }
         if (!executed.reply?.control) {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1218,7 +1225,7 @@ export class AgentsHost {
         }
         if (executed.reply.control.kind === 'start-protocol') {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1229,7 +1236,7 @@ export class AgentsHost {
         }
         if (executed.reply.control.kind === 'attention-only') {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -2188,9 +2195,7 @@ export class AgentsHost {
         this.recordCollaborationOutcome(msg.channel_id, {
             responseState: executed.completed && executed.reply?.awaitingUser
                 ? 'blocked'
-                : executed.completed
-                    ? 'responded'
-                    : 'failed',
+                : this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
             ...(executed.completed && executed.reply?.awaitingUser
                 ? {
@@ -2444,6 +2449,65 @@ export class AgentsHost {
                     turnExecutionId: activeTurn.turnExecutionId,
                 });
             }
+            if (error instanceof ProviderTurnCancelledError) {
+                const cancelledReplyText = error.publicReplyText?.trim();
+                if (!silentTurn &&
+                    !deferDelivery &&
+                    typeof cancelledReplyText === 'string' &&
+                    cancelledReplyText.length > 0 &&
+                    this.started &&
+                    !this.controlPlaneClosed) {
+                    reply = { text: cancelledReplyText };
+                    publicReplyText = cancelledReplyText;
+                    visibleReplyBody = this.resolveVisibleTurnBody(activeTurn, reply, publicReplyText);
+                    try {
+                        const posted = await this.borgee.postMessage({
+                            channelId,
+                            body: visibleReplyBody,
+                            replyToId: activeTurn?.delivery?.replyToId,
+                        });
+                        this.logger.debug('posted cancelled turn feedback', {
+                            ...turnContext,
+                            durationMs: Date.now() - turnStartedAt,
+                            replyLength: publicReplyText.length,
+                            delivery: 'post',
+                        });
+                        return {
+                            reply,
+                            deliveredMessageId: posted.messageId,
+                            publicReplyText,
+                            visibleReplyBody,
+                            deliveryState: 'posted',
+                            stale: activeTurn?.superseded === true,
+                            completed: false,
+                            cancelled: true,
+                        };
+                    }
+                    catch (postError) {
+                        this.logger.debugError('failed to post cancelled turn feedback', {
+                            ...turnContext,
+                            error: postError,
+                        });
+                        this.logger.error('failed to post cancelled turn feedback', {
+                            ...turnContext,
+                            error: summarizeError(postError),
+                        });
+                    }
+                }
+                this.logger.debug('cancelled turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                });
+                return {
+                    reply,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: 'not-delivered',
+                    stale: activeTurn?.superseded === true,
+                    completed: false,
+                    cancelled: true,
+                };
+            }
             this.logger.debugError('failed to generate or send reply', {
                 ...turnContext,
                 error,
@@ -2655,6 +2719,29 @@ export class AgentsHost {
             activeTurn.turnExecutionId = null;
         }
     }
+    async stopTurn(channelId) {
+        const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;
+        const aborted = await this.provider.cancelTurn?.(channelId) ?? false;
+        if (!aborted) {
+            return { aborted: false };
+        }
+        if (activeTurn) {
+            this.supersedeActiveTurn(channelId, activeTurn);
+        }
+        else {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'superseded',
+                deliveryState: 'not-delivered',
+            });
+        }
+        return { aborted: true };
+    }
+    responseStateForExecuted(executed) {
+        if (executed.cancelled) {
+            return 'superseded';
+        }
+        return executed.completed ? 'responded' : 'failed';
+    }
     rememberRecentTurn(channelState, activeTurn) {
         if (!activeTurn.turnExecutionId) {
             channelState.recentTurn = undefined;
@@ -2853,6 +2940,34 @@ export class AgentsHost {
             task = null;
         }
         if (task && task.assigneeId === selfAgentId) {
+            const executionLocalDirectory = task.properties?.[TASK_EXECUTION_LOCAL_DIRECTORY_PROPERTY_KEY];
+            if (typeof executionLocalDirectory !== 'string' || executionLocalDirectory.trim().length === 0) {
+                try {
+                    await this.borgee.postMessage({
+                        channelId: msg.channel_id,
+                        body: TASK_EXECUTION_LOCAL_DIRECTORY_REMINDER,
+                    });
+                }
+                catch (error) {
+                    this.logger.debugError('task local directory reminder post failed', {
+                        channelId: msg.channel_id,
+                        error,
+                    });
+                }
+                return null;
+            }
+            try {
+                await this.borgee.postMessage({
+                    channelId: msg.channel_id,
+                    body: `${TASK_EXECUTION_LOCAL_DIRECTORY_IN_USE_PREFIX} ${executionLocalDirectory}`,
+                });
+            }
+            catch (error) {
+                this.logger.debugError('task local directory notice post failed', {
+                    channelId: msg.channel_id,
+                    error,
+                });
+            }
             if (task.status === 'open') {
                 try {
                     await this.borgee.updateTask({

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

@@ -1,6 +1,7 @@
-import type { ReportTurnActivityInput, TurnActivityReporter } from '../plugin-sdk.js';
+import type { ReportTurnActivityInput, StopTurnHandler, TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 export interface ChatControlPlane {
+    onStopTurn?(handler: StopTurnHandler | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;

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

@@ -1,7 +1,7 @@
-import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type TurnActivityReporter } from '../plugin-sdk.js';
+import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type StopTurnHandler, type TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 import type { ChatControlPlane } from './chat-control-plane.js';
-type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'onStopTurn' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
 type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'pluginId'>;
 /**
@@ -16,6 +16,7 @@ export declare class SdkChatControlPlane implements ChatControlPlane {
     private connected;
     private me;
     constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, options?: SdkChatControlPlaneOptions);
+    onStopTurn(handler: StopTurnHandler | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;

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

@@ -14,6 +14,9 @@ export class SdkChatControlPlane {
     constructor(baseUrl, apiKey, createClient = createBorgeePlugin, options = {}) {
         this.client = createClient({ baseUrl, apiKey, ...options });
     }
+    onStopTurn(handler) {
+        this.client.onStopTurn(handler);
+    }
     async connect(onMessage) {
         this.unsubscribe = this.client.on('message', (event) => {
             const message = mapInboundToChannelMessage(event);
@@ -46,6 +49,7 @@ export class SdkChatControlPlane {
         this.pendingMessages = [];
         this.unsubscribe?.();
         this.unsubscribe = null;
+        this.client.onStopTurn(undefined);
         await this.client.close();
     }
     async postMessage(input) {

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

@@ -9,5 +9,6 @@ export declare class ClaudeProviderAdapter implements ProviderAdapter {
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -25,6 +25,9 @@ export class ClaudeProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async dispose() {
         await this.cli.dispose();
     }

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

@@ -43,6 +43,7 @@ export declare class ClaudeCliClient {
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId: string): string | undefined;
+    cancelTurn(channelId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;

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

@@ -9,6 +9,7 @@ import { assertClaudeCommandCompatibility, DEFAULT_CLAUDE_COMMAND, isLegacyClaud
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { readClaudeActivityMetadata } from './activity-metadata.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { buildClaudeSessionPromptAppend } from '../../context/prompt.js';
@@ -32,6 +33,7 @@ const DEFAULT_SESSION_CAPABILITIES = {
 };
 const CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD_ENV = 'CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD';
 const require = createRequire(import.meta.url);
+const CLAUDE_CANCELLED_REPLY_TEXT = 'Info: Operation cancelled by user';
 const DEFAULT_RUNTIME = {
     spawn,
     client,
@@ -495,6 +497,22 @@ export class ClaudeCliClient {
     sessionIdForChannel(channelId) {
         return this.channels.get(channelId)?.session?.sessionId;
     }
+    async cancelTurn(channelId) {
+        const state = this.channels.get(channelId);
+        const session = state?.session;
+        if (!state?.activeTurn || !session) {
+            return false;
+        }
+        this.idleBackendShutdown.cancel();
+        const activeSession = session;
+        if (typeof activeSession.cancel === 'function') {
+            await activeSession.cancel({ sessionId: session.sessionId });
+            return true;
+        }
+        const cancelMethod = this.runtime.methods.agent.session?.cancel ?? 'session/cancel';
+        await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
+        return true;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -975,6 +993,11 @@ export class ClaudeCliClient {
                     throw markSessionTainted(error);
                 }
                 const output = collector.getFinalText();
+                if (response.stopReason === 'cancelled') {
+                    throw new ProviderTurnCancelledError('Claude ACP turn cancelled', {
+                        publicReplyText: hasVisibleText(output) ? output : CLAUDE_CANCELLED_REPLY_TEXT,
+                    });
+                }
                 if (response.stopReason !== 'end_turn' && !hasVisibleText(output)) {
                     throw new Error(`Claude ACP turn stopped with stopReason "${response.stopReason}"`);
                 }

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

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

package/dist/providers/codex/adapter.js

@@ -25,6 +25,9 @@ export class CodexProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async dispose() {
         await this.cli.dispose();
     }

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

@@ -49,6 +49,7 @@ export declare class CodexCliClient {
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId: string): string | undefined;
+    cancelTurn(channelId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;

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

@@ -6,6 +6,7 @@ import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 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';
@@ -34,6 +35,7 @@ const CODEX_CONTEXT_ROOT_DIRNAME = 'codex-context';
 const PROJECTION_UNAVAILABLE_PLACEHOLDER = '[codex-projection-unavailable]';
 const QUEUED_TURN_DROPPED_MESSAGE = 'Codex ACP session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
 const require = createRequire(import.meta.url);
+const CODEX_CANCELLED_REPLY_TEXT = 'Info: Operation cancelled by user';
 const DEFAULT_RUNTIME = {
     spawn,
     client,
@@ -230,6 +232,23 @@ export class CodexCliClient {
     sessionIdForChannel(channelId) {
         return this.channels.get(channelId)?.session?.sessionId;
     }
+    async cancelTurn(channelId) {
+        const state = this.channels.get(channelId);
+        const session = state?.session;
+        if (!state?.activeTurn || !session) {
+            return false;
+        }
+        this.clearIdleTimer(state);
+        this.idleBackendShutdown.cancel();
+        const activeSession = session;
+        if (typeof activeSession.cancel === 'function') {
+            await activeSession.cancel({ sessionId: session.sessionId });
+            return true;
+        }
+        const cancelMethod = this.runtime.methods.agent.session?.cancel ?? 'session/cancel';
+        await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
+        return true;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -831,10 +850,15 @@ export class CodexCliClient {
                 catch (error) {
                     throw markSessionTainted(error);
                 }
+                const output = collector.getFinalText();
+                if (response.stopReason === 'cancelled') {
+                    throw new ProviderTurnCancelledError('Codex ACP turn cancelled', {
+                        publicReplyText: output || CODEX_CANCELLED_REPLY_TEXT,
+                    });
+                }
                 if (response.stopReason !== 'end_turn') {
                     throw new Error(`Codex ACP turn stopped with stopReason "${response.stopReason}"`);
                 }
-                const output = collector.getFinalText();
                 if (!output) {
                     throw new Error('Codex ACP returned empty output');
                 }

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

@@ -9,5 +9,6 @@ export declare class CopilotProviderAdapter implements ProviderAdapter {
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: CopilotCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -25,6 +25,9 @@ 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) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async dispose() {
         await this.cli.dispose();
     }

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

@@ -51,6 +51,7 @@ export declare class CopilotCliClient {
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId: string): string | undefined;
+    cancelTurn(channelId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;

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

@@ -3,6 +3,7 @@ import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
@@ -170,6 +171,23 @@ export class CopilotCliClient {
     sessionIdForChannel(channelId) {
         return this.channels.get(channelId)?.session?.sessionId;
     }
+    async cancelTurn(channelId) {
+        const state = this.channels.get(channelId);
+        const session = state?.session;
+        if (!state?.activeTurn || !session) {
+            return false;
+        }
+        this.clearIdleTimer(state);
+        this.idleBackendShutdown.cancel();
+        const activeSession = session;
+        if (typeof activeSession.cancel === 'function') {
+            await activeSession.cancel({ sessionId: session.sessionId });
+            return true;
+        }
+        const cancelMethod = this.runtime.methods.agent.session?.cancel ?? 'session/cancel';
+        await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
+        return true;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -651,6 +669,9 @@ export class CopilotCliClient {
                 catch (error) {
                     throw markSessionTainted(error);
                 }
+                if (response.stopReason === 'cancelled') {
+                    throw new ProviderTurnCancelledError('Copilot ACP turn cancelled');
+                }
                 if (response.stopReason !== 'end_turn') {
                     throw new Error(`Copilot ACP turn stopped with stopReason "${response.stopReason}"`);
                 }

package/dist/providers/create-provider.js

@@ -30,6 +30,9 @@ class ProviderV2CompatibilityAdapter {
             turn: preparedTurn,
         }, options);
     }
+    async cancelTurn(channelId) {
+        return this.provider.cancelTurn?.(channelId) ?? false;
+    }
     async dispose() {
         await this.provider.shutdown?.();
     }
@@ -47,6 +50,9 @@ class CliBackedProviderV2 {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.turn.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async shutdown() {
         await this.cli.dispose();
     }

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

@@ -33,8 +33,15 @@ export declare function createHostedProviderCapabilities(params: {
     sharedHostFallback?: SharedHostAttachmentMetadataFallbackCapability;
 }): ProviderCapabilities;
 export declare const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES: ProviderCapabilities;
+export declare class ProviderTurnCancelledError extends Error {
+    readonly publicReplyText?: string;
+    constructor(message?: string, options?: {
+        publicReplyText?: string;
+    });
+}
 export interface ProviderAdapter {
     readonly capabilities: ProviderCapabilities;
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn?(channelId: string): Promise<boolean>;
     dispose?(): Promise<void>;
 }

package/dist/providers/provider-adapter.js

@@ -42,3 +42,11 @@ export const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabi
         delivery: [],
     },
 });
+export class ProviderTurnCancelledError extends Error {
+    publicReplyText;
+    constructor(message = 'provider turn cancelled', options) {
+        super(message);
+        this.name = 'ProviderTurnCancelledError';
+        this.publicReplyText = options?.publicReplyText;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.62",
+  "version": "0.2.65",
   "private": false,
   "publishConfig": {
     "access": "public"