@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/platform/agentHost/common/otlp/otlpLogEmitter.d.ts

@@ -0,0 +1,198 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { AbstractMessageLogger, LogLevel } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log";
+/**
+ * Channel URI template advertised by an agent host that has an
+ * {@link OtlpLogEmitter} attached. Clients expand `{level}` to one of the
+ * short OTLP severity names (`trace`/`debug`/`info`/`warn`/`error`/`fatal`)
+ * and subscribe to the resulting concrete URI.
+ *
+ * Kept as a constant so producer (host) and consumer (workbench) cannot
+ * drift out of sync.
+ */
+export declare const OTLP_LOGS_CHANNEL_TEMPLATE = "ahp-otlp://logs/{level}";
+/**
+ * Scheme used by every OTLP channel URI. Lets routers tell them apart from
+ * `ahp-*` state channels by URI alone.
+ */
+export declare const OTLP_CHANNEL_SCHEME = "ahp-otlp";
+/**
+ * Short OTLP severity names defined by the protocol's `{level}` template
+ * variable. Listed in ascending order so a numeric index can act as a
+ * coarse "minimum severity" bucket.
+ */
+export declare const OTLP_LOG_LEVELS: readonly [
+    "trace",
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "fatal"
+];
+export type OtlpLogLevelName = typeof OTLP_LOG_LEVELS[number];
+/**
+ * Lowest [OTLP `SeverityNumber`](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-severitynumber)
+ * within each named severity band. A record is delivered when its
+ * `severityNumber >= levelToSeverityNumber(subscribed level)`.
+ */
+export declare function levelToSeverityNumber(level: OtlpLogLevelName): number;
+/**
+ * Parse one of {@link OTLP_LOG_LEVELS} from an arbitrary (case-insensitive)
+ * string. Returns `undefined` for anything that is not a recognised name so
+ * callers can decide how to handle unknown levels.
+ */
+export declare function parseOtlpLogLevel(value: string): OtlpLogLevelName | undefined;
+/**
+ * Map a VS Code {@link LogLevel} onto the corresponding OTLP
+ * `SeverityNumber` and short name.
+ */
+export declare function logLevelToOtlpSeverity(level: LogLevel): {
+    severityNumber: number;
+    severityText: OtlpLogLevelName;
+};
+/**
+ * Map a VS Code {@link LogLevel} onto the matching OTLP level name used in
+ * the protocol's `{level}` template. Returns `undefined` for
+ * {@link LogLevel.Off} since "no logs" is represented by not subscribing
+ * at all.
+ */
+export declare function logLevelToOtlpLevelName(level: LogLevel): OtlpLogLevelName | undefined;
+/**
+ * Reverse of {@link logLevelToOtlpSeverity}: returns the closest VS Code
+ * log level for a given OTLP `SeverityNumber`. Used on the client side to
+ * pick which `ILogger.{trace,debug,...}` call to route an incoming record
+ * through.
+ */
+export declare function severityNumberToLogLevel(severityNumber: number): LogLevel;
+/**
+ * Scalar value types accepted for a structured log attribute. Mirrors the
+ * subset of OTLP `AnyValue` we serialise on the wire
+ * (`stringValue`/`intValue`/`doubleValue`/`boolValue`).
+ */
+export type OtelAttributeValue = string | number | boolean;
+/**
+ * Structured metadata a log call can carry alongside its human-readable
+ * message. Pass an instance as the final argument to any `ILogger` method
+ * (e.g. `logService.info('MCP server started', new OtelData({ server: 'github' }))`).
+ *
+ * - For the regular file logger the value is rendered via {@link toJSON}
+ *   using the usual log formatting (`JSON.stringify`), so it appears as a
+ *   compact object after the message.
+ * - For the {@link OtlpEmitterLogger} the attributes are lifted out of the
+ *   message and emitted as spec-conformant OTLP `LogRecord.attributes`,
+ *   keeping the body free of serialised JSON.
+ */
+export declare class OtelData {
+    readonly attributes: Readonly<Record<string, OtelAttributeValue>>;
+    constructor(attributes: Readonly<Record<string, OtelAttributeValue>>);
+    toJSON(): Readonly<Record<string, OtelAttributeValue>>;
+}
+/**
+ * A single log record produced by an {@link OtlpEmitterLogger}. The shape
+ * mirrors the relevant fields from the OTLP/JSON `LogRecord` spec but is
+ * kept intentionally small — only what we need to populate a
+ * spec-conformant `ExportLogsServiceRequest` envelope.
+ */
+export interface IOtlpLogRecord {
+    /**
+     * Time the record was produced, in nanoseconds since the Unix epoch.
+     * Encoded as a string because JS numbers cannot losslessly represent
+     * 64-bit nanosecond timestamps (this matches the OTLP/JSON wire format).
+     */
+    readonly timeUnixNano: string;
+    /** OTLP `SeverityNumber` in the range 1..24 (see {@link levelToSeverityNumber}). */
+    readonly severityNumber: number;
+    /** Short severity name (`trace`/`debug`/...) matching the protocol's `{level}` vocabulary. */
+    readonly severityText: OtlpLogLevelName;
+    /**
+     * Pre-formatted log body. We send the same string the existing
+     * `ILogger` printed to the file logger — the OTLP spec models this as
+     * `body: { stringValue }`.
+     */
+    readonly body: string;
+    /**
+     * Optional structured metadata carried by an {@link OtelData} argument
+     * on the originating log call. Serialised to OTLP `LogRecord.attributes`
+     * and absent when the call had no {@link OtelData}.
+     */
+    readonly attributes?: Readonly<Record<string, OtelAttributeValue>>;
+}
+/**
+ * Connection-process-wide hub that {@link OtlpEmitterLogger} writes to and
+ * the protocol server reads from. Decouples log production (which happens
+ * via {@link ILogger}) from protocol broadcast (which needs awareness of
+ * connected clients and their subscribed severity).
+ */
+export declare class OtlpLogEmitter extends Disposable {
+    private readonly _onDidLog;
+    readonly onDidLog: Event<IOtlpLogRecord>;
+    emit(record: IOtlpLogRecord): void;
+}
+/**
+ * `AbstractMessageLogger` that converts each `log(level, message)` call
+ * into an {@link IOtlpLogRecord} and emits it on the shared
+ * {@link OtlpLogEmitter}. Designed to be installed alongside the regular
+ * file logger via `new LogService(primary, [otlpLogger])` so every log
+ * call is mirrored to OTLP subscribers without duplicating call sites.
+ */
+export declare class OtlpEmitterLogger extends AbstractMessageLogger {
+    private readonly _emitter;
+    constructor(_emitter: OtlpLogEmitter, initialLevel?: LogLevel);
+    trace(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string | Error, ...args: unknown[]): void;
+    protected log(level: LogLevel, message: string): void;
+    /**
+     * Formats `message` + `args` into the OTLP record body, lifting any
+     * {@link OtelData} argument out into structured `attributes` so the
+     * metadata is emitted over the channel rather than serialised into the
+     * body. Mirrors the formatting the base `AbstractMessageLogger` would
+     * apply (including the verbose flag for `trace`).
+     */
+    private _emit;
+}
+/**
+ * Build an OTLP/JSON `ExportLogsServiceRequest` envelope from a single
+ * record. The payload is the minimum the spec allows: one `ResourceLogs` →
+ * one `ScopeLogs` → one `LogRecord`.
+ *
+ * Callers that want to batch multiple records can use
+ * {@link toResourceLogsPayloadBatch}.
+ */
+export declare function toResourceLogsPayload(record: IOtlpLogRecord): Record<string, unknown>;
+/**
+ * Build an OTLP/JSON `ExportLogsServiceRequest` envelope from a batch of
+ * records. All records share the same `ResourceLogs`/`ScopeLogs` parent —
+ * which is fine since this emitter only ever runs inside a single agent
+ * host process and instrumentation scope.
+ */
+export declare function toResourceLogsPayloadBatch(records: readonly IOtlpLogRecord[]): Record<string, unknown>;
+/**
+ * Walk an OTLP/JSON `ExportLogsServiceRequest` payload and yield each
+ * embedded `LogRecord` in a shape matching {@link IOtlpLogRecord}. Used by
+ * clients to decode incoming `otlp/exportLogs` notifications without
+ * dragging in an OpenTelemetry SDK.
+ *
+ * Anything that does not look like a log record is silently skipped —
+ * the OTLP spec gives hosts considerable freedom and we don't want a
+ * malformed nested object to bring down the entire batch.
+ */
+export declare function iterateOtlpLogRecords(payload: unknown): IterableIterator<IOtlpLogRecord>;
+/**
+ * Parse an `ahp-otlp:` channel URI string and extract the `{level}` path
+ * segment (if present). Returns the parsed level — or `undefined` if the
+ * URI does not encode one or the encoded value is not a recognised name.
+ *
+ * The URI shape advertised by this host implementation is
+ * `ahp-otlp://logs/<level>` where `<level>` is one of {@link OTLP_LOG_LEVELS}.
+ */
+export declare function extractLevelFromOtlpLogsUri(uri: string): OtlpLogLevelName | undefined;
+/**
+ * Build the concrete `ahp-otlp:` channel URI a client subscribes to for a
+ * given minimum severity. Used both by clients deciding which URI to send
+ * with `subscribe` and by hosts deciding which URI to put on outbound
+ * notifications.
+ */
+export declare function buildOtlpLogsChannelUri(level: OtlpLogLevelName): string;

