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

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

@@ -0,0 +1,45 @@
+
+
+const AGENT_SDK_SETUP_STATUS_KEY_PREFIX = "vscode.agentSdkSetup.status.";
+const AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY = "vscode.agentSdkSetup.downloadRequest";
+const AGENT_SDK_SETUP_RELOAD_REQUEST_KEY = "vscode.agentSdkSetup.reloadRequest";
+function readOne(value, agent) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const info = value;
+    if (info.download !== "notDownloaded" && info.download !== "downloadOnUse" && info.download !== "downloading" && info.download !== "ready") {
+        return undefined;
+    }
+    return {
+        agent,
+        download: info.download,
+        setupDocsUrl: typeof info.setupDocsUrl === "string" ? info.setupDocsUrl : undefined,
+        signInProviderName: typeof info.signInProviderName === "string" && info.signInProviderName.length > 0 ? info.signInProviderName : undefined
+    };
+}
+function readAgentSdkSetupInfos(state) {
+    const meta = state?._meta;
+    const values = state?.config?.values;
+    const infos = [];
+    const seen = ( new Set());
+    for (const bag of [values, meta]) {
+        for (const key of ( Object.keys(bag ?? {}))) {
+            if (!key.startsWith(AGENT_SDK_SETUP_STATUS_KEY_PREFIX)) {
+                continue;
+            }
+            const agent = key.slice(AGENT_SDK_SETUP_STATUS_KEY_PREFIX.length);
+            if (!agent || ( seen.has(agent))) {
+                continue;
+            }
+            const info = readOne(bag?.[key], agent);
+            if (info) {
+                seen.add(agent);
+                infos.push(info);
+            }
+        }
+    }
+    return infos;
+}
+
+export { AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY, AGENT_SDK_SETUP_RELOAD_REQUEST_KEY, readAgentSdkSetupInfos };

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

