agentConfigurationService.ts ×16

Frontier kind: Code frontier

unlabeled · c_66539901fd80

1442 tests · 18791 LOC · 72 files · introduces 0 tests · 335 LOC · 2 files

Introduces — evidence that enters the hierarchy at this concept

Code
18 ranges335 lines · 2 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
1432 ranges18791 lines · 72 files · Browse complete extent
All tests (intent)
1442 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.

2 files ranked by introduced lines: 335 introduced LOC across 18 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/platform/agentHost/node/agentConfigurationService.ts 197 introduced LOC · 16 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- agentConfigurationService.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 * as fs from 'fs';
7 > import { Emitter, Event } from '../../../base/common/event.js';
8 > import { Disposable } from '../../../base/common/lifecycle.js';
9 > import { dirname } from '../../../base/common/path.js';
10 > import { hasKey } from '../../../base/common/types.js';
11 > import { URI } from '../../../base/common/uri.js';
12 > import { createDecorator } from '../../instantiation/common/instantiation.js';
13 > import { ILogService } from '../../log/common/log.js';
14 > import { AgentHostConfigKey, agentHostCustomizationConfigSchema, defaultAgentHostCustomizationConfigValues } from '../common/agentHostCustomizationConfig.js';
15 > import { getAgentCustomizationSettingsEntries, getProviderBackedRootConfigKeys, withAgentCustomizationSettings, type IAgentCustomizationSettingsRegistration } from '../common/agentCustomizationSettings.js';
16 > import { copilotCliConfigSchema } from '../common/copilotCliConfig.js';
17 > import { sandboxConfigSchema } from '../common/sandboxConfigSchema.js';
18 > import type { ISchema, SchemaDefinition, SchemaValue } from '../common/agentHostSchema.js';
19 > import { ProtocolError } from '../common/state/sessionProtocol.js';
20 > import { ActionType } from '../common/state/sessionActions.js';
21 > import { parseSubagentSessionUri, ROOT_STATE_URI, type URI as ProtocolURI } from '../common/state/sessionState.js';
22 > import { AgentSession } from '../common/agentService.js';
23 > import { AgentHostStateManager } from './agentHostStateManager.js';
24 > import type { WorktreeIsolation } from './shared/worktreeIsolation.js';
25 >
26 > export const IAgentConfigurationService = createDecorator<IAgentConfigurationService>('agentConfigurationService');
27 >
28 > export interface IAgentSessionConfigurationChangeEvent {
29 > readonly session: ProtocolURI;
30 > readonly config: Record<string, unknown>;
31 > }
32 >
33 > /**
34 > * Cohesive read/write surface for agent-host configuration.
35 > *
36 > * All platform-layer consumers (tool auto-approval, side effects, future
37 > * host-config editors) should read and mutate config values through this
38 > * service rather than reaching into raw session state. The service owns
39 > * the `session → parent session → host` inheritance chain so that
40 > * host-level defaults, subagent inheritance, and per-session overrides
41 > * compose the same way everywhere.
42 > *
43 > * Reads go through a caller-supplied {@link ISchema}: each raw value is
44 > * validated against the property's schema before being returned, so a
45 > * malformed value in one layer transparently falls back to the next.
46 > */
47 > export interface IAgentConfigurationService {
48 > readonly _serviceBrand: undefined;
49 >
50 > /**
51 > * Fires whenever a {@link ActionType.RootConfigChanged} action is
52 > * processed by the state manager, signalling that callers should
53 > * re-read any root config values they depend on.
54 > */
55 > readonly onDidRootConfigChange: Event<void>;
56 >
57 > /** Fires whenever a session configuration change is processed. */
58 > readonly onDidSessionConfigChange: Event<IAgentSessionConfigurationChangeEvent>;
59 >
60 > /**
61 > * Returns the effective value of `key` for `session`, walking the
62 > * `session → parent session → host` chain and returning the first
63 > * layer that provides a value which validates against
64 > * `schema.definition[key]`. Layers that provide a malformed value
65 > * are logged and skipped. Returns `undefined` when no layer provides
66 > * a valid value.
67 > */
68 > getEffectiveValue<D extends SchemaDefinition, K extends keyof D & string>(
69 > session: ProtocolURI,
70 > schema: ISchema<D>,
71 > key: K,
72 > ): SchemaValue<D[K]> | undefined;
73 >
74 > /**
75 > * Returns the effective working directory for a session, falling back
76 > * to the parent (subagent) session's working directory when the
77 > * session itself does not have one set. The host layer does not carry
78 > * a working directory.
79 > */
80 > getEffectiveWorkingDirectory(session: ProtocolURI): string | undefined;
81 >
82 > /**
83 > * Whether a fresh worktree-isolation session's worktree has not yet been
84 > * created. Agents consult this to defer prewarming (and any other eager
85 > * materialization) until the host resolves the worktree on the first send.
86 > */
87 > isWorkingDirectoryPending(session: ProtocolURI): boolean;
88 >
89 > /** Resolves a persisted working directory, repairing a removed worktree when possible. */
90 > resolveWorkingDirectoryForResume(session: ProtocolURI, workingDirectory: URI): Promise<URI>;
91 >
92 > /**
93 > * Merges a partial config patch into a session's values via a
94 > * {@link ActionType.SessionConfigChanged} action. Keys not present in
95 > * `patch` are left untouched. The patch is applied atomically through
96 > * the state manager's reducer.
97 > */
98 > updateSessionConfig(session: ProtocolURI, patch: Record<string, unknown>): void;
99 >
100 > /**
101 > * Returns the merged config values currently stored on `session`.
102 > *
103 > * Reflects the live state managed by the reducer: every
104 > * {@link ActionType.SessionConfigChanged} action mutates these values
105 > * before this method returns. Callers materializing a provisional session
106 > * use this to read the user's latest selections without subscribing to
107 > * the action stream themselves.
108 > */
109 > getSessionConfigValues(session: ProtocolURI): Record<string, unknown> | undefined;
110 >
111 > /**
112 > * Returns the host-level value for `key`, validating it against
113 > * `schema.definition[key]`. Invalid persisted values are logged and treated
114 > * as missing.
115 > */
116 > getRootValue<D extends SchemaDefinition, K extends keyof D & string>(
117 > schema: ISchema<D>,
118 > key: K,
119 > ): SchemaValue<D[K]> | undefined;
120 >
121 > /**
122 > * Merges a partial config patch into the host-level value bag and persists
123 > * the updated values for future agent-host lifetimes.
124 > */
125 > updateRootConfig(patch: Record<string, unknown>, replace?: boolean): void;
126 >
127 > /**
128 > * Persists the current host-level value bag without mutating it.
129 > */
130 > persistRootConfig(): void;
131 >
132 > /**
133 > * Resolves once any in-flight root-config write has settled.
134 > */
135 > whenIdle(): Promise<void>;
136 >
137 > registerProviderConfiguration?(registration: IAgentCustomizationSettingsRegistration): void;
138 > getRootConfigValues?(): Readonly<Record<string, unknown>>;
139 > }
140 >
141 > export class AgentConfigurationService extends Disposable implements IAgentConfigurationService {
142 > declare readonly _serviceBrand: undefined;
143 > private _rootConfigWrite = Promise.resolve();
144 >
145 > private readonly _onDidRootConfigChange = this._register(new Emitter<void>());
146 > readonly onDidRootConfigChange: Event<void> = this._onDidRootConfigChange.event;
147 > private readonly _onDidSessionConfigChange = this._register(new Emitter<IAgentSessionConfigurationChangeEvent>());
148 > readonly onDidSessionConfigChange: Event<IAgentSessionConfigurationChangeEvent> = this._onDidSessionConfigChange.event;
149 >
150 > /**
151 > * Host-owned worktree isolation controller. Injected after construction (via
152 > * {@link setWorktreeIsolation}) because it only becomes available once the
153 > * branch-name generator has been wired, which happens after this service is
154 > * built. Consulted by {@link isWorkingDirectoryPending}, which degrades to
155 > * folder behavior while it is unset (tests, early startup).
156 > */
157 > private _worktree: WorktreeIsolation | undefined;
158 >
159 > setWorktreeIsolation(worktree: WorktreeIsolation): void {
160 > this._worktree = worktree;
161 > }
162 >
163 > constructor(
164 private readonly _stateManager: AgentHostStateManager,
165 @ILogService private readonly _logService: ILogService,
197 }));
198 }
200 > getEffectiveValue<D extends SchemaDefinition, K extends keyof D & string>(
201 session: ProtocolURI,
202 schema: ISchema<D>,
218 return undefined;
219 }
221 > getEffectiveWorkingDirectory(session: ProtocolURI): string | undefined {
222 const own = this._stateManager.getSessionState(session)?.workingDirectories?.[0];
223 if (own !== undefined) {
230 return undefined;
231 }
233 > isWorkingDirectoryPending(session: ProtocolURI): boolean {
234 return this._worktree?.isWorkingDirectoryPending(AgentSession.id(session)) ?? false;
235 }
237 > async resolveWorkingDirectoryForResume(session: ProtocolURI, workingDirectory: URI): Promise<URI> {
238 return this._worktree?.resolveWorkingDirectoryForResume(URI.parse(session), AgentSession.id(session), workingDirectory) ?? workingDirectory;
239 }
241 > updateSessionConfig(session: ProtocolURI, patch: Record<string, unknown>): void {
242 this._stateManager.dispatchServerAction(session, {
243 type: ActionType.SessionConfigChanged,
245 });
246 }
248 > getSessionConfigValues(session: ProtocolURI): Record<string, unknown> | undefined {
249 return this._stateManager.getSessionState(session)?.config?.values;
250 }
252 > getRootValue<D extends SchemaDefinition, K extends keyof D & string>(
253 schema: ISchema<D>,
254 key: K,
268 }
269 }
271 > updateRootConfig(patch: Record<string, unknown>, replace = false): void {
272 this._stateManager.dispatchServerAction(ROOT_STATE_URI, {
273 type: ActionType.RootConfigChanged,
277 this.persistRootConfig();
278 }
280 > persistRootConfig(): void {
281 if (!this._rootConfigResource) {
282 return;
302 });
303 }
305 > async whenIdle(): Promise<void> {
306 await this._rootConfigWrite;
307 }
309 > registerProviderConfiguration(registration: IAgentCustomizationSettingsRegistration): void {
310 const config = this._stateManager.rootState.config;
311 if (!config) {
327 }]);
328 }
330 > getRootConfigValues(): Readonly<Record<string, unknown>> {
331 return this._stateManager.rootState.config?.values ?? {};
332 }
334 > /**
335 > * Yields the raw value bags that contribute to the effective config
336 > * for `session`, in precedence order: session, parent subagent
337 > * session (if any), host.
338 > */
339 > private *_effectiveChain(session: ProtocolURI): Iterable<Record<string, unknown>> {
340 const own = this._stateManager.getSessionState(session)?.config?.values;
341 if (own) {
354 }
355 }
357 > private _loadPersistedRootConfig(): Record<string, unknown> {
358 const defaults = defaultAgentHostCustomizationConfigValues;
359 if (!this._rootConfigResource) {
src/vs/platform/agentHost/common/agentHostCustomizationConfig.ts 138 introduced LOC · 2 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- agentHostCustomizationConfig.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 { createSchema, schemaProperty } from './agentHostSchema.js';
8 > import { CustomizationType, type Customization, type PluginCustomization } from './state/protocol/state.js';
9 > import { customizationId } from './state/sessionState.js';
10 >
11 > export const codexUsageSources = ['copilot', 'openai'] as const;
12 > export type CodexUsageSource = typeof codexUsageSources[number];
13 >
14 > /**
15 > * Well-known root-config keys used by the platform to configure agent-host
16 > * customizations.
17 > */
18 > export const enum AgentHostConfigKey {
19 > /** Host-owned Open Plugins available to remote sessions. */
20 > Customizations = 'customizations',
21 > /**
22 > * Absolute path to the shell executable for host-managed terminals.
23 > * TODO: revisit magic key in config; refine into a dedicated typed channel. https://github.com/microsoft/vscode/issues/313812
24 > */
25 > DefaultShell = 'defaultShell',
26 > /**
27 > * When true (the default), the Claude provider routes all Anthropic
28 > * `messages` traffic through the local Copilot-CAPI proxy (Copilot-routed
29 > * Claude). When false, the Claude Agent SDK talks to Anthropic directly on
30 > * the user's own credentials (BYO Anthropic — Phase 19).
31 > */
32 > ClaudeUseCopilotProxy = 'claudeUseCopilotProxy',
33 > CodexUsageSource = 'codexUsageSource',
34 > /** Controls whether session-scoped file customizations come from local scan or SDK discovery. */
35 > SessionCustomizationDiscoveryMode = 'sessionCustomizationDiscoveryMode',
36 > /**
37 > * Optional GitHub Enterprise base URI (e.g. `https://ghe.example.com` for a
38 > * GitHub Enterprise Server, or `https://tenant.ghe.com` for GitHub Enterprise
39 > * Cloud). When set, the agent host computes its GitHub protected resources and
40 > * REST/GraphQL endpoints from this base instead of github.com. Normally pushed
41 > * by the local VS Code client from the workbench `github-enterprise.uri`
42 > * setting; remote operators set it directly in the remote
43 > * `agent-host-config.json`.
44 > */
45 > GithubEnterpriseUri = 'githubEnterpriseUri',
46 > }
47 >
48 > export const SESSION_CUSTOMIZATION_DISCOVERY_MODES = ['scan', 'discover'] as const;
49 > export type SessionCustomizationDiscoveryMode = typeof SESSION_CUSTOMIZATION_DISCOVERY_MODES[number];
50 > export const DEFAULT_SESSION_CUSTOMIZATION_DISCOVERY_MODE: SessionCustomizationDiscoveryMode = 'scan';
51 >
52 > /**
53 > * Persisted on-disk shape for a host-configured plugin. Kept stable across
54 > * the customization protocol refactor so existing `agent-host-config.json`
55 > * files keep working; entries are mapped to the new
56 > * {@link Customization} shape at read time by
57 > * {@link getAgentHostConfiguredCustomizations}.
58 > */
59 > interface IPersistedCustomizationConfigEntry {
60 > uri: string;
61 > displayName: string;
62 > description?: string;
63 > }
64 >
65 > export const agentHostCustomizationConfigSchema = createSchema({
66 > [AgentHostConfigKey.Customizations]: schemaProperty<IPersistedCustomizationConfigEntry[]>({
67 > type: 'array',
68 > title: localize('agentHost.config.customizations.title', "Plugins"),
69 > description: localize('agentHost.config.customizations.description', "Plugins configured on this agent host and available to remote sessions."),
70 > default: [],
71 > items: {
72 > type: 'object',
73 > title: localize('agentHost.config.customizations.itemTitle', "Plugin"),
74 > properties: {
75 > uri: {
76 > type: 'string',
77 > title: localize('agentHost.config.customizations.uri', "Plugin URI"),
78 > },
79 > displayName: {
80 > type: 'string',
81 > title: localize('agentHost.config.customizations.displayName', "Name"),
82 > },
83 > description: {
84 > type: 'string',
85 > title: localize('agentHost.config.customizations.descriptionField', "Description"),
86 > },
87 > },
88 > required: ['uri', 'displayName'],
89 > },
90 > }),
91 > [AgentHostConfigKey.DefaultShell]: schemaProperty<string>({
92 > type: 'string',
93 > title: localize('agentHost.config.defaultShell.title', "Default Shell"),
94 > description: localize('agentHost.config.defaultShell.description', "Absolute path to the shell executable used by host-managed terminals. Normally pushed by the connected VS Code client from `terminal.integrated.agentHostProfile.<os>` (falling back to `terminal.integrated.defaultProfile.<os>`); when unset, the agent host falls back to the system shell. Only the path is supported; `args` and `env` from the workbench profile are not piped through yet. The workbench only pushes this for the local agent host — remote agent host operators should set this directly in the remote machine's `agent-host-config.json`."),
95 > }),
96 > [AgentHostConfigKey.ClaudeUseCopilotProxy]: schemaProperty<boolean>({
97 > type: 'boolean',
98 > title: localize('agentHost.config.claudeUseCopilotProxy.title', "Route Claude Through Copilot"),
99 > description: localize('agentHost.config.claudeUseCopilotProxy.description', "When enabled (the default), the Claude agent routes all requests through GitHub Copilot. When disabled, Claude talks to Anthropic directly using your own credentials (API key or Claude subscription)."),
100 > default: true,
101 > }),
102 > [AgentHostConfigKey.CodexUsageSource]: schemaProperty<CodexUsageSource>({
103 > type: 'string',
104 > title: localize('agentHost.config.codexUsageSource.title', "Codex Usage Source"),
105 > description: localize('agentHost.config.codexUsageSource.description', "Choose whether Codex usage is routed through GitHub Copilot or uses an existing Codex OpenAI login. VS Code does not provide the OpenAI sign-in flow; authenticate Codex separately before selecting OpenAI."),
106 > default: 'copilot',
107 > enum: [...codexUsageSources],
108 > }),
109 > [AgentHostConfigKey.SessionCustomizationDiscoveryMode]: schemaProperty<SessionCustomizationDiscoveryMode>({
110 > type: 'string',
111 > enum: [...SESSION_CUSTOMIZATION_DISCOVERY_MODES],
112 > title: localize('agentHost.config.sessionCustomizationDiscoveryMode.title', "Session Customization Discovery Mode"),
113 > description: localize('agentHost.config.sessionCustomizationDiscoveryMode.description', "Controls whether session-scoped customizations are populated from local file scanning or from Copilot SDK discovery."),
114 > default: DEFAULT_SESSION_CUSTOMIZATION_DISCOVERY_MODE,
115 > }),
116 > [AgentHostConfigKey.GithubEnterpriseUri]: schemaProperty<string>({
117 > type: 'string',
118 > title: localize('agentHost.config.githubEnterpriseUri.title', "GitHub Enterprise URI"),
119 > description: localize('agentHost.config.githubEnterpriseUri.description', "Optional base URI of a GitHub Enterprise instance (for example \"https://ghe.example.com\" for GitHub Enterprise Server, or \"https://tenant.ghe.com\" for GitHub Enterprise Cloud). When set, the agent host authenticates and makes GitHub API calls against this instance instead of github.com. Normally pushed by the connected VS Code client from the `github-enterprise.uri` setting; remote agent host operators can set it directly in the remote `agent-host-config.json`."),
120 > }),
121 > });
122 >
123 > export const defaultAgentHostCustomizationConfigValues = {
124 > [AgentHostConfigKey.Customizations]: [] as IPersistedCustomizationConfigEntry[],
125 > };
126 >
127 > /**
128 > * Reads the persisted (legacy-shaped) plugin entries from the agent-host
129 > * root config and lifts them into the new {@link Customization} container
130 > * shape used by the rest of the platform.
131 > */
132 > export function getAgentHostConfiguredCustomizations(values: Record<string, unknown> | undefined): readonly Customization[] {
133 const raw = values?.[AgentHostConfigKey.Customizations];
134 const entries = agentHostCustomizationConfigSchema.validate(AgentHostConfigKey.Customizations, raw)
137 return entries.map(toContainerCustomization);
138 }
140 > /**
141 > * Lifts a persisted plugin config entry into the new
142 > * {@link Customization} container shape.
143 > */
144 > export function toContainerCustomization(entry: IPersistedCustomizationConfigEntry): PluginCustomization {
145 return {
146 type: CustomizationType.Plugin,