src/vs/platform/agentHost/common/agentHostSchema.ts

732 LOC · 711 covered · 21 uncovered · 99 ranges · 3812 concepts · 41 introducers · 1797 tests
File neighbourhood

The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
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 related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
  1
  >
  /*---------------------------------------------------------------------------------------------
  
agentHostSchema.ts ×21

  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 {
  
agentHostSchema.ts ×2

  56
  >
  			assertFn(value, '');
  
  57
  >
  			return true;
  
  58
  >
  		} catch {
  
  59
  >
  			return false;
  
agentHostSchema.ts ×1

  60
  >
  		}
  
  61
  >
  	};
  
agentHostSchema.ts ×2

  62
  >
  	return { protocol, validate, assertValid };
  
agentHostSchema.ts ×21

  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> = {};
  
agentHostSchema.ts ×1

  132
  >
  			for (const key of Object.keys(definition)) {
  
  133
  >
  				properties[key] = definition[key].protocol;
  
  134
  >
  			}
  
  135
  >
  			return { type: 'object', properties };
  
  136
  >
  		},
  
  137
  >
  		values(values) {
  
agentHostSchema.ts ×21

  138
  >
  			const raw = values as Record<string, unknown>;
  
agentHostSchema.ts ×3

  139
  >
  			for (const key of Object.keys(definition)) {
  
  140
  >
  				const value = raw[key];
  
  141
  >
  				if (value === undefined) {
  
  142
  >
  					continue;
  
agentHostSchema.ts ×2

  143
  >
  				}
  
  144
  >
  				// Local with explicit annotation so TypeScript accepts the
  
agentHostSchema.ts ×3

  145
  >
  				// assertion-signature call (per TS4104).
  
  146
  >
  				const prop: ISchemaProperty<unknown> = definition[key];
  
  147
  >
  				prop.assertValid(value, key);
  
  148
  >
  			}
  
  149
  >
  			return { ...raw };
  
agentHostSchema.ts ×2

  150
  >
  		},
  
agentHostSchema.ts ×3

  151
  >
  		validate<K extends keyof D & string>(key: K, value: unknown): value is SchemaValue<D[K]> {
  
agentHostSchema.ts ×21

  152
  >
  			const prop = definition[key];
  
agentHostSchema.ts ×1

  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 ×21

  156
  >
  			const prop: ISchemaProperty<unknown> | undefined = definition[key];
  
agentHostSchema.ts ×2

  157
  >
  			if (!prop) {
  
  158
  >
  				throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Unknown schema key '${key}'`);
  
agentHostSchema.ts ×1

  159
  >
  			}
  
  160
  >
  			// Re-bind post-narrowing to keep the call target explicitly typed
  
agentHostSchema.ts ×1

  161
  >
  			// (required for assertion-signature calls, TS4104).
  
  162
  >
  			const narrowed: ISchemaProperty<unknown> = prop;
  
  163
  >
  			narrowed.assertValid(value, key);
  
  164
  >
  		},
  
agentHostSchema.ts ×2

  165
  >
  		validateOrDefault<T extends Partial<{ [K in keyof D]: SchemaValue<D[K]> }>>(values: { [K in keyof T]?: unknown } | undefined, defaults: T): T {
  
agentHostSchema.ts ×21

  166
  >
  			const result: Record<string, unknown> = {};
  
agentHostSchema.ts ×3

  167
  >
  			const raw: { [K in keyof T]?: unknown } = values ?? {};
  
  168
  >
  			for (const key of Object.keys(definition)) {
  
  169
  >
  				const prop = definition[key];
  
  170
  >
  				const candidate = raw[key];
  
  171
  >
  				if (candidate !== undefined && prop.validate(candidate)) {
  
  172
  >
  					result[key] = candidate;
  
agentHostSchema.ts ×1

  173
  >
  				} else if (Object.prototype.hasOwnProperty.call(defaults, key)) {
  
agentHostSchema.ts ×3

  174
  >
  					result[key] = (defaults as Record<string, unknown>)[key];
  
agentHostSchema.ts ×1

  175
  >
  				}
  
  176
  >
  				// else: key not in defaults and incoming value missing/invalid
  
agentHostSchema.ts ×3

  177
  >
  				// → leave unset so higher-scope defaults can fill in.
  
  178
  >
  			}
  
  179
  >
  			return result as T;
  
  180
  >
  		},
  
  181
  >
  	};
  
agentHostSchema.ts ×21

  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)) {
  
agentHostSchema.ts ×4

  202
  >
  				throw invalidParams(path, 'object', value);
  
agentHostSchema.ts ×1

  203
  >
  			}
  
  204
  >
  			const obj = value as Record<string, unknown>;
  
agentHostSchema.ts ×4

  205
  >
  			for (const key of Object.keys(propAsserts)) {
  
  206
  >
  				const childPath = joinPath(path, key);
  
  207
  >
  				if (obj[key] === undefined) {
  
  208
  >
  					if (required.has(key)) {
  
agentHostSchema.ts ×1

  209
  >
  						throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Missing required property at '${childPath}'`);
  
agentHostSchema.ts ×1

  210
  >
  					}
  
  211
  >
  					continue;
  
agentHostSchema.ts ×1

  212
  >
  				}
  
  213
  >
  				propAsserts[key](obj[key], childPath);
  
agentHostSchema.ts ×1

  214
  >
  			}
  
  215
  >
  		};
  
agentHostSchema.ts ×4

  216
  >
  	}
  
agentHostSchema.ts ×21

  217
  >
  	if (schema.type === 'array' && schema.items) {
  
  218
  >
  		const itemAssert = buildAssert(schema.items as SessionConfigPropertySchema);
  
  219
  >
  		return (value, path) => {
  
  220
  >
  			if (!Array.isArray(value)) {
  
agentHostSchema.ts ×3

  221
  >
  				throw invalidParams(path, 'array', value);
  
agentHostSchema.ts ×1

  222
  >
  			}
  
  223
  >
  			for (let i = 0; i < value.length; i++) {
  
agentHostSchema.ts ×3

  224
  >
  				itemAssert(value[i], `${path}[${i}]`);
  
agentHostSchema.ts ×1

  225
  >
  			}
  
  226
  >
  		};
  
agentHostSchema.ts ×3

  227
  >
  	}
  
agentHostSchema.ts ×21

  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) {
  
agentHostSchema.ts ×2

  235
  >
  			case 'string': if (typeof value !== 'string') { throw invalidParams(path, 'string', value); } break;
  
  236
  >
  			case 'number': if (typeof value !== 'number') { throw invalidParams(path, 'number', value); } break;
  
  237
  >
  			case 'boolean': if (typeof value !== 'boolean') { throw invalidParams(path, 'boolean', value); } break;
  
  238
  >
  			case 'array': if (!Array.isArray(value)) { throw invalidParams(path, 'array', value); } break;
  
  239
  >
  			case 'object': if (typeof value !== 'object' || value === null || Array.isArray(value)) { throw invalidParams(path, 'object', value); } break;
  
  240
  >
  		}
  
  241
  >
  		if (schema.enum && !enumDynamic && !schema.enum.includes(value as string)) {
  
  242
  >
  			throw new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Invalid value at '${path || '<root>'}': ${safeStringify(value)} is not one of [${schema.enum.map(v => JSON.stringify(v)).join(', ')}]`);
  
agentHostSchema.ts ×1

  243
  >
  		}
  
  244
  >
  	};
  
agentHostSchema.ts ×2

  245
  >
  }
  
agentHostSchema.ts ×21

  246
  >
  
  247
  >
  function invalidParams(path: string, expected: string, value: unknown): ProtocolError {
  
agentHostSchema.ts ×1

  248
  >
  	return new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Invalid value at '${path || '<root>'}': expected ${expected}, got ${safeStringify(value)}`);
  
  249
  >
  }
  
  250
  >
  
agentHostSchema.ts ×21

  251
  >
  function joinPath(parent: string, key: string): string {
  
agentHostSchema.ts ×4

  252
  >
  	return parent ? `${parent}.${key}` : key;
  
  253
  >
  }
  
  254
  >
  
agentHostSchema.ts ×21

  255
  >
  function safeStringify(value: unknown): string {
  
agentHostSchema.ts ×2

  256
  >
  	try {
  
  257
  >
  		return JSON.stringify(value);
  
  258
  >
  	} catch {
  
  259
  
  		return String(value);
  
  260
  
  	}
  
  261
  >
  }
  
agentHostSchema.ts ×2

  262
  >
  
agentHostSchema.ts ×21

  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') {
  
agentHostSchema.ts ×1

  368
  >
  		return config;
  
agentHostSchema.ts ×1

  369
  >
  	}
  
  370
  >
  	const migrated: Record<string, unknown> = { ...config };
  
agentHostSchema.ts ×2

  371
  >
  	if (migrated[SessionConfigKey.Mode] !== 'plan') {
  
  372
  >
  		migrated[SessionConfigKey.Mode] = 'autopilot' satisfies SessionMode;
  
agentHostSchema.ts ×1

  373
  >
  	}
  
  374
  >
  	migrated[SessionConfigKey.AutoApprove] = 'default' satisfies AutoApproveLevel;
  
agentHostSchema.ts ×2

  375
  >
  	return migrated as T;
  
  376
  >
  }
  
  377
  >
  
agentHostSchema.ts ×21

  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);
  
  489
  
  	const ignoreDefaults = configurationService.getValue<boolean>(TERMINAL_IGNORE_DEFAULT_AUTO_APPROVE_RULES_SETTING_ID) === true;
  
  490
  
  	return normalizeAgentHostTerminalAutoApproveRulesConfig(config, configInspectValue, ignoreDefaults);
  
  491
  
  }
  
  492
  >
  
agentHostSchema.ts ×21

  493
  >
  export function normalizeAgentHostTerminalAutoApproveRulesConfig(config: AgentHostTerminalAutoApproveRules | undefined, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>, ignoreDefaults: boolean): AgentHostTerminalAutoApproveRules {
  
  494
  >
  	if (!config) {
  
agentHostSchema.ts ×3

  495
  
  		return {};
  
  496
  
  	}
  
  497
  >
  
agentHostSchema.ts ×3

  498
  >
  	const rules: AgentHostTerminalAutoApproveRules = {};
  
  499
  >
  	for (const [key, value] of Object.entries(config)) {
  
  500
  >
  		if (ignoreDefaults && isDefaultOnlyAutoApproveRule(key, value, configInspectValue)) {
  
  501
  >
  			continue;
  
agentHostSchema.ts ×11

  502
  >
  		}
  
  503
  >
  		rules[key] = value;
  
agentHostSchema.ts ×3

  504
  >
  	}
  
  505
  >
  	return rules;
  
  506
  >
  }
  
  507
  >
  
agentHostSchema.ts ×21

  508
  >
  function isDefaultOnlyAutoApproveRule(key: string, value: AgentHostTerminalAutoApproveRuleValue, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>): boolean {
  
agentHostSchema.ts ×11

  509
  >
  	const defaultValue = configInspectValue.default?.value;
  
  510
  >
  	const isDefaultRule = hasMatchingRule(defaultValue, key, value);
  
  511
  >
  	if (!isDefaultRule) {
  
  512
  >
  		return false;
  
equals.ts ×1

  513
  >
  	}
  
  514
  >
  
agentHostSchema.ts ×11

  515
  >
  	const sourceTarget = getAutoApproveRuleSourceTarget(key, value, configInspectValue);
  
  516
  >
  
  517
  >
  	return sourceTarget === ConfigurationTarget.DEFAULT;
  
  518
  >
  }
  
  519
  >
  
agentHostSchema.ts ×21

  520
  >
  function getAutoApproveRuleSourceTarget(key: string, value: AgentHostTerminalAutoApproveRuleValue, configInspectValue: IConfigurationValue<Readonly<AgentHostTerminalAutoApproveRules>>): ConfigurationTarget {
  
agentHostSchema.ts ×11

  521
  >
  	if (hasMatchingRule(configInspectValue.workspaceFolderValue, key, value)) {
  
  522
  
  		return ConfigurationTarget.WORKSPACE_FOLDER;
  
  523
  
  	}
  
  524
  >
  	if (hasMatchingRule(configInspectValue.workspaceValue, key, value)) {
  
agentHostSchema.ts ×11

  525
  
  		return ConfigurationTarget.WORKSPACE;
  
  526
  
  	}
  
  527
  >
  	if (hasMatchingRule(configInspectValue.userRemoteValue, key, value)) {
  
agentHostSchema.ts ×11

  528
  
  		return ConfigurationTarget.USER_REMOTE;
  
  529
  
  	}
  
  530
  >
  	if (hasMatchingRule(configInspectValue.userLocalValue, key, value)) {
  
agentHostSchema.ts ×11

  531
  
  		return ConfigurationTarget.USER_LOCAL;
  
  532
  
  	}
  
  533
  >
  	if (hasMatchingRule(configInspectValue.userValue, key, value)) {
  
agentHostSchema.ts ×11

  534
  >
  		return ConfigurationTarget.USER;
  
agentHostSchema.ts ×1

  535
  >
  	}
  
  536
  >
  	if (hasMatchingRule(configInspectValue.applicationValue, key, value)) {
  
agentHostSchema.ts ×11

  537
  
  		return ConfigurationTarget.APPLICATION;
  
  538
  
  	}
  
  539
  >
  	return ConfigurationTarget.DEFAULT;
  
agentHostSchema.ts ×11

  540
  >
  }
  
  541
  >
  
agentHostSchema.ts ×21

  542
  >
  function hasMatchingRule(config: Readonly<AgentHostTerminalAutoApproveRules> | undefined, key: string, value: AgentHostTerminalAutoApproveRuleValue): boolean {
  
agentHostSchema.ts ×11

  543
  >
  	return !!config && Object.prototype.hasOwnProperty.call(config, key) && structuralEquals(config[key], value);
  
  544
  >
  }
  
  545
  >
  
agentHostSchema.ts ×21

  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) {
  
agentHostSchema.ts ×5

  571
  >
  		case TelemetryLevel.NONE:
  
  572
  >
  			return TelemetryConfiguration.OFF;
  
agentHostSchema.ts ×2

  573
  >
  		case TelemetryLevel.CRASH:
  
agentHostSchema.ts ×5

  574
  
  			return TelemetryConfiguration.CRASH;
  
  575
  >
  		case TelemetryLevel.ERROR:
  
agentHostSchema.ts ×5

  576
  >
  			return TelemetryConfiguration.ERROR;
  
agentHostSchema.ts ×2

  577
  >
  		case TelemetryLevel.USAGE:
  
agentHostSchema.ts ×5

  578
  >
  			return TelemetryConfiguration.ON;
  
agentHostStateManager.ts ×4

  579
  >
  	}
  
agentHostSchema.ts ×5

  580
  >
  }
  
  581
  >
  
agentHostSchema.ts ×21

  582
  >
  export function agentHostConfigValueToTelemetryLevel(value: unknown): TelemetryLevel | undefined {
  
  583
  >
  	switch (value) {
  
agentHostSchema.ts ×6

  584
  >
  		case TelemetryConfiguration.OFF:
  
  585
  >
  			return TelemetryLevel.NONE;
  
agentHostSchema.ts ×2

  586
  >
  		case TelemetryConfiguration.CRASH:
  
agentHostSchema.ts ×6

  587
  
  			return TelemetryLevel.CRASH;
  
  588
  >
  		case TelemetryConfiguration.ERROR:
  
agentHostSchema.ts ×6

  589
  >
  			return TelemetryLevel.ERROR;
  
agentHostSchema.ts ×2

  590
  >
  		case TelemetryConfiguration.ON:
  
agentHostSchema.ts ×6

  591
  >
  			return TelemetryLevel.USAGE;
  
agentService.ts ×10

  592
  >
  		default:
  
agentHostSchema.ts ×6

  593
  >
  			return undefined;
  
agentHostSchema.ts ×1

  594
  >
  	}
  
agentHostSchema.ts ×6

  595
  >
  }
  
  596
  >
  
agentHostSchema.ts ×21

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