agentHostSchema.ts ×21

Frontier kind: Code frontier

unlabeled · c_046fcf9292d2

1797 tests · 6625 LOC · 33 files · introduces 0 tests · 546 LOC · 1 file

Introduces — evidence that enters the hierarchy at this concept

Code
21 ranges546 lines · 1 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
556 ranges6625 lines · 33 files · Browse complete extent
All tests (intent)
1797 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

1 file ranked by introduced lines: 546 introduced LOC across 21 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/platform/agentHost/common/agentHostSchema.ts 546 introduced LOC · 21 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- agentHostSchema.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { localize } from '../../../nls.js';
7 > import { structuralEquals } from '../../../base/common/equals.js';
8 > import { ConfigurationTarget, type IConfigurationService, type IConfigurationValue } from '../../configuration/common/configuration.js';
9 > import type { IMcpServerConfiguration } from '../../mcp/common/mcpPlatformTypes.js';
10 > import { TelemetryConfiguration, TelemetryLevel } from '../../telemetry/common/telemetry.js';
11 > import { SessionConfigKey } from './sessionConfigKeys.js';
12 > import type { SessionConfigPropertySchema, SessionConfigSchema } from './state/protocol/commands.js';
13 > import { JsonRpcErrorCodes, ProtocolError } from './state/sessionProtocol.js';
14 >
15 > // ---- Schema builder --------------------------------------------------------
16 >
17 > /**
18 > * A schema property with a phantom TypeScript type and a precomputed
19 > * runtime validator.
20 > *
21 > * The `<T>` type parameter is the developer's assertion about the
22 > * property's runtime shape; the validator derived from `protocol`
23 > * (`type`, `enum`, `items`, `properties`, `required`) enforces it at
24 > * runtime.
25 > */
26 > export interface ISchemaProperty<T> {
27 > readonly protocol: SessionConfigPropertySchema;
28 > /**
29 > * Returns `true` iff `value` conforms to {@link protocol}. Narrows
30 > * the type to `T` for callers. The boolean form is preferred for
31 > * control flow; use {@link assertValid} when you want a descriptive
32 > * error for the offending path.
33 > */
34 > validate(value: unknown): value is T;
35 > /**
36 > * Throws a {@link ProtocolError} with `JsonRpcErrorCodes.InvalidParams`
37 > * describing the offending path (e.g. `'permissions.allow[2]'`) when
38 > * `value` does not conform to {@link protocol}. Otherwise returns and
39 > * narrows the type to `T`.
40 > *
41 > * @param path Dotted path prefix to embed in error messages. Defaults
42 > * to empty (the value itself).
43 > */
44 > assertValid(value: unknown, path?: string): asserts value is T;
45 > }
46 >
47 > /**
48 > * Defines a strongly-typed schema property whose runtime validator is
49 > * derived from the supplied JSON-schema descriptor.
50 > */
51 > export function schemaProperty<T>(protocol: SessionConfigPropertySchema): ISchemaProperty<T> {
52 > const assertFn = buildAssert(protocol);
53 > const assertValid = (value: unknown, path: string = ''): asserts value is T => assertFn(value, path);
54 > const validate = (value: unknown): value is T => {
55 try {
56 assertFn(value, '');
60 }
61 };
62 > return { protocol, validate, assertValid }; agentHostSchema.ts
63 > }
64 >
65 > // eslint-disable-next-line @typescript-eslint/no-explicit-any
66 > export type SchemaDefinition = Record<string, ISchemaProperty<any>>;
67 >
68 > export type SchemaValue<P> = P extends ISchemaProperty<infer T> ? T : never;
69 >
70 > export type SchemaValues<D extends SchemaDefinition> = {
71 > [K in keyof D]?: SchemaValue<D[K]>;
72 > };
73 >
74 > /**
75 > * A bundle of named schema properties plus helpers for serializing to the
76 > * protocol shape, validating a values bag at write sites, and validating
77 > * a single key at read sites.
78 > */
79 > export interface ISchema<D extends SchemaDefinition> {
80 > readonly definition: D;
81 > /** Returns the protocol-serializable schema for this bundle. */
82 > toProtocol(): SessionConfigSchema;
83 > /**
84 > * Validates each known key in `values` against its schema and returns
85 > * a new plain record. Throws a {@link ProtocolError} with a path like
86 > * `'permissions.allow[2]'` when any supplied value fails validation.
87 > * Unknown keys are passed through untouched for forward-compatibility.
88 > */
89 > values(values: SchemaValues<D>): Record<string, unknown>;
90 > /**
91 > * Returns `true` iff `value` validates against the schema for `key`.
92 > * Unknown keys return `false`.
93 > */
94 > validate<K extends keyof D & string>(key: K, value: unknown): value is SchemaValue<D[K]>;
95 > /**
96 > * Throws a {@link ProtocolError} describing the offending path when
97 > * `value` does not validate against the schema for `key`, or when
98 > * `key` is not defined in the schema.
99 > */
100 > assertValid<K extends keyof D & string>(key: K, value: unknown): asserts value is SchemaValue<D[K]>;
101 > /**
102 > * Returns a fully-typed values bag by validating each key of the
103 > * schema against `values` and falling back to the default when
104 > * the incoming value is missing or fails validation.
105 > *
106 > * Semantics: for every key declared in the schema `definition`:
107 > * - if `values[key]` validates, it is kept;
108 > * - else if `key` is present in `defaults`, the default is used;
109 > * - else the key is omitted from the result.
110 > *
111 > * This means callers MAY supply defaults for only a subset of the
112 > * schema — keys not present in `defaults` are simply left unset
113 > * when the incoming value is missing or invalid. This is useful
114 > * when some properties (e.g. per-session `permissions`) should be
115 > * inherited from a higher scope rather than materialized on every
116 > * new session.
117 > *
118 > * Intended for sanitizing untrusted input at protocol boundaries
119 > * (e.g. `resolveSessionConfig`). Keys that fail validation are
120 > * silently replaced with their default or dropped; use
121 > * {@link values} or {@link assertValid} when you want a descriptive
122 > * {@link ProtocolError} instead.
123 > */
124 > validateOrDefault<T extends Partial<{ [K in keyof D]: SchemaValue<D[K]> }>>(values: { [K in keyof T]?: unknown } | undefined, defaults: T): T;
125 > }
126 >
127 > export function createSchema<D extends SchemaDefinition>(definition: D): ISchema<D> {
128 > return {
129 > definition,
130 > toProtocol(): SessionConfigSchema {
131 const properties: Record<string, SessionConfigPropertySchema> = {};
132 for (const key of Object.keys(definition)) {
135 return { type: 'object', properties };
136 },
137 > values(values) { agentHostSchema.ts
138 const raw = values as Record<string, unknown>;
139 for (const key of Object.keys(definition)) {
149 return { ...raw };
150 },
151 > validate<K extends keyof D & string>(key: K, value: unknown): value is SchemaValue<D[K]> { agentHostSchema.ts
152 const prop = definition[key];
153 return prop ? prop.validate(value) : false;
154 },
155 > assertValid<K extends keyof D & string>(key: K, value: unknown): asserts value is SchemaValue<D[K]> { agentHostSchema.ts
156 const prop: ISchemaProperty<unknown> | undefined = definition[key];
157 if (!prop) {
163 narrowed.assertValid(value, key);
164 },
165 > validateOrDefault<T extends Partial<{ [K in keyof D]: SchemaValue<D[K]> }>>(values: { [K in keyof T]?: unknown } | undefined, defaults: T): T { agentHostSchema.ts
166 const result: Record<string, unknown> = {};
167 const raw: { [K in keyof T]?: unknown } = values ?? {};
179 return result as T;
180 },
182 > }
183 >
184 > // ---- Validator derivation --------------------------------------------------
185 >
186 > /**
187 > * A validator that throws a {@link ProtocolError} annotated with the
188 > * offending path when `value` does not conform, or returns normally
189 > * when it does.
190 > */
191 > type AssertValidator = (value: unknown, path: string) => void;
192 >
193 > function buildAssert(schema: SessionConfigPropertySchema): AssertValidator {
194 > if (schema.type === 'object' && schema.properties) {
195 > const propAsserts: Record<string, AssertValidator> = {};
196 > for (const key of Object.keys(schema.properties)) {
197 > propAsserts[key] = buildAssert(schema.properties[key] as SessionConfigPropertySchema);
198 > }
199 > const required = new Set(schema.required ?? []);
200 > return (value, path) => {
201 if (typeof value !== 'object' || value === null || Array.isArray(value)) {
202 throw invalidParams(path, 'object', value);
214 }
215 };
217 > if (schema.type === 'array' && schema.items) {
218 > const itemAssert = buildAssert(schema.items as SessionConfigPropertySchema);
219 > return (value, path) => {
220 if (!Array.isArray(value)) {
221 throw invalidParams(path, 'array', value);
225 }
226 };
228 > return buildPrimitiveAssert(schema);
229 > }
230 >
231 > function buildPrimitiveAssert(schema: SessionConfigPropertySchema): AssertValidator {
232 > const enumDynamic = schema.enumDynamic === true;
233 > return (value, path) => {
234 switch (schema.type) {
235 case 'string': if (typeof value !== 'string') { throw invalidParams(path, 'string', value); } break;
243 }
244 };
246 >
247 function invalidParams(path: string, expected: string, value: unknown): ProtocolError {
248 return new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Invalid value at '${path || '<root>'}': expected ${expected}, got ${safeStringify(value)}`);
249 }
251 function joinPath(parent: string, key: string): string {
252 return parent ? `${parent}.${key}` : key;
253 }
255 function safeStringify(value: unknown): string {
256 try {
260 }
261 }
263 > // ---- Platform-owned schema -------------------------------------------------
264 >
265 > export type AutoApproveLevel = 'default' | 'assisted' | 'autoApprove';
266 >
267 > export type SessionMode = 'interactive' | 'plan' | 'autopilot';
268 >
269 > export interface IPermissionsValue {
270 > readonly allow: readonly string[];
271 > readonly deny: readonly string[];
272 > }
273 >
274 > const permissionsProperty = schemaProperty<IPermissionsValue>({
275 > type: 'object',
276 > title: localize('agentHost.sessionConfig.permissions', "Permissions"),
277 > description: localize('agentHost.sessionConfig.permissionsDescription', "Per-tool session permissions. Updated automatically when approving a tool \"in this Session\"."),
278 > properties: {
279 > allow: {
280 > type: 'array',
281 > title: localize('agentHost.sessionConfig.permissions.allow', "Allowed tools"),
282 > items: {
283 > type: 'string',
284 > title: localize('agentHost.sessionConfig.permissions.toolName', "Tool name"),
285 > },
286 > },
287 > deny: {
288 > type: 'array',
289 > title: localize('agentHost.sessionConfig.permissions.deny', "Denied tools"),
290 > items: {
291 > type: 'string',
292 > title: localize('agentHost.sessionConfig.permissions.toolName', "Tool name"),
293 > },
294 > },
295 > },
296 > default: { allow: [], deny: [] },
297 > sessionMutable: true,
298 > });
299 >
300 > /**
301 > * Session-config properties owned by the platform itself — i.e. consumed
302 > * by the agent host rather than by any particular agent.
303 > *
304 > * Agents extend this schema by spreading `platformSessionSchema.definition`
305 > * into their own {@link createSchema} call together with any
306 > * provider-specific properties.
307 > */
308 > export const platformSessionSchema = createSchema({
309 > [SessionConfigKey.AutoApprove]: schemaProperty<AutoApproveLevel>({
310 > type: 'string',
311 > title: localize('agentHost.sessionConfig.autoApprove', "Approvals"),
312 > description: localize('agentHost.sessionConfig.autoApproveDescription', "Tool approval behavior for this session"),
313 > enum: ['default', 'assisted', 'autoApprove'],
314 > enumLabels: [
315 > localize('agentHost.sessionConfig.autoApprove.default', "Default approvals"),
316 > localize('agentHost.sessionConfig.autoApprove.assisted', "Assisted permissions"),
317 > localize('agentHost.sessionConfig.autoApprove.bypass', "Allow all"),
318 > ],
319 > enumDescriptions: [
320 > localize('agentHost.sessionConfig.autoApprove.defaultDescription', "Asks when approval settings don't apply"),
321 > localize('agentHost.sessionConfig.autoApprove.assistedDescription', "Evaluates risk before running tools"),
322 > localize('agentHost.sessionConfig.autoApprove.bypassDescription', "Runs tool calls without asking"),
323 > ],
324 > default: 'default',
325 > sessionMutable: true,
326 > }),
327 > [SessionConfigKey.Permissions]: permissionsProperty,
328 > [SessionConfigKey.Mode]: schemaProperty<SessionMode>({
329 > type: 'string',
330 > title: localize('agentHost.sessionConfig.mode', "Agent Mode"),
331 > description: localize('agentHost.sessionConfig.modeDescription', "How the agent should approach this turn"),
332 > enum: ['interactive', 'plan', 'autopilot'],
333 > enumLabels: [
334 > localize('agentHost.sessionConfig.mode.interactive', "Interactive"),
335 > localize('agentHost.sessionConfig.mode.plan', "Plan"),
336 > localize('agentHost.sessionConfig.mode.autopilot', "Autopilot"),
337 > ],
338 > enumDescriptions: [
339 > localize('agentHost.sessionConfig.mode.interactiveDescription', "Step-by-step collaboration"),
340 > localize('agentHost.sessionConfig.mode.planDescription', "Plan first, execute when ready"),
341 > localize('agentHost.sessionConfig.mode.autopilotDescription', "Autonomously iterates from start to finish"),
342 > ],
343 > default: 'interactive',
344 > sessionMutable: true,
345 > }),
346 > });
347 >
348 > /**
349 > * Rewrites a legacy `autoApprove='autopilot'` config value — used before
350 > * Autopilot moved from the `autoApprove` axis onto the orthogonal `mode`
351 > * axis — into the current two-axis shape:
352 > *
353 > * - `autoApprove='autopilot'` + `mode='plan'` → `mode='plan'`, `autoApprove='default'`
354 > * (legacy `plan` took precedence over autopilot when resolving the SDK mode).
355 > * - `autoApprove='autopilot'` + any other mode → `mode='autopilot'`, `autoApprove='default'`.
356 > *
357 > * Returns a shallow copy with the migration applied, or the original
358 > * reference unchanged when no legacy value is present. Safe to call on
359 > * `undefined`.
360 > *
361 > * Without this, a session persisted (or a "remembered" picker value seeded)
362 > * with `autoApprove='autopilot'` would fail the new schema's enum validation
363 > * and silently fall back to `default`, downgrading the session from
364 > * autonomous Autopilot to manual per-tool confirmation.
365 > */
366 > export function migrateLegacyAutopilotConfig<T extends Record<string, unknown> | undefined>(config: T): T {
367 if (!config || config[SessionConfigKey.AutoApprove] !== 'autopilot') {
368 return config;
375 return migrated as T;
376 }
378 > /**
379 > * Root (agent host) config properties owned by the platform itself.
380 > *
381 > * Root config acts as the baseline that applies to every session:
382 > *
383 > * - {@link SessionConfigKey.Permissions} — host-wide allow/deny lists
384 > * unioned with each session's own permissions when evaluating tool
385 > * auto-approval. See `SessionPermissionManager` for the evaluation
386 > * rules.
387 > */
388 > export const AgentHostTelemetryLevelConfigKey = 'telemetryLevel';
389 >
390 > /** Legacy Copilot Chat debug switch that disables `request.repoInfo` collection. */
391 > export const AgentHostDisableRepoInfoTelemetryConfigKey = 'disableRepoInfoTelemetry';
392 >
393 > /** VS Code setting forwarded into {@link AgentHostDisableRepoInfoTelemetryConfigKey}. */
394 > export const DISABLE_REPO_INFO_TELEMETRY_SETTING_ID = 'chat.advanced.debug.disableRepoInfoTelemetry';
395 >
396 > /**
397 > * Root config key forwarded from the renderer when VS Code's
398 > * `chat.sessionSync.enabled` setting changes. Controls the `remote` flag
399 > * passed to the copilot-sdk `CopilotClientOptions`.
400 > */
401 > export const AgentHostSessionSyncEnabledConfigKey = 'sessionSyncEnabled';
402 >
403 > /**
404 > * Root config key forwarded from the renderer carrying the experiment-aware
405 > * value of `chat.agentHost.codexAgent.enabled`. The host registers the Codex
406 > * provider when this is `true`; disabling requires an agent host restart.
407 > */
408 > export const AgentHostCodexEnabledConfigKey = 'codexAgentEnabled';
409 >
410 > /**
411 > * Root config key forwarded from the renderer when VS Code's
412 > * `chat.tools.terminal.enableAutoApprove` setting changes. Controls whether
413 > * agent-host shell permission checks may apply terminal auto-approve rules.
414 > */
415 > export const AgentHostTerminalAutoApproveEnabledConfigKey = 'terminalAutoApproveEnabled';
416 >
417 > /**
418 > * The VS Code setting ID for terminal auto approve enablement. Defined here so
419 > * renderer-side agent-host clients can forward it without importing from
420 > * workbench terminal contributions.
421 > */
422 > export const TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID = 'chat.tools.terminal.enableAutoApprove';
423 >
424 > /**
425 > * Root config key forwarded from the renderer when VS Code's
426 > * `chat.tools.global.autoApprove` setting changes. When `true`, the global
427 > * auto-approve ("approve everything") setting is enabled and the agent host
428 > * treats every tool call as auto-approved — equivalent to a session running
429 > * with Allow all.
430 > */
431 > export const AgentHostGlobalAutoApproveEnabledConfigKey = 'globalAutoApproveEnabled';
432 >
433 > /**
434 > * The VS Code setting ID for global auto approve. Defined here so renderer-side
435 > * agent-host clients can forward it without importing from `workbench/contrib/chat`.
436 > */
437 > export const GLOBAL_AUTO_APPROVE_SETTING_ID = 'chat.tools.global.autoApprove';
438 >
439 > /**
440 > * Root config key forwarded from the renderer when VS Code's `chat.autoReply`
441 > * setting changes. When `true`, the agent host auto-answers `ask_user`
442 > * questions instead of blocking on the user — the user is treated as
443 > * unavailable and the agent is told to use its best judgment, mirroring the
444 > * behavior of `autopilot` mode.
445 > */
446 > export const AgentHostAutoReplyEnabledConfigKey = 'autoReplyEnabled';
447 >
448 > /**
449 > * The VS Code setting ID for auto-reply. Defined here so renderer-side
450 > * agent-host clients can forward it without importing from `workbench/contrib/chat`.
451 > */
452 > export const AUTO_REPLY_SETTING_ID = 'chat.autoReply';
453 >
454 > // Root config key forwarded from the renderer when Copilot Chat's `github.copilot.chat.preferLongContext.enabled` setting changes.
455 > export const AgentHostPreferLongContextEnabledConfigKey = 'preferLongContextEnabled';
456 >
457 > // The Copilot Chat setting ID for preferring long context, forwarded into the agent host root config.
458 > export const PREFER_LONG_CONTEXT_SETTING_ID = 'github.copilot.chat.preferLongContext.enabled';
459 >
460 > /** Root config key forwarded from the renderer for automatic OS system proxy discovery. */
461 > export const AgentHostSystemProxyEnabledConfigKey = 'systemProxyEnabled';
462 >
463 > /**
464 > * Root config key forwarded from the renderer when VS Code's
465 > * `chat.tools.terminal.autoApprove` setting changes. Holds the effective
466 > * terminal auto-approve rule object for agent-host shell permission checks.
467 > */
468 > export const AgentHostTerminalAutoApproveRulesConfigKey = 'terminalAutoApproveRules';
469 >
470 > export interface IAgentHostTerminalAutoApproveRule {
471 > readonly approve: boolean;
472 > readonly matchCommandLine?: boolean;
473 > }
474 >
475 > export type AgentHostTerminalAutoApproveRuleValue = boolean | null | IAgentHostTerminalAutoApproveRule;
476 > export type AgentHostTerminalAutoApproveRules = Record<string, AgentHostTerminalAutoApproveRuleValue>;
477 >
478 > /**
479 > * The VS Code setting IDs for terminal auto approve rules. Defined here so
480 > * renderer-side agent-host clients can forward them without importing from
481 > * workbench terminal contributions.
482 > */
483 > export const TERMINAL_AUTO_APPROVE_SETTING_ID = 'chat.tools.terminal.autoApprove';
484 > export const TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID = 'chat.tools.terminal.ignoreDefaultAutoApproveRules';
485 >
486 > export function getAgentHostTerminalAutoApproveRulesConfig(configurationService: IConfigurationService): AgentHostTerminalAutoApproveRules {
487 const config = configurationService.getValue<AgentHostTerminalAutoApproveRules | undefined>(TERMINAL_AUTO_APPROVE_SETTING_ID);
488 const configInspectValue = configurationService.inspect<Readonly<AgentHostTerminalAutoApproveRules>>(TERMINAL_AUTO_APPROVE_SETTING_ID);
490 return normalizeAgentHostTerminalAutoApproveRulesConfig(config, configInspectValue, ignoreDefaults);
491 }
493 > export function normalizeAgentHostTerminalAutoApproveRulesConfig(config: AgentHostTerminalAutoApproveRules | undefined, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>, ignoreDefaults: boolean): AgentHostTerminalAutoApproveRules {
494 if (!config) {
495 return {};
505 return rules;
506 }
508 function isDefaultOnlyAutoApproveRule(key: string, value: AgentHostTerminalAutoApproveRuleValue, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>): boolean {
509 const defaultValue = configInspectValue.default?.value;
517 return sourceTarget === ConfigurationTarget.DEFAULT;
518 }
520 function getAutoApproveRuleSourceTarget(key: string, value: AgentHostTerminalAutoApproveRuleValue, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>): ConfigurationTarget {
521 if (hasMatchingRule(configInspectValue.workspaceFolderValue, key, value)) {
539 return ConfigurationTarget.DEFAULT;
540 }
542 function hasMatchingRule(config: Readonly<AgentHostTerminalAutoApproveRules> | undefined, key: string, value: AgentHostTerminalAutoApproveRuleValue): boolean {
543 return !!config && Object.prototype.hasOwnProperty.call(config, key) && structuralEquals(config[key], value);
544 }
546 > /**
547 > * Root config key holding agent-host-level MCP server definitions.
548 > *
549 > * The value is a map of server name → {@link IMcpServerConfiguration}
550 > * (the same `servers` shape used by `mcp.json`). These servers are
551 > * exposed to every session created by the host, merged with any
552 > * plugin-provided MCP servers when launching the copilot-sdk client.
553 > */
554 > export const AgentHostMcpServersConfigKey = 'mcpServers';
555 >
556 > /**
557 > * Map of server name → MCP server configuration, as stored in the
558 > * {@link AgentHostMcpServersConfigKey} root config value.
559 > */
560 > export type AgentHostMcpServers = Record<string, IMcpServerConfiguration>;
561 >
562 > /**
563 > * The VS Code setting ID for session sync. Defined here so the platform
564 > * layer (renderer-side forwarding) can reference it without importing from
565 > * `workbench/contrib/chat`.
566 > */
567 > export const SESSION_SYNC_ENABLED_SETTING_ID = 'chat.sessionSync.enabled';
568 >
569 > export function telemetryLevelToAgentHostConfigValue(telemetryLevel: TelemetryLevel): TelemetryConfiguration {
570 switch (telemetryLevel) {
571 case TelemetryLevel.NONE:
579 }
580 }
582 > export function agentHostConfigValueToTelemetryLevel(value: unknown): TelemetryLevel | undefined {
583 switch (value) {
584 case TelemetryConfiguration.OFF:
594 }
595 }
597 > /**
598 > * Field descriptors for a single MCP server entry, shared by the stdio and
599 > * http shapes. The agent-host config schema has no `oneOf`, so both variants'
600 > * fields are described together; `type` selects which fields apply
601 > * (`stdio` uses `command`/`args`/`env`/`cwd`, `http` uses `url`/`headers`).
602 > */
603 > const mcpServerConfigProperties: Record<string, SessionConfigPropertySchema> = {
604 > type: {
605 > type: 'string',
606 > title: localize('agentHost.config.mcpServers.type.title', "Server Type"),
607 > description: localize('agentHost.config.mcpServers.type.description', "The transport used to reach the server: `stdio` for a local command, `http` for a remote endpoint."),
608 > enum: ['stdio', 'http'],
609 > },
610 > command: {
611 > type: 'string',
612 > title: localize('agentHost.config.mcpServers.command.title', "Command"),
613 > description: localize('agentHost.config.mcpServers.command.description', "For `stdio` servers, the executable to spawn."),
614 > },
615 > args: {
616 > type: 'array',
617 > title: localize('agentHost.config.mcpServers.args.title', "Arguments"),
618 > description: localize('agentHost.config.mcpServers.args.description', "For `stdio` servers, the arguments passed to the command."),
619 > items: { type: 'string', title: localize('agentHost.config.mcpServers.arg.title', "Argument") },
620 > },
621 > env: {
622 > type: 'object',
623 > title: localize('agentHost.config.mcpServers.env.title', "Environment"),
624 > description: localize('agentHost.config.mcpServers.env.description', "For `stdio` servers, environment variables set on the spawned process."),
625 > },
626 > cwd: {
627 > type: 'string',
628 > title: localize('agentHost.config.mcpServers.cwd.title', "Working Directory"),
629 > description: localize('agentHost.config.mcpServers.cwd.description', "For `stdio` servers, the working directory the command runs in."),
630 > },
631 > url: {
632 > type: 'string',
633 > title: localize('agentHost.config.mcpServers.url.title', "URL"),
634 > description: localize('agentHost.config.mcpServers.url.description', "For `http` servers, the endpoint URL of the MCP server."),
635 > },
636 > headers: {
637 > type: 'object',
638 > title: localize('agentHost.config.mcpServers.headers.title', "Headers"),
639 > description: localize('agentHost.config.mcpServers.headers.description', "For `http` servers, HTTP headers sent with every request."),
640 > },
641 > };
642 >
643 > /**
644 > * Documents the value shape of the {@link AgentHostMcpServersConfigKey} map.
645 > *
646 > * The config value is a map of server name → server config. The schema
647 > * language has no `additionalProperties`, so the per-entry shape is attached
648 > * under a placeholder key (`<serverName>`) rather than at the map level —
649 > * this keeps the field descriptions discoverable without the runtime
650 > * validator mistaking a real server named e.g. `command` for the `command`
651 > * field. Real entries (keyed by actual server names) are passed through.
652 > */
653 > const mcpServersValueProperties: Record<string, SessionConfigPropertySchema> = {
654 > '<serverName>': {
655 > type: 'object',
656 > title: localize('agentHost.config.mcpServers.entry.title', "MCP Server"),
657 > description: localize('agentHost.config.mcpServers.entry.description', "A single MCP server entry. The property key is the server name."),
658 > properties: mcpServerConfigProperties,
659 > },
660 > };
661 >
662 > export const platformRootSchema = createSchema({
663 > [SessionConfigKey.Permissions]: permissionsProperty,
664 > [AgentHostDisableRepoInfoTelemetryConfigKey]: schemaProperty<boolean>({
665 > type: 'boolean',
666 > title: localize('agentHost.config.disableRepoInfoTelemetry.title', "Disable Repository Information Telemetry"),
667 > description: localize('agentHost.config.disableRepoInfoTelemetry.description', "Whether repository information telemetry is disabled for Agent Host sessions."),
668 > default: false,
669 > }),
670 > [AgentHostTelemetryLevelConfigKey]: schemaProperty<TelemetryConfiguration>({
671 > type: 'string',
672 > title: localize('agentHost.config.telemetryLevel.title', "Telemetry Level"),
673 > description: localize('agentHost.config.telemetryLevel.description', "Most restrictive telemetry level requested by connected clients."),
674 > enum: [TelemetryConfiguration.ON, TelemetryConfiguration.ERROR, TelemetryConfiguration.CRASH, TelemetryConfiguration.OFF],
675 > default: TelemetryConfiguration.ON,
676 > }),
677 > [AgentHostSessionSyncEnabledConfigKey]: schemaProperty<boolean>({
678 > type: 'boolean',
679 > title: localize('agentHost.config.sessionSyncEnabled.title', "Session Sync"),
680 > description: localize('agentHost.config.sessionSyncEnabled.description', "Whether remote session sync is enabled for the copilot-sdk CLI."),
681 > default: false,
682 > }),
683 > [AgentHostCodexEnabledConfigKey]: schemaProperty<boolean>({
684 > type: 'boolean',
685 > title: localize('agentHost.config.codexAgentEnabled.title', "Codex Agent"),
686 > description: localize('agentHost.config.codexAgentEnabled.description', "Whether the Codex provider is enabled."),
687 > default: false,
688 > }),
689 > [AgentHostTerminalAutoApproveEnabledConfigKey]: schemaProperty<boolean>({
690 > type: 'boolean',
691 > title: localize('agentHost.config.terminalAutoApproveEnabled.title', "Terminal Auto Approve"),
692 > description: localize('agentHost.config.terminalAutoApproveEnabled.description', "Whether terminal auto-approve rules forwarded by the connected client are allowed to apply to agent-host shell permission requests."),
693 > default: true,
694 > }),
695 > [AgentHostGlobalAutoApproveEnabledConfigKey]: schemaProperty<boolean>({
696 > type: 'boolean',
697 > title: localize('agentHost.config.globalAutoApproveEnabled.title', "Global Auto Approve"),
698 > description: localize('agentHost.config.globalAutoApproveEnabled.description', "Whether VS Code's global auto-approve setting is enabled. When `true`, every tool call is auto-approved, equivalent to a session using Allow all."),
699 > default: false,
700 > }),
701 > [AgentHostAutoReplyEnabledConfigKey]: schemaProperty<boolean>({
702 > type: 'boolean',
703 > title: localize('agentHost.config.autoReplyEnabled.title', "Auto Reply"),
704 > description: localize('agentHost.config.autoReplyEnabled.description', "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."),
705 > default: false,
706 > }),
707 > [AgentHostPreferLongContextEnabledConfigKey]: schemaProperty<boolean>({
708 > type: 'boolean',
709 > title: localize('agentHost.config.preferLongContextEnabled.title', "Prefer Long Context"),
710 > description: localize('agentHost.config.preferLongContextEnabled.description', "Whether Copilot Chat's prefer-long-context setting is enabled. When `true`, models with a free long context window only show the long context option in the picker. When `false` (default), the smaller default context option stays selectable."),
711 > default: false,
712 > }),
713 > [AgentHostSystemProxyEnabledConfigKey]: schemaProperty<boolean>({
714 > type: 'boolean',
715 > title: localize('agentHost.config.systemProxyEnabled.title', "System Proxy Discovery"),
716 > description: localize('agentHost.config.systemProxyEnabled.description', "Whether Copilot sessions automatically discover and use the operating system's proxy configuration."),
717 > default: true,
718 > }),
719 > [AgentHostTerminalAutoApproveRulesConfigKey]: schemaProperty<AgentHostTerminalAutoApproveRules>({
720 > type: 'object',
721 > title: localize('agentHost.config.terminalAutoApproveRules.title', "Terminal Auto Approve Rules"),
722 > description: localize('agentHost.config.terminalAutoApproveRules.description', "Terminal auto-approve rules forwarded by the connected client for agent-host shell permission checks."),
723 > default: {},
724 > }),
725 > [AgentHostMcpServersConfigKey]: schemaProperty<AgentHostMcpServers>({
726 > type: 'object',
727 > title: localize('agentHost.config.mcpServers.title', "MCP Servers"),
728 > description: localize('agentHost.config.mcpServers.description', "Agent-host-level MCP servers exposed to every session, keyed by server name. Each value is a server configuration (see `<serverName>`)."),
729 > properties: mcpServersValueProperties,
730 > default: {},
731 > }),
732 > });