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

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

@@ -0,0 +1,39 @@
+/** The metadata key for VS Code-owned chat-surface information. */
+export declare const VSCODE_CHAT_SURFACE_META_KEY = "vscode.chat.surface";
+interface IHasChatSurfaceMeta {
+    readonly _meta?: Record<string, unknown>;
+}
+/** Typed metadata for a terminal-backed chat session. */
+export interface ITerminalChatSurfaceMeta {
+    readonly surface: "terminal";
+    readonly shellType?: string;
+    readonly osName: string;
+}
+/** Metadata describing an editor inline-chat surface. */
+export interface IEditorInlineChatSurfaceMeta {
+    readonly surface: "editorInline";
+    readonly languageId?: string;
+    readonly targetUri?: string;
+}
+/** VS Code-owned metadata describing the chat surface that created a session. */
+export type IChatSurfaceMeta = ITerminalChatSurfaceMeta | IEditorInlineChatSurfaceMeta;
+/** Reads recognized chat-surface metadata, dropping malformed values. */
+export declare function readChatSurfaceMeta(source: IHasChatSurfaceMeta): IChatSurfaceMeta | undefined;
+/** Adds VS Code's typed chat-surface metadata to an open request metadata bag. */
+export declare function withChatSurfaceMeta(meta: Record<string, unknown> | undefined, surface: IChatSurfaceMeta | undefined): Record<string, unknown> | undefined;
+/**
+ * Builds the per-turn host instruction for a terminal chat surface.
+ *
+ * Lives next to {@link ITerminalChatSurfaceMeta} because it is a pure function
+ * of that shape, so the prompt and the metadata it consumes cannot drift.
+ *
+ * This is additive context layered on top of the harness's own system prompt —
+ * it biases toward terse, shell-appropriate command answers but does not by
+ * itself prevent an agentic harness from exploring with tools first.
+ */
+export declare function createTerminalChatInstruction(surface: ITerminalChatSurfaceMeta): string;
+/**
+ * Builds the per-turn host instruction for an editor inline-chat surface.
+ */
+export declare function createEditorInlineChatInstruction(surface: IEditorInlineChatSurfaceMeta): string;
+export {};

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

@@ -0,0 +1,25 @@
+
+
+const VSCODE_CHAT_SURFACE_META_KEY = 'vscode.chat.surface';
+function withChatSurfaceMeta(meta, surface) {
+    if (!surface) {
+        return meta;
+    }
+    const serializedSurface = surface.surface === 'terminal'
+        ? {
+            surface: surface.surface,
+            ...(surface.shellType !== undefined ? { shellType: surface.shellType } : {}),
+            osName: surface.osName,
+        }
+        : {
+            surface: 'editorInline',
+            ...(surface.languageId !== undefined ? { languageId: surface.languageId } : {}),
+            ...(surface.targetUri !== undefined ? { targetUri: surface.targetUri } : {}),
+        };
+    return {
+        ...({}),
+        [VSCODE_CHAT_SURFACE_META_KEY]: serializedSurface,
+    };
+}
+
+export { VSCODE_CHAT_SURFACE_META_KEY, withChatSurfaceMeta };

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

@@ -0,0 +1,110 @@
+import type { SimpleMessageAttachment } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Well-known typed views over a `SimpleMessageAttachment`'s `_meta` bag as
+ * produced by the `completions` command, populated by the slash-command and
+ * skill completion providers and read by the session handler. Read the bag
+ * through {@link readCompletionAttachmentMeta} rather than indexing `_meta`
+ * directly. Two variants are distinguished by which discriminating key is
+ * present: a slash command (`command`) or a skill (`uri`).
+ */
+/**
+ * A client-side side effect a command completion carries. When present, the
+ * workbench interprets it on accept (see the shared agent-host completion action
+ * handler) rather than treating the item as a plain text/reference insertion.
+ *
+ * Used by Copilot agent-host permission/mode toggles (e.g. `/yolo`,
+ * `/autopilot on`): the item applies a well-known session-config change. Whether
+ * the item leaves text behind is expressed by its `insertText` (empty for a pure
+ * toggle; `/command ` for an item that keeps the text so an argument can be
+ * typed, with {@link ICommandCompletionAttachmentMeta.argumentHint} as ghost text).
+ */
+export interface IAgentHostCompletionAction {
+    /**
+     * A partial agent-host session-config change to apply when the completion is
+     * accepted, keyed by well-known session-config property (e.g. `autoApprove`,
+     * `mode`) to the string-enum value. Applied via the active session's provider
+     * so the corresponding picker updates reactively.
+     */
+    readonly applyConfig?: Readonly<Record<string, string>>;
+}
+/**
+ * The `_meta` shape attached to a `completions` result that resolves to a slash
+ * command.
+ */
+export interface ICommandCompletionAttachmentMeta {
+    /** The slash command name (without the leading `/`). */
+    readonly command: string;
+    /** Whether this text-dispatched command originated from a runtime skill. */
+    readonly isSkill?: true;
+    /** Optional human-readable description of the command. */
+    readonly description?: string;
+    /**
+     * Optional hint describing the argument the command expects. Rendered as
+     * inline placeholder (ghost text) after an accepted command completion.
+     */
+    readonly argumentHint?: string;
+    /**
+     * Optional client-side action to run when the completion is accepted (e.g. a
+     * permission/mode session-config toggle). See {@link IAgentHostCompletionAction}.
+     */
+    readonly action?: IAgentHostCompletionAction;
+}
+/**
+ * The `_meta` shape attached to a `completions` result that resolves to a skill.
+ */
+export interface ISkillCompletionAttachmentMeta {
+    /** The skill resource URI as a string. */
+    readonly uri: string;
+    /** Optional internal name of the skill. */
+    readonly name?: string;
+    /** Optional human-readable display name (e.g. the slash-command name). */
+    readonly displayName?: string;
+    /** Optional human-readable description of the skill. */
+    readonly description?: string;
+}
+/**
+ * A typed, discriminated view over the well-known `completions` attachment
+ * `_meta` variants. The `kind` discriminant is computed by
+ * {@link readCompletionAttachmentMeta} from which key is present on the wire; it
+ * is not itself carried in `_meta`.
+ */
+export type CompletionAttachmentMeta = ({
+    readonly kind: "command";
+} & ICommandCompletionAttachmentMeta) | ({
+    readonly kind: "skill";
+} & ISkillCompletionAttachmentMeta);
+/**
+ * Reads the well-known `completions` attachment `_meta` keys, classifying the
+ * bag into a {@link CompletionAttachmentMeta} variant by its discriminating key
+ * (`command` for a slash command, `uri` for a skill). Returns `undefined` when
+ * the bag is absent or matches neither variant; wrong-typed keys are dropped.
+ */
+export declare function readCompletionAttachmentMeta(attachment: SimpleMessageAttachment): CompletionAttachmentMeta | undefined;
+/**
+ * Serializes a typed {@link ICommandCompletionAttachmentMeta} into the `_meta`
+ * record, dropping `undefined` entries. Build a slash-command completion's
+ * `_meta` through this so producers stay in lock-step with
+ * {@link readCompletionAttachmentMeta}.
+ */
+export declare function toCommandCompletionAttachmentMeta(meta: ICommandCompletionAttachmentMeta): Record<string, unknown>;
+/**
+ * Reads the optional {@link IAgentHostCompletionAction} carried on a command
+ * completion's raw `_meta` bag (under the `action` key). Kept as the single
+ * seam consumers use to obtain the action, mirroring {@link getCommandArgumentHint}.
+ * Returns `undefined` when absent or malformed; wrong-typed sub-fields are dropped.
+ */
+export declare function getCompletionAction(meta: Record<string, unknown> | undefined): IAgentHostCompletionAction | undefined;
+/**
+ * Reads the well-known `argumentHint` from a raw completion attachment `_meta`
+ * bag. Kept as the single seam that consumers use to obtain the hint, so a
+ * future promotion of `argumentHint` to a first-class attachment field only
+ * needs to change this reader. Returns `undefined` when absent or wrong-typed.
+ */
+export declare function getCommandArgumentHint(meta: Record<string, unknown> | undefined): string | undefined;
+/**
+ * Serializes a typed {@link ISkillCompletionAttachmentMeta} into the `_meta`
+ * record, dropping `undefined` entries. Build a skill completion's `_meta`
+ * through this so producers stay in lock-step with
+ * {@link readCompletionAttachmentMeta}.
+ */
+export declare function toSkillCompletionAttachmentMeta(meta: ISkillCompletionAttachmentMeta): Record<string, unknown>;

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

@@ -0,0 +1,38 @@
+
+
+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 };

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(2080, "Agent Sandbox")),
         properties: {
             [AgentHostSandboxKey.Enabled]: {
                 type: "string",
-                title: ( localize(1921, "Sandbox Enabled")),
-                enum: [
-                    AgentSandboxEnabledValue.Off,
-                    AgentSandboxEnabledValue.On,
-                    AgentSandboxEnabledValue.AllowNetwork
-                ]
+                title: ( localize(2081, "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(2082, "Sandbox Enabled (Windows)")),
+                enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.AllowNetwork]: {
                 type: "boolean",
-                title: ( localize(1923, "Allow Network"))
+                title: ( localize(2083, "Allow Network"))
             },
             [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
                 type: "boolean",
-                title: ( localize(1924, "Allow Unsandboxed Commands"))
+                title: ( localize(2084, "Allow Unsandboxed Commands"))
             },
             [AgentHostSandboxKey.LinuxFileSystem]: {
                 type: "object",
-                title: ( localize(1925, "Linux Sandbox Filesystem"))
+                title: ( localize(2085, "Linux Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.MacFileSystem]: {
                 type: "object",
-                title: ( localize(1926, "macOS Sandbox Filesystem"))
+                title: ( localize(2086, "macOS Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.WindowsFileSystem]: {
                 type: "object",
-                title: ( localize(1927, "Windows Sandbox Filesystem"))
+                title: ( localize(2087, "Windows Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.AdvancedRuntime]: {
                 type: "object",
-                title: ( localize(1928, "Advanced Sandbox Runtime"))
+                title: ( localize(2088, "Advanced Sandbox Runtime"))
             },
             [AgentHostSandboxKey.AllowedNetworkDomains]: {
                 type: "array",
-                title: ( localize(1929, "Allowed Network Domains")),
+                title: ( localize(2089, "Allowed Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(1930, "Domain"))
+                    title: ( localize(2090, "Domain"))
                 }
             },
             [AgentHostSandboxKey.DeniedNetworkDomains]: {
                 type: "array",
-                title: ( localize(1931, "Denied Network Domains")),
+                title: ( localize(2091, "Denied Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(1932, "Domain"))
+                    title: ( localize(2092, "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 };