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

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

@@ -9,6 +9,7 @@ import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/th
 import { isUriComponents, URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { AGENT_PLUGIN_SCHEMA, AGENT_PLUGIN_MCP_SCHEMA } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentPlugins/common/agentPluginParser';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
 import { IFileDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
@@ -28,22 +29,27 @@ const VALID_PLUGIN_NAME = /^[a-z0-9]([a-z0-9\-.]*[a-z0-9])?$/;
 const INVALID_CONSECUTIVE = /--|[.][.]/;
 function validatePluginName(name) {
     if (!name) {
-        return localize(5420, "Plugin name is required.");
+        return localize(5842, "Plugin name is required.");
     }
     if (name.length > 64) {
-        return localize(5421, "Plugin name must be at most 64 characters.");
+        return localize(5843, "Plugin name must be at most 64 characters.");
     }
     if (!VALID_PLUGIN_NAME.test(name)) {
         return localize(
-            5422,
+            5844,
             "Plugin name must contain only lowercase alphanumeric characters, hyphens, and periods, and must start and end with an alphanumeric character."
         );
     }
     if (INVALID_CONSECUTIVE.test(name)) {
-        return localize(5423, "Plugin name must not contain consecutive hyphens or periods.");
+        return localize(5845, "Plugin name must not contain consecutive hyphens or periods.");
     }
     return undefined;
 }
+var PluginCreationFormat;
+(function(PluginCreationFormat) {
+    PluginCreationFormat[PluginCreationFormat["AgentPlugin"] = 0] = "AgentPlugin";
+    PluginCreationFormat[PluginCreationFormat["AgentPluginWithLegacyCompatibility"] = 1] = "AgentPluginWithLegacyCompatibility";
+})(PluginCreationFormat || (PluginCreationFormat = {}));
 function isUserDefined(storage) {
     return storage === PromptsStorage.local || storage === PromptsStorage.user;
 }
@@ -72,7 +78,7 @@ class CreatePluginAction extends Action2 {
     constructor() {
         super({
             id: CreatePluginAction.ID,
-            title: ( localize2(5424, "Create Plugin")),
+            title: ( localize2(5846, "Create Plugin")),
             category: CHAT_CATEGORY,
             f1: true,
             precondition: ChatContextKeys.enabled,
@@ -132,11 +138,11 @@ class CreatePluginAction extends Action2 {
                     children
                 });
             };
-            addGroup(instructions, "instruction", ( localize(5425, "Instructions")), Codicon.book);
-            addGroup(prompts, "prompt", ( localize(5426, "Prompts")), Codicon.comment);
-            addGroup(agents, "agent", ( localize(5427, "Agents")), Codicon.copilot);
-            addGroup(skills, "skill", ( localize(5428, "Skills")), Codicon.lightbulb);
-            addGroup(hooks, "hook", ( localize(5429, "Hooks")), Codicon.zap);
+            addGroup(instructions, "instruction", ( localize(5847, "Instructions")), Codicon.book);
+            addGroup(prompts, "prompt", ( localize(5848, "Prompts")), Codicon.comment);
+            addGroup(agents, "agent", ( localize(5849, "Agents")), Codicon.copilot);
+            addGroup(skills, "skill", ( localize(5850, "Skills")), Codicon.lightbulb);
+            addGroup(hooks, "hook", ( localize(5851, "Hooks")), Codicon.zap);
             const mcpChildren = [];
             for (const collection of mcpCollections) {
                 if (!showAll && !isUserDefinedMcpCollection(collection)) {
@@ -158,7 +164,7 @@ class CreatePluginAction extends Action2 {
             }
             if (mcpChildren.length > 0) {
                 groups.push({
-                    label: ( localize(5430, "MCP Servers")),
+                    label: ( localize(5852, "MCP Servers")),
                     iconClass: ThemeIcon.asClassName(Codicon.mcp),
                     checked: undefined,
                     collapsed: false,
@@ -170,15 +176,15 @@ class CreatePluginAction extends Action2 {
         };
         const disposables = ( new DisposableStore());
         const tree = disposables.add(quickInputService.createQuickTree());
-        tree.placeholder = ( localize(5431, "Select resources to include in the plugin"));
+        tree.placeholder = ( localize(5853, "Select resources to include in the plugin"));
         tree.matchOnDescription = true;
         tree.matchOnLabel = true;
         tree.sortByLabel = false;
-        tree.title = ( localize(5432, "Create Plugin"));
+        tree.title = ( localize(5854, "Create Plugin"));
         tree.setItemTree(buildTree());
         const toggleButton = {
             iconClass: ThemeIcon.asClassName(Codicon.filter),
-            tooltip: ( localize(5433, "Show Built-in, Extension, and Plugin Resources"))
+            tooltip: ( localize(5855, "Show Built-in, Extension, and Plugin Resources"))
         };
         tree.buttons = [toggleButton];
         disposables.add(tree.onDidTriggerButton(button => {
@@ -202,8 +208,23 @@ class CreatePluginAction extends Action2 {
             return;
         }
         const selected = selectedItems.filter(i => !!i.resourceType);
+        const formatPick = await quickInputService.pick([{
+            label: ( localize(5856, "Agent Plugin")),
+            description: ( localize(5857, "Standard plugin format")),
+            format: PluginCreationFormat.AgentPlugin
+        }, {
+            label: ( localize(5858, "Open Plugin (Legacy Compatibility)")),
+            description: ( localize(5859, "Also supports older clients")),
+            format: PluginCreationFormat.AgentPluginWithLegacyCompatibility
+        }], {
+            title: ( localize(5860, "Select Plugin Format")),
+            placeHolder: ( localize(5861, "Select how the plugin should be created"))
+        });
+        if (!formatPick) {
+            return;
+        }
         const pluginName = await quickInputService.input({
-            prompt: ( localize(5434, "Enter a name for the plugin")),
+            prompt: ( localize(5862, "Enter a name for the plugin")),
             placeHolder: "my-plugin",
             validateInput: async value => validatePluginName(value)
         });
@@ -214,8 +235,8 @@ class CreatePluginAction extends Action2 {
             canSelectFiles: false,
             canSelectFolders: true,
             canSelectMany: false,
-            title: ( localize(5435, "Select Plugin Save Location")),
-            openLabel: ( localize(5436, "Select Folder"))
+            title: ( localize(5863, "Select Plugin Save Location")),
+            openLabel: ( localize(5864, "Select Folder"))
         });
         if (!folderUris || folderUris.length === 0) {
             return;
@@ -224,48 +245,76 @@ class CreatePluginAction extends Action2 {
         const pluginRoot = joinPath(targetDir, pluginName);
         if (await fileService.exists(pluginRoot)) {
             notificationService.error(( localize(
-                5437,
+                5865,
                 "A directory named '{0}' already exists at this location. Please choose a different name or location.",
                 pluginName
             )));
             return;
         }
         try {
-            await writePluginToDisk(fileService, pluginRoot, pluginName, selected);
+            await writePluginToDisk(fileService, pluginRoot, pluginName, selected, formatPick.format);
             await updateMarketplaceIfNeeded(fileService, targetDir, pluginName);
             try {
                 await commandService.executeCommand("revealFileInOS", pluginRoot);
             } catch {}
-            notificationService.info(( localize(5438, "Plugin '{0}' created successfully.", pluginName)));
+            notificationService.info(( localize(5866, "Plugin '{0}' created successfully.", pluginName)));
         } catch (err) {
-            notificationService.error(( localize(5439, "Failed to create plugin: {0}", String(err))));
+            notificationService.error(( localize(5867, "Failed to create plugin: {0}", String(err))));
         }
     }
 }
-async function writePluginToDisk(fileService, pluginRoot, pluginName, selected) {
+async function writePluginToDisk(
+    fileService,
+    pluginRoot,
+    pluginName,
+    selected,
+    format = PluginCreationFormat.AgentPlugin
+) {
+    const byType = {
+        instruction: selected.filter(i => i.resourceType === "instruction"),
+        prompt: selected.filter(i => i.resourceType === "prompt"),
+        agent: selected.filter(i => i.resourceType === "agent"),
+        skill: selected.filter(i => i.resourceType === "skill"),
+        hook: selected.filter(i => i.resourceType === "hook"),
+        mcp: selected.filter(i => i.resourceType === "mcp")
+    };
+    const mcpServers = {};
+    for (const item of byType.mcp) {
+        if (item.mcpServer) {
+            const definition = item.mcpServer.definition;
+            mcpServers[definition.label] = serializeMcpLaunch(definition.launch, definition.label);
+        }
+    }
     await fileService.createFolder(pluginRoot);
-    const manifestDir = joinPath(pluginRoot, ".plugin");
-    await fileService.createFolder(manifestDir);
     const manifest = {
+        $schema: AGENT_PLUGIN_SCHEMA,
         name: pluginName,
         version: "1.0.0",
         description: ""
     };
     await fileService.writeFile(
-        joinPath(manifestDir, "plugin.json"),
+        joinPath(pluginRoot, "plugin.json"),
         VSBuffer.fromString(JSON.stringify(manifest, null, "\t"))
     );
-    const byType = {
-        instruction: selected.filter(i => i.resourceType === "instruction"),
-        prompt: selected.filter(i => i.resourceType === "prompt"),
-        agent: selected.filter(i => i.resourceType === "agent"),
-        skill: selected.filter(i => i.resourceType === "skill"),
-        hook: selected.filter(i => i.resourceType === "hook"),
-        mcp: selected.filter(i => i.resourceType === "mcp")
-    };
+    if (format === PluginCreationFormat.AgentPluginWithLegacyCompatibility) {
+        const legacyManifestDir = joinPath(pluginRoot, ".plugin");
+        await fileService.createFolder(legacyManifestDir);
+        await fileService.writeFile(
+            joinPath(legacyManifestDir, "plugin.json"),
+            VSBuffer.fromString(JSON.stringify({
+                name: pluginName,
+                version: "1.0.0",
+                description: ""
+            }, null, "\t"))
+        );
+    }
+    const copilotExtensionDir = joinPath(pluginRoot, "com.github.copilot");
     if (byType.instruction.length > 0) {
-        const rulesDir = joinPath(pluginRoot, "rules");
-        await fileService.createFolder(rulesDir);
+        const rulesDirs = [joinPath(copilotExtensionDir, "rules")];
+        if (format === PluginCreationFormat.AgentPluginWithLegacyCompatibility) {
+            rulesDirs.push(joinPath(pluginRoot, "rules"));
+        }
+        await Promise.all(( rulesDirs.map(dir => fileService.createFolder(dir))));
         for (const item of byType.instruction) {
             if (!item.promptPath) {
                 continue;
@@ -273,12 +322,15 @@ async function writePluginToDisk(fileService, pluginRoot, pluginName, selected)
             const name = getResourceFileName(item.promptPath);
             const fileName = name.endsWith(".instructions.md") || name.endsWith(".mdc") || name.endsWith(".md") ? name : name + ".instructions.md";
             const content = await fileService.readFile(item.promptPath.uri);
-            await fileService.writeFile(joinPath(rulesDir, fileName), content.value);
+            await Promise.all(( rulesDirs.map(dir => fileService.writeFile(joinPath(dir, fileName), content.value))));
         }
     }
     if (byType.prompt.length > 0) {
-        const commandsDir = joinPath(pluginRoot, "commands");
-        await fileService.createFolder(commandsDir);
+        const commandsDirs = [joinPath(copilotExtensionDir, "commands")];
+        if (format === PluginCreationFormat.AgentPluginWithLegacyCompatibility) {
+            commandsDirs.push(joinPath(pluginRoot, "commands"));
+        }
+        await Promise.all(( commandsDirs.map(dir => fileService.createFolder(dir))));
         for (const item of byType.prompt) {
             if (!item.promptPath) {
                 continue;
@@ -286,12 +338,15 @@ async function writePluginToDisk(fileService, pluginRoot, pluginName, selected)
             const name = getResourceFileName(item.promptPath);
             const fileName = name.endsWith(".md") ? name : name + ".md";
             const content = await fileService.readFile(item.promptPath.uri);
-            await fileService.writeFile(joinPath(commandsDir, fileName), content.value);
+            await Promise.all(( commandsDirs.map(dir => fileService.writeFile(joinPath(dir, fileName), content.value))));
         }
     }
     if (byType.agent.length > 0) {
-        const agentsDir = joinPath(pluginRoot, "agents");
-        await fileService.createFolder(agentsDir);
+        const agentsDirs = [joinPath(copilotExtensionDir, "agents")];
+        if (format === PluginCreationFormat.AgentPluginWithLegacyCompatibility) {
+            agentsDirs.push(joinPath(pluginRoot, "agents"));
+        }
+        await Promise.all(( agentsDirs.map(dir => fileService.createFolder(dir))));
         for (const item of byType.agent) {
             if (!item.promptPath) {
                 continue;
@@ -299,7 +354,7 @@ async function writePluginToDisk(fileService, pluginRoot, pluginName, selected)
             const name = getResourceFileName(item.promptPath);
             const fileName = name.endsWith(".md") ? name : name + ".md";
             const content = await fileService.readFile(item.promptPath.uri);
-            await fileService.writeFile(joinPath(agentsDir, fileName), content.value);
+            await Promise.all(( agentsDirs.map(dir => fileService.writeFile(joinPath(dir, fileName), content.value))));
         }
     }
     if (byType.skill.length > 0) {
@@ -319,8 +374,11 @@ async function writePluginToDisk(fileService, pluginRoot, pluginName, selected)
         }
     }
     if (byType.hook.length > 0) {
-        const hooksDir = joinPath(pluginRoot, "hooks");
-        await fileService.createFolder(hooksDir);
+        const hooksDirs = [joinPath(copilotExtensionDir, "hooks")];
+        if (format === PluginCreationFormat.AgentPluginWithLegacyCompatibility) {
+            hooksDirs.push(joinPath(pluginRoot, "hooks"));
+        }
+        await Promise.all(( hooksDirs.map(dir => fileService.createFolder(dir))));
         const mergedHooks = {};
         for (const item of byType.hook) {
             if (!item.promptPath) {
@@ -347,27 +405,30 @@ async function writePluginToDisk(fileService, pluginRoot, pluginName, selected)
         const hooksJson = {
             hooks: mergedHooks
         };
-        await fileService.writeFile(
-            joinPath(hooksDir, "hooks.json"),
-            VSBuffer.fromString(JSON.stringify(hooksJson, null, "\t"))
-        );
+        const hooksContent = VSBuffer.fromString(JSON.stringify(hooksJson, null, "\t"));
+        await Promise.all(( hooksDirs.map(dir => fileService.writeFile(joinPath(dir, "hooks.json"), hooksContent))));
     }
-    if (byType.mcp.length > 0) {
-        const mcpServers = {};
-        for (const item of byType.mcp) {
-            if (!item.mcpServer) {
-                continue;
-            }
-            const def = item.mcpServer.definition;
-            mcpServers[def.label] = serializeMcpLaunch(def.launch);
-        }
+    if (( Object.keys(mcpServers)).length > 0) {
         const mcpJson = {
+            $schema: AGENT_PLUGIN_MCP_SCHEMA,
             mcpServers
         };
         await fileService.writeFile(
-            joinPath(pluginRoot, ".mcp.json"),
+            joinPath(pluginRoot, "mcp.json"),
             VSBuffer.fromString(JSON.stringify(mcpJson, null, "\t"))
         );
+        if (format === PluginCreationFormat.AgentPluginWithLegacyCompatibility) {
+            const legacyMcpServers = {};
+            for (const item of byType.mcp) {
+                if (item.mcpServer) {
+                    const definition = item.mcpServer.definition;
+                    legacyMcpServers[definition.label] = serializeLegacyMcpLaunch(definition.launch, definition.label);
+                }
+            }
+            await fileService.writeFile(joinPath(pluginRoot, ".mcp.json"), VSBuffer.fromString(JSON.stringify({
+                mcpServers: legacyMcpServers
+            }, null, "\t")));
+        }
     }
 }
 function serializeHookCommand(cmd) {
@@ -397,8 +458,47 @@ function serializeHookCommand(cmd) {
     }
     return result;
 }
-function serializeMcpLaunch(launch) {
+function serializeMcpLaunch(launch, serverLabel = "") {
     if (launch.type === McpServerTransportType.Stdio) {
+        if (!isPortableMcpCommand(launch.command)) {
+            throw ( new Error(( localize(
+                5868,
+                "MCP server '{0}' cannot be exported because its command is not a bare executable name or a plugin-relative path.",
+                serverLabel
+            ))));
+        }
+        if (launch.cwd && !isPortableMcpWorkingDirectory(launch.cwd)) {
+            throw ( new Error(( localize(
+                5869,
+                "MCP server '{0}' cannot be exported because its working directory is not plugin-relative.",
+                serverLabel
+            ))));
+        }
+        if (launch.envFile) {
+            throw ( new Error(( localize(
+                5870,
+                "MCP server '{0}' cannot be exported because Agent Plugins do not support environment files.",
+                serverLabel
+            ))));
+        }
+        if (launch.sandbox) {
+            throw ( new Error(( localize(
+                5871,
+                "MCP server '{0}' cannot be exported because Agent Plugins do not support sandbox configuration.",
+                serverLabel
+            ))));
+        }
+        const env = {};
+        for (const [key, value] of Object.entries(launch.env)) {
+            if (typeof value !== "string" || key.toUpperCase() === "PLUGIN_ROOT" || key.toUpperCase() === "PLUGIN_DATA") {
+                throw ( new Error(( localize(
+                    5872,
+                    "MCP server '{0}' cannot be exported because its environment contains values that Agent Plugins do not support.",
+                    serverLabel
+                ))));
+            }
+            env[key] = value;
+        }
         const result = {
             type: "stdio",
             command: launch.command
@@ -409,26 +509,76 @@ function serializeMcpLaunch(launch) {
         if (launch.cwd) {
             result["cwd"] = launch.cwd;
         }
-        if (( Object.keys(launch.env)).length > 0) {
-            result["env"] = {
-                ...launch.env
-            };
+        if (( Object.keys(env)).length > 0) {
+            result["env"] = env;
         }
         return result;
     } else {
+        if (launch.headers.length > 0) {
+            throw ( new Error(( localize(
+                5873,
+                "MCP server '{0}' cannot be exported because portable plugins cannot include HTTP headers.",
+                serverLabel
+            ))));
+        }
         const result = {
-            type: "http",
-            url: ( launch.uri.toString())
+            type: launch.transport ?? "streamable-http",
+            url: ( launch.uri.toString(true))
         };
-        if (launch.headers.length > 0) {
-            const headers = {};
-            for (const [key, value] of launch.headers) {
-                headers[key] = value;
+        return result;
+    }
+}
+function serializeLegacyMcpLaunch(launch, serverLabel = "") {
+    const portableLaunch = serializeMcpLaunch(launch, serverLabel);
+    if (launch.type === McpServerTransportType.Stdio) {
+        return portableLaunch;
+    }
+    return {
+        type: "http",
+        ...(launch.transport === "sse" ? {
+            transport: "sse"
+        } : {}),
+        url: ( launch.uri.toString(true))
+    };
+}
+function isPortableMcpCommand(command) {
+    if (!command) {
+        return false;
+    }
+    return command.startsWith("./") ? command.length > 2 && isContainedRelativePath(command.slice(2)) : !/[\\/\s]/.test(command);
+}
+function isPortableMcpWorkingDirectory(cwd) {
+    if (cwd.startsWith("./")) {
+        return isContainedRelativePath(cwd.slice(2));
+    }
+    for (const root of ["${PLUGIN_ROOT}", "${PLUGIN_DATA}"]) {
+        if (cwd === root) {
+            return true;
+        }
+        if (cwd.startsWith(`${root}/`)) {
+            return isContainedRelativePath(cwd.slice(root.length + 1));
+        }
+    }
+    return false;
+}
+function isContainedRelativePath(path) {
+    let depth = 0;
+    for (const segment of path.split("/")) {
+        if (!segment || segment === ".") {
+            continue;
+        }
+        if (segment === "..") {
+            if (depth === 0) {
+                return false;
             }
-            result["headers"] = headers;
+            depth--;
+        } else if (segment.includes("\\")) {
+            return false;
+        } else {
+            depth++;
         }
-        return result;
     }
+    return true;
 }
 async function copyDirectory(fileService, source, target) {
     const stat = await fileService.resolve(source);
@@ -481,4 +631,4 @@ function registerCreatePluginAction() {
     return store;
 }
 
-export { copyDirectory, getResourceFileName, getResourceLabel, registerCreatePluginAction, serializeHookCommand, serializeMcpLaunch, updateMarketplaceIfNeeded, validatePluginName, writePluginToDisk };
+export { PluginCreationFormat, copyDirectory, getResourceFileName, getResourceLabel, registerCreatePluginAction, serializeHookCommand, serializeLegacyMcpLaunch, serializeMcpLaunch, updateMarketplaceIfNeeded, validatePluginName, writePluginToDisk };

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

@@ -1,8 +1,14 @@
+import { type VSBufferReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { type IAgentHostDebugLogsArtifact, type IAgentHostDebugLogsChunk } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { type SessionState } 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 { IFileDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
 import { IAgentHostDebugLogsExportService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.service";
 /**
  * Description of the agent-host session whose logs should be exported. If
@@ -12,40 +18,79 @@ import { IAgentHostDebugLogsExportService } from "@codingame/monaco-vscode-api/v
 export interface IActiveAgentHostSessionForExport {
     /** The chat session resource. */
     readonly resource: URI;
-    /** Optional display title used to derive the default zip filename. */
-    readonly title: string | undefined;
+    /** Optional owning-session title used to namespace the default zip filename. */
+    readonly sessionTitle: string | undefined;
+    /** Optional active-chat title used to derive the default zip filename. */
+    readonly chatTitle: string | undefined;
     /** True for local agent-host sessions (`agent-host-*` scheme). */
     readonly isLocal: boolean;
+    /** Backend chat identifier selected within the session. */
+    readonly chatId: string;
+    /** Exact host-published backend chat resource, when already resolved by the provider. */
+    readonly backendChatResource: URI | undefined;
 }
+export type IAgentHostDebugLogFile = {
+    readonly path: string;
+    readonly contents: string;
+    readonly size: number;
+} | {
+    readonly path: string;
+    readonly resource: URI;
+    readonly size: number;
+};
 export interface IAgentHostDebugLogsExport {
-    readonly files: {
-        path: string;
-        contents: string;
-    }[];
-    readonly exportName: string;
+    readonly files: IAgentHostDebugLogFile[];
+    readonly hostArtifact: IAgentHostDebugLogsHostArtifact | undefined;
+}
+/**
+ * A debug-log artifact produced by an agent host, paired with the means to read
+ * its bytes. For a remote host the artifact lives on the remote disk, so
+ * {@link readChunk} streams it over AHP in bounded slices instead of
+ * materializing the whole archive in one protocol message.
+ */
+export interface IAgentHostDebugLogsHostArtifact {
+    readonly artifact: IAgentHostDebugLogsArtifact;
+    readonly readChunk: (resource: URI, position: number) => Promise<IAgentHostDebugLogsChunk>;
 }
 export declare class BrowserAgentHostDebugLogsExportService implements IAgentHostDebugLogsExportService {
     private readonly fileDialogService;
     private readonly fileService;
+    private readonly logService;
     readonly _serviceBrand: undefined;
-    constructor(fileDialogService: IFileDialogService, fileService: IFileService);
-    save(exportName: string, files: readonly {
-        path: string;
-        contents: string;
-    }[]): Promise<boolean>;
+    readonly hostArtifactKind = "directory";
+    constructor(fileDialogService: IFileDialogService, fileService: IFileService, logService: ILogService);
+    selectDestination(exportName: string): Promise<URI | undefined>;
+    save(destination: URI, files: readonly IAgentHostDebugLogFile[], hostArtifact: IAgentHostDebugLogsHostArtifact | undefined): Promise<void>;
 }
+export declare function resolveAgentHostDebugLogsChat(activeSession: Pick<IActiveAgentHostSessionForExport, "backendChatResource" | "chatId" | "sessionTitle">, state: SessionState | Error | undefined): {
+    backendChat: URI | undefined;
+    sessionTitle: string | undefined;
+};
+/**
+ * Streams a host-owned artifact by repeatedly calling `readChunk`. The stream
+ * fails if the host overruns or underruns the size it declared, so a
+ * truncated or runaway transfer can never be silently zipped up.
+ */
+export declare function createHostArtifactStream(artifact: IAgentHostDebugLogsArtifact, readChunk: (position: number) => Promise<IAgentHostDebugLogsChunk>): VSBufferReadableStream;
 /**
  * Shared implementation of "Export Agent Host Debug Logs". Collects the
- * Copilot CLI session events file (if available), the window/shared/local
- * agent-host output channel logs, remote forwarded logs, and the AHP
- * transport JSONL logs.
+ * Agent Host's own debug-log bundle (collected and packaged by the host), plus
+ * the logs this side owns: the window/shared-process output channels, remote
+ * forwarded logs, the AHP transport JSONL logs, and the client-local capture
+ * sidecars.
  *
  * Both the workbench-side action (resolves the active session via
  * `IChatWidgetService`) and the sessions-app-side action (resolves it via
  * `ISessionsManagementService`) call into this helper.
  */
-export declare function collectAgentHostDebugLogs(accessor: ServicesAccessor, activeSession: IActiveAgentHostSessionForExport | undefined): Promise<IAgentHostDebugLogsExport | undefined>;
+export declare function collectAgentHostDebugLogs(accessor: ServicesAccessor, activeSession: IActiveAgentHostSessionForExport | undefined, onDidCreateHostArtifact: (artifact: IAgentHostDebugLogsArtifact) => void): Promise<IAgentHostDebugLogsExport>;
+export declare function getAgentHostDebugLogsExportName(sessionTitle: string | undefined, chatTitle: string | undefined, isPrimaryChat: boolean): string;
+export declare function prepareAgentHostDebugLogsExport(selectDestination: () => Promise<URI | undefined>, collectLogs: () => Promise<IAgentHostDebugLogsExport>): Promise<[
+    PromiseSettledResult<IAgentHostDebugLogsExport>,
+    PromiseSettledResult<URI | undefined>
+]>;
 export declare function exportAgentHostDebugLogs(accessor: ServicesAccessor, activeSession: IActiveAgentHostSessionForExport | undefined): Promise<void>;
+export declare function notifyAgentHostDebugLogsExported(notificationService: INotificationService, clipboardService: IClipboardService, isInternal: boolean, savedResource: URI): void;
 /**
  * Workbench-side action. Uses the last-focused chat widget's view model to
  * find the active Copilot CLI chat session. Suitable for vscode where the
@@ -62,4 +107,6 @@ export declare class ExportAgentHostDebugLogsAction extends Action2 {
  * session (i.e. local AH or remote AH; the EH CLI extension's own
  * `copilotcli:` sessions are excluded).
  */
-export declare function toActiveAgentHostSession(resource: URI, title: string | undefined): IActiveAgentHostSessionForExport | undefined;
+export declare function toActiveAgentHostSession(resource: URI, chatTitle: string | undefined, sessionTitle?: string): IActiveAgentHostSessionForExport | undefined;
+export declare function collectRotatedLogFiles(path: string, current: URI, fileService: IFileService, maxInlineSize?: number): Promise<IAgentHostDebugLogFile[]>;
+export declare function findOutputChannelLogFiles(windowLogsPath: URI, fileNames: ReadonlySet<string>, fileService: IFileService): Promise<URI[]>;