@@ -0,0 +1,130 @@
+import { type Changeset, type ISessionGitState, type ISessionWithDefaultChat, type URI } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+/** Stable id and change kind of the Agent Merge changeset. */
+export declare const AGENT_MERGE_CHANGESET_ID = "agent-merge";
+/** Localized human-readable label for the branch changeset entry. */
+export declare const branchChangesetLabel: () => string;
+/** Localized human-readable label for the session-wide changeset entry. */
+export declare const sessionChangesetLabel: () => string;
+/** Localized human-readable description for the session-wide changeset entry. */
+export declare const sessionChangesetDescription: () => string;
+/** Localized human-readable label for the uncommitted-changes changeset entry. */
+export declare const uncommittedChangesetLabel: () => string;
+/** Localized human-readable description for the uncommitted-changes changeset entry. */
+export declare const uncommittedChangesetDescription: () => string;
+/** Localized human-readable label for the per-turn changeset template entry. */
+export declare const thisTurnChangesetLabel: () => string;
+/** Localized human-readable description for the per-turn changeset template entry. */
+export declare const thisTurnChangesetDescription: () => string;
+/** Localized human-readable label for the compare-turns changeset template entry. */
+export declare const compareTurnsChangesetLabel: () => string;
+/** Localized human-readable description for the compare-turns changeset template entry. */
+export declare const compareTurnsChangesetDescription: () => string;
+/**
+ * Returns the description shown next to the `Branch Changes` catalogue
+ * entry. Prefers `${branchName} → ${baseBranchName}` when both values
+ * are known (typical worktree-isolation case). If `baseBranchName` is
+ * unknown, falls back to `${branchName} → ${upstreamBranchName}` when an
+ * upstream is available. Finally falls back to `branchName` alone.
+ * Returns `undefined` only when no branch name is known at all, so
+ * callers can omit the description entirely.
+ */
+export declare function formatBranchChangesetDescription(gitState: ISessionGitState): string | undefined;
+/** Discriminates the well-known changeset URI shapes. */
+export declare enum ChangesetKind {
+    Branch = "branch",
+    Uncommitted = "uncommitted",
+    Session = "session",
+    Turn = "turn",
+    Compare = "compare-turns",
+    /** Producer-defined id we don't recognise (single-segment only). */
+    Unknown = "unknown"
+}
+/** Changeset kinds that can represent a session's default changes view. */
+export type DefaultChangesetKind = ChangesetKind.Branch | ChangesetKind.Uncommitted | ChangesetKind.Session;
+/** Selects the configured default changeset, falling back to the first catalogue entry. */
+export declare function selectDefaultChangeset<T extends Pick<Changeset, "changeKind">>(changesets: readonly T[] | undefined, defaultKind?: DefaultChangesetKind): T | undefined;
+/**
+ * Resolve a {@link Changeset.uriTemplate} from a session's catalogue into a
+ * subscribable URI template.
+ *
+ * A host may publish the template relative to the session channel
+ * (`changeset/branch`); used verbatim that addresses the client's own
+ * filesystem. Templates that already carry a scheme are returned unchanged.
+ */
+export declare function resolveChangesetUriTemplate(sessionUri: URI, uriTemplate: string): string;
+export declare function buildBranchChangesetUri(sessionUri: URI): URI;
+/** Returns the subscribable URI for the session-wide changeset. */
+export declare function buildSessionChangesetUri(sessionUri: URI): URI;
+/** Returns the subscribable URI for the uncommitted-changes changeset. */
+export declare function buildUncommittedChangesetUri(sessionUri: URI): URI;
+/**
+ * Returns the URI _template_ that catalogue entries advertise for the
+ * per-turn changeset; clients expand `{turnId}` to build the
+ * subscribable URI via {@link buildTurnChangesetUri}.
+ */
+export declare function buildTurnChangesetUriTemplate(sessionUri: URI): URI;
+/** Returns the subscribable URI for the per-turn changeset of `turnId`. */
+export declare function buildTurnChangesetUri(sessionUri: URI, turnId: string): URI;
+/**
+ * Returns the URI _template_ that catalogue entries advertise for the
+ * compare-turns changeset; clients expand both `{originalTurnId}` and
+ * `{modifiedTurnId}` to build the subscribable URI via
+ * {@link buildCompareTurnsChangesetUri}.
+ */
+export declare function buildCompareTurnsChangesetUriTemplate(sessionUri: URI): URI;
+/**
+ * Returns the subscribable URI for the compare-turns changeset between
+ * `originalTurnId` (the "from" endpoint) and `modifiedTurnId` (the "to"
+ * endpoint). Diff direction is `originalTurnId → modifiedTurnId`.
+ */
+export declare function buildCompareTurnsChangesetUri(sessionUri: URI, originalTurnId: string, modifiedTurnId: string): URI;
+/**
+ * Returns the subscribable URI for an opaque, producer-defined
+ * `changesetId`. The id must not contain `/` — well-known multi-segment
+ * shapes have dedicated builders (e.g. {@link buildTurnChangesetUri}).
+ */
+export declare function buildChangesetUri(sessionUri: URI, changesetId: string): URI;
+/**
+ * Parses a changeset URI back into `(sessionUri, changesetId, kind)`,
+ * or returns `undefined` if `uri` is not a changeset URI we recognise.
+ */
+export declare function parseChangesetUri(uri: URI): {
+    sessionUri: URI;
+    changesetId: string;
+    kind: ChangesetKind;
+    turnId?: string;
+    originalTurnId?: string;
+    modifiedTurnId?: string;
+} | undefined;
+/** Returns `true` iff `uri` looks like a changeset URI we recognise. */
+export declare function isChangesetUri(uri: URI): boolean;
+/** Returns `true` iff `uri` is the session-wide changeset URI. */
+export declare function isSessionChangesetUri(uri: URI): boolean;
+/** Returns `true` iff `uri` is the uncommitted-changes changeset URI. */
+export declare function isUncommittedChangesetUri(uri: URI): boolean;
+/** Returns the parsed turn id when `uri` is a per-turn changeset URI. */
+export declare function parseTurnChangesetUri(uri: URI): {
+    sessionUri: URI;
+    turnId: string;
+} | undefined;
+/** Returns the parsed turn ids when `uri` is a compare-turns changeset URI. */
+export declare function parseCompareTurnsChangesetUri(uri: URI): {
+    sessionUri: URI;
+    originalTurnId: string;
+    modifiedTurnId: string;
+} | undefined;
+/**
+ * Builds the ordered `summary.changesets` catalogue for a session. Aggregate
+ * counts are filled in later by the diff producer as compute passes complete.
+ *
+ * The first two entries (`Branch Changes`, `Uncommitted Changes`) are
+ * git-only; `AgentService._attachGitState` strips them asynchronously
+ * for sessions whose working directory is not a git repo. The backing
+ * per-changeset states are still registered for every session — only
+ * the catalogue advertisements are stripped.
+ *
+ * The Agent Merge entry reuses the compare-turns URI template. It is advertised
+ * after Agent Merge is enabled and remains available for the rest of the
+ * session, including after Agent Merge is disabled.
+ */
+export declare function buildDefaultChangesetCatalog(sessionUri: URI, state?: ISessionWithDefaultChat): Changeset[];

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

