@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.0

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

@@ -1,3 +1,6 @@
+import { type IConfigurationValue } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import { type IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import type { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
 import { TelemetryConfiguration, TelemetryLevel } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry";
 import type { SessionConfigPropertySchema, SessionConfigSchema } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 /**
@@ -96,8 +99,8 @@ export interface ISchema<D extends SchemaDefinition> {
     } | undefined, defaults: T): T;
 }
 export declare function createSchema<D extends SchemaDefinition>(definition: D): ISchema<D>;
-export type AutoApproveLevel = "default" | "autoApprove" | "autopilot";
-export type SessionMode = "interactive" | "plan";
+export type AutoApproveLevel = "default" | "autoApprove";
+export type SessionMode = "interactive" | "plan" | "autopilot";
 export interface IPermissionsValue {
     readonly allow: readonly string[];
     readonly deny: readonly string[];
@@ -115,6 +118,25 @@ export declare const platformSessionSchema: ISchema<{
     permissions: ISchemaProperty<IPermissionsValue>;
     mode: ISchemaProperty<SessionMode>;
 }>;
+/**
+ * Rewrites a legacy `autoApprove='autopilot'` config value — used before
+ * Autopilot moved from the `autoApprove` axis onto the orthogonal `mode`
+ * axis — into the current two-axis shape:
+ *
+ *  - `autoApprove='autopilot'` + `mode='plan'`  → `mode='plan'`, `autoApprove='default'`
+ *    (legacy `plan` took precedence over autopilot when resolving the SDK mode).
+ *  - `autoApprove='autopilot'` + any other mode → `mode='autopilot'`, `autoApprove='default'`.
+ *
+ * Returns a shallow copy with the migration applied, or the original
+ * reference unchanged when no legacy value is present. Safe to call on
+ * `undefined`.
+ *
+ * Without this, a session persisted (or a "remembered" picker value seeded)
+ * with `autoApprove='autopilot'` would fail the new schema's enum validation
+ * and silently fall back to `default`, downgrading the session from
+ * autonomous Autopilot to manual per-tool confirmation.
+ */
+export declare function migrateLegacyAutopilotConfig<T extends Record<string, unknown> | undefined>(config: T): T;
 /**
  * Root (agent host) config properties owned by the platform itself.
  *
@@ -132,6 +154,85 @@ export declare const AgentHostTelemetryLevelConfigKey = "telemetryLevel";
  * passed to the copilot-sdk `CopilotClientOptions`.
  */
 export declare const AgentHostSessionSyncEnabledConfigKey = "sessionSyncEnabled";
+/**
+ * Root config key forwarded from the renderer carrying the experiment-aware
+ * value of `chat.agentHost.codexAgent.enabled`. The host registers the Codex
+ * provider when this is `true`; disabling requires an agent host restart.
+ */
+export declare const AgentHostCodexEnabledConfigKey = "codexAgentEnabled";
+/**
+ * Root config key forwarded from the renderer when VS Code's
+ * `chat.tools.terminal.enableAutoApprove` setting changes. Controls whether
+ * agent-host shell permission checks may apply terminal auto-approve rules.
+ */
+export declare const AgentHostTerminalAutoApproveEnabledConfigKey = "terminalAutoApproveEnabled";
+/**
+ * The VS Code setting ID for terminal auto approve enablement. Defined here so
+ * renderer-side agent-host clients can forward it without importing from
+ * workbench terminal contributions.
+ */
+export declare const TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID = "chat.tools.terminal.enableAutoApprove";
+/**
+ * Root config key forwarded from the renderer when VS Code's
+ * `chat.tools.global.autoApprove` setting changes. When `true`, the global
+ * auto-approve ("approve everything") setting is enabled and the agent host
+ * treats every tool call as auto-approved — equivalent to a session running
+ * with Bypass Approvals.
+ */
+export declare const AgentHostGlobalAutoApproveEnabledConfigKey = "globalAutoApproveEnabled";
+/**
+ * The VS Code setting ID for global auto approve. Defined here so renderer-side
+ * agent-host clients can forward it without importing from `workbench/contrib/chat`.
+ */
+export declare const GLOBAL_AUTO_APPROVE_SETTING_ID = "chat.tools.global.autoApprove";
+/**
+ * Root config key forwarded from the renderer when VS Code's `chat.autoReply`
+ * setting changes. When `true`, the agent host auto-answers `ask_user`
+ * questions instead of blocking on the user — the user is treated as
+ * unavailable and the agent is told to use its best judgment, mirroring the
+ * behavior of `autopilot` mode.
+ */
+export declare const AgentHostAutoReplyEnabledConfigKey = "autoReplyEnabled";
+/**
+ * The VS Code setting ID for auto-reply. Defined here so renderer-side
+ * agent-host clients can forward it without importing from `workbench/contrib/chat`.
+ */
+export declare const AUTO_REPLY_SETTING_ID = "chat.autoReply";
+/**
+ * Root config key forwarded from the renderer when VS Code's
+ * `chat.tools.terminal.autoApprove` setting changes. Holds the effective
+ * terminal auto-approve rule object for agent-host shell permission checks.
+ */
+export declare const AgentHostTerminalAutoApproveRulesConfigKey = "terminalAutoApproveRules";
+export interface IAgentHostTerminalAutoApproveRule {
+    readonly approve: boolean;
+    readonly matchCommandLine?: boolean;
+}
+export type AgentHostTerminalAutoApproveRuleValue = boolean | null | IAgentHostTerminalAutoApproveRule;
+export type AgentHostTerminalAutoApproveRules = Record<string, AgentHostTerminalAutoApproveRuleValue>;
+/**
+ * The VS Code setting IDs for terminal auto approve rules. Defined here so
+ * renderer-side agent-host clients can forward them without importing from
+ * workbench terminal contributions.
+ */
+export declare const TERMINAL_AUTO_APPROVE_SETTING_ID = "chat.tools.terminal.autoApprove";
+export declare const TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID = "chat.tools.terminal.ignoreDefaultAutoApproveRules";
+export declare function getAgentHostTerminalAutoApproveRulesConfig(configurationService: IConfigurationService): AgentHostTerminalAutoApproveRules;
+export declare function normalizeAgentHostTerminalAutoApproveRulesConfig(config: AgentHostTerminalAutoApproveRules | undefined, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>, ignoreDefaults: boolean): AgentHostTerminalAutoApproveRules;
+/**
+ * Root config key holding agent-host-level MCP server definitions.
+ *
+ * The value is a map of server name → {@link IMcpServerConfiguration}
+ * (the same `servers` shape used by `mcp.json`). These servers are
+ * exposed to every session created by the host, merged with any
+ * plugin-provided MCP servers when launching the copilot-sdk client.
+ */
+export declare const AgentHostMcpServersConfigKey = "mcpServers";
+/**
+ * Map of server name → MCP server configuration, as stored in the
+ * {@link AgentHostMcpServersConfigKey} root config value.
+ */
+export type AgentHostMcpServers = Record<string, IMcpServerConfiguration>;
 /**
  * The VS Code setting ID for session sync. Defined here so the platform
  * layer (renderer-side forwarding) can reference it without importing from
@@ -144,4 +245,10 @@ export declare const platformRootSchema: ISchema<{
     permissions: ISchemaProperty<IPermissionsValue>;
     telemetryLevel: ISchemaProperty<TelemetryConfiguration>;
     sessionSyncEnabled: ISchemaProperty<boolean>;
+    codexAgentEnabled: ISchemaProperty<boolean>;
+    terminalAutoApproveEnabled: ISchemaProperty<boolean>;
+    globalAutoApproveEnabled: ISchemaProperty<boolean>;
+    autoReplyEnabled: ISchemaProperty<boolean>;
+    terminalAutoApproveRules: ISchemaProperty<AgentHostTerminalAutoApproveRules>;
+    mcpServers: ISchemaProperty<AgentHostMcpServers>;
 }>;

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

@@ -1,5 +1,7 @@
 
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { TelemetryLevel, TelemetryConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
 import { SessionConfigKey } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/sessionConfigKeys';
 import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
@@ -173,26 +175,26 @@ function safeStringify(value) {
 }
 const permissionsProperty = schemaProperty({
     type: "object",
-    title: ( localize(1824, "Permissions")),
+    title: ( localize(1836, "Permissions")),
     description: ( localize(
-        1825,
+        1837,
         "Per-tool session permissions. Updated automatically when approving a tool \"in this Session\"."
     )),
     properties: {
         allow: {
             type: "array",
-            title: ( localize(1826, "Allowed tools")),
+            title: ( localize(1838, "Allowed tools")),
             items: {
                 type: "string",
-                title: ( localize(1827, "Tool name"))
+                title: ( localize(1839, "Tool name"))
             }
         },
         deny: {
             type: "array",
-            title: ( localize(1828, "Denied tools")),
+            title: ( localize(1840, "Denied tools")),
             items: {
                 type: "string",
-                title: ( localize(1827, "Tool name"))
+                title: ( localize(1839, "Tool name"))
             }
         }
     },
@@ -205,28 +207,104 @@ const permissionsProperty = schemaProperty({
 createSchema({
     [SessionConfigKey.AutoApprove]: schemaProperty({
         type: "string",
-        title: ( localize(1829, "Approvals")),
-        description: ( localize(1830, "Tool approval behavior for this session")),
-        enum: ["default", "autoApprove", "autopilot"],
-        enumLabels: [( localize(1831, "Default Approvals")), ( localize(1832, "Bypass Approvals")), ( localize(1833, "Autopilot (Preview)"))],
-        enumDescriptions: [( localize(1834, "Copilot uses your configured settings")), ( localize(1835, "All tool calls are auto-approved")), ( localize(1836, "Autonomously iterates from start to finish"))],
+        title: ( localize(1841, "Approvals")),
+        description: ( localize(1842, "Tool approval behavior for this session")),
+        enum: ["default", "autoApprove"],
+        enumLabels: [( localize(1843, "Default Approvals")), ( localize(1844, "Bypass Approvals"))],
+        enumDescriptions: [( localize(1845, "Copilot uses your configured settings")), ( localize(1846, "All tool calls are auto-approved"))],
         default: "default",
         sessionMutable: true
     }),
     [SessionConfigKey.Permissions]: permissionsProperty,
     [SessionConfigKey.Mode]: schemaProperty({
         type: "string",
-        title: ( localize(1837, "Agent Mode")),
-        description: ( localize(1838, "How the agent should approach this turn")),
-        enum: ["interactive", "plan"],
-        enumLabels: [( localize(1839, "Interactive")), ( localize(1840, "Plan"))],
-        enumDescriptions: [( localize(1841, "Ask for input and approval for each action")), ( localize(1842, "Generate a plan first, then choose how to execute it"))],
+        title: ( localize(1847, "Agent Mode")),
+        description: ( localize(1848, "How the agent should approach this turn")),
+        enum: ["interactive", "plan", "autopilot"],
+        enumLabels: [( localize(1849, "Interactive")), ( localize(1850, "Plan")), ( localize(1851, "Autopilot"))],
+        enumDescriptions: [( localize(1852, "Step-by-step collaboration")), ( localize(1853, "Plan first, execute when ready")), ( localize(1854, "Autonomously iterates from start to finish"))],
         default: "interactive",
         sessionMutable: true
     })
 });
+function migrateLegacyAutopilotConfig(config) {
+    if (!config || config[SessionConfigKey.AutoApprove] !== "autopilot") {
+        return config;
+    }
+    const migrated = {
+        ...config
+    };
+    if (migrated[SessionConfigKey.Mode] !== "plan") {
+        migrated[SessionConfigKey.Mode] = "autopilot";
+    }
+    migrated[SessionConfigKey.AutoApprove] = "default";
+    return migrated;
+}
 const AgentHostTelemetryLevelConfigKey = "telemetryLevel";
 const AgentHostSessionSyncEnabledConfigKey = "sessionSyncEnabled";
+const AgentHostCodexEnabledConfigKey = "codexAgentEnabled";
+const AgentHostTerminalAutoApproveEnabledConfigKey = "terminalAutoApproveEnabled";
+const TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID = "chat.tools.terminal.enableAutoApprove";
+const AgentHostGlobalAutoApproveEnabledConfigKey = "globalAutoApproveEnabled";
+const GLOBAL_AUTO_APPROVE_SETTING_ID = "chat.tools.global.autoApprove";
+const AgentHostAutoReplyEnabledConfigKey = "autoReplyEnabled";
+const AUTO_REPLY_SETTING_ID = "chat.autoReply";
+const AgentHostTerminalAutoApproveRulesConfigKey = "terminalAutoApproveRules";
+const TERMINAL_AUTO_APPROVE_SETTING_ID = "chat.tools.terminal.autoApprove";
+const TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID = "chat.tools.terminal.ignoreDefaultAutoApproveRules";
+function getAgentHostTerminalAutoApproveRulesConfig(configurationService) {
+    const config = configurationService.getValue(TERMINAL_AUTO_APPROVE_SETTING_ID);
+    const configInspectValue = configurationService.inspect(TERMINAL_AUTO_APPROVE_SETTING_ID);
+    const ignoreDefaults = configurationService.getValue(TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID) === true;
+    return normalizeAgentHostTerminalAutoApproveRulesConfig(config, configInspectValue, ignoreDefaults);
+}
+function normalizeAgentHostTerminalAutoApproveRulesConfig(config, configInspectValue, ignoreDefaults) {
+    if (!config) {
+        return {};
+    }
+    const rules = {};
+    for (const [key, value] of Object.entries(config)) {
+        if (ignoreDefaults && isDefaultOnlyAutoApproveRule(key, value, configInspectValue)) {
+            continue;
+        }
+        rules[key] = value;
+    }
+    return rules;
+}
+function isDefaultOnlyAutoApproveRule(key, value, configInspectValue) {
+    const defaultValue = configInspectValue.default?.value;
+    const isDefaultRule = hasMatchingRule(defaultValue, key, value);
+    if (!isDefaultRule) {
+        return false;
+    }
+    const sourceTarget = getAutoApproveRuleSourceTarget(key, value, configInspectValue);
+    return sourceTarget === ConfigurationTarget.DEFAULT;
+}
+function getAutoApproveRuleSourceTarget(key, value, configInspectValue) {
+    if (hasMatchingRule(configInspectValue.workspaceFolderValue, key, value)) {
+        return ConfigurationTarget.WORKSPACE_FOLDER;
+    }
+    if (hasMatchingRule(configInspectValue.workspaceValue, key, value)) {
+        return ConfigurationTarget.WORKSPACE;
+    }
+    if (hasMatchingRule(configInspectValue.userRemoteValue, key, value)) {
+        return ConfigurationTarget.USER_REMOTE;
+    }
+    if (hasMatchingRule(configInspectValue.userLocalValue, key, value)) {
+        return ConfigurationTarget.USER_LOCAL;
+    }
+    if (hasMatchingRule(configInspectValue.userValue, key, value)) {
+        return ConfigurationTarget.USER;
+    }
+    if (hasMatchingRule(configInspectValue.applicationValue, key, value)) {
+        return ConfigurationTarget.APPLICATION;
+    }
+    return ConfigurationTarget.DEFAULT;
+}
+function hasMatchingRule(config, key, value) {
+    return !!config && Object.prototype.hasOwnProperty.call(config, key) && structuralEquals(config[key], value);
+}
+const AgentHostMcpServersConfigKey = "mcpServers";
 const SESSION_SYNC_ENABLED_SETTING_ID = "chat.sessionSync.enabled";
 function telemetryLevelToAgentHostConfigValue(telemetryLevel) {
     switch (telemetryLevel) {
@@ -240,12 +318,68 @@ function telemetryLevelToAgentHostConfigValue(telemetryLevel) {
         return TelemetryConfiguration.ON;
     }
 }
+const mcpServerConfigProperties = {
+    type: {
+        type: "string",
+        title: ( localize(1855, "Server Type")),
+        description: ( localize(
+            1856,
+            "The transport used to reach the server: `stdio` for a local command, `http` for a remote endpoint."
+        )),
+        enum: ["stdio", "http"]
+    },
+    command: {
+        type: "string",
+        title: ( localize(1857, "Command")),
+        description: ( localize(1858, "For `stdio` servers, the executable to spawn."))
+    },
+    args: {
+        type: "array",
+        title: ( localize(1859, "Arguments")),
+        description: ( localize(1860, "For `stdio` servers, the arguments passed to the command.")),
+        items: {
+            type: "string",
+            title: ( localize(1861, "Argument"))
+        }
+    },
+    env: {
+        type: "object",
+        title: ( localize(1862, "Environment")),
+        description: ( localize(
+            1863,
+            "For `stdio` servers, environment variables set on the spawned process."
+        ))
+    },
+    cwd: {
+        type: "string",
+        title: ( localize(1864, "Working Directory")),
+        description: ( localize(1865, "For `stdio` servers, the working directory the command runs in."))
+    },
+    url: {
+        type: "string",
+        title: ( localize(1866, "URL")),
+        description: ( localize(1867, "For `http` servers, the endpoint URL of the MCP server."))
+    },
+    headers: {
+        type: "object",
+        title: ( localize(1868, "Headers")),
+        description: ( localize(1869, "For `http` servers, HTTP headers sent with every request."))
+    }
+};
+const mcpServersValueProperties = {
+    "<serverName>": {
+        type: "object",
+        title: ( localize(1870, "MCP Server")),
+        description: ( localize(1871, "A single MCP server entry. The property key is the server name.")),
+        properties: mcpServerConfigProperties
+    }
+};
 createSchema({
     [SessionConfigKey.Permissions]: permissionsProperty,
     [AgentHostTelemetryLevelConfigKey]: schemaProperty({
         type: "string",
-        title: ( localize(1843, "Telemetry Level")),
-        description: ( localize(1844, "Most restrictive telemetry level requested by connected clients.")),
+        title: ( localize(1872, "Telemetry Level")),
+        description: ( localize(1873, "Most restrictive telemetry level requested by connected clients.")),
         enum: [
             TelemetryConfiguration.ON,
             TelemetryConfiguration.ERROR,
@@ -256,10 +390,62 @@ createSchema({
     }),
     [AgentHostSessionSyncEnabledConfigKey]: schemaProperty({
         type: "boolean",
-        title: ( localize(1845, "Session Sync")),
-        description: ( localize(1846, "Whether remote session sync is enabled for the copilot-sdk CLI.")),
+        title: ( localize(1874, "Session Sync")),
+        description: ( localize(1875, "Whether remote session sync is enabled for the copilot-sdk CLI.")),
+        default: false
+    }),
+    [AgentHostCodexEnabledConfigKey]: schemaProperty({
+        type: "boolean",
+        title: ( localize(1876, "Codex Agent")),
+        description: ( localize(1877, "Whether the Codex provider is enabled.")),
+        default: false
+    }),
+    [AgentHostTerminalAutoApproveEnabledConfigKey]: schemaProperty({
+        type: "boolean",
+        title: ( localize(1878, "Terminal Auto Approve")),
+        description: ( localize(
+            1879,
+            "Whether terminal auto-approve rules forwarded by the connected client are allowed to apply to agent-host shell permission requests."
+        )),
+        default: true
+    }),
+    [AgentHostGlobalAutoApproveEnabledConfigKey]: schemaProperty({
+        type: "boolean",
+        title: ( localize(1880, "Global Auto Approve")),
+        description: ( localize(
+            1881,
+            "Whether VS Code's global auto-approve setting is enabled. When `true`, every tool call is auto-approved, equivalent to a session using Bypass Approvals."
+        )),
         default: false
+    }),
+    [AgentHostAutoReplyEnabledConfigKey]: schemaProperty({
+        type: "boolean",
+        title: ( localize(1882, "Auto Reply")),
+        description: ( localize(
+            1883,
+            "Whether VS Code's auto-reply setting is enabled. When `true`, `ask_user` questions are auto-answered instead of blocking on the user, mirroring autopilot mode."
+        )),
+        default: false
+    }),
+    [AgentHostTerminalAutoApproveRulesConfigKey]: schemaProperty({
+        type: "object",
+        title: ( localize(1884, "Terminal Auto Approve Rules")),
+        description: ( localize(
+            1885,
+            "Terminal auto-approve rules forwarded by the connected client for agent-host shell permission checks."
+        )),
+        default: {}
+    }),
+    [AgentHostMcpServersConfigKey]: schemaProperty({
+        type: "object",
+        title: ( localize(1886, "MCP Servers")),
+        description: ( localize(
+            1887,
+            "Agent-host-level MCP servers exposed to every session, keyed by server name. Each value is a server configuration (see `<serverName>`)."
+        )),
+        properties: mcpServersValueProperties,
+        default: {}
     })
 });
 
-export { AgentHostSessionSyncEnabledConfigKey, AgentHostTelemetryLevelConfigKey, SESSION_SYNC_ENABLED_SETTING_ID, createSchema, schemaProperty, telemetryLevelToAgentHostConfigValue };
+export { AUTO_REPLY_SETTING_ID, AgentHostAutoReplyEnabledConfigKey, AgentHostCodexEnabledConfigKey, AgentHostGlobalAutoApproveEnabledConfigKey, AgentHostMcpServersConfigKey, AgentHostSessionSyncEnabledConfigKey, AgentHostTelemetryLevelConfigKey, AgentHostTerminalAutoApproveEnabledConfigKey, AgentHostTerminalAutoApproveRulesConfigKey, GLOBAL_AUTO_APPROVE_SETTING_ID, SESSION_SYNC_ENABLED_SETTING_ID, TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID, TERMINAL_AUTO_APPROVE_SETTING_ID, TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID, createSchema, getAgentHostTerminalAutoApproveRulesConfig, migrateLegacyAutopilotConfig, normalizeAgentHostTerminalAutoApproveRulesConfig, schemaProperty, telemetryLevelToAgentHostConfigValue };