@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.js

@@ -1,120 +1,245 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { newWriteableBufferStream, VSBuffer, streamToBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { joinPath, basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
 import { Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { agentHostAuthority, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { AgentHostEnabledSettingId } from '../../../../../platform/agentHost/common/agentService.js';
+import { IAgentHostConnectionsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service';
+import { AGENT_HOST_ENABLED_CONTEXT_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService';
 import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
-import { AGENT_HOST_LOG_OUTPUT_CHANNEL_ID, remoteAgentHostLogOutputChannelId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { remoteAgentHostLogOutputChannelId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
 import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { getSessionChatResource, StateComponents, DEFAULT_CHAT_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IsWebContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
 import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
-import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { ByteSize } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
-import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
 import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
-import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
-import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { resolveEventsUri, getCopilotCliSessionRawId, buildLocalCopilotLogsUri, buildRemoteCopilotLogsUri, COPILOT_CLI_LOCAL_AH_SCHEME, parseRemoteAuthorityFromScheme } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+import { getCopilotCliSessionRawId, COPILOT_CLI_LOCAL_AH_SCHEME, parseRemoteAuthorityFromScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+import { sanitizeFilePart, getRemoteConnectionForSession } from '../chatDebug/agentHostLogSources.js';
+import { buildAgentHostUsageUri, buildAgentHostCustomizationsUri } from '../chatDebug/agentHostUsageSidecar.js';
 import { IAgentHostDebugLogsExportService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.service';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 
-const AGENT_HOST_LOGGER_CHANNEL_ID = AGENT_HOST_LOG_OUTPUT_CHANNEL_ID;
-const WINDOW_LOG_CHANNEL_ID = "rendererLog";
-const SHARED_PROCESS_LOG_CHANNEL_ID = "shared";
-const MAX_COPILOT_LOG_SCAN_FILES = 20;
-const MAX_COPILOT_LOG_FILE_SIZE = 10 * 1024 * 1024;
+const SHARED_PROCESS_LOG_FILE_NAME = "sharedprocess.log";
+const OUTPUT_LOG_FOLDER_PREFIX = "output_";
+const MAX_INLINE_DEBUG_LOGS_BYTES = 30 * ByteSize.MB;
 let BrowserAgentHostDebugLogsExportService = class BrowserAgentHostDebugLogsExportService {
-    constructor(fileDialogService, fileService) {
+    constructor(fileDialogService, fileService, logService) {
         this.fileDialogService = fileDialogService;
         this.fileService = fileService;
+        this.logService = logService;
+        this.hostArtifactKind = "directory";
     }
-    async save(exportName, files) {
-        return exportFilesToLocalFolder(this.fileDialogService, this.fileService, exportName, files);
+    async selectDestination(exportName) {
+        const folders = await this.fileDialogService.showOpenDialog({
+            title: ( localize(5874, "Select Folder for Agent Host Debug Logs")),
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            availableFileSystems: [Schemas.file]
+        });
+        return folders?.[0] ? joinPath(folders[0], exportName) : undefined;
+    }
+    async save(destination, files, hostArtifact) {
+        await exportFilesToLocalFolder(destination, files, hostArtifact, this.fileService, this.logService);
     }
 };
-BrowserAgentHostDebugLogsExportService = ( __decorate([( __param(0, IFileDialogService)), ( __param(1, IFileService))], BrowserAgentHostDebugLogsExportService));
-async function collectAgentHostDebugLogs(accessor, activeSession) {
-    const pathService = accessor.get(IPathService);
+BrowserAgentHostDebugLogsExportService = ( __decorate([( __param(0, IFileDialogService)), ( __param(1, IFileService)), ( __param(2, ILogService))], BrowserAgentHostDebugLogsExportService));
+function resolveAgentHostDebugLogsChat(activeSession, state) {
+    let backendChat = activeSession.backendChatResource;
+    let sessionTitle = activeSession.sessionTitle;
+    if (state && !(state instanceof Error)) {
+        if (!backendChat) {
+            const backendChatResource = getSessionChatResource(state, activeSession.chatId);
+            if (backendChatResource) {
+                backendChat = ( URI.parse(backendChatResource));
+            }
+        }
+        sessionTitle ??= state.title;
+    }
+    return {
+        backendChat,
+        sessionTitle
+    };
+}
+function createHostArtifactStream(artifact, readChunk) {
+    const stream = newWriteableBufferStream();
+    (async () => {
+        let position = 0;
+        while (true) {
+            const chunk = await readChunk(position);
+            const byteLength = chunk.data.byteLength;
+            if (byteLength > 0) {
+                position += byteLength;
+                if (position > artifact.size) {
+                    throw ( new Error(
+                        `Agent Host debug log artifact exceeded its declared size of ${artifact.size} bytes`
+                    ));
+                }
+                await stream.write(chunk.data);
+            }
+            if (chunk.eof) {
+                break;
+            }
+            if (byteLength === 0) {
+                throw ( new Error(
+                    "Agent Host returned an empty debug log chunk before the end of the artifact"
+                ));
+            }
+        }
+        if (position !== artifact.size) {
+            throw ( new Error(
+                `Agent Host debug log artifact ended after ${position} bytes, expected ${artifact.size}`
+            ));
+        }
+        stream.end();
+    })().catch(error => {
+        stream.error(error instanceof Error ? error : ( new Error(String(error))));
+        stream.end();
+    });
+    return stream;
+}
+async function collectAgentHostDebugLogs(accessor, activeSession, onDidCreateHostArtifact) {
     const agentHostService = accessor.get(IAgentHostService);
+    const agentHostConnectionsService = accessor.get(IAgentHostConnectionsService);
     const remoteAgentHostService = accessor.get(IRemoteAgentHostService);
-    const outputService = accessor.get(IOutputService);
     const fileService = accessor.get(IFileService);
-    const notificationService = accessor.get(INotificationService);
-    const textModelService = accessor.get(ITextModelService);
-    const productService = accessor.get(IProductService);
     const logService = accessor.get(ILogService);
-    const environmentService = accessor.get(IEnvironmentService);
-    const userHome = pathService.userHome({
-        preferLocal: true
-    });
-    const eventsResult = resolveEventsUri(
-        activeSession?.resource,
-        userHome,
-        authority => remoteAgentHostService.connections.find(c => agentHostAuthority(c.address) === authority)
-    );
-    const channelIds = ( new Set());
-    let remoteConnection;
+    const environmentService = accessor.get(IWorkbenchEnvironmentService);
+    const exportService = accessor.get(IAgentHostDebugLogsExportService);
+    let connection;
+    let backendSession;
+    let backendChat;
+    if (activeSession) {
+        const sessionResolution = agentHostConnectionsService.resolveSessionResource(activeSession.resource);
+        if (!sessionResolution) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] No live Agent Host connection owns session ${( activeSession.resource.toString())}; exporting client-owned logs only`
+            );
+        } else {
+            connection = sessionResolution.connection;
+            backendSession = sessionResolution.backendSession;
+            const state = connection.getSubscriptionUnmanaged(StateComponents.Session, backendSession)?.value;
+            backendChat = resolveAgentHostDebugLogsChat(activeSession, state).backendChat;
+            if (!backendChat) {
+                const reason = !state || state instanceof Error ? "session state is unavailable" : `chat '${activeSession.chatId}' is unavailable`;
+                logService.warn(
+                    `[ExportAgentHostDebugLogs] Cannot resolve the active chat because ${reason} for ${( activeSession.resource.toString())}; exporting session and client-owned logs`
+                );
+            }
+        }
+    } else {
+        connection = agentHostConnectionsService.ambientConnection;
+    }
+    let hostArtifact;
+    if (connection) {
+        try {
+            hostArtifact = await connection.collectDebugLogs(backendSession, exportService.hostArtifactKind, backendChat);
+            onDidCreateHostArtifact(hostArtifact);
+        } catch (error) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] Failed to collect Agent Host logs: ${error instanceof Error ? error.message : String(error)}; exporting client-owned logs only`
+            );
+        }
+    }
+    let remainingInlineBytes = MAX_INLINE_DEBUG_LOGS_BYTES;
+    const forwardedAgentHostLogFileNames = ( new Set());
     let ahpLogNameFilter;
     if (activeSession) {
         if (activeSession.isLocal) {
-            channelIds.add(AGENT_HOST_LOGGER_CHANNEL_ID);
             const localClientId = sanitizeFilePart(agentHostService.clientId);
             ahpLogNameFilter = name => name.includes(localClientId);
         } else {
-            remoteConnection = getRemoteConnectionForSession(activeSession.resource, remoteAgentHostService.connections);
+            const remoteConnection = getRemoteConnectionForSession(activeSession.resource, remoteAgentHostService.connections);
             if (remoteConnection) {
-                channelIds.add(remoteAgentHostLogOutputChannelId(remoteConnection.address));
+                forwardedAgentHostLogFileNames.add(
+                    getOutputChannelLogFileName(remoteAgentHostLogOutputChannelId(remoteConnection.address))
+                );
+                const remoteConnectionId = sanitizeFilePart(remoteConnection.address);
+                ahpLogNameFilter = name => name.includes(remoteConnectionId);
             }
         }
     } else {
-        channelIds.add(AGENT_HOST_LOGGER_CHANNEL_ID);
-        for (const connection of remoteAgentHostService.connections) {
-            channelIds.add(remoteAgentHostLogOutputChannelId(connection.address));
+        for (const remoteConnection of remoteAgentHostService.connections) {
+            forwardedAgentHostLogFileNames.add(
+                getOutputChannelLogFileName(remoteAgentHostLogOutputChannelId(remoteConnection.address))
+            );
         }
     }
-    channelIds.add(WINDOW_LOG_CHANNEL_ID);
-    channelIds.add(SHARED_PROCESS_LOG_CHANNEL_ID);
     const files = [];
-    if (eventsResult.kind === "ok") {
-        try {
-            const content = await fileService.readFile(eventsResult.resource);
-            files.push({
-                path: "events.jsonl",
-                contents: ( content.value.toString())
-            });
-        } catch {}
-    }
-    for (const channelId of channelIds) {
-        const channel = outputService.getChannel(channelId);
-        const descriptor = outputService.getChannelDescriptor(channelId);
-        if (!channel || !descriptor) {
-            continue;
+    const appendFile = file => {
+        files.push(file);
+        if (hasKey(file, {
+            contents: true
+        })) {
+            remainingInlineBytes -= file.size;
+        }
+    };
+    const appendFiles = collectedFiles => {
+        for (const file of collectedFiles) {
+            appendFile(file);
         }
-        const modelRef = await textModelService.createModelReference(channel.uri);
+    };
+    const processLogs = [{
+        folder: "Window",
+        resource: environmentService.logFile
+    }, {
+        folder: "Shared",
+        resource: joinPath(environmentService.logsHome, SHARED_PROCESS_LOG_FILE_NAME)
+    }];
+    for (const processLog of processLogs) {
         try {
-            const filename = `${descriptor.label.replace(/[/\\:*?"<>|]/g, "-")}.log`;
-            files.push({
-                path: filename,
-                contents: modelRef.object.textEditorModel.getValue()
-            });
-        } finally {
-            modelRef.dispose();
+            appendFiles(await collectRotatedLogFiles(
+                `vscode-logs/${processLog.folder}`,
+                processLog.resource,
+                fileService,
+                remainingInlineBytes
+            ));
+        } catch (error) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] Failed to collect rotated logs for '${( processLog.resource.toString())}': ${error instanceof Error ? error.message : String(error)}`
+            );
         }
     }
+    try {
+        const forwardedLogs = await findOutputChannelLogFiles(
+            environmentService.windowLogsPath,
+            forwardedAgentHostLogFileNames,
+            fileService
+        );
+        for (const forwardedLog of forwardedLogs) {
+            const file = await createDebugLogFile(
+                `vscode-logs/Agent Host/${basename(forwardedLog)}`,
+                forwardedLog,
+                fileService,
+                undefined,
+                remainingInlineBytes
+            );
+            if (file) {
+                appendFile(file);
+            }
+        }
+    } catch (error) {
+        logService.warn(
+            `[ExportAgentHostDebugLogs] Failed to collect forwarded Agent Host logs: ${error instanceof Error ? error.message : String(error)}`
+        );
+    }
     try {
         const ahpDir = joinPath(environmentService.logsHome, "ahp");
         const stat = await fileService.resolve(ahpDir, {
@@ -125,11 +250,16 @@ async function collectAgentHostDebugLogs(accessor, activeSession) {
                 continue;
             }
             try {
-                const content = await fileService.readFile(child.resource);
-                files.push({
-                    path: `ahp/${child.name}`,
-                    contents: ( content.value.toString())
-                });
+                const file = await createDebugLogFile(
+                    `ahp/${child.name}`,
+                    child.resource,
+                    fileService,
+                    child.size,
+                    remainingInlineBytes
+                );
+                if (file) {
+                    appendFile(file);
+                }
             } catch (error) {
                 logService.warn(
                     `[ExportAgentHostDebugLogs] Failed to read AHP log '${child.name}': ${error instanceof Error ? error.message : String(error)}`
@@ -137,164 +267,167 @@ async function collectAgentHostDebugLogs(accessor, activeSession) {
             }
         }
     } catch {}
-    if (remoteConnection?.defaultDirectory) {
-        try {
-            const remoteLog = await readRemoteAgentHostLog(remoteConnection, productService.serverDataFolderName, fileService);
-            if (remoteLog) {
-                files.push({
-                    path: "remote-agenthost.log",
-                    contents: remoteLog
-                });
-            }
-        } catch (error) {
-            logService.warn(
-                `[ExportAgentHostDebugLogs] Failed to download remote agenthost.log: ${error instanceof Error ? error.message : String(error)}`
-            );
-        }
-    }
     const rawSessionId = getCopilotCliSessionRawId(activeSession?.resource);
     if (rawSessionId) {
-        const copilotLogsDir = activeSession?.isLocal ? buildLocalCopilotLogsUri(userHome) : remoteConnection ? buildRemoteCopilotLogsUri(remoteConnection) : undefined;
-        if (copilotLogsDir) {
-            const copilotLogFiles = await readCopilotLogsForSession(copilotLogsDir, rawSessionId, fileService, logService);
-            files.push(...copilotLogFiles);
+        const sidecars = [{
+            path: "usage.jsonl",
+            resource: buildAgentHostUsageUri(environmentService.userRoamingDataHome, rawSessionId)
+        }, {
+            path: "customizations.json",
+            resource: buildAgentHostCustomizationsUri(environmentService.userRoamingDataHome, rawSessionId)
+        }];
+        for (const sidecar of sidecars) {
+            try {
+                const file = await createDebugLogFile(
+                    sidecar.path,
+                    sidecar.resource,
+                    fileService,
+                    undefined,
+                    remainingInlineBytes
+                );
+                if (file) {
+                    appendFile(file);
+                }
+            } catch {}
         }
     }
-    if (files.length === 0) {
-        notificationService.notify({
-            severity: Severity.Warning,
-            message: activeSession ? ( localize(5440, "No log files were found for the active Agent Host session.")) : ( localize(5441, "No Agent Host log files were found for the current window."))
-        });
-        return undefined;
-    }
-    const titleSlug = activeSession?.title ? `-${activeSession.title.replace(/[/\\:*?"<>|\s]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40)}` : "";
     return {
         files,
-        exportName: `ah-logs${titleSlug}`
+        hostArtifact: hostArtifact && connection ? {
+            artifact: hostArtifact,
+            readChunk: createChunkReader(connection)
+        } : undefined
     };
 }
-async function readCopilotLogsForSession(logsDir, rawSessionId, fileService, logService) {
-    let children;
+function getAgentHostDebugLogsExportName(sessionTitle, chatTitle, isPrimaryChat) {
+    const namespace = [
+        toDebugLogsTitleSlug(sessionTitle),
+        ...(!isPrimaryChat ? [toDebugLogsTitleSlug(chatTitle)] : [])
+    ].filter(title => title.length > 0);
+    return namespace.length > 0 ? `ah-logs-${namespace.join("--")}` : "ah-logs";
+}
+function prepareAgentHostDebugLogsExport(selectDestination, collectLogs) {
+    const destinationPromise = selectDestination();
+    const collectionPromise = collectLogs();
+    return Promise.allSettled([collectionPromise, destinationPromise]);
+}
+function toDebugLogsTitleSlug(title) {
+    return title?.replace(/[/\\:*?"<>|\s]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) ?? "";
+}
+function createChunkReader(connection) {
+    return (resource, position) => connection.readDebugLogsChunk(resource, position);
+}
+async function exportAgentHostDebugLogs(accessor, activeSession) {
+    const exportService = accessor.get(IAgentHostDebugLogsExportService);
+    const notificationService = accessor.get(INotificationService);
+    const chatEntitlementService = accessor.get(IChatEntitlementService);
+    const clipboardService = accessor.get(IClipboardService);
+    const fileService = accessor.get(IFileService);
+    const logService = accessor.get(ILogService);
+    const progressService = accessor.get(IProgressService);
+    let hostArtifact;
     try {
-        children = (await fileService.resolve(logsDir, {
-            resolveMetadata: true
-        })).children;
-    } catch {
-        return [];
-    }
-    const files = [];
-    const candidateLogs = (children ?? []).filter(
-        child => !child.isDirectory && child.name.endsWith(".log") && child.size <= MAX_COPILOT_LOG_FILE_SIZE
-    ).sort((a, b) => b.mtime - a.mtime).slice(0, MAX_COPILOT_LOG_SCAN_FILES);
-    for (const child of candidateLogs) {
+        const exportName = resolveAgentHostDebugLogsExportName(accessor, activeSession);
+        const [collectionResult, destinationResult] = await prepareAgentHostDebugLogsExport(
+            () => exportService.selectDestination(exportName),
+            () => progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: ( localize(5875, "Collecting Agent Host debug logs...")),
+                delay: 500
+            }, () => collectAgentHostDebugLogs(accessor, activeSession, artifact => hostArtifact = artifact))
+        );
+        if (collectionResult.status === "rejected") {
+            notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    5876,
+                    "Failed to collect debug logs: {0}",
+                    collectionResult.reason instanceof Error ? collectionResult.reason.message : String(collectionResult.reason)
+                ))
+            });
+            return;
+        }
+        if (destinationResult.status === "rejected") {
+            notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    5877,
+                    "Failed to save debug logs: {0}",
+                    destinationResult.reason instanceof Error ? destinationResult.reason.message : String(destinationResult.reason)
+                ))
+            });
+            return;
+        }
+        const destination = destinationResult.value;
+        if (!destination) {
+            return;
+        }
         try {
-            if (await logStreamContains(child.resource, rawSessionId, fileService)) {
-                const content = await fileService.readFile(child.resource, {
-                    limits: {
-                        size: MAX_COPILOT_LOG_FILE_SIZE
-                    }
-                });
-                const contents = ( content.value.toString());
-                files.push({
-                    path: `copilot-logs/${child.name}`,
-                    contents
+            await exportService.save(
+                destination,
+                collectionResult.value.files,
+                collectionResult.value.hostArtifact
+            );
+            notifyAgentHostDebugLogsExported(
+                notificationService,
+                clipboardService,
+                chatEntitlementService.isInternal,
+                destination
+            );
+        } catch (error) {
+            notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    5877,
+                    "Failed to save debug logs: {0}",
+                    error instanceof Error ? error.message : String(error)
+                ))
+            });
+        }
+    } finally {
+        if (hostArtifact) {
+            try {
+                await fileService.del(hostArtifact.resource, {
+                    recursive: hostArtifact.kind === "directory"
                 });
+            } catch (error) {
+                logService.warn(
+                    `[ExportAgentHostDebugLogs] Failed to delete temporary Agent Host log artifact: ${error instanceof Error ? error.message : String(error)}`
+                );
             }
-        } catch (error) {
-            logService.warn(
-                `[ExportAgentHostDebugLogs] Failed to read Copilot log '${child.name}': ${error instanceof Error ? error.message : String(error)}`
-            );
         }
     }
-    return files;
 }
-async function logStreamContains(resource, rawSessionId, fileService) {
-    const tokenSource = ( new CancellationTokenSource());
-    let stream;
-    try {
-        stream = (await fileService.readFileStream(resource, {
-            length: MAX_COPILOT_LOG_FILE_SIZE,
-            limits: {
-                size: MAX_COPILOT_LOG_FILE_SIZE
-            }
-        }, tokenSource.token)).value;
-    } catch (error) {
-        tokenSource.dispose(true);
-        throw error;
+function resolveAgentHostDebugLogsExportName(accessor, activeSession) {
+    let sessionTitle = activeSession?.sessionTitle;
+    if (activeSession && !sessionTitle) {
+        const sessionResolution = accessor.get(IAgentHostConnectionsService).resolveSessionResource(activeSession.resource);
+        if (sessionResolution) {
+            const state = sessionResolution.connection.getSubscriptionUnmanaged(StateComponents.Session, sessionResolution.backendSession)?.value;
+            sessionTitle = resolveAgentHostDebugLogsChat(activeSession, state).sessionTitle;
+        }
     }
-    return ( new Promise((resolve, reject) => {
-        let settled = false;
-        let previous = "";
-        const cleanup = removeErrorListener => {
-            stream.removeListener("data", onData);
-            stream.removeListener("end", onEnd);
-            if (removeErrorListener) {
-                stream.removeListener("error", onError);
-            }
-        };
-        const settle = contains => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            tokenSource.dispose(contains);
-            cleanup(!contains);
-            resolve(contains);
-        };
-        const onData = chunk => {
-            const text = previous + ( chunk.toString());
-            if (text.includes(rawSessionId)) {
-                settle(true);
-                return;
-            }
-            previous = text.slice(Math.max(0, text.length - rawSessionId.length + 1));
-        };
-        const onError = error => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            tokenSource.dispose();
-            cleanup(true);
-            reject(error);
-        };
-        const onEnd = () => {
-            settle(false);
-        };
-        stream.on("error", onError);
-        stream.on("end", onEnd);
-        stream.on("data", onData);
-    }));
+    return getAgentHostDebugLogsExportName(
+        sessionTitle,
+        activeSession?.chatTitle,
+        activeSession?.chatId === DEFAULT_CHAT_ID
+    );
 }
-async function exportAgentHostDebugLogs(accessor, activeSession) {
-    const exportService = accessor.get(IAgentHostDebugLogsExportService);
-    const notificationService = accessor.get(INotificationService);
-    const chatEntitlementService = accessor.get(IChatEntitlementService);
-    const logs = await collectAgentHostDebugLogs(accessor, activeSession);
-    if (!logs) {
-        return;
-    }
-    try {
-        const saved = await exportService.save(logs.exportName, logs.files);
-        if (saved) {
-            notificationService.warn(chatEntitlementService.isInternal ? ( localize(
-                5442,
-                "Note: This log may contain personal information such as auth tokens, file contents, or terminal output. It MUST be shared privately via Slack or in an issue filed on the microsoft/vscode-internalbacklog repo."
-            )) : ( localize(
-                5443,
-                "Note: This log may contain personal information such as auth tokens, file contents, or terminal output. Please consider sharing privately or reviewing the contents carefully before sharing."
-            )));
+function notifyAgentHostDebugLogsExported(notificationService, clipboardService, isInternal, savedResource) {
+    const savedPath = savedResource.scheme === Schemas.file ? savedResource.fsPath : ( savedResource.toString(true));
+    notificationService.notify({
+        severity: Severity.Warning,
+        message: isInternal ? ( localize(
+            5878,
+            "Note: This log may contain personal information such as auth tokens, file contents, or terminal output. It MUST be shared privately via Slack or in an issue filed on the microsoft/vscode-internalbacklog repo."
+        )) : ( localize(
+            5879,
+            "Note: This log may contain personal information such as auth tokens, file contents, or terminal output. Please consider sharing privately or reviewing the contents carefully before sharing."
+        )),
+        actions: {
+            primary: [( new Action("copyAgentHostDebugLogsPath", ( localize(5880, "Copy Path")), undefined, true, () => clipboardService.writeText(savedPath)))]
         }
-    } catch (error) {
-        notificationService.notify({
-            severity: Severity.Error,
-            message: ( localize(
-                5444,
-                "Failed to save debug logs: {0}",
-                error instanceof Error ? error.message : String(error)
-            ))
-        });
-    }
+    });
 }
 class ExportAgentHostDebugLogsAction extends Action2 {
     static {
@@ -303,10 +436,10 @@ class ExportAgentHostDebugLogsAction extends Action2 {
     constructor() {
         super({
             id: ExportAgentHostDebugLogsAction.ID,
-            title: ( localize2(5445, "Export Agent Host Debug Logs...")),
+            title: ( localize2(5881, "Export Agent Host Debug Logs...")),
             f1: true,
             category: Categories.Developer,
-            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( IsWebContext.negate()), ( ContextKeyExpr.equals(`config.${AgentHostEnabledSettingId}`, true))))
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( IsWebContext.negate()), AGENT_HOST_ENABLED_CONTEXT_KEY))
         });
     }
     async run(accessor) {
@@ -317,44 +450,49 @@ class ExportAgentHostDebugLogsAction extends Action2 {
         await exportAgentHostDebugLogs(accessor, activeSession);
     }
 }
-function toActiveAgentHostSession(resource, title) {
+function toActiveAgentHostSession(resource, chatTitle, sessionTitle) {
     if (resource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME) {
         return {
-            resource,
-            title,
-            isLocal: true
+            resource: resource.with({
+                fragment: null
+            }),
+            sessionTitle,
+            chatTitle,
+            isLocal: true,
+            chatId: resource.fragment || DEFAULT_CHAT_ID,
+            backendChatResource: undefined
         };
     }
     if (parseRemoteAuthorityFromScheme(resource.scheme)) {
         return {
-            resource,
-            title,
-            isLocal: false
+            resource: resource.with({
+                fragment: null
+            }),
+            sessionTitle,
+            chatTitle,
+            isLocal: false,
+            chatId: resource.fragment || DEFAULT_CHAT_ID,
+            backendChatResource: undefined
         };
     }
     return undefined;
 }
-function getRemoteConnectionForSession(sessionResource, connections) {
-    const authority = parseRemoteAuthorityFromScheme(sessionResource.scheme);
-    return authority ? connections.find(connection => agentHostAuthority(connection.address) === authority) : undefined;
-}
-function sanitizeFilePart(value) {
-    return value.replace(/[\\/:\*\?"<>|\s]+/g, "-").replace(/^-+|-+$/g, "") || "connection";
-}
-async function exportFilesToLocalFolder(fileDialogService, fileService, exportName, files) {
-    const folders = await fileDialogService.showOpenDialog({
-        title: ( localize(5446, "Select Folder for Agent Host Debug Logs")),
-        canSelectFiles: false,
-        canSelectFolders: true,
-        canSelectMany: false,
-        availableFileSystems: [Schemas.file]
-    });
-    const parentFolder = folders?.[0];
-    if (!parentFolder) {
-        return false;
-    }
-    const exportFolder = joinPath(parentFolder, exportName);
+async function exportFilesToLocalFolder(exportFolder, files, hostArtifact, fileService, logService) {
     await fileService.createFolder(exportFolder);
+    if (hostArtifact) {
+        try {
+            if (hostArtifact.artifact.kind !== "directory") {
+                throw ( new Error(
+                    `Expected an Agent Host debug-log directory, got ${hostArtifact.artifact.kind}`
+                ));
+            }
+            await copyHostArtifactDirectory(exportFolder, hostArtifact, fileService);
+        } catch (error) {
+            logService.warn(
+                `[ExportAgentHostDebugLogs] Failed to save Agent Host logs: ${error instanceof Error ? error.message : String(error)}; saving client-owned logs only`
+            );
+        }
+    }
     for (const file of files) {
         const segments = toSafeRelativePathSegments(file.path);
         if (segments.length === 0) {
@@ -365,81 +503,168 @@ async function exportFilesToLocalFolder(fileDialogService, fileService, exportNa
             folder = joinPath(folder, segment);
             await fileService.createFolder(folder);
         }
+        const target = joinPath(folder, segments[segments.length - 1]);
+        if (hasKey(file, {
+            contents: true
+        })) {
+            await fileService.writeFile(target, VSBuffer.fromString(file.contents));
+        } else {
+            const source = await fileService.readFileStream(file.resource, {
+                length: file.size
+            });
+            await fileService.writeFile(target, source.value);
+        }
+    }
+}
+async function copyHostArtifactDirectory(target, hostArtifact, fileService) {
+    let copiedSize = 0;
+    for (const entry of hostArtifact.artifact.entries) {
+        copiedSize += entry.size;
+        if (copiedSize > hostArtifact.artifact.uncompressedSize) {
+            throw ( new Error(
+                `Agent Host debug-log directory exceeded its declared size of ${hostArtifact.artifact.uncompressedSize} bytes`
+            ));
+        }
+        const source = joinPath(hostArtifact.artifact.resource, ...entry.path.split("/"));
+        const segments = toSafeRelativePathSegments(entry.path);
+        if (segments.length === 0) {
+            throw ( new Error(`Agent Host returned an invalid debug-log artifact path: ${entry.path}`));
+        }
+        let targetFolder = target;
+        for (const segment of segments.slice(0, -1)) {
+            targetFolder = joinPath(targetFolder, segment);
+            await fileService.createFolder(targetFolder);
+        }
+        const entryTarget = joinPath(targetFolder, segments[segments.length - 1]);
+        if (source.scheme === Schemas.file) {
+            const sourceStat = await fileService.resolve(source, {
+                resolveMetadata: true
+            });
+            if (!sourceStat.isFile || sourceStat.isSymbolicLink || sourceStat.size !== entry.size) {
+                throw ( new Error(`Agent Host debug-log file no longer matches its manifest: ${entry.path}`));
+            }
+            await fileService.copy(source, entryTarget, true);
+            continue;
+        }
+        const artifact = {
+            size: entry.size};
         await fileService.writeFile(
-            joinPath(folder, segments[segments.length - 1]),
-            VSBuffer.fromString(file.contents)
+            entryTarget,
+            createHostArtifactStream(artifact, position => hostArtifact.readChunk(source, position))
         );
     }
-    return true;
+    if (copiedSize !== hostArtifact.artifact.uncompressedSize) {
+        throw ( new Error(
+            `Agent Host debug-log directory manifest accounts for ${copiedSize} bytes, expected ${hostArtifact.artifact.uncompressedSize}`
+        ));
+    }
 }
-function toSafeRelativePathSegments(path) {
-    return (path.replace(/\\/g, "/").split("/").filter(segment => {
-        return segment.length > 0 && segment !== "." && segment !== "..";
-    }).map(segment => segment.replace(/[/\\:*?"<>|]/g, "-")));
+async function createDebugLogFile(path, resource, fileService, size, maxInlineSize) {
+    if (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeUserData) {
+        const observedSize = size ?? (await fileService.resolve(resource, {
+            resolveMetadata: true
+        })).size;
+        return {
+            path,
+            resource,
+            size: observedSize
+        };
+    }
+    const observedSize = size ?? (await fileService.resolve(resource, {
+        resolveMetadata: true
+    })).size;
+    const readSize = Math.min(observedSize, maxInlineSize);
+    if (readSize === 0) {
+        return undefined;
+    }
+    const stream = await fileService.readFileStream(resource, {
+        position: observedSize - readSize,
+        length: readSize
+    });
+    return createInlineDebugLogFile(path, await streamToBuffer(stream.value), maxInlineSize);
 }
-async function readRemoteAgentHostLog(connection, serverDataFolderName, fileService) {
-    const homePath = connection.defaultDirectory;
-    if (!homePath) {
+function createInlineDebugLogFile(path, content, maxInlineSize) {
+    const size = Math.min(content.byteLength, maxInlineSize);
+    if (size === 0) {
         return undefined;
     }
-    const authority = agentHostAuthority(connection.address);
-    const homeUri = toAgentHostUri(( URI.from({
-        scheme: "file",
-        path: homePath
-    })), authority);
-    const candidates = ( new Set());
-    if (serverDataFolderName) {
-        candidates.add(serverDataFolderName);
-        if (serverDataFolderName.endsWith("-dev")) {
-            candidates.add(serverDataFolderName.slice(0, -"-dev".length));
+    const capturedContent = size === content.byteLength ? content : content.slice(content.byteLength - size);
+    return {
+        path,
+        contents: ( capturedContent.toString()),
+        size
+    };
+}
+async function collectRotatedLogFiles(path, current, fileService, maxInlineSize = MAX_INLINE_DEBUG_LOGS_BYTES) {
+    const currentName = basename(current);
+    const parent = await fileService.resolve(dirname(current), {
+        resolveMetadata: true
+    });
+    const files = [];
+    let remainingInlineSize = maxInlineSize;
+    for (const child of parent.children ?? []) {
+        if (child.isFile && !child.isSymbolicLink && isRotatedLogFile(child.name, currentName)) {
+            const file = await createDebugLogFile(
+                `${path}/${child.name}`,
+                child.resource,
+                fileService,
+                child.size,
+                remainingInlineSize
+            );
+            if (file) {
+                files.push(file);
+                if (hasKey(file, {
+                    contents: true
+                })) {
+                    remainingInlineSize -= file.size;
+                }
+            }
         }
     }
-    candidates.add(".vscode-server");
-    candidates.add(".vscode-server-insiders");
-    candidates.add(".vscode-server-oss");
-    candidates.add(".vscode-server-exploration");
-    let best;
-    for (const folderName of candidates) {
-        const logsDirUri = joinPath(homeUri, folderName, "data", "logs");
-        let entries;
-        try {
-            const stat = await fileService.resolve(logsDirUri, {
-                resolveMetadata: true
-            });
-            entries = stat.children;
-        } catch {
-            continue;
-        }
-        if (!entries) {
-            continue;
-        }
-        for (const dir of entries) {
-            if (!dir.isDirectory) {
-                continue;
-            }
-            const logUri = joinPath(dir.resource, "agenthost.log");
-            let logStat;
-            try {
-                logStat = await fileService.resolve(logUri, {
-                    resolveMetadata: true
-                });
-            } catch {
-                continue;
-            }
-            const mtime = logStat.mtime ?? 0;
-            if (!best || mtime > best.mtime) {
-                best = {
-                    uri: logUri,
-                    mtime
-                };
+    return files;
+}
+async function findOutputChannelLogFiles(windowLogsPath, fileNames, fileService) {
+    if (fileNames.size === 0) {
+        return [];
+    }
+    const windowLogs = await fileService.resolve(windowLogsPath);
+    const outputFolders = (windowLogs.children ?? []).filter(
+        child => child.isDirectory && child.name.startsWith(OUTPUT_LOG_FOLDER_PREFIX)
+    ).sort((a, b) => b.name.localeCompare(a.name));
+    const remaining = ( new Set(fileNames));
+    const result = [];
+    for (const outputFolder of outputFolders) {
+        const folder = await fileService.resolve(outputFolder.resource);
+        for (const child of folder.children ?? []) {
+            if (child.isFile && !child.isSymbolicLink && remaining.delete(child.name)) {
+                result.push(child.resource);
             }
         }
+        if (remaining.size === 0) {
+            break;
+        }
     }
-    if (!best) {
-        return undefined;
+    return result;
+}
+function getOutputChannelLogFileName(channelId) {
+    return `${channelId.replace(/[\\/:\*\?"<>\|]/g, "")}.log`;
+}
+function isRotatedLogFile(candidate, current) {
+    if (candidate === current) {
+        return true;
+    }
+    const stem = current.endsWith(".log") ? current.slice(0, -".log".length) : current;
+    const prefix = `${stem}.`;
+    if (!candidate.startsWith(prefix) || !candidate.endsWith(".log")) {
+        return false;
     }
-    const content = await fileService.readFile(best.uri);
-    return ( content.value.toString());
+    const rotation = candidate.slice(prefix.length, -".log".length);
+    return /^[1-9]\d*$/.test(rotation);
+}
+function toSafeRelativePathSegments(path) {
+    return (path.replace(/\\/g, "/").split("/").filter(segment => {
+        return segment.length > 0 && segment !== "." && segment !== "..";
+    }).map(segment => segment.replace(/[/\\:*?"<>|]/g, "-")));
 }
 
-export { BrowserAgentHostDebugLogsExportService, ExportAgentHostDebugLogsAction, collectAgentHostDebugLogs, exportAgentHostDebugLogs, toActiveAgentHostSession };
+export { BrowserAgentHostDebugLogsExportService, ExportAgentHostDebugLogsAction, collectAgentHostDebugLogs, collectRotatedLogFiles, createHostArtifactStream, exportAgentHostDebugLogs, findOutputChannelLogFiles, getAgentHostDebugLogsExportName, notifyAgentHostDebugLogsExported, prepareAgentHostDebugLogsExport, resolveAgentHostDebugLogsChat, toActiveAgentHostSession };