@@ -0,0 +1,41 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/nls';
+import './agentMerge.js';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/meta/agentSystemNotificationMeta';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+
+const BRANCH_CHANGESET_ID = "branch";
+const TURN_CHANGESET_PREFIX = "turn/";
+const CHANGESET_PATH_SEGMENT = "/changeset/";
+var ChangesetKind;
+(function(ChangesetKind) {
+    ChangesetKind["Branch"] = "branch";
+    ChangesetKind["Uncommitted"] = "uncommitted";
+    ChangesetKind["Session"] = "session";
+    ChangesetKind["Turn"] = "turn";
+    ChangesetKind["Compare"] = "compare-turns";
+    ChangesetKind["Unknown"] = "unknown";
+})(ChangesetKind || (ChangesetKind = {}));
+function selectDefaultChangeset(changesets, defaultKind = ChangesetKind.Branch) {
+    return changesets?.find(changeset => changeset.changeKind === defaultKind) ?? changesets?.[0];
+}
+const URI_SCHEME_PREFIX = /^[a-zA-Z][a-zA-Z0-9+.\-]*:/;
+function resolveChangesetUriTemplate(sessionUri, uriTemplate) {
+    if (URI_SCHEME_PREFIX.test(uriTemplate)) {
+        return uriTemplate;
+    }
+    return `${sessionUri.replace(/\/+$/, "")}/${uriTemplate.replace(/^\/+/, "")}`;
+}
+function buildBranchChangesetUri(sessionUri) {
+    return `${sessionUri}${CHANGESET_PATH_SEGMENT}${BRANCH_CHANGESET_ID}`;
+}
+function buildTurnChangesetUri(sessionUri, turnId) {
+    if (!turnId || turnId.includes("/")) {
+        throw ( new Error(
+            `buildTurnChangesetUri: turnId must be non-empty and not contain '/' (got ${JSON.stringify(turnId)})`
+        ));
+    }
+    return `${sessionUri}${CHANGESET_PATH_SEGMENT}${TURN_CHANGESET_PREFIX}${turnId}`;
+}
+
+export { ChangesetKind, buildBranchChangesetUri, buildTurnChangesetUri, resolveChangesetUriTemplate, selectDefaultChangeset };

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

