@borgee/agents-host 0.2.35 → 0.2.56

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

@@ -1,11 +1,16 @@
 import { Readable, Writable } from 'node:stream';
+import { createHash } from 'node:crypto';
 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 { buildClaudeSessionPromptAppend } from '../../context/prompt.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';
@@ -23,6 +28,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,
@@ -30,6 +36,7 @@ const DEFAULT_RUNTIME = {
     ndJsonStream,
     methods,
     protocolVersion: PROTOCOL_VERSION,
+    fetch,
     cwd: process.cwd(),
     idleBackendShutdownMs: IDLE_BACKEND_SHUTDOWN_DISABLED_MS,
     idleShutdownGracePeriodMs: DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS,
@@ -42,6 +49,25 @@ function hasVisibleText(value) {
 function normalizeError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
+function isAbsoluteHttpUrl(value) {
+    return value.startsWith('http://') || value.startsWith('https://');
+}
+function resolveHostedAttachmentUrl(rawUrl, borgeeBaseUrl) {
+    if (isAbsoluteHttpUrl(rawUrl)) {
+        return rawUrl;
+    }
+    const base = borgeeBaseUrl.replace(/\/$/, '');
+    const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;
+    return `${base}${path}`;
+}
+function isSameOrigin(left, right) {
+    try {
+        return new URL(left).origin === new URL(right).origin;
+    }
+    catch {
+        return false;
+    }
+}
 function parsePersistedSessionRecord(rawValue) {
     const trimmed = rawValue.trim();
     if (trimmed.startsWith('{')) {
@@ -90,85 +116,98 @@ 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;
+        }
+        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.lastPublished = text;
-        this.onProgress({ text });
+        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, prompt, sessionPersistence, promptContext, options) {
+function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options) {
     let settled = false;
     let resolvePromise;
     let rejectPromise;
@@ -178,9 +217,8 @@ function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext
     });
     return {
         channelId,
-        prompt,
+        preparedTurn,
         sessionPersistence,
-        promptContext,
         options,
         promise,
         resolve(value) {
@@ -204,6 +242,9 @@ function resolveSessionRouting(turn) {
         persistence: turn.providerSessionRouting?.persistence ?? 'persistent',
     };
 }
+function asImagePart(part) {
+    return part.type === 'image' ? part : null;
+}
 function asObject(value) {
     return typeof value === 'object' && value !== null ? value : null;
 }
@@ -267,68 +308,120 @@ function resolveClaudeLaunch(command, args, baseCwd) {
         args: args.map((arg) => (isRelativePathLike(arg) ? resolve(baseCwd, arg) : arg)),
     };
 }
-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 = [];
-    if (promptContext.channelContextPayloadPath) {
-        lines.push('Channel-scoped local context is available for this session.');
-        lines.push(`Channel context payload: ${promptContext.channelContextPayloadPath}`);
-    }
-    if (promptContext.skillRuntime) {
-        lines.push(`Skill guide: ${promptContext.skillRuntime.skillMarkdownPath}`);
-        lines.push(`Node bootstrap CLI: node ${promptContext.skillRuntime.nodeCliPath} --context ${promptContext.channelContextPayloadPath} --print-bootstrap`);
-        lines.push(`Python bootstrap CLI: python3 ${promptContext.skillRuntime.pythonCliPath} --context ${promptContext.channelContextPayloadPath} --print-bootstrap`);
-    }
-    if (promptContext.localhostGateway && promptContext.gatewayAuthPath) {
-        lines.push(`Gateway auth sidecar for this session: ${promptContext.gatewayAuthPath}`);
-        if (promptContext.localhostGateway.baseUrl) {
-            lines.push(`Loopback gateway base URL: ${promptContext.localhostGateway.baseUrl}`);
-        }
-    }
-    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.');
-    }
-    if (promptContext.taskAssignmentContext?.currentTaskId) {
-        lines.push(`Current assigned task id: ${promptContext.taskAssignmentContext.currentTaskId}.`);
+    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`);
     }
-    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) {
         directories.add(dirname(promptContext.channelContextPayloadPath));
     }
-    if (promptContext?.gatewayAuthPath) {
-        directories.add(dirname(promptContext.gatewayAuthPath));
+    if (promptContext?.gatewayCredentialPath) {
+        directories.add(dirname(promptContext.gatewayCredentialPath));
     }
     if (promptContext?.skillRuntime?.skillDirectoryPath) {
         directories.add(promptContext.skillRuntime.skillDirectoryPath);
     }
     return directories.size > 0 ? [...directories].sort((left, right) => left.localeCompare(right)) : undefined;
 }
-function resolveSessionVisibilityKey(promptContext) {
+function hashSessionAppend(systemPromptAppend) {
+    if (!systemPromptAppend) {
+        return undefined;
+    }
+    return createHash('sha256').update(systemPromptAppend).digest('hex');
+}
+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 projectedBriefHash = promptContext?.claudeProjectedBriefHash;
+    if (!additionalDirectories
+        && !sessionAppendHash
+        && !projectedBriefHash
+        && !promptContext?.gatewayCredentialPath
+        && !explicitPromptStrategy) {
         return undefined;
     }
-    return JSON.stringify({ additionalDirectories });
+    if (sessionAppendHash) {
+        return JSON.stringify({
+            ...(additionalDirectories ? { additionalDirectories } : {}),
+            sessionAppendHash,
+            ...(projectedBriefHash ? { projectedBriefHash } : {}),
+            ...(explicitPromptStrategy ? { promptStrategy: explicitPromptStrategy } : {}),
+        });
+    }
+    return JSON.stringify({
+        ...(additionalDirectories ? { additionalDirectories } : {}),
+        ...(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: [],
@@ -369,6 +462,7 @@ export class ClaudeCliClient {
     sessionStore;
     resolveSessionStoreAgentId;
     logger;
+    imageInputConfig;
     runtime;
     channels = new Map();
     /**
@@ -407,12 +501,13 @@ export class ClaudeCliClient {
     sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
     idleBackendShutdown;
     childStderr = '';
-    constructor(command, args = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger()) {
+    constructor(command, args = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), imageInputConfig = {}) {
         this.command = command;
         this.args = args;
         this.sessionStore = sessionStore;
         this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.logger = logger;
+        this.imageInputConfig = imageInputConfig;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
         assertClaudeCommandCompatibility(command, args, 'Claude provider runtime');
         this.idleBackendShutdown = new IdleBackendShutdownScheduler({
@@ -434,19 +529,26 @@ export class ClaudeCliClient {
         if (this.fatalError) {
             throw this.fatalError;
         }
-        const preparedTurn = typeof channelIdOrTurn === 'string'
+        const preparedTurnBase = typeof channelIdOrTurn === 'string'
             ? {
                 channelId: channelIdOrTurn,
+                incomingContent: '',
+                incomingParts: [],
                 prompt: typeof promptOrOptions === 'string' ? promptOrOptions : '',
             }
             : channelIdOrTurn;
+        const preparedTurn = {
+            ...preparedTurnBase,
+            incomingContent: preparedTurnBase.incomingContent ?? '',
+            incomingParts: preparedTurnBase.incomingParts ?? [],
+        };
         const options = typeof channelIdOrTurn === 'string'
             ? maybeOptions
             : promptOrOptions;
         const sessionRouting = resolveSessionRouting(preparedTurn);
         const state = this.getOrCreateChannelState(sessionRouting.key, preparedTurn.channelId, sessionRouting.persistence);
         this.idleBackendShutdown.cancel();
-        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn.prompt, sessionRouting.persistence, preparedTurn.promptContext, options);
+        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn, sessionRouting.persistence, options);
         state.queue.push(turn);
         this.processChannelQueue(sessionRouting.key, state);
         return turn.promise;
@@ -618,14 +720,16 @@ export class ClaudeCliClient {
                     }
                     state.activeTurn = turn;
                     try {
-                        state.cwd = this.resolveSessionCwd(turn.promptContext);
-                        state.visibilityKey = resolveSessionVisibilityKey(turn.promptContext);
+                        state.cwd = this.resolveSessionCwd(turn.preparedTurn.promptContext);
+                        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.promptContext);
+                        const session = await this.getOrCreateSession(channelId, state, turn.preparedTurn, sessionPromptAppend);
                         let reply;
                         try {
-                            reply = await this.runTurn(session, turn.prompt, turn.options);
+                            const promptInput = await this.buildPromptInput(turn.preparedTurn);
+                            reply = await this.runTurn(session, promptInput, turn.options);
                         }
                         catch (error) {
                             if (isSessionTainted(error)) {
@@ -665,7 +769,7 @@ export class ClaudeCliClient {
             }
         })();
     }
-    async getOrCreateSession(channelId, state, promptContext) {
+    async getOrCreateSession(channelId, state, turn, systemPromptAppend) {
         if (state.session) {
             return state.session;
         }
@@ -679,10 +783,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;
@@ -721,11 +825,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') {
@@ -733,13 +837,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',
@@ -752,10 +856,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');
         }
@@ -767,7 +871,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);
@@ -792,7 +896,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;
@@ -824,7 +928,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 {
@@ -850,6 +955,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);
         }
     }
@@ -1199,4 +1310,37 @@ export class ClaudeCliClient {
             }
         }
     }
+    async buildPromptInput(turn) {
+        const imageParts = turn.incomingParts.map(asImagePart).filter((part) => part !== null);
+        if (imageParts.length === 0) {
+            return turn.prompt;
+        }
+        const imageBlocks = await Promise.all(imageParts.map(async (part) => this.fetchImageBlock(part.attachment.url, part.attachment.contentType)));
+        return [
+            { type: 'text', text: turn.prompt },
+            ...imageBlocks,
+        ];
+    }
+    async fetchImageBlock(rawUrl, contentType) {
+        const baseUrl = this.imageInputConfig.borgeeBaseUrl?.trim();
+        const agentApiKey = this.imageInputConfig.agentApiKey?.trim();
+        if (!baseUrl || !agentApiKey) {
+            throw new Error('Claude image input requires Borgee base URL and agent API key');
+        }
+        const resolvedUrl = resolveHostedAttachmentUrl(rawUrl, baseUrl);
+        if (!isSameOrigin(resolvedUrl, baseUrl)) {
+            throw new Error(`Claude image input only supports Borgee-origin attachments: ${resolvedUrl}`);
+        }
+        const init = { headers: { Authorization: `Bearer ${agentApiKey}` } };
+        const response = await this.runtime.fetch(resolvedUrl, init);
+        if (!response.ok) {
+            throw new Error(`Claude image fetch failed with ${response.status} ${response.statusText}`.trim());
+        }
+        const blob = Buffer.from(await response.arrayBuffer()).toString('base64');
+        return {
+            type: 'image',
+            mimeType: contentType,
+            data: blob,
+        };
+    }
 }

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

@@ -1,10 +1,12 @@
-import type { ProviderAdapter } from '../provider-adapter.js';
+import { type ProviderAdapter } from '../provider-adapter.js';
 import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
 import { CodexCliClient } from './cli-client.js';
+export declare const CODEX_HOSTED_PROVIDER_CAPABILITIES: import("../provider-adapter.js").ProviderCapabilities;
 export declare class CodexProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
+    readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: CodexCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;

package/dist/providers/codex/adapter.js

@@ -1,7 +1,17 @@
+import { createHostedProviderCapabilities } from '../provider-adapter.js';
 import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
+export const CODEX_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilities({
+    imageInputTransport: {
+        source: 'transport-derived',
+        support: 'supported',
+        reason: 'real-media-delivered',
+        delivery: ['blob'],
+    },
+});
 export class CodexProviderAdapter {
     cli;
     turnPreparer;
+    capabilities = CODEX_HOSTED_PROVIDER_CAPABILITIES;
     constructor(cli, turnPreparer) {
         this.cli = cli;
         this.turnPreparer = turnPreparer;