@codingame/monaco-vscode-api 36.2.7 → 37.0.0

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

@@ -0,0 +1,638 @@
+import type { VSBuffer } from "../../../base/common/buffer.js";
+import { Event } from "../../../base/common/event.js";
+import { IReference } from "../../../base/common/lifecycle.js";
+import type { IObservable } from "../../../base/common/observable.js";
+import { URI } from "../../../base/common/uri.js";
+import type { IConfigurationChangeEvent } from "../../configuration/common/configuration.js";
+import { IConfigurationService } from "../../configuration/common/configuration.service.js";
+import { AgentSandboxSettingId } from "../../sandbox/common/settings.js";
+import type { IActiveSubscriptionInfo, IAgentSubscription } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/agentSubscription";
+import type { IRemoteWatchHandle } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentHostFileSystemProvider";
+import type { IAgentHostResourceUriMapper } from "./agentHostUri.js";
+import type { CompletionsParams, CompletionsResult, CreateTerminalParams, ResolveSessionConfigResult, SessionConfigCompletionsResult } from "./state/protocol/commands.js";
+import type { InitializeResult } from "./state/protocol/common/commands.js";
+import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "./state/protocol/channels-changeset/commands.js";
+import type { FetchAutomationRunsParams, FetchAutomationRunsResult, ListAutomationTriggerDefinitionsParams, ListAutomationTriggerDefinitionsResult, RunAutomationParams, RunAutomationResult } from "./state/protocol/channels-automation/commands.js";
+import type { ActionEnvelope, ClientAutomationAction, ClientAutomationRunAction, INotification, IRootConfigChangedAction, SessionAction, ChatAction, TerminalAction, ClientAnnotationsAction, ClientChangesetAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+import type { ContentEncoding, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMkdirParams, ResourceMkdirResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceResolveParams, ResourceResolveResult, ResourceWriteParams, ResourceWriteResult, CreateResourceWatchParams, CreateResourceWatchResult } from "./state/sessionProtocol.js";
+import { ComponentToState, StateComponents, type RootState } from "./state/sessionState.js";
+import { type AgentProvider, type AuthenticateParams, type AuthenticateResult, type IAgentCreateChatRequestOptions, type IAgentCreateSessionConfig, type IAgentSessionMetadata, type IAgentResolveSessionConfigParams, type IAgentSessionConfigCompletionsParams, type IMcpNotification, type IAgentHostNetworkEndpoint, type IAgentHostManagedSettingsSnapshot } from "./agent.js";
+export type { IAgent, IAgentChats, IAgentChatContext, IAgentCreateChatOptions, IAgentCreateChatRequestOptions, IAgentCreateChatForkSource, IAgentCreateChatSideChatSelection, IAgentCreateChatSideChatSource, IAgentCreateChatResult, IAgentCreateSessionConfig, IAgentCreateSessionResult, IAgentChatMetadata, IAgentSessionMetadata, IAgentSessionProjectInfo, IAgentLegacyChat, IAgentChatAdoptionResult, IAgentSpawnedChatParent, IAgentSpawnChatEvent, IAgentMaterializeChatEvent, IAgentChatDataChange, IAgentResolveChatConfigParams, IAgentChatConfigCompletionsParams, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentModelInfo, AgentSignal, IAgentActionSignal, IAgentToolPendingConfirmationSignal, IAgentSubagentStartedSignal, IAgentSubagentResumedSignal, IAgentSubagentCompletedSignal, IAgentSteeringConsumedSignal, IMcpNotification, IActiveClient, AgentProvider, IAgentCapabilities, IAgentDescriptor, AuthenticateParams, IAgentHostAuthTokenRequest, AuthenticateResult, IAgentHostNetworkEndpoint, IAgentHostManagedSettingsSnapshot, } from "./agent.js";
+export { AgentSession, CLAUDE_AGENT_PROVIDER_ID, CODEX_AGENT_PROVIDER_ID, GITHUB_COPILOT_PROTECTED_RESOURCE, GITHUB_REPO_PROTECTED_RESOURCE, protectedResourcesRequireGitHubCopilotSignIn, resolveAgentChatContext, resolveAgentChatOrigin, resolveSubagentChatParent, resolveAgentHostCustomizations, subagentChatTitle, SubagentChatSignal, } from "./agent.js";
+export declare enum AgentHostIpcChannels {
+    /** Channel for the agent host service on the main-process side */
+    AgentHost = "agentHost",
+    /** Channel for log forwarding from the agent host process */
+    Logger = "agentHostLogger",
+    /** Channel for WebSocket client connection count (server process management only) */
+    ConnectionTracker = "agentHostConnectionTracker",
+    /** Channel carrying raw Agent Host Protocol frames over a MessagePort. */
+    Protocol = "agentHostProtocol",
+    /** Narrow local management channel that remains outside of the AHP data plane. */
+    Management = "agentHostManagement",
+    /**
+     * Channel registered by the remote server that proxies AHP JSON-RPC
+     * frames between a renderer and the agent host running on the server.
+     * Pairs with `AgentHostIpcChannelTransport` on the renderer side.
+     */
+    RemoteProxy = "agentHostProxy"
+}
+/** Configuration key that controls whether AHP JSONL logs are written for agent host transports. */
+export declare const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
+export type AgentHostDebugLogsArtifactKind = "archive" | "directory";
+/** Maximum number of files in one Agent Host debug-log artifact. */
+export declare const AGENT_HOST_DEBUG_LOGS_MAX_ENTRIES = 1000;
+/**
+ * Maximum payload of a single {@link IAgentHostDebugLogsChunk}. Debug-log
+ * artifacts are streamed in chunks of at most this size so a remote agent host
+ * never has to encode a whole archive into one JSON-RPC message.
+ */
+export declare const AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES: number;
+export interface IAgentHostDebugLogsArtifactEntry {
+    readonly path: string;
+    readonly size: number;
+}
+export interface IAgentHostDebugLogsArtifact {
+    readonly kind: AgentHostDebugLogsArtifactKind;
+    readonly resource: URI;
+    readonly providerLogsIncluded: boolean;
+    readonly size: number;
+    readonly uncompressedSize: number;
+    /** Exact regular files staged in the artifact. Paths are relative, normalized, and unique. */
+    readonly entries: readonly IAgentHostDebugLogsArtifactEntry[];
+}
+/** One bounded slice of a debug-log artifact, read via `readDebugLogsChunk`. */
+export interface IAgentHostDebugLogsChunk {
+    /** Raw bytes for this slice. Empty once `position` is at or past the end. */
+    readonly data: VSBuffer;
+    /** `true` when this slice reaches the end of the artifact. */
+    readonly eof: boolean;
+}
+/** Configuration key controlling automatic OS system proxy discovery for agent-host Copilot sessions. */
+export declare const AgentHostSystemProxyEnabledSettingId = "chat.agentHost.systemProxy.enabled";
+/** Configuration key controlling the GitHub MCP server in agent-host sessions. */
+export declare const AgentHostGitHubMcpServerEnabledSettingId = "chat.agentHost.githubMcpServer.enabled";
+/** Configuration key gating active-agent session and chat title generation. */
+export declare const AgentHostActiveAgentTitleGenerationSettingId = "chat.agentHost.experimental.activeAgentTitleGeneration";
+/** Configuration key enabling rich-link guidance for Markdown plan documents. */
+export declare const AgentHostMarkdownPlanRichLinksEnabledSettingId = "chat.agentHost.experimental.markdownPlanRichLinks";
+/** Configuration key gating the artifact tools and their agent instruction. */
+export declare const ArtifactToolsSettingId = "chat.artifactTools.enabled";
+/** Configuration key controlling automatic pull request association for the checked-out branch. */
+export declare const AgentHostAutoAttachPullRequestsSettingId = "chat.agentHost.experimental.autoAttachPullRequests";
+/**
+ * Configuration key gating multiple-working-directory support for the Copilot
+ * agent-host provider. When `true`, the Copilot provider advertises the
+ * `multipleWorkingDirectories` capability, so a session created in a multi-root
+ * workspace can span every workspace folder. Hidden from the Settings UI and
+ * off by default while the feature is dogfooded; the agent host re-advertises
+ * on change, so newly created sessions pick it up without a restart.
+ */
+export declare const AgentHostCopilotMultiRootEnabledSettingId = "chat.agentHost.copilotAgent.multiRootEnabled";
+/**
+ * Configuration key gating multiple-working-directory support for the Claude
+ * agent-host provider. When `true`, the Claude provider advertises the
+ * `multipleWorkingDirectories` capability, so a session created in a multi-root
+ * workspace can span every workspace folder. Independent of
+ * {@link AgentHostCopilotMultiRootEnabledSettingId} because the Claude Agent SDK
+ * already supports additional directories while the Copilot SDK does not. Hidden
+ * from the Settings UI and off by default while the feature is dogfooded; the
+ * agent host re-advertises on change, so newly created sessions pick it up
+ * without a restart.
+ */
+export declare const AgentHostClaudeMultiRootEnabledSettingId = "chat.agentHost.claudeAgent.multiRootEnabled";
+/**
+ * Configuration key gating multiple-working-directory support for the Codex
+ * agent-host provider. Hidden from the Settings UI and off by default while the
+ * feature is dogfooded.
+ */
+export declare const AgentHostCodexMultiRootEnabledSettingId = "chat.agentHost.codexAgent.multiRootEnabled";
+/**
+ * Experimentation setting id gating the conditional agent-window auth feature.
+ * When `true`, the agent window opens for a signed-out user instead of forcing
+ * GitHub sign-in; each session type then gates on its own GitHub requirement, so
+ * a type usable without GitHub (e.g. Claude in native mode with an existing local
+ * setup) works signed out while types that need GitHub prompt for it on demand.
+ *
+ * This is the **workbench** VS Code setting id. The workbench registers the
+ * configuration schema and forwards the value into the agent-host root config
+ * under the short key `AgentHostConfigKey.AllowSignedOutWhenUsable`, which the
+ * Claude provider reads node-side via `getRootValue`. Until it is wired and
+ * enabled the root key is absent, so it reads `false` and behavior is identical
+ * to today.
+ */
+export declare const AgentHostAllowSignedOutWhenUsableSettingId = "chat.agentHost.allowSignedOutWhenUsable";
+/**
+ * Configuration key controlling whether the Claude provider is registered in
+ * the agent host process. When `false`, the agent host skips registering the
+ * Claude provider regardless of SDK availability. Defaults to `true`.
+ *
+ * The agent host process must be restarted for changes to take effect.
+ */
+export declare const AgentHostClaudeAgentEnabledSettingId = "chat.agentHost.claudeAgent.enabled";
+/**
+ * Configuration key controlling whether the Codex provider is registered in
+ * the agent host process. When `false`, the agent host skips registering the
+ * Codex provider regardless of SDK availability. The setting defaults to
+ * enabled outside Stable and disabled in Stable, subject to its startup
+ * experiment override. The agent host process must be restarted to unregister
+ * a provider that is already running.
+ */
+export declare const AgentHostCodexAgentEnabledSettingId = "chat.agentHost.codexAgent.enabled";
+/**
+ * Configuration key controlling whether extension-provided BYOK ("bring your
+ * own key") models are published and included in new agent-host sessions.
+ * Changes are synchronized to the running agent host.
+ */
+export declare const AgentHostByokModelsEnabledSettingId = "chat.agentHost.byokModels.enabled";
+/**
+ * Optional override that points at an **SDK root directory** containing a
+ * `node_modules/@anthropic-ai/claude-agent-sdk` subtree. When set, the agent
+ * host loads the Claude SDK from that path instead of the bare import (which
+ * resolves via this repo's `node_modules` in dev) or the on-demand download
+ * from `product.agentSdks.claude` (built products). Mainly exists for the
+ * remote server's `--claude-sdk-root` CLI flag and for one-off developer
+ * overrides pointing at an out-of-tree SDK build.
+ */
+export declare const AgentHostClaudeSdkRootEnvVar = "VSCODE_AGENT_HOST_CLAUDE_SDK_ROOT";
+/**
+ * Environment variable form of {@link AgentHostClaudeAgentEnabledSettingId}.
+ * Set by the agent host starters from the setting. Accepts `'true'` /
+ * `'false'`; absent uses the agent host's Claude fallback (`true`). The
+ * starters normally forward the resolved setting explicitly.
+ */
+export declare const AgentHostClaudeAgentEnabledEnvVar = "VSCODE_AGENT_HOST_CLAUDE_AGENT_ENABLED";
+/**
+ * Environment variable form of {@link AgentHostCodexAgentEnabledSettingId}.
+ * Set by the agent host starters from the setting. Accepts `'true'` /
+ * `'false'`; absent uses the host-level fallback (`false`), independently of
+ * the product-quality-specific setting default. The starters normally forward
+ * the resolved setting explicitly.
+ */
+export declare const AgentHostCodexAgentEnabledEnvVar = "VSCODE_AGENT_HOST_CODEX_AGENT_ENABLED";
+/** Overrides the soft cap on resident session roots. Primarily used by integration tests. */
+export declare const AgentHostSessionResidencyLimitEnvVar = "VSCODE_AGENT_HOST_SESSION_RESIDENCY_LIMIT";
+/** Overrides the retry delay after a provider temporarily vetoes session release. Primarily used by integration tests. */
+export declare const AgentHostSessionReleaseRetryMsEnvVar = "VSCODE_AGENT_HOST_SESSION_RELEASE_RETRY_MS";
+/**
+ * Resolves the effective enable state for a Claude/Codex provider from the
+ * env-var value forwarded by the starter. Recognized values (case- and
+ * whitespace-insensitive):
+ *
+ *  - `'true'`  / `'1'` → enabled
+ *  - `'false'` / `'0'` → disabled
+ *  - `undefined`, empty string, or any other value → falls through to
+ *    {@link defaultEnabled}
+ */
+export declare function isAgentEnabled(envValue: string | undefined, defaultEnabled: boolean): boolean;
+/**
+ * Configuration key that controls the sandbox mode for the Copilot SDK's built-in
+ * shell tool. Supported values are:
+ *
+ *  - `'off'` (the default): sandboxing is explicitly disabled for the SDK shell
+ *    path \u2014 commands run unsandboxed.
+ *  - `'on'`: the Agent Host runs the SDK\u2019s shell tool inside a sandbox
+ *    using the user's `chat.agent.sandbox.fileSystem.*` filesystem policy.
+ *    Outbound network is blocked.
+ *
+ * Unrestricted outbound network is controlled separately by
+ * `chat.agent.sandbox.allowNetwork`.
+ */
+export declare const AgentHostSdkSandboxEnabledSettingId = "chat.agentHost.sdkSandbox.enabled";
+/**
+ * Configuration key that controls the sandbox mode for the Copilot SDK's
+ * built-in shell tool on Windows. This is independent of
+ * {@link AgentHostSdkSandboxEnabledSettingId} so Windows support can be rolled
+ * out separately. Supported values are `'off'` and `'on'`; the default is
+ * `'off'`.
+ */
+export declare const AgentHostSdkSandboxWindowsEnabledSettingId = "chat.agentHost.sdkSandbox.enabledWindows";
+export type AgentHostCopilotSandboxSettingId = AgentSandboxSettingId.AgentSandboxEnabled | AgentSandboxSettingId.AgentSandboxWindowsEnabled | typeof AgentHostSdkSandboxEnabledSettingId | typeof AgentHostSdkSandboxWindowsEnabledSettingId;
+export declare function getAgentHostCopilotSandboxSettingId(windows?: boolean): AgentHostCopilotSandboxSettingId;
+/**
+ * Selects whether the regular workbench surfaces Codex from the agent host
+ * instead of the OpenAI extension.
+ */
+export declare const CodexPreferAgentHostEditorSettingId = "chat.editor.codex.preferAgentHost";
+export declare function affectsAgentHostProviderPreference(event: IConfigurationChangeEvent, isSessionsWindow: boolean): boolean;
+export declare function shouldSurfaceLocalAgentHostProvider(provider: AgentProvider, configurationService: IConfigurationService, isSessionsWindow: boolean): boolean;
+/**
+ * Absolute path to the **SDK root directory** containing a
+ * `node_modules/@openai/codex` subtree. When non-empty, the agent host treats
+ * it as a dev override and skips the on-demand download from
+ * `product.agentSdks.codex`. Empty (the default) falls through to product
+ * config; if neither is present, the provider is not registered.
+ */
+export declare const AgentHostCodexAgentSdkRootSettingId = "chat.agentHost.codexAgent.sdkRoot";
+/**
+ * Optional override for `$CODEX_HOME`. When set, the codex app-server child
+ * process inherits this value, controlling where rollouts and config live.
+ */
+export declare const AgentHostCodexAgentCodexHomeSettingId = "chat.agentHost.codexAgent.codexHome";
+/**
+ * Additional command-line arguments passed to `codex app-server`. Mainly for
+ * debugging (e.g. `--log-level=debug`).
+ */
+export declare const AgentHostCodexAgentBinaryArgsSettingId = "chat.agentHost.codexAgent.binaryArgs";
+/**
+ * Environment variable form of {@link AgentHostCodexAgentSdkRootSettingId}.
+ * Forwarded by the starters from the setting.
+ */
+export declare const AgentHostCodexAgentSdkRootEnvVar = "VSCODE_AGENT_HOST_CODEX_SDK_ROOT";
+/** Forwarded `$CODEX_HOME`. */
+export declare const AgentHostCodexAgentCodexHomeEnvVar = "CODEX_HOME";
+/** Forwarded extra args for `codex app-server` (JSON-encoded string[]). */
+export declare const AgentHostCodexAgentBinaryArgsEnvVar = "VSCODE_AGENT_HOST_CODEX_APP_SERVER_ARGS";
+/** Master toggle for agent-host OTel. Explicit opt-in; other settings imply this when set. */
+export declare const AgentHostOTelEnabledSettingId = "chat.agentHost.otel.enabled";
+/** Exporter type for the SDK's OTel pipeline. One of: `otlp-http`, `otlp-grpc`, `console`, `file`. */
+export declare const AgentHostOTelExporterTypeSettingId = "chat.agentHost.otel.exporterType";
+/**
+ * OTLP wire protocol (`http/json`, `http/protobuf`, `grpc`). Policy-only delivery slot (no user UI):
+ * carries the enterprise-managed `telemetry.protocol` so it can be threaded into the agent host's
+ * `OTEL_EXPORTER_OTLP_PROTOCOL` env, which the runtime needs to distinguish protobuf from json
+ * (the `exporterType` setting only models transport, not the HTTP wire encoding).
+ */
+export declare const AgentHostOTelOtlpProtocolSettingId = "chat.agentHost.otel.otlpProtocol";
+/** OTLP endpoint URL when `exporterType` is `otlp-http` or `otlp-grpc`. */
+export declare const AgentHostOTelOtlpEndpointSettingId = "chat.agentHost.otel.otlpEndpoint";
+/** Whether to include prompt/response content in span attributes (privacy-sensitive). */
+export declare const AgentHostOTelCaptureContentSettingId = "chat.agentHost.otel.captureContent";
+/** Output path when `exporterType` is `file`. */
+export declare const AgentHostOTelOutfileSettingId = "chat.agentHost.otel.outfile";
+/** Policy-only delivery slot for the enterprise-managed OTel `service.name` (no user UI). */
+export declare const AgentHostOTelServiceNameSettingId = "chat.agentHost.otel.serviceName";
+/** Policy-only delivery slot for enterprise-managed OTel resource attributes (no user UI). */
+export declare const AgentHostOTelResourceAttributesSettingId = "chat.agentHost.otel.resourceAttributes";
+/** When true, ALL spans are persisted to a local SQLite store regardless of `exporterType`. */
+export declare const AgentHostOTelDbSpanExporterEnabledSettingId = "chat.agentHost.otel.dbSpanExporter.enabled";
+/**
+ * Path of the local SQLite span database, relative to `INativeEnvironmentService.userDataPath`.
+ * Kept here so both the renderer-side export action and the agent-host-side service
+ * use the same on-disk location.
+ */
+export declare const AgentHostOTelSpansDbSubPath = "agent-host/otel/agent-host-traces.db";
+/**
+ * Environment variables consumed by `AgentHostOTelService` inside the agent host
+ * process. The workbench-side agent-host starters translate the corresponding
+ * `chat.agentHost.otel.*` settings into these variables (settings → env), while
+ * any value already present on the parent process's env wins (developer override).
+ *
+ * These names match the conventions documented in
+ * `extensions/copilot/docs/monitoring/agent_monitoring.md` so the same external
+ * tooling and `OTEL_EXPORTER_OTLP_*` config recipes work unchanged.
+ */
+export declare const AgentHostOTelEnvVars: Readonly<{
+    readonly Enabled: "COPILOT_OTEL_ENABLED";
+    readonly ExporterType: "COPILOT_OTEL_EXPORTER_TYPE";
+    readonly OtlpEndpoint: "OTEL_EXPORTER_OTLP_ENDPOINT";
+    readonly OtlpEndpointAlt: "COPILOT_OTEL_ENDPOINT";
+    readonly OtlpProtocol: "OTEL_EXPORTER_OTLP_PROTOCOL";
+    readonly OtlpTracesProtocol: "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL";
+    readonly OtlpMetricsProtocol: "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL";
+    readonly OtlpHeaders: "OTEL_EXPORTER_OTLP_HEADERS";
+    readonly CaptureContent: "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+    readonly FilePath: "COPILOT_OTEL_FILE_EXPORTER_PATH";
+    readonly SourceName: "COPILOT_OTEL_SOURCE_NAME";
+    readonly ServiceName: "OTEL_SERVICE_NAME";
+    readonly ResourceAttributes: "OTEL_RESOURCE_ATTRIBUTES";
+    readonly DbSpanExporterEnabled: "COPILOT_OTEL_DB_SPAN_EXPORTER_ENABLED";
+}>;
+/**
+ * Snapshot of the `chat.agentHost.otel.*` settings; produced by the workbench-side
+ * starters and merged with the parent process's env (env wins on key collision).
+ */
+export interface IAgentHostOTelSettings {
+    readonly enabled?: boolean;
+    readonly exporterType?: string;
+    readonly otlpProtocol?: string;
+    readonly otlpEndpoint?: string;
+    readonly captureContent?: boolean;
+    readonly outfile?: string;
+    readonly serviceName?: string;
+    readonly resourceAttributes?: Record<string, string>;
+    readonly dbSpanExporterEnabled?: boolean;
+}
+/**
+ * IPC channel (renderer -> main) the desktop agent-host path uses to hand the
+ * enterprise-resolved `chat.agentHost.otel.*` policy to `ElectronAgentHostStarter`.
+ *
+ * The main-process configuration service does NOT include the renderer-only
+ * `AccountPolicyService` (managed settings: server / native-MDM / file channels), so a
+ * starter running in the main process sees `policyValue === undefined` for these keys.
+ * The renderer — whose policy layer does include managed settings — forwards the resolved
+ * values here just before requesting the agent-host connection, so the host is spawned with
+ * the managed OTel env. See {@link readAgentHostOTelPolicySettings}.
+ */
+export declare const AgentHostOTelPolicyIpcChannel = "vscode:agentHostOTelPolicy";
+/** Renderer-to-main request to replace the shared local Agent Host process. */
+export declare const AgentHostRestartIpcChannel = "vscode:restartAgentHost";
+/** Main-to-renderer notification sent before replacement so each local client reconnects immediately. */
+export declare const AgentHostWillRestartIpcChannel = "vscode:agentHostWillRestart";
+/**
+ * Resolve the enterprise-policy values for the `chat.agentHost.otel.*` settings from a
+ * configuration service whose policy layer includes managed settings (i.e. the renderer's).
+ * Each field is `undefined` when no policy is set. Intended as the `policySettings` argument
+ * of {@link buildAgentHostOTelEnv}.
+ */
+export declare function readAgentHostOTelPolicySettings(configurationService: IConfigurationService): IAgentHostOTelSettings;
+/**
+ * Validate/normalize an {@link IAgentHostOTelSettings} received over IPC, keeping only
+ * well-typed fields. Defends the main process against a malformed payload before the values
+ * are turned into agent-host process env vars.
+ */
+export declare function sanitizeAgentHostOTelPolicySettings(raw: unknown): IAgentHostOTelSettings;
+/**
+ * Build the env-var overlay for the agent host process from user settings and
+ * inherited env. Settings are translated to env vars, but if the same env var is
+ * already present on `inheritedEnv` it wins (developer override).
+ *
+ * Only sets a key when the underlying setting was explicitly configured — empty
+ * string / undefined settings are dropped so they don't shadow inherited env.
+ */
+export declare function buildAgentHostOTelEnv(settings: IAgentHostOTelSettings, inheritedEnv: Readonly<Record<string, string | undefined>>, policySettings?: IAgentHostOTelSettings): Record<string, string>;
+/**
+ * Settings -> env-var fan-out for the Claude/Codex SDK overrides that the
+ * agent host process consumes. Shared by both starters
+ * (`nodeAgentHostStarter.ts`, `electronAgentHostStarter.ts`) so they don't
+ * drift the next time someone adds a setting.
+ *
+ * The shape mirrors {@link buildAgentHostOTelEnv}: only set a key when the
+ * underlying setting has a non-empty value AND the inherited env doesn't
+ * already define it (developer override wins). Returns a partial env map
+ * the caller spreads into the spawned child's environment.
+ */
+export interface IAgentSdkStarterSettings {
+    readonly codexSdkRoot?: string;
+    readonly codexHome?: string;
+    readonly codexBinaryArgs?: readonly string[];
+    readonly claudeAgentEnabled?: boolean;
+    readonly codexAgentEnabled?: boolean;
+}
+export declare function buildAgentSdkEnv(settings: IAgentSdkStarterSettings, inheritedEnv: Readonly<Record<string, string | undefined>>): Record<string, string>;
+/** Result of starting the agent host WebSocket server on-demand. */
+export interface IAgentHostSocketInfo {
+    readonly socketPath: string;
+}
+/** Inspector listener information for the agent host process. */
+export interface IAgentHostInspectInfo {
+    readonly host: string;
+    readonly port: number;
+    /** A `devtools://` URL that can be opened with `INativeHostService.openDevToolsWindow`. */
+    readonly devtoolsUrl: string;
+}
+/** Host-level network context for diagnostics, produced by {@link IAgentConnection.getNetworkDiagnosticsInfo}. */
+export interface IAgentHostNetworkDiagnosticsInfo {
+    /** Agent host product version. */
+    readonly version: string;
+    /** Operating system platform of the agent host process (`process.platform`). */
+    readonly os: string;
+    /** CPU architecture of the agent host process (`process.arch`). */
+    readonly arch: string;
+    /** Authenticated GitHub account login, when known. */
+    readonly account?: string;
+    /** VS Code `http.*` proxy settings observed by the agent host, keyed by setting id (only those that are set). */
+    readonly proxySettings: Readonly<Record<string, string>>;
+    /** Proxy-related environment variables observed by the agent host process, keyed by name (only those that are set). */
+    readonly proxyEnv: Readonly<Record<string, string>>;
+    /** Endpoints the agent host suggests probing via {@link IAgentConnection.diagnosticsFetch}. */
+    readonly endpoints: readonly IAgentHostNetworkEndpoint[];
+}
+export interface IAgentHostManagedSettingsDiagnostics {
+    readonly provider: AgentProvider;
+    readonly snapshot?: IAgentHostManagedSettingsSnapshot;
+    readonly error?: string;
+}
+/** Result of a DNS lookup for a single address family, part of {@link IAgentHostNetworkFetchResult}. */
+export interface IAgentHostDnsResult {
+    /** The resolved address, when the lookup succeeded. */
+    readonly address?: string;
+    /** Time taken by the lookup, in milliseconds. */
+    readonly durationMs?: number;
+    /** Lookup error message, when it failed. */
+    readonly error?: string;
+}
+/** Result of a single connectivity probe, produced by {@link IAgentConnection.diagnosticsFetch}. */
+export interface IAgentHostNetworkFetchResult {
+    /** The URL that was probed. */
+    readonly url: string;
+    /** The resolved proxy URL for this endpoint, or `undefined` for a direct connection. */
+    readonly proxyUrl?: string;
+    /** IPv4 DNS lookup result for the host. */
+    readonly dnsIpv4?: IAgentHostDnsResult;
+    /** IPv6 DNS lookup result for the host. */
+    readonly dnsIpv6?: IAgentHostDnsResult;
+    /** HTTP status code from the probe, when a response arrived. */
+    readonly statusCode?: number;
+    /** HTTP status message from the probe, when a response arrived. */
+    readonly statusMessage?: string;
+    /** Response body text (possibly truncated), when a response arrived. Callers use it to check expected content. */
+    readonly body?: string;
+    /** Time taken by the reachability probe, in milliseconds. */
+    readonly durationMs?: number;
+    /** Probe error message, when the connection failed. */
+    readonly error?: string;
+}
+/**
+ * IPC service exposed on the {@link AgentHostIpcChannels.ConnectionTracker}
+ * channel. Used by the server process for lifetime management and by the
+ * shared process to request a local WebSocket listener on-demand.
+ */
+export interface IConnectionTrackerService {
+    readonly onDidChangeConnectionCount: Event<number>;
+    /** Resolves after the WebSocket listener configured at process startup is bound. */
+    waitForConfiguredWebSocketServer(): Promise<void>;
+    /**
+     * Request the agent host to start a WebSocket server on a local
+     * pipe/socket. Returns the socket path.
+     * If a server is already running, returns the existing info.
+     */
+    startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+    /**
+     * Get inspector listener info for the agent host process. If the inspector
+     * is not currently active and `tryEnable` is true, opens the inspector on
+     * a random local port. Returns `undefined` if the inspector cannot be
+     * enabled (e.g. running in an environment without `node:inspector`).
+     */
+    getInspectInfo(tryEnable: boolean): Promise<IAgentHostInspectInfo | undefined>;
+}
+/**
+ * Narrow renderer-to-local-agent-host control surface. All stateful agent
+ * operations travel over {@link AgentHostIpcChannels.Protocol}.
+ */
+export interface IAgentHostManagementService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Local-only compatibility path for session fields not yet represented by
+     * AHP `createSession` (`model`, `agent`, and `importConversation`).
+     */
+    createSessionWithExtensions(config: IAgentCreateSessionConfig): Promise<URI>;
+    /**
+     * Local-only compatibility path for chat fields not yet represented by AHP
+     * `createChat` (`title` and `model`).
+     */
+    createChatWithExtensions(session: URI, chat: URI, options: IAgentCreateChatRequestOptions): Promise<void>;
+    createDetachedWorktree(session: URI, prompt: string): Promise<{
+        handle: string;
+        worktree: URI;
+    }>;
+    setDetachedWorktreeArchived(handle: string, archived: boolean): Promise<void>;
+    claimDetachedWorktree(handle: string): Promise<void>;
+    deleteDetachedWorktree(handle: string): Promise<void>;
+    reconcileDetachedWorktrees(scope: string, activeHandles: readonly string[]): Promise<void>;
+    shutdown(): Promise<void>;
+    getNetworkDiagnosticsInfo(): Promise<IAgentHostNetworkDiagnosticsInfo>;
+    getManagedSettingsDiagnostics(): Promise<readonly IAgentHostManagedSettingsDiagnostics[]>;
+    diagnosticsFetch(url: string): Promise<IAgentHostNetworkFetchResult>;
+    getSessionStateFile(session: URI, chat?: URI): Promise<URI | undefined>;
+    collectDebugLogs(session: URI | undefined, kind: AgentHostDebugLogsArtifactKind, chat?: URI): Promise<IAgentHostDebugLogsArtifact>;
+    readDebugLogsChunk(resource: URI, position: number): Promise<IAgentHostDebugLogsChunk>;
+    startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+    getInspectInfo(tryEnable: boolean): Promise<IAgentHostInspectInfo | undefined>;
+}
+/**
+ * Consumer-facing connection to an agent host. Session handlers, terminal
+ * contributions, and other features program against this interface.
+ *
+ * Implementations wrap an {@link IAgentService} and layer subscription
+ * management and optimistic write-ahead on top.
+ */
+export interface IAgentConnection {
+    readonly clientId: string;
+    readonly resourceUris: IAgentHostResourceUriMapper;
+    readonly rootState: IAgentSubscription<RootState>;
+    /**
+     * Acquire a refcounted subscription to `resource`. `owner` names the
+     * caller holding the reference so inspection surfaces can attribute who
+     * is retaining a subscription; use a stable identifier such as the
+     * acquiring class name.
+     */
+    getSubscription<T extends StateComponents>(kind: T, resource: URI, owner: string): IReference<IAgentSubscription<ComponentToState[T]>>;
+    getSubscriptionUnmanaged<T extends StateComponents>(kind: T, resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
+    /**
+     * Returns the in-flight `createSession` Promise for `resource`, or `undefined` if no create is pending. Callers
+     * that need to gate work on a racing eager `createSession` (e.g. before deciding whether to fall through to a
+     * duplicate create) should await this first.
+     */
+    getInflightSessionCreate(resource: URI): Promise<unknown> | undefined;
+    /**
+     * Read-only descriptors of every active resource subscription on this
+     * connection, for inspection/debug surfaces. Excludes the always-live
+     * {@link rootState}.
+     */
+    getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
+    /**
+     * Dispatch a client-originated action. `channel` is the protocol URI
+     * string identifying the channel the action targets (a session URI for
+     * session actions, terminal URI for terminal actions, or
+     * `ROOT_STATE_URI` for root-config actions). Strings are used rather
+     * than {@link URI} objects so authority-less scheme URIs like
+     * `ahp-root://` survive the wire format without normalization.
+     */
+    dispatch(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction): void;
+    readonly onDidNotification: Event<INotification>;
+    readonly onDidAction: Event<ActionEnvelope>;
+    /**
+     * Fires when the host forwards an MCP server notification (e.g.
+     * `notifications/tools/list_changed`) over the `mcp://` side channel.
+     * The `channel` field on the notification routes the payload to the
+     * matching {@link McpServerCustomization}.
+     */
+    readonly onMcpNotification: Event<IMcpNotification>;
+    /**
+     * Send a request on an `mcp://` AHP side channel. `channel` is the
+     * `mcp://` URI advertised by the matching {@link McpServerCustomization}
+     * (only available while the server is `ready`). `method` is the raw MCP
+     * JSON-RPC method (e.g. `tools/call`, `resources/read`,
+     * `sampling/createMessage`); `params` are the JSON-RPC params (the
+     * connection adds the routing envelope's `channel` field automatically).
+     *
+     * Rejects with an `Error` whose message begins with `Method not found`
+     * when the channel is unknown or the host doesn't recognise the method.
+     */
+    handleMcpRequest(channel: string, method: string, params: Record<string, unknown> | undefined): Promise<unknown>;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    /** Requires the VS Code artifact removal capability advertised by initialize. */
+    removeSessionArtifact?(session: URI, artifactId: string): Promise<void>;
+    createDetachedWorktree?(session: URI, prompt: string): Promise<{
+        handle: string;
+        worktree: URI;
+    }>;
+    claimDetachedWorktree?(handle: string): Promise<void>;
+    setDetachedWorktreeArchived?(handle: string, archived: boolean): Promise<void>;
+    deleteDetachedWorktree?(handle: string): Promise<void>;
+    reconcileDetachedWorktrees?(scope: string, activeHandles: readonly string[]): Promise<void>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<SessionConfigCompletionsResult>;
+    completions(params: CompletionsParams): Promise<CompletionsResult>;
+    listAutomationTriggerDefinitions(params: ListAutomationTriggerDefinitionsParams): Promise<ListAutomationTriggerDefinitionsResult>;
+    runAutomation(params: RunAutomationParams): Promise<RunAutomationResult>;
+    fetchAutomationRuns(params: FetchAutomationRunsParams): Promise<FetchAutomationRunsResult>;
+    /**
+     * Trigger characters announced by the connected agent host that should
+     * cause the client to issue a `completions` request when typed in a
+     * user-message input. Resolves once on first request and is cached.
+     */
+    getCompletionTriggerCharacters(): Promise<readonly string[]>;
+    /**
+     * The host's `initialize` handshake result, exposed observably so callers
+     * can derive advertised capabilities (e.g. {@link InitializeResult.terminalCommandPrefix},
+     * {@link InitializeResult.completionTriggerCharacters}). `undefined` until
+     * the handshake completes.
+     */
+    readonly initializeResult: IObservable<InitializeResult | undefined>;
+    disposeSession(session: URI): Promise<void>;
+    /**
+     * Host-level network context for diagnostics (version, OS/arch, account,
+     * proxy settings/env, endpoints). Runs on the agent host process (local or
+     * remote), so the result reflects the environment the Copilot SDK actually
+     * runs in.
+     */
+    getNetworkDiagnosticsInfo(): Promise<IAgentHostNetworkDiagnosticsInfo>;
+    /** Resolve managed settings through each provider's native SDK/runtime implementation. */
+    getManagedSettingsDiagnostics(): Promise<readonly IAgentHostManagedSettingsDiagnostics[]>;
+    /**
+     * Probe connectivity from the agent host to a single `url`. Runs on the
+     * agent host process (local or remote), so the result reflects the
+     * environment the Copilot SDK actually runs in.
+     */
+    diagnosticsFetch(url: string): Promise<IAgentHostNetworkFetchResult>;
+    getSessionStateFile(session: URI, chat?: URI): Promise<URI | undefined>;
+    collectDebugLogs(session: URI | undefined, kind: AgentHostDebugLogsArtifactKind, chat?: URI): Promise<IAgentHostDebugLogsArtifact>;
+    /**
+     * Read one bounded slice of an artifact previously returned by
+     * {@link collectDebugLogs}. Only artifacts this host produced are readable.
+     */
+    readDebugLogsChunk(resource: URI, position: number): Promise<IAgentHostDebugLogsChunk>;
+    /**
+     * Create an additional peer chat inside an existing session. `chat` is a
+     * client-chosen chat URI (see {@link buildChatUri}). The host adds the
+     * chat to the session's catalog and publishes `session/chatAdded`.
+     */
+    createChat(session: URI, chat: URI, options?: IAgentCreateChatRequestOptions): Promise<void>;
+    /** Dispose an additional chat created via {@link createChat}. */
+    disposeChat(chat: URI): Promise<void>;
+    createTerminal(params: CreateTerminalParams): Promise<void>;
+    disposeTerminal(terminal: URI): Promise<void>;
+    invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
+    resourceList(uri: URI): Promise<ResourceListResult>;
+    resourceRead(uri: URI, encoding?: ContentEncoding): Promise<ResourceReadResult>;
+    resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
+    resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
+    resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
+    resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
+    resourceResolve(params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    resourceMkdir(params: ResourceMkdirParams): Promise<ResourceMkdirResult>;
+    createResourceWatch(params: CreateResourceWatchParams): Promise<CreateResourceWatchResult>;
+    /**
+     * Convenience method that bundles
+     * {@link createResourceWatch} + {@link subscribe} + a typed
+     * {@link IFileChange}[] event stream, so consumers (notably
+     * `AHPFileSystemProvider.watch`) can drive a watcher without
+     * understanding the underlying channel protocol. Disposing the
+     * returned handle unsubscribes.
+     */
+    watchResource(params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
+}