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

package/vscode/src/vs/platform/agentHost/common/meta/agentCompletionAttachmentMeta.js

@@ -0,0 +1,79 @@
+
+
+function readCompletionAttachmentMeta(attachment) {
+    const meta = attachment._meta;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return undefined;
+    }
+    if (typeof meta["command"] === "string") {
+        const action = readCompletionActionMeta(meta["action"]);
+        return {
+            kind: "command",
+            command: meta["command"],
+            ...(meta["isSkill"] === true ? {
+                isSkill: true
+            } : {}),
+            ...(typeof meta["description"] === "string" ? {
+                description: meta["description"]
+            } : {}),
+            ...(typeof meta["argumentHint"] === "string" ? {
+                argumentHint: meta["argumentHint"]
+            } : {}),
+            ...(action ? {
+                action
+            } : {})
+        };
+    }
+    if (typeof meta["uri"] === "string") {
+        return {
+            kind: "skill",
+            uri: meta["uri"],
+            ...(typeof meta["name"] === "string" ? {
+                name: meta["name"]
+            } : {}),
+            ...(typeof meta["displayName"] === "string" ? {
+                displayName: meta["displayName"]
+            } : {}),
+            ...(typeof meta["description"] === "string" ? {
+                description: meta["description"]
+            } : {})
+        };
+    }
+    return undefined;
+}
+function getCompletionAction(meta) {
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return undefined;
+    }
+    return readCompletionActionMeta(meta["action"]);
+}
+function readCompletionActionMeta(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = value;
+    let applyConfig;
+    const rawApplyConfig = raw["applyConfig"];
+    if (rawApplyConfig && typeof rawApplyConfig === "object" && !Array.isArray(rawApplyConfig)) {
+        for (const [key, entry] of Object.entries(rawApplyConfig)) {
+            if (typeof entry === "string") {
+                applyConfig ??= {};
+                applyConfig[key] = entry;
+            }
+        }
+    }
+    if (applyConfig === undefined) {
+        return undefined;
+    }
+    return {
+        applyConfig
+    };
+}
+function getCommandArgumentHint(meta) {
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return undefined;
+    }
+    return typeof meta["argumentHint"] === "string" ? meta["argumentHint"] : undefined;
+}
+
+export { getCommandArgumentHint, getCompletionAction, readCompletionAttachmentMeta };

package/vscode/src/vs/platform/agentHost/common/meta/agentCustomizationMeta.d.ts

@@ -0,0 +1,27 @@
+import type { AgentCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Well-known typed view over a custom agent's `_meta` bag (see
+ * `AgentCustomization._meta`), populated by the host's customization discovery
+ * and read by the agents-window customization providers. Read it through
+ * {@link readAgentCustomizationMeta} rather than indexing `_meta` directly.
+ */
+export interface IAgentCustomizationMeta {
+    /**
+     * Whether the user may invoke this custom agent directly (e.g. from the
+     * agent picker). Absent is treated as `true` by convention — only an
+     * explicit `false` hides the agent from direct user invocation.
+     */
+    readonly userInvocable?: boolean;
+}
+/**
+ * Reads the well-known {@link IAgentCustomizationMeta} keys from a custom
+ * agent's `_meta` bag, dropping unknown keys and wrong-typed values.
+ */
+export declare function readAgentCustomizationMeta(agent: AgentCustomization): IAgentCustomizationMeta;
+/**
+ * Serializes a typed {@link IAgentCustomizationMeta} into the `_meta` record,
+ * dropping `undefined` entries and returning `undefined` when empty. Build a
+ * custom agent's `_meta` through this so producers stay in lock-step with
+ * {@link readAgentCustomizationMeta}.
+ */
+export declare function toAgentCustomizationMeta(meta: IAgentCustomizationMeta): Record<string, unknown> | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/agentCustomizationMeta.js

@@ -0,0 +1,14 @@
+
+
+function readAgentCustomizationMeta(agent) {
+    const meta = agent._meta;
+    const result = {};
+    if (agent.disableUserInvocation === true) {
+        result.userInvocable = false;
+    } else if (typeof meta?.["userInvocable"] === "boolean") {
+        result.userInvocable = meta["userInvocable"];
+    }
+    return result;
+}
+
+export { readAgentCustomizationMeta };

package/vscode/src/vs/platform/agentHost/common/meta/agentEphemeralSessionMeta.d.ts

@@ -0,0 +1,14 @@
+/** VS Code-owned request metadata indicating a throwaway chat surface. */
+export declare const VSCODE_EPHEMERAL_SESSION_META_KEY = "vscode.chat.ephemeralSession";
+interface IHasEphemeralSessionMeta {
+    readonly _meta?: Record<string, unknown>;
+}
+/** Typed view over VS Code's ephemeral-session request metadata. */
+export interface IEphemeralSessionMeta {
+    readonly isEphemeral?: boolean;
+}
+/** Reads recognized ephemeral-session metadata, dropping wrong-typed values. */
+export declare function readEphemeralSessionMeta(source: IHasEphemeralSessionMeta): IEphemeralSessionMeta;
+/** Adds VS Code's ephemeral-session metadata to an open request metadata bag. */
+export declare function withEphemeralSessionMeta(meta: Record<string, unknown> | undefined, isEphemeral: boolean | undefined): Record<string, unknown> | undefined;
+export {};

package/vscode/src/vs/platform/agentHost/common/meta/agentEphemeralSessionMeta.js

@@ -0,0 +1,11 @@
+
+
+const VSCODE_EPHEMERAL_SESSION_META_KEY = 'vscode.chat.ephemeralSession';
+function withEphemeralSessionMeta(meta, isEphemeral) {
+    if (isEphemeral === undefined) {
+        return meta;
+    }
+    return { ...(meta ?? {}), [VSCODE_EPHEMERAL_SESSION_META_KEY]: isEphemeral };
+}
+
+export { VSCODE_EPHEMERAL_SESSION_META_KEY, withEphemeralSessionMeta };

package/vscode/src/vs/platform/agentHost/common/meta/agentHostArtifactRemovalMeta.d.ts

@@ -0,0 +1,4 @@
+import type { InitializeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
+export declare const AgentHostArtifactRemovalCapabilityMetaKey = "vscode.removeSessionArtifact";
+/** Whether the host advertises the VS Code-only artifact removal request. */
+export declare function supportsAgentHostArtifactRemoval(result: InitializeResult | undefined): boolean;

package/vscode/src/vs/platform/agentHost/common/meta/clientPluginCustomizationMeta.d.ts

@@ -0,0 +1,7 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import type { ClientPluginCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+export type ClientPluginMcpDefaultCwds = Readonly<Record<string, URI | null>>;
+export declare function toClientPluginMcpDefaultCwdsMeta(defaultCwds: ClientPluginMcpDefaultCwds): Record<string, unknown>;
+export declare function hasClientPluginMcpDefaultCwds(customization: ClientPluginCustomization): boolean;
+export declare function hasClientPluginMcpDefaultCwd(customization: ClientPluginCustomization, serverName: string): boolean;
+export declare function readClientPluginMcpDefaultCwd(customization: ClientPluginCustomization, serverName: string, primaryCwd: URI | undefined): URI | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/clientPluginCustomizationMeta.js

@@ -0,0 +1,14 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+
+const mcpDefaultCwdsKey = "mcpDefaultCwds";
+function toClientPluginMcpDefaultCwdsMeta(defaultCwds) {
+    return {
+        [mcpDefaultCwdsKey]: Object.fromEntries(( Object.entries(defaultCwds).map(([name, cwd]) => [name, cwd?.toString() ?? null])))
+    };
+}
+
+export { toClientPluginMcpDefaultCwdsMeta };

package/vscode/src/vs/platform/agentHost/common/sandboxConfigSchema.d.ts

@@ -49,15 +49,15 @@ export type ISandboxConfigValue = Partial<{
  * normalized form of each setting is declared here — the workbench is
  * expected to:
  *
- *  - map legacy boolean sandbox enabled values to the `'on' | 'off' | 'allowNetwork'`
+ *  - map legacy boolean sandbox enabled values to the `'on' | 'off'`
  *    agent-host enum, and
  *  - migrate values from any deprecated setting IDs to their modern key
  *
  * before pushing a `RootConfigChanged` action. That keeps the agent-host
  * schema (and validation) free of backward-compat baggage.
  */
-export declare const sandboxConfigSchema: import("./agentHostSchema.js").ISchema<{
-    sandbox: import("./agentHostSchema.js").ISchemaProperty<Partial<{
+export declare const sandboxConfigSchema: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchema<{
+    sandbox: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<Partial<{
         enabled: AgentSandboxEnabledValue;
         "enabled.windows": AgentSandboxEnabledValue;
         allowNetwork: boolean;

package/vscode/src/vs/platform/agentHost/common/sandboxConfigSchema.js

@@ -2,7 +2,7 @@
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { AgentNetworkDomainSettingId } from '../../networkFilter/common/settings.js';
 import { AgentSandboxEnabledValue, AgentSandboxSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
-import { createSchema, schemaProperty } from './agentHostSchema.js';
+import { createSchema, schemaProperty } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
 
 var AgentHostSandboxConfigKey;
 (function(AgentHostSandboxConfigKey) {
@@ -24,64 +24,56 @@ var AgentHostSandboxKey;
 createSchema({
     [AgentHostSandboxConfigKey.Sandbox]: schemaProperty({
         type: "object",
-        title: ( localize(1920, "Agent Sandbox")),
+        title: ( localize(2126, "Agent Sandbox")),
         properties: {
             [AgentHostSandboxKey.Enabled]: {
                 type: "string",
-                title: ( localize(1921, "Sandbox Enabled")),
-                enum: [
-                    AgentSandboxEnabledValue.Off,
-                    AgentSandboxEnabledValue.On,
-                    AgentSandboxEnabledValue.AllowNetwork
-                ]
+                title: ( localize(2127, "Sandbox Enabled")),
+                enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.WindowsEnabled]: {
                 type: "string",
-                title: ( localize(1922, "Sandbox Enabled (Windows)")),
-                enum: [
-                    AgentSandboxEnabledValue.Off,
-                    AgentSandboxEnabledValue.On,
-                    AgentSandboxEnabledValue.AllowNetwork
-                ]
+                title: ( localize(2128, "Sandbox Enabled (Windows)")),
+                enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.AllowNetwork]: {
                 type: "boolean",
-                title: ( localize(1923, "Allow Network"))
+                title: ( localize(2129, "Allow Network"))
             },
             [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
                 type: "boolean",
-                title: ( localize(1924, "Allow Unsandboxed Commands"))
+                title: ( localize(2130, "Allow Unsandboxed Commands"))
             },
             [AgentHostSandboxKey.LinuxFileSystem]: {
                 type: "object",
-                title: ( localize(1925, "Linux Sandbox Filesystem"))
+                title: ( localize(2131, "Linux Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.MacFileSystem]: {
                 type: "object",
-                title: ( localize(1926, "macOS Sandbox Filesystem"))
+                title: ( localize(2132, "macOS Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.WindowsFileSystem]: {
                 type: "object",
-                title: ( localize(1927, "Windows Sandbox Filesystem"))
+                title: ( localize(2133, "Windows Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.AdvancedRuntime]: {
                 type: "object",
-                title: ( localize(1928, "Advanced Sandbox Runtime"))
+                title: ( localize(2134, "Advanced Sandbox Runtime"))
             },
             [AgentHostSandboxKey.AllowedNetworkDomains]: {
                 type: "array",
-                title: ( localize(1929, "Allowed Network Domains")),
+                title: ( localize(2135, "Allowed Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(1930, "Domain"))
+                    title: ( localize(2136, "Domain"))
                 }
             },
             [AgentHostSandboxKey.DeniedNetworkDomains]: {
                 type: "array",
-                title: ( localize(1931, "Denied Network Domains")),
+                title: ( localize(2137, "Denied Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(1932, "Domain"))
+                    title: ( localize(2138, "Domain"))
                 }
             }
         }

package/vscode/src/vs/platform/agentHost/common/semanticSearchConstants.d.ts

@@ -0,0 +1,8 @@
+/** VS Code setting that exposes the workbench semantic search to Copilot agent sessions. */
+export declare const CopilotSemanticSearchEnabledSettingId = "chat.copilot.semanticSearch.enabled";
+/** Stable contribution id of the Copilot extension's workbench semantic-search tool. */
+export declare const CLIENT_SEMANTIC_SEARCH_TOOL_ID = "copilot_searchCodebase";
+/** Runtime/model-facing name; overrides the Copilot SDK's built-in tool of the same name. */
+export declare const SEMANTIC_SEARCH_TOOL_NAME = "semantic_search";
+/** Client/workbench-facing tool reference name (`#codebase`). */
+export declare const CLIENT_SEMANTIC_SEARCH_REFERENCE_NAME = "codebase";

package/vscode/src/vs/platform/agentHost/common/semanticSearchConstants.js

@@ -0,0 +1,8 @@
+
+
+const CopilotSemanticSearchEnabledSettingId = 'chat.copilot.semanticSearch.enabled';
+const CLIENT_SEMANTIC_SEARCH_TOOL_ID = 'copilot_searchCodebase';
+const SEMANTIC_SEARCH_TOOL_NAME = 'semantic_search';
+const CLIENT_SEMANTIC_SEARCH_REFERENCE_NAME = 'codebase';
+
+export { CLIENT_SEMANTIC_SEARCH_REFERENCE_NAME, CLIENT_SEMANTIC_SEARCH_TOOL_ID, CopilotSemanticSearchEnabledSettingId, SEMANTIC_SEARCH_TOOL_NAME };

package/vscode/src/vs/platform/agentHost/common/sessionArtifacts.d.ts

@@ -0,0 +1,75 @@
+import type { SessionSummaryMeta } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+/**
+ * The kinds an agent can record on its session, as either an artifact (the
+ * session produced it) or a reference (the session found it worth returning
+ * to). Each kind carries the one field the client needs to open it, plus a
+ * label.
+ */
+export declare enum SessionArtifactType {
+    PullRequest = "pullRequest",
+    Issue = "issue",
+    Commit = "commit",
+    Website = "website",
+    File = "file",
+    Resource = "resource"
+}
+export declare const SESSION_ARTIFACT_TYPES: readonly SessionArtifactType[];
+/** A session artifact or reference as stored by the host and published to clients. */
+export interface ISessionArtifact {
+    readonly id: string;
+    readonly type: SessionArtifactType;
+    readonly label: string;
+    /**
+     * `true` for an artifact — something this session produced — and `false` for
+     * a reference, something it only points the user at.
+     */
+    readonly isArtifact: boolean;
+    /** Link for pull request, issue, commit and website entries. */
+    readonly link?: string;
+    /** Resource URI for file and resource entries. */
+    readonly uri?: string;
+    /** Commit hash for commit entries. */
+    readonly commitHash?: string;
+    /** Whether a pull request or issue link points at GitHub. Host-computed. */
+    readonly isGitHub?: boolean;
+}
+/**
+ * Reserved key under {@link SessionSummaryMeta} holding the session's agent-set
+ * artifacts and references. VS Code convention layered on the protocol's
+ * generic `_meta` bag.
+ */
+export declare const SESSION_META_ARTIFACTS_KEY = "agentHost/sessionArtifacts";
+/** Reads the artifacts recorded on a session's `_meta` bag. */
+export declare function readSessionArtifacts(meta: SessionSummaryMeta | undefined): readonly ISessionArtifact[];
+/**
+ * The artifacts recorded on a session's `_meta` bag, most recent first.
+ * Artifacts are appended as the agent records them, so the stored order runs
+ * oldest to newest, while every surface lists the newest entry at the top of
+ * its group.
+ */
+export declare function readSessionArtifactsNewestFirst(meta: SessionSummaryMeta | undefined): readonly ISessionArtifact[];
+/** Returns `meta` with the artifact slot replaced, dropping it when empty. */
+export declare function withSessionArtifacts(meta: SessionSummaryMeta | undefined, artifacts: readonly ISessionArtifact[]): SessionSummaryMeta | undefined;
+/** Serializes artifacts for the session database. */
+export declare function stringifySessionArtifacts(artifacts: readonly ISessionArtifact[]): string;
+/** The outcome of reading persisted artifacts: what was read, and what was lost. */
+export interface IParsedSessionArtifacts {
+    readonly artifacts: readonly ISessionArtifact[];
+    /** Why nothing could be read, when the payload itself was unreadable. */
+    readonly error?: Error;
+    /** How many individual entries were rejected as malformed. */
+    readonly dropped: number;
+}
+/**
+ * Parses artifacts previously written by {@link stringifySessionArtifacts}.
+ * Reports what could not be read rather than silently returning less, so a
+ * corrupt row does not empty a session's artifacts without a trace.
+ */
+export declare function parseSessionArtifacts(value: string | undefined): IParsedSessionArtifacts;
+/**
+ * The value that identifies an entry for de-duplication: its link, resource
+ * URI or commit hash, normalized for comparison.
+ */
+export declare function getSessionArtifactValue(artifact: ISessionArtifact): string;
+/** Whether a pull request or issue link points at github.com or a GitHub Enterprise host. */
+export declare function isGitHubArtifactLink(link: string): boolean;

package/vscode/src/vs/platform/agentHost/common/sessionArtifacts.js

@@ -0,0 +1,84 @@
+
+
+var SessionArtifactType;
+(function(SessionArtifactType) {
+    SessionArtifactType["PullRequest"] = "pullRequest";
+    SessionArtifactType["Issue"] = "issue";
+    SessionArtifactType["Commit"] = "commit";
+    SessionArtifactType["Website"] = "website";
+    SessionArtifactType["File"] = "file";
+    SessionArtifactType["Resource"] = "resource";
+})(SessionArtifactType || (SessionArtifactType = {}));
+const SESSION_ARTIFACT_TYPES = [
+    SessionArtifactType.PullRequest,
+    SessionArtifactType.Issue,
+    SessionArtifactType.Commit,
+    SessionArtifactType.Website,
+    SessionArtifactType.File,
+    SessionArtifactType.Resource
+];
+const SESSION_META_ARTIFACTS_KEY = "agentHost/sessionArtifacts";
+function isSessionArtifactType(value) {
+    return typeof value === "string" && SESSION_ARTIFACT_TYPES.includes(value);
+}
+function parseSessionArtifact(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = value;
+    if (typeof raw["id"] !== "string" || typeof raw["label"] !== "string" || !isSessionArtifactType(raw["type"])) {
+        return undefined;
+    }
+    const isArtifact = raw["isArtifact"];
+    if (isArtifact !== undefined && typeof isArtifact !== "boolean") {
+        return undefined;
+    }
+    const artifact = {
+        id: raw["id"],
+        type: raw["type"],
+        label: raw["label"],
+        isArtifact: isArtifact ?? true
+    };
+    if (typeof raw["link"] === "string") {
+        artifact.link = raw["link"];
+    }
+    if (typeof raw["uri"] === "string") {
+        artifact.uri = raw["uri"];
+    }
+    if (typeof raw["commitHash"] === "string") {
+        artifact.commitHash = raw["commitHash"];
+    }
+    if (typeof raw["isGitHub"] === "boolean") {
+        artifact.isGitHub = raw["isGitHub"];
+    }
+    return artifact;
+}
+function readSessionArtifacts(meta) {
+    const value = meta?.[SESSION_META_ARTIFACTS_KEY];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const artifacts = [];
+    for (const entry of value) {
+        const artifact = parseSessionArtifact(entry);
+        if (artifact) {
+            artifacts.push(artifact);
+        }
+    }
+    return artifacts;
+}
+function readSessionArtifactsNewestFirst(meta) {
+    return readSessionArtifacts(meta).slice().reverse();
+}
+function isGitHubArtifactLink(link) {
+    try {
+        const {
+            hostname
+        } = ( new URL(link));
+        return hostname === "github.com" || hostname === "www.github.com" || hostname.endsWith(".github.com") || hostname.startsWith("github.");
+    } catch {
+        return false;
+    }
+}
+
+export { SESSION_ARTIFACT_TYPES, SESSION_META_ARTIFACTS_KEY, SessionArtifactType, isGitHubArtifactLink, readSessionArtifacts, readSessionArtifactsNewestFirst };

package/vscode/src/vs/platform/agentHost/common/shellInitScript.d.ts

@@ -0,0 +1,24 @@
+export type ShellInitScriptShell = "bash" | "powershell";
+/**
+ * One client-generated script sourced before every SDK built-in shell command.
+ * The array-valued session config carries either no script (`[]`) or this one
+ * script, so clearing a previously applied script is explicit.
+ */
+export interface IShellInitScript {
+    readonly shell: ShellInitScriptShell;
+    readonly script: string;
+}
+/**
+ * Creates the single script VS Code registers with the SDK shell tool.
+ *
+ * Profile loading comes first so activation runs against the user's shell
+ * setup. Activation is whatever command the Python Environments extension
+ * published for the folder; nothing tool-specific is added here.
+ *
+ * Every script ends successfully unless sourced profile code itself
+ * terminates the shell: the runtime reports a nonzero init-script status
+ * before every later command, and discards Bash init-script stderr.
+ */
+export declare function createShellInitScript(shell: ShellInitScriptShell, pythonActivation: string | undefined): IShellInitScript;
+/** Validates the client-pushed list before the agent host writes it to disk. */
+export declare function isShellInitScriptList(value: unknown): value is readonly IShellInitScript[];

package/vscode/src/vs/platform/agentHost/common/shellInitScript.js

@@ -0,0 +1,63 @@
+
+import { encodeBase64, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+
+function quoteBash(value) {
+    return `'${value.replaceAll(`'`, `'\\''`)}'`;
+}
+function encodedPowerShellExpression(value) {
+    const encoded = encodeBase64(VSBuffer.fromString(value));
+    return `[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${encoded}'))`;
+}
+function powerShellBlock(body, failureMessage) {
+    return [
+        `$__vscodePreviousErrorActionPreference = $ErrorActionPreference`,
+        `try {`,
+        `\t$ErrorActionPreference = 'Stop'`,
+        ...body,
+        `} catch {`,
+        `\tWrite-Output '${failureMessage.replaceAll(`'`, `''`)}'`,
+        `} finally {`,
+        `\t$ErrorActionPreference = $__vscodePreviousErrorActionPreference`,
+        `}`,
+    ];
+}
+function createShellInitScript(shell, pythonActivation) {
+    return shell === 'powershell'
+        ? createPowerShellInitScript(pythonActivation)
+        : createBashInitScript(pythonActivation);
+}
+function createBashInitScript(pythonActivation) {
+    const lines = [
+        `# Generated by VS Code for Agent Host shell commands.`,
+        `if [ -r "$HOME/.bashrc" ]; then`,
+        `\tbuiltin source "$HOME/.bashrc" || builtin true`,
+        `fi`,
+    ];
+    if (pythonActivation?.trim()) {
+        lines.push(`if ! builtin eval ${quoteBash(pythonActivation)}; then`, `\tprintf '%s\\n' 'copilot shell init: Python activation failed; continuing without the selected environment.'`, `fi`);
+    }
+    lines.push(`builtin true`, ``);
+    return { shell: 'bash', script: lines.join('\n') };
+}
+function createPowerShellInitScript(pythonActivation) {
+    const lines = [
+        `# Generated by VS Code for Agent Host shell commands.`,
+        `$ErrorActionPreference = 'Continue'`,
+        `foreach ($__vscodeProfile in @($PROFILE.CurrentUserAllHosts, $PROFILE.CurrentUserCurrentHost)) {`,
+        `\ttry {`,
+        `\t\tif ($__vscodeProfile -and (Test-Path -LiteralPath $__vscodeProfile)) {`,
+        `\t\t\t. $__vscodeProfile`,
+        `\t\t}`,
+        `\t} catch {`,
+        `\t\tWrite-Output 'copilot shell init: loading the PowerShell profile failed; continuing.'`,
+        `\t}`,
+        `}`,
+    ];
+    if (pythonActivation?.trim()) {
+        lines.push(...powerShellBlock([`\tInvoke-Expression (${encodedPowerShellExpression(pythonActivation)})`], 'copilot shell init: Python activation failed; continuing without the selected environment.'));
+    }
+    lines.push(`$global:LASTEXITCODE = 0`, ``);
+    return { shell: 'powershell', script: lines.join('\n') };
+}
+
+export { createShellInitScript };