package/vscode/src/vs/platform/agentHost/common/otlp/otlpLogEmitter.js

@@ -0,0 +1,197 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+
+const OTLP_LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
+function parseOtlpLogLevel(value) {
+    const lower = value.toLowerCase();
+    return OTLP_LOG_LEVELS.includes(lower) ? lower : undefined;
+}
+function logLevelToOtlpSeverity(level) {
+    switch (level) {
+    case LogLevel.Trace:
+        return {
+            severityNumber: 1,
+            severityText: "trace"
+        };
+    case LogLevel.Debug:
+        return {
+            severityNumber: 5,
+            severityText: "debug"
+        };
+    case LogLevel.Info:
+        return {
+            severityNumber: 9,
+            severityText: "info"
+        };
+    case LogLevel.Warning:
+        return {
+            severityNumber: 13,
+            severityText: "warn"
+        };
+    case LogLevel.Error:
+        return {
+            severityNumber: 17,
+            severityText: "error"
+        };
+    case LogLevel.Off:
+        return {
+            severityNumber: 0,
+            severityText: "trace"
+        };
+    }
+}
+function logLevelToOtlpLevelName(level) {
+    if (level === LogLevel.Off) {
+        return undefined;
+    }
+    return logLevelToOtlpSeverity(level).severityText;
+}
+function severityNumberToLogLevel(severityNumber) {
+    if (severityNumber >= 17) {
+        return LogLevel.Error;
+    }
+    if (severityNumber >= 13) {
+        return LogLevel.Warning;
+    }
+    if (severityNumber >= 9) {
+        return LogLevel.Info;
+    }
+    if (severityNumber >= 5) {
+        return LogLevel.Debug;
+    }
+    return LogLevel.Trace;
+}
+function* iterateOtlpLogRecords(payload) {
+    if (!payload || typeof payload !== "object") {
+        return;
+    }
+    const resourceLogs = payload.resourceLogs;
+    if (!Array.isArray(resourceLogs)) {
+        return;
+    }
+    for (const resourceLog of resourceLogs) {
+        if (!resourceLog || typeof resourceLog !== "object") {
+            continue;
+        }
+        const scopeLogs = resourceLog.scopeLogs;
+        if (!Array.isArray(scopeLogs)) {
+            continue;
+        }
+        for (const scopeLog of scopeLogs) {
+            if (!scopeLog || typeof scopeLog !== "object") {
+                continue;
+            }
+            const logRecords = scopeLog.logRecords;
+            if (!Array.isArray(logRecords)) {
+                continue;
+            }
+            for (const raw of logRecords) {
+                const record = coerceLogRecord(raw);
+                if (record) {
+                    yield record;
+                }
+            }
+        }
+    }
+}
+function coerceLogRecord(raw) {
+    if (!raw || typeof raw !== "object") {
+        return undefined;
+    }
+    const r = raw;
+    const severityNumber = typeof r.severityNumber === "number" ? r.severityNumber : 0;
+    const severityTextRaw = typeof r.severityText === "string" ? r.severityText.toLowerCase() : "";
+    const severityText = parseOtlpLogLevel(severityTextRaw) ?? severityNameFromNumber(severityNumber);
+    const timeUnixNano = typeof r.timeUnixNano === "string" ? r.timeUnixNano : typeof r.observedTimeUnixNano === "string" ? r.observedTimeUnixNano : "0";
+    const body = extractBody(r.body);
+    const attributes = otlpToAttributes(r.attributes);
+    return attributes ? {
+        timeUnixNano,
+        severityNumber,
+        severityText,
+        body,
+        attributes
+    } : {
+        timeUnixNano,
+        severityNumber,
+        severityText,
+        body
+    };
+}
+function otlpToAttributes(raw) {
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const result = {};
+    for (const entry of raw) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const key = entry.key;
+        if (typeof key !== "string") {
+            continue;
+        }
+        const value = fromAnyValue(entry.value);
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return ( Object.keys(result)).length > 0 ? result : undefined;
+}
+function fromAnyValue(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const v = value;
+    if (typeof v.stringValue === "string") {
+        return v.stringValue;
+    }
+    if (typeof v.boolValue === "boolean") {
+        return v.boolValue;
+    }
+    if (typeof v.intValue === "number") {
+        return Number.isSafeInteger(v.intValue) ? v.intValue : undefined;
+    }
+    if (typeof v.intValue === "string") {
+        const parsed = Number(v.intValue);
+        return Number.isSafeInteger(parsed) ? parsed : undefined;
+    }
+    if (typeof v.doubleValue === "number") {
+        return Number.isFinite(v.doubleValue) ? v.doubleValue : undefined;
+    }
+    return undefined;
+}
+function severityNameFromNumber(n) {
+    if (n >= 21) {
+        return "fatal";
+    }
+    if (n >= 17) {
+        return "error";
+    }
+    if (n >= 13) {
+        return "warn";
+    }
+    if (n >= 9) {
+        return "info";
+    }
+    if (n >= 5) {
+        return "debug";
+    }
+    return "trace";
+}
+function extractBody(body) {
+    if (typeof body === "string") {
+        return body;
+    }
+    if (body && typeof body === "object") {
+        const value = body.stringValue;
+        if (typeof value === "string") {
+            return value;
+        }
+    }
+    return "";
+}
+
+export { OTLP_LOG_LEVELS, iterateOtlpLogRecords, logLevelToOtlpLevelName, logLevelToOtlpSeverity, parseOtlpLogLevel, severityNumberToLogLevel };

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

@@ -1,6 +1,6 @@
 
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { AgentNetworkDomainSettingId } from '../../networkFilter/common/settings.js';
+import { AgentNetworkDomainSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/networkFilter/common/settings';
 import { AgentSandboxEnabledValue, AgentSandboxSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings';
 import { createSchema, schemaProperty } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
 
@@ -24,56 +24,56 @@ var AgentHostSandboxKey;
 createSchema({
     [AgentHostSandboxConfigKey.Sandbox]: schemaProperty({
         type: "object",
-        title: ( localize(2126, "Agent Sandbox")),
+        title: ( localize(2144, "Agent Sandbox")),
         properties: {
             [AgentHostSandboxKey.Enabled]: {
                 type: "string",
-                title: ( localize(2127, "Sandbox Enabled")),
+                title: ( localize(2145, "Sandbox Enabled")),
                 enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.WindowsEnabled]: {
                 type: "string",
-                title: ( localize(2128, "Sandbox Enabled (Windows)")),
+                title: ( localize(2146, "Sandbox Enabled (Windows)")),
                 enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.AllowNetwork]: {
                 type: "boolean",
-                title: ( localize(2129, "Allow Network"))
+                title: ( localize(2147, "Allow Network"))
             },
             [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
                 type: "boolean",
-                title: ( localize(2130, "Allow Unsandboxed Commands"))
+                title: ( localize(2148, "Allow Unsandboxed Commands"))
             },
             [AgentHostSandboxKey.LinuxFileSystem]: {
                 type: "object",
-                title: ( localize(2131, "Linux Sandbox Filesystem"))
+                title: ( localize(2149, "Linux Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.MacFileSystem]: {
                 type: "object",
-                title: ( localize(2132, "macOS Sandbox Filesystem"))
+                title: ( localize(2150, "macOS Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.WindowsFileSystem]: {
                 type: "object",
-                title: ( localize(2133, "Windows Sandbox Filesystem"))
+                title: ( localize(2151, "Windows Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.AdvancedRuntime]: {
                 type: "object",
-                title: ( localize(2134, "Advanced Sandbox Runtime"))
+                title: ( localize(2152, "Advanced Sandbox Runtime"))
             },
             [AgentHostSandboxKey.AllowedNetworkDomains]: {
                 type: "array",
-                title: ( localize(2135, "Allowed Network Domains")),
+                title: ( localize(2153, "Allowed Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(2136, "Domain"))
+                    title: ( localize(2154, "Domain"))
                 }
             },
             [AgentHostSandboxKey.DeniedNetworkDomains]: {
                 type: "array",
-                title: ( localize(2137, "Denied Network Domains")),
+                title: ( localize(2155, "Denied Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(2138, "Domain"))
+                    title: ( localize(2156, "Domain"))
                 }
             }
         }

package/vscode/src/vs/platform/agentHost/common/state/sessionWorkingDirectories.d.ts

@@ -1,5 +1,5 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { type SessionWorkingDirectoryAction } from "./sessionActions.js";
+import { type SessionWorkingDirectoryAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionActions";
 /**
  * Compares two additional (non-primary) working-directory lists. A session's
  * additional directories are unordered peers, so only membership matters.

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

@@ -0,0 +1,63 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+/**
+ * IPC channel name for the main-process WSL service.
+ */
+export declare const WSL_REMOTE_AGENT_HOST_CHANNEL = "wslRemoteAgentHost";
+export declare const WSL_INSTALL_DOCS_URL = "https://aka.ms/vscode-remote/wsl/install-wsl";
+/**
+ * Prefix for WSL display addresses (`wsl:<distro>`). This is NOT a `ws://`
+ * URL — it identifies a managed WSL connection and must never be funneled
+ * into the raw WebSocket connect path.
+ */
+export declare const WSL_ADDRESS_PREFIX = "wsl:";
+/** Controls whether opening a chat automatically starts its stopped WSL host. */
+export declare const WslAutoStartSettingId = "chat.agentHost.wsl.autoStart";
+/**
+ * A WSL distribution discovered via `wsl --list`. Only WSL 2 distros are
+ * surfaced — WSL 1 lacks the kernel features needed to host the agent.
+ */
+export interface IWSLDistro {
+    readonly name: string;
+    readonly isDefault: boolean;
+    readonly isRunning: boolean;
+    readonly version: 2;
+}
+export interface IWSLAgentHostConfig {
+    readonly distro: string;
+    /** Display name (defaults to the distro name in callers). */
+    readonly name: string;
+    /** Dev override: custom command to start the remote agent host. See SSH equivalent. */
+    readonly remoteAgentHostCommand?: string;
+    /** Whether an explicit user action initiated the connection. */
+    readonly userInitiated?: boolean;
+}
+export interface IWSLConnectProgress {
+    readonly connectionKey: string;
+    readonly message: string;
+}
+export interface IWSLConnectResult {
+    readonly connectionId: string;
+    /** Display address: `wsl:<distro>`. NOT the underlying ws:// URL. */
+    readonly address: string;
+    readonly distro: string;
+    readonly name: string;
+    readonly connectionToken: string | undefined;
+}
+export interface IWSLAgentHostConnection extends IDisposable {
+    readonly distro: string;
+    readonly localAddress: string;
+    readonly name: string;
+    readonly onDidClose: Event<void>;
+}
+/**
+ * A WSL distro the user has connected to during this or a previous window.
+ * Persisted by {@link IWSLRemoteAgentHostService} so its connection factory
+ * can supply startup entries. This is the WSL analogue of the tunnel
+ * service's cached-tunnels list — WSL connections are managed in-memory and
+ * are never written to the remote agent hosts setting.
+ */
+export interface IWSLCachedDistro {
+    readonly distro: string;
+    readonly name: string;
+}

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

@@ -0,0 +1,7 @@
+
+
+const WSL_INSTALL_DOCS_URL = 'https://aka.ms/vscode-remote/wsl/install-wsl';
+const WSL_ADDRESS_PREFIX = 'wsl:';
+const WslAutoStartSettingId = 'chat.agentHost.wsl.autoStart';
+
+export { WSL_ADDRESS_PREFIX, WSL_INSTALL_DOCS_URL, WslAutoStartSettingId };

package/vscode/src/vs/platform/agentHost/common/wslRemoteAgentHost.service.d.ts

@@ -0,0 +1,51 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/sessions/sessions.web.main.internal";
+import { IRelayMessage } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/relayTransport";
+import { IWSLConnectProgress, IWSLAgentHostConnection, IWSLDistro, IWSLAgentHostConfig, IWSLCachedDistro, type IWSLConnectResult } from "./wslRemoteAgentHost.js";
+export declare const IWSLRemoteAgentHostService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IWSLRemoteAgentHostService>;
+/**
+* Manages WSL-bootstrapped connections to remote agent host processes.
+*
+* Each connection enters a WSL 2 distro, ensures the VS Code CLI is
+* available inside the distro, starts `code agent-host`, and creates a
+* stdio relay through the shared process.
+*/
+export interface IWSLRemoteAgentHostService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeConnections: Event<void>;
+    readonly onDidReportConnectProgress: Event<IWSLConnectProgress>;
+    readonly connections: readonly IWSLAgentHostConnection[];
+    isWSLAvailable(): Promise<boolean>;
+    listDistros(): Promise<IWSLDistro[]>;
+    listRunningDistros(): Promise<string[]>;
+    connect(config: IWSLAgentHostConfig): Promise<IWSLAgentHostConnection>;
+    disconnect(distro: string): Promise<void>;
+    /** Reconnect a cached distro, optionally as an automatic recovery attempt. */
+    reconnect(distro: string, name: string, userInitiated?: boolean): Promise<IWSLAgentHostConnection>;
+    /**
+    * Distros the user has connected to, persisted across windows. Drives the
+    * remote agent host service's startup auto-connect. WSL connections
+    * themselves live in-memory, mirroring how tunnels are handled.
+    */
+    getCachedDistros(): readonly IWSLCachedDistro[];
+}
+export declare const IWSLRemoteAgentHostMainService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IWSLRemoteAgentHostMainService>;
+/**
+* Main-process service that performs the actual WSL work. The renderer
+* calls this over IPC; the renderer-side WSL connection factory owns protocol
+* client creation and registration with {@link IRemoteAgentHostService}.
+*/
+export interface IWSLRemoteAgentHostMainService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeConnections: Event<void>;
+    readonly onDidCloseConnection: Event<string>;
+    readonly onDidReportConnectProgress: Event<IWSLConnectProgress>;
+    readonly onDidRelayMessage: Event<IRelayMessage>;
+    readonly onDidRelayClose: Event<string>;
+    relaySend(connectionId: string, message: string): Promise<void>;
+    isWSLAvailable(): Promise<boolean>;
+    listDistros(): Promise<IWSLDistro[]>;
+    listRunningDistros(): Promise<string[]>;
+    connect(config: IWSLAgentHostConfig): Promise<IWSLConnectResult>;
+    disconnect(distro: string): Promise<void>;
+    reconnect(distro: string, name: string, remoteAgentHostCommand?: string, userInitiated?: boolean): Promise<IWSLConnectResult>;
+}

package/vscode/src/vs/platform/agentHost/common/wslRemoteAgentHost.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const IWSLRemoteAgentHostService = ( createDecorator("wslRemoteAgentHostService"));
+
+export { IWSLRemoteAgentHostService };

package/vscode/src/vs/platform/networkFilter/common/networkFilterService.js

@@ -6,8 +6,8 @@ import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map
 import { matchesScheme, Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { extractDomainFromUri, isDomainAllowed } from './domainMatcher.js';
-import { AgentNetworkDomainSettingId } from './settings.js';
+import { extractDomainFromUri, isDomainAllowed } from '@codingame/monaco-vscode-api/vscode/vs/platform/networkFilter/common/domainMatcher';
+import { AgentNetworkDomainSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/networkFilter/common/settings';
 
 function isFilteredNetworkScheme(uri) {
     return matchesScheme(uri, Schemas.http) || matchesScheme(uri, Schemas.https) || matchesScheme(uri, "ws") || matchesScheme(uri, "wss");
@@ -61,7 +61,7 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
     formatError(uri) {
         const domain = extractDomainFromUri(uri);
         return localize(
-            2409,
+            2427,
             "Access to {0} is blocked by network domain policy (see `{1}` and `{2}` settings).",
             domain ?? uri.authority,
             AgentNetworkDomainSettingId.AllowedNetworkDomains,

package/vscode/src/vs/platform/sandbox/common/terminalSandboxEngine.d.ts

@@ -4,7 +4,7 @@ import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/com
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { AgentNetworkDomainSettingId } from "../../networkFilter/common/settings.js";
+import { AgentNetworkDomainSettingId } from "@codingame/monaco-vscode-api/vscode/vs/platform/networkFilter/common/settings";
 import { ISandboxDependencyStatus, type IWindowsMxcConfig, IWindowsMxcFilesystemPolicy, type IWindowsMxcPolicyContainment, type IWindowsMxcSandboxPolicy } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService";
 import { AgentSandboxSettingId } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/settings";
 import { IWindowsMxcTerminalSandboxRuntime } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxMxcRuntime.service";