@@ -0,0 +1,73 @@
+/**
+ * A single flattened completion form of a config-action slash command (the bare
+ * command or one of its named sub-arguments), ready to be emitted as a
+ * completion item.
+ */
+export interface ICopilotConfigSlashCommandItem {
+    /**
+     * The text inserted when accepted. Empty for a pure toggle (nothing is left
+     * in the input); `/command ` (trailing space) for an item that keeps the text
+     * so an argument can be typed.
+     */
+    readonly insertText: string;
+    /** The display label shown in the picker (e.g. `/autopilot on`). */
+    readonly label: string;
+    /** The command name (without the leading `/`). */
+    readonly command: string;
+    /** Human-readable description shown in completion detail. */
+    readonly description: string;
+    /** Argument hint (ghost text) shown after acceptance for keep-text items. */
+    readonly argumentHint?: string;
+    /** The session-config change applied when accepted. */
+    readonly applyConfig: Readonly<Record<string, string>>;
+    /** Sort key used to order completions. */
+    readonly sortText: string;
+}
+/**
+ * The set of command names that are config-action commands. Used by the send
+ * path to decide whether a leading slash command should be intercepted (applied
+ * + stripped) rather than dispatched to the runtime.
+ */
+export declare function isCopilotConfigSlashCommand(command: string): boolean;
+/**
+ * The current session-config state used to filter config-action slash command
+ * completions so only the state-changing forms are offered (e.g. `/autopilot on`
+ * is hidden while already in autopilot mode).
+ */
+export interface ICopilotConfigSlashCommandState {
+    /** The session's current `mode` axis value (e.g. `interactive` / `plan` / `autopilot`). */
+    readonly mode?: string;
+    /** The session's current `autoApprove` axis value (e.g. `default` / `autoApprove`). */
+    readonly autoApprove?: string;
+}
+/**
+ * Returns the flattened completion items (one per command form) whose command
+ * name fuzzy matches `typed` (the text after the leading `/`, case-insensitive).
+ * When `typed` is empty, all items are returned.
+ *
+ * When `state` (the session's current config values) is provided, pure toggle
+ * forms that would be a no-op are filtered out so only the state-changing forms
+ * are offered (see {@link shouldOfferOption}).
+ */
+export declare function getCopilotConfigSlashCommandItems(typed: string, state?: ICopilotConfigSlashCommandState): ICopilotConfigSlashCommandItem[];
+/**
+ * Result of resolving a config-action slash command on send.
+ */
+export interface ICopilotConfigSlashCommandSendResult {
+    /** The session-config change to (re-)apply. */
+    readonly applyConfig: Readonly<Record<string, string>>;
+    /**
+     * The prompt text that should be forwarded to the runtime after stripping the
+     * command token (and any recognized sub-argument). Empty when the command is a
+     * pure toggle with no trailing prompt.
+     */
+    readonly strippedPrompt: string;
+}
+/**
+ * Resolves a leading config-action slash command for the send path: maps the
+ * command (and any recognized `on`/`off` sub-argument) to the session-config
+ * change to apply, and returns the remaining prompt text to forward with the
+ * command token stripped. Returns `undefined` for non-config-action commands so
+ * callers fall through to their normal (runtime) handling.
+ */
+export declare function resolveCopilotConfigSlashCommandOnSend(command: string, rest: string): ICopilotConfigSlashCommandSendResult | undefined;

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

@@ -0,0 +1,141 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+
+const AUTO_APPROVE_BYPASS = "autoApprove";
+const AUTO_APPROVE_DEFAULT = "default";
+const MODE_INTERACTIVE = "interactive";
+const MODE_PLAN = "plan";
+const MODE_AUTOPILOT = "autopilot";
+function setBypassDetail() {
+    return localize(2094, "Set permissions to bypass approvals");
+}
+function setDefaultDetail() {
+    return localize(2095, "Set permissions back to default");
+}
+function autopilotOnDetail() {
+    return localize(2096, "Switch to autopilot mode");
+}
+function exitAutopilotDetail() {
+    return localize(2097, "Switch to interactive mode");
+}
+function autopilotPromptDetail() {
+    return localize(2098, "Switch to autopilot mode with an objective");
+}
+function planPromptDetail() {
+    return localize(2099, "Create an implementation plan before coding");
+}
+function autopilotArgumentHint() {
+    return localize(2100, "objective");
+}
+function promptArgumentHint() {
+    return localize(2101, "Describe what you want to plan or research");
+}
+function getConfigSlashCommands() {
+    return [{
+        command: "yolo",
+        sortText: "z1_yolo",
+        options: [{
+            arg: "on",
+            detail: setBypassDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_BYPASS
+            }
+        }, {
+            arg: "off",
+            detail: setDefaultDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_DEFAULT
+            }
+        }]
+    }, {
+        command: "allow-all",
+        sortText: "z1_allow-all",
+        options: [{
+            arg: "on",
+            detail: setBypassDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_BYPASS
+            }
+        }, {
+            arg: "off",
+            detail: setDefaultDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_DEFAULT
+            }
+        }]
+    }, {
+        command: "autopilot",
+        sortText: "z1_autopilot",
+        options: [{
+            arg: "on",
+            detail: autopilotOnDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_AUTOPILOT
+            }
+        }, {
+            arg: "off",
+            detail: exitAutopilotDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_INTERACTIVE
+            }
+        }, {
+            detail: autopilotPromptDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_AUTOPILOT
+            },
+            argumentHint: autopilotArgumentHint()
+        }]
+    }, {
+        command: "plan",
+        sortText: "z1_plan",
+        options: [{
+            detail: planPromptDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_PLAN
+            },
+            argumentHint: promptArgumentHint()
+        }]
+    }, {
+        command: "goal",
+        sortText: "z1_goal",
+        options: [{
+            detail: planPromptDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_PLAN
+            },
+            argumentHint: promptArgumentHint()
+        }]
+    }];
+}
+function resolveCopilotConfigSlashCommandOnSend(command, rest) {
+    const descriptor = getConfigSlashCommands().find(c => c.command.toLowerCase() === command.toLowerCase());
+    if (!descriptor) {
+        return undefined;
+    }
+    const trimmedRest = rest.trim();
+    const namedOptions = descriptor.options.filter(o => o.arg !== undefined);
+    const baseOption = descriptor.options.find(o => o.arg === undefined);
+    if (namedOptions.length > 0 && trimmedRest.length > 0) {
+        const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(trimmedRest);
+        const firstToken = match?.[1]?.toLowerCase();
+        const matched = namedOptions.find(o => o.arg?.toLowerCase() === firstToken);
+        if (matched) {
+            return {
+                applyConfig: matched.config,
+                strippedPrompt: (match?.[2] ?? "").trim()
+            };
+        }
+        if (!baseOption) {
+            return undefined;
+        }
+    }
+    const fallback = baseOption ?? descriptor.options[0];
+    return {
+        applyConfig: fallback.config,
+        strippedPrompt: trimmedRest
+    };
+}
+
+export { resolveCopilotConfigSlashCommandOnSend };

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

@@ -1,5 +1,5 @@
-import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { type AgentCustomization, type Customization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type AgentCustomization, type ClientPluginCustomization, type Customization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 /**
  * Computes the effective set of selectable custom agents for a session.
  *
@@ -15,6 +15,12 @@ import { type AgentCustomization, type Customization } from "@codingame/monaco-v
  * duplicates within the session's customization list are coalesced.
  */
 export declare function getEffectiveAgents(sessionCustomizations: readonly Customization[] | undefined): readonly AgentCustomization[];
+/**
+ * Filters draft agents by their published plugin container enablement.
+ * Unmatched agents remain selectable because they may be loose agents or precede
+ * their plugin ref during a client update.
+ */
+export declare function getEffectiveClientAgents(clientCustomizations: readonly ClientPluginCustomization[] | undefined, clientAgents: readonly AgentCustomization[]): readonly AgentCustomization[];
 /**
  * Storage key used by the custom-agent pickers to remember the user's last
  * selection per session-resource scheme. Shared between the Agents Window

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

@@ -1,10 +1,17 @@
 
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
 
 function agentHostAgentPickerStorageKey(resourceScheme) {
     return `workbench.agentsession.agentHostAgentPicker.${resourceScheme}.selectedAgentUri`;

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>;