@borgee/agents-host 0.2.44 → 0.2.62

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

@@ -1,12 +1,18 @@
 import { Readable, Writable } from 'node:stream';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, resolve } from 'node:path';
 import spawn from 'cross-spawn';
+import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from '../../projection-strategy-values.js';
 import { assertClaudeCommandCompatibility, DEFAULT_CLAUDE_COMMAND, isLegacyClaudeCompatibilityAlias, } from '../../config.js';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
+import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { readClaudeActivityMetadata } from './activity-metadata.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
-import { buildSkillManualLines } from '../../context/skill-manual.js';
+import { buildClaudeSessionPromptAppend } from '../../context/prompt.js';
+import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const IDLE_BACKEND_STOPPED_MESSAGE = 'Claude ACP backend stopped after idle timeout';
@@ -24,6 +30,7 @@ const DEFAULT_SESSION_CAPABILITIES = {
     loadSession: false,
     resumeSession: false,
 };
+const CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD_ENV = 'CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD';
 const require = createRequire(import.meta.url);
 const DEFAULT_RUNTIME = {
     spawn,
@@ -111,82 +118,95 @@ class ClaudeCliProcessError extends Error {
         this.stderrLineCount = stderrLineCount;
     }
 }
-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 parseCompactionBanner(text) {
+    if (/(?:^|\n\n)Compacting\.\.\.\s*$/u.test(text)) {
+        return { stage: 'started' };
     }
+    if (/(?:^|\n\n)Compacting completed\.\s*$/u.test(text)) {
+        return { stage: 'completed' };
+    }
+    const match = /(?:^|\n\n)Compacting failed(?::\s*(.+?)|\.)\s*$/u.exec(text);
+    if (!match) {
+        return null;
+    }
+    return {
+        stage: 'failed',
+        ...(match?.[1] ? { failureReason: match[1].trim() } : {}),
+    };
 }
-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 ClaudeProgressCollector {
+class ClaudeCompactionObserver {
     onProgress;
-    publicText = '';
-    lastPublished = null;
-    toolTitles = new Map();
+    answerText = '';
+    compactionState = 'idle';
+    lastCompactionBannerKey = null;
     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();
+    consumeAnswerChunk(chunk) {
+        this.answerText += chunk;
+        this.publishCompactionFromText(this.answerText);
     }
-    publishFallback(text) {
-        if (hasVisibleText(this.publicText)) {
+    consumeUsageUpdate(usedTokens, contextWindowTokens) {
+        if (!this.onProgress || this.compactionState !== 'completed-awaiting-usage') {
             return;
         }
-        this.publish(text);
+        this.compactionState = 'idle';
+        this.onProgress({
+            type: 'compaction',
+            compaction: {
+                provider: 'claude',
+                stage: 'completed',
+                usedTokens,
+                contextWindowTokens,
+            },
+        });
     }
-    publish(text) {
-        if (!this.onProgress || !hasVisibleText(text) || text === this.lastPublished) {
+    publishCompactionFromText(text) {
+        if (!this.onProgress) {
             return;
         }
-        this.lastPublished = text;
-        this.onProgress({ text });
+        const banner = parseCompactionBanner(text);
+        if (!banner) {
+            return;
+        }
+        const bannerKey = `${banner.stage}:${banner.stage === 'failed' ? banner.failureReason ?? '' : ''}:${text.trimEnd().length}`;
+        if (bannerKey === this.lastCompactionBannerKey) {
+            return;
+        }
+        this.lastCompactionBannerKey = bannerKey;
+        switch (banner.stage) {
+            case 'started':
+                this.compactionState = 'active';
+                this.onProgress({
+                    type: 'compaction',
+                    compaction: {
+                        provider: 'claude',
+                        stage: 'started',
+                    },
+                });
+                return;
+            case 'completed':
+                this.compactionState = 'completed-awaiting-usage';
+                this.onProgress({
+                    type: 'compaction',
+                    compaction: {
+                        provider: 'claude',
+                        stage: 'completed',
+                    },
+                });
+                return;
+            case 'failed':
+                this.compactionState = 'idle';
+                this.onProgress({
+                    type: 'compaction',
+                    compaction: {
+                        provider: 'claude',
+                        stage: 'failed',
+                        ...(banner.failureReason ? { failureReason: banner.failureReason } : {}),
+                    },
+                });
+                return;
+        }
     }
 }
 function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options) {
@@ -290,39 +310,65 @@ function resolveClaudeLaunch(command, args, baseCwd) {
         args: args.map((arg) => (isRelativePathLike(arg) ? resolve(baseCwd, arg) : arg)),
     };
 }
-export function buildClaudeSessionSystemPrompt(promptContext) {
-    if (!promptContext) {
+function resolveClaudeSdkCompactionControl() {
+    const rawThreshold = process.env[CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD_ENV];
+    if (!hasVisibleText(rawThreshold)) {
         return undefined;
     }
-    const lines = [];
-    // Every command the CLI carries needs the gateway credential file, so the session names it only
-    // when one exists; otherwise the model is handed an invocation template it cannot fill.
-    if (promptContext.skillRuntime && promptContext.gatewayCredentialPath) {
-        lines.push(...buildSkillManualLines(promptContext.skillRuntime));
-    }
-    if (promptContext.localhostGateway && promptContext.gatewayCredentialPath) {
-        lines.push(`Gateway credential file for this session: ${promptContext.gatewayCredentialPath}`);
-    }
-    if (promptContext.taskWorkspace) {
-        lines.push(`Task-scoped writable workspace root: ${promptContext.taskWorkspace.rootPath}.`);
-        lines.push('This writable workspace is local to agents-host for the current task thread and does not imply that the target repository is already checked out there.');
+    const parsedThreshold = Number(rawThreshold.trim());
+    if (!Number.isSafeInteger(parsedThreshold) || parsedThreshold <= 0) {
+        throw new Error(`Invalid ${CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD_ENV}: expected a positive integer context token threshold for the experiment-scoped Claude SDK compaction opt-in`);
     }
-    if (promptContext.taskAssignmentContext?.currentTaskId) {
-        lines.push(`Current assigned task id: ${promptContext.taskAssignmentContext.currentTaskId}.`);
-    }
-    return lines.length > 0 ? lines.join('\n') : undefined;
+    return {
+        enabled: true,
+        context_token_threshold: parsedThreshold,
+    };
 }
-function buildClaudeSessionMeta(promptContext) {
-    const systemPromptAppend = buildClaudeSessionSystemPrompt(promptContext);
-    if (!systemPromptAppend) {
+function buildClaudeSessionMeta(systemPromptAppend) {
+    const sdkCompactionControl = resolveClaudeSdkCompactionControl();
+    if (!systemPromptAppend && !sdkCompactionControl) {
         return undefined;
     }
     return {
-        systemPrompt: {
-            append: systemPromptAppend,
-        },
+        ...(systemPromptAppend
+            ? {
+                systemPrompt: {
+                    append: systemPromptAppend,
+                },
+            }
+            : {}),
+        ...(sdkCompactionControl
+            ? {
+                claudeCode: {
+                    options: {
+                        compaction_control: sdkCompactionControl,
+                    },
+                },
+            }
+            : {}),
     };
 }
+function buildFallbackClaudeSessionPrompt(agentName, promptContext, promptStrategy) {
+    if (!promptContext) {
+        return undefined;
+    }
+    return buildClaudeSessionPromptAppend({
+        agentName: agentName ?? 'Borgee agent',
+        promptContext,
+        promptStrategy,
+    });
+}
+function resolveProjectionStrategy(promptStrategy) {
+    return normalizeProjectionStrategy(promptStrategy) ?? DEFAULT_PROJECTION_STRATEGY;
+}
+function resolveTurnSessionPromptAppend(turn) {
+    const promptStrategy = resolveProjectionStrategy(turn.projectionStrategy);
+    if (promptStrategy === 'turn-full') {
+        return undefined;
+    }
+    return turn.claudeSessionPromptAppend
+        ?? buildFallbackClaudeSessionPrompt(turn.agentName, turn.promptContext, promptStrategy);
+}
 function resolveSessionAdditionalDirectories(promptContext) {
     const directories = new Set();
     if (promptContext?.channelContextPayloadPath) {
@@ -336,27 +382,68 @@ function resolveSessionAdditionalDirectories(promptContext) {
     }
     return directories.size > 0 ? [...directories].sort((left, right) => left.localeCompare(right)) : undefined;
 }
-/**
- * A session carries its scope from `session/new`: the directories it may read, plus the append that
- * names the CLI manual and this channel's gateway credential file. The credential file sits in the
- * channel context directory the payload already contributes, so its absence is invisible in the
- * directory set alone — without the path itself in the key, a session opened while the credential
- * write failed keeps an append that never names the CLI for as long as the session lives.
- */
-function resolveSessionVisibilityKey(promptContext) {
+function hashSessionAppend(systemPromptAppend) {
+    if (!systemPromptAppend) {
+        return undefined;
+    }
+    return createHash('sha256').update(systemPromptAppend).digest('hex');
+}
+function resolveSkillManualContentHash(promptContext) {
+    const skillMarkdownPath = promptContext?.skillRuntime?.skillMarkdownPath;
+    if (!skillMarkdownPath) {
+        return undefined;
+    }
+    try {
+        return createHash('sha256')
+            .update(skillMarkdownPath)
+            .update('\0')
+            .update(readFileSync(skillMarkdownPath))
+            .digest('hex');
+    }
+    catch {
+        return `unreadable:${skillMarkdownPath}`;
+    }
+}
+function resolveSessionVisibilityKey(promptContext, systemPromptAppend, promptStrategy) {
+    const resolvedPromptStrategy = resolveProjectionStrategy(promptStrategy);
+    const explicitPromptStrategy = resolvedPromptStrategy === DEFAULT_PROJECTION_STRATEGY && promptStrategy == null
+        ? undefined
+        : resolvedPromptStrategy === DEFAULT_PROJECTION_STRATEGY
+            ? undefined
+            : resolvedPromptStrategy;
     const additionalDirectories = resolveSessionAdditionalDirectories(promptContext);
-    if (!additionalDirectories) {
+    const sessionAppendHash = hashSessionAppend(systemPromptAppend);
+    const skillManualContentHash = resolveSkillManualContentHash(promptContext);
+    const projectedBriefHash = promptContext?.claudeProjectedBriefHash;
+    if (!additionalDirectories
+        && !sessionAppendHash
+        && !skillManualContentHash
+        && !projectedBriefHash
+        && !promptContext?.gatewayCredentialPath
+        && !explicitPromptStrategy) {
         return undefined;
     }
+    if (sessionAppendHash) {
+        return JSON.stringify({
+            ...(additionalDirectories ? { additionalDirectories } : {}),
+            sessionAppendHash,
+            ...(skillManualContentHash ? { skillManualContentHash } : {}),
+            ...(projectedBriefHash ? { projectedBriefHash } : {}),
+            ...(explicitPromptStrategy ? { promptStrategy: explicitPromptStrategy } : {}),
+        });
+    }
     return JSON.stringify({
-        additionalDirectories,
+        ...(additionalDirectories ? { additionalDirectories } : {}),
+        ...(skillManualContentHash ? { skillManualContentHash } : {}),
         ...(promptContext?.gatewayCredentialPath
             ? { gatewayCredentialPath: promptContext.gatewayCredentialPath }
             : {}),
+        ...(projectedBriefHash ? { projectedBriefHash } : {}),
+        ...(explicitPromptStrategy ? { promptStrategy: explicitPromptStrategy } : {}),
     });
 }
-function buildSessionRequest(cwd, promptContext, additionalDirectories) {
-    const meta = buildClaudeSessionMeta(promptContext);
+function buildSessionRequest(cwd, systemPromptAppend, additionalDirectories) {
+    const meta = buildClaudeSessionMeta(systemPromptAppend);
     return {
         cwd,
         mcpServers: [],
@@ -656,10 +743,14 @@ export class ClaudeCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = this.resolveSessionCwd(turn.preparedTurn.promptContext);
-                        state.visibilityKey = resolveSessionVisibilityKey(turn.preparedTurn.promptContext);
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                            ? 'deny-all'
+                            : 'default';
+                        const sessionPromptAppend = resolveTurnSessionPromptAppend(turn.preparedTurn);
+                        state.visibilityKey = resolveSessionVisibilityKey(turn.preparedTurn.promptContext, sessionPromptAppend, turn.preparedTurn.projectionStrategy);
                         await this.ensureStarted();
                         await this.recycleSessionIfScopeChanged(channelId, state);
-                        const session = await this.getOrCreateSession(channelId, state, turn.preparedTurn.promptContext);
+                        const session = await this.getOrCreateSession(channelId, state, turn.preparedTurn, sessionPromptAppend);
                         let reply;
                         try {
                             const promptInput = await this.buildPromptInput(turn.preparedTurn);
@@ -703,7 +794,7 @@ export class ClaudeCliClient {
             }
         })();
     }
-    async getOrCreateSession(channelId, state, promptContext) {
+    async getOrCreateSession(channelId, state, turn, systemPromptAppend) {
         if (state.session) {
             return state.session;
         }
@@ -717,10 +808,10 @@ export class ClaudeCliClient {
         const persistedSessionId = state.sessionPersistence === 'persistent'
             ? await this.readPersistedSessionId(channelId, cwd, state.visibilityKey)
             : undefined;
-        const additionalDirectories = resolveSessionAdditionalDirectories(promptContext);
+        const additionalDirectories = resolveSessionAdditionalDirectories(turn.promptContext);
         const sessionPromise = persistedSessionId
-            ? this.restoreOrCreateSession(channelId, persistedSessionId, cwd, promptContext, additionalDirectories)
-            : this.startFreshSession(channelId, cwd, promptContext, additionalDirectories);
+            ? this.restoreOrCreateSession(channelId, persistedSessionId, cwd, systemPromptAppend, additionalDirectories)
+            : this.startFreshSession(channelId, cwd, systemPromptAppend, additionalDirectories);
         this.pendingSessionStarts.add(sessionPromise);
         state.sessionPromise = sessionPromise;
         let sessionAdopted = false;
@@ -759,11 +850,11 @@ export class ClaudeCliClient {
             }
         }
     }
-    async startFreshSession(channelId, cwd, promptContext, additionalDirectories) {
+    async startFreshSession(channelId, cwd, systemPromptAppend, additionalDirectories) {
         if (!this.connection) {
             throw new Error('Claude ACP connection is not available');
         }
-        const session = await this.connection.agent.buildSession(buildSessionRequest(cwd, promptContext, additionalDirectories)).start();
+        const session = await this.connection.agent.buildSession(buildSessionRequest(cwd, systemPromptAppend, additionalDirectories)).start();
         this.logger?.debug('started fresh Claude ACP session', { channelId, cwd });
         const state = this.channels.get(channelId);
         if (state?.sessionPersistence === 'persistent') {
@@ -771,13 +862,13 @@ export class ClaudeCliClient {
         }
         return session;
     }
-    async restoreOrCreateSession(channelId, sessionId, cwd, promptContext, additionalDirectories) {
+    async restoreOrCreateSession(channelId, sessionId, cwd, systemPromptAppend, additionalDirectories) {
         if (!this.sessionCapabilities.resumeSession) {
             this.logger?.debug('Claude ACP restore unsupported; starting fresh session', { channelId });
-            return this.startFreshSession(channelId, cwd, promptContext, additionalDirectories);
+            return this.startFreshSession(channelId, cwd, systemPromptAppend, additionalDirectories);
         }
         try {
-            const session = await this.restoreSession(sessionId, cwd, promptContext, additionalDirectories);
+            const session = await this.restoreSession(sessionId, cwd, systemPromptAppend, additionalDirectories);
             this.logger?.debug('restored Claude ACP session', {
                 channelId,
                 restoreMethod: this.sessionCapabilities.resumeSession ? 'session/resume' : 'session/load',
@@ -790,10 +881,10 @@ export class ClaudeCliClient {
             }
             this.logger?.debug('discarded stale Claude ACP session and started fresh', { channelId });
             await this.clearPersistedSessionBestEffort(channelId);
-            return this.startFreshSession(channelId, cwd, promptContext, additionalDirectories);
+            return this.startFreshSession(channelId, cwd, systemPromptAppend, additionalDirectories);
         }
     }
-    async restoreSession(sessionId, cwd, promptContext, additionalDirectories) {
+    async restoreSession(sessionId, cwd, systemPromptAppend, additionalDirectories) {
         if (!this.connection) {
             throw new Error('Claude ACP connection is not available');
         }
@@ -805,7 +896,7 @@ export class ClaudeCliClient {
         try {
             const request = {
                 sessionId,
-                ...buildSessionRequest(cwd, promptContext, additionalDirectories),
+                ...buildSessionRequest(cwd, systemPromptAppend, additionalDirectories),
             };
             if (this.sessionCapabilities.resumeSession) {
                 await this.connection.agent.request(this.runtime.methods.agent.session.resume, request);
@@ -830,7 +921,7 @@ export class ClaudeCliClient {
         }
     }
     resolveSessionCwd(promptContext) {
-        return promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
     }
     async recycleSessionIfScopeChanged(channelId, state) {
         const session = state.session;
@@ -862,7 +953,8 @@ export class ClaudeCliClient {
         const promptFailure = new Promise((_, reject) => {
             void promptPromise.catch((error) => reject(markSessionTainted(error)));
         });
-        const collector = new ClaudeProgressCollector(options?.onProgress);
+        const collector = new AcpProgressCollector(options?.onProgress, readClaudeActivityMetadata);
+        const compactionObserver = new ClaudeCompactionObserver(options?.onProgress);
         for (;;) {
             let update;
             try {
@@ -888,6 +980,12 @@ export class ClaudeCliClient {
                 }
                 return output;
             }
+            if (update.update.sessionUpdate === 'agent_message_chunk' && update.update.content.type === 'text') {
+                compactionObserver.consumeAnswerChunk(update.update.content.text);
+            }
+            if (update.update.sessionUpdate === 'usage_update') {
+                compactionObserver.consumeUsageUpdate(update.update.used, update.update.size);
+            }
             collector.consume(update);
         }
     }
@@ -926,13 +1024,15 @@ export class ClaudeCliClient {
         this.shutdownPromise = this.shutdownBackend(error);
     }
     handlePermissionRequest(params) {
+        const state = this.findChannelStateBySessionId(params.sessionId);
         return resolveCopilotPermissionResponse({
             gateEnabled: true,
             policyMode: 'enforce',
             params,
             logger: this.logger,
             agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
-            channelId: this.findChannelIdBySessionId(params.sessionId),
+            channelId: state?.channelId,
+            toolPermissionMode: state?.toolPermissionMode ?? 'default',
         });
     }
     invalidateSession(channelId, state, session) {
@@ -984,10 +1084,10 @@ export class ClaudeCliClient {
         }
         state.queue.length = 0;
     }
-    findChannelIdBySessionId(sessionId) {
+    findChannelStateBySessionId(sessionId) {
         for (const state of this.channels.values()) {
             if (state.session?.sessionId === sessionId) {
-                return state.channelId;
+                return state;
             }
         }
         return undefined;

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

@@ -108,6 +108,8 @@ export declare class CodexCliClient {
     private failAll;
     private closeSession;
     private clearIdleTimer;
+    private handlePermissionRequest;
+    private findChannelStateBySessionId;
     private reconcileIdleChannelState;
     private ensureSessionStoreLoaded;
     private readPersistedSessionId;