@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostResponseFileChanges.d.ts

@@ -0,0 +1,62 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { type ChangesetFile } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IEditSessionEntryDiff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
+import { IChatResponseFileChangesProvider, IChatResponseFileEdit } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService";
+/** Maps one Agent Host changeset file into the diff shape used by chat editors. */
+export declare function agentHostChangesetFileToEntryDiff(file: ChangesetFile, connectionAuthority: string): IEditSessionEntryDiff | undefined;
+/**
+ * Supplies the chat "Changed N files" summary for agent host responses from the
+ * authoritative per-turn changeset the host computes server-side (the same
+ * source backing the Agents-app Changes view), rather than from the chat
+ * editing session.
+ *
+ * For each `(sessionResource, requestId)` it subscribes to the session's
+ * per-turn changeset — `requestId` is the agent host turn id — and maps its
+ * files into {@link IEditSessionEntryDiff} entries. Subscriptions are acquired
+ * lazily inside the returned observable (so they exist only while a summary is
+ * actually observing the diffs) and the per-request observables are memoized so
+ * repeated lookups share one subscription.
+ *
+ * The per-request diffs are monotonic: a turn that has reported changes keeps
+ * them, because every recompute, resubscribe and reconnect passes through a
+ * window where the client can see no files and consumers hide themselves when
+ * a turn reports nothing.
+ */
+export declare class AgentHostResponseFileChangesProvider extends Disposable implements IChatResponseFileChangesProvider {
+    private readonly _connection;
+    private readonly _connectionAuthority;
+    private readonly _resolveBackendSession;
+    private readonly _resolveBackendChat;
+    private readonly _logService;
+    private readonly _perRequest;
+    private readonly _perRequestFileEdits;
+    constructor(_connection: IAgentConnection, _connectionAuthority: string, _resolveBackendSession: (sessionResource: URI) => URI | undefined, _resolveBackendChat: ((sessionResource: URI) => URI | undefined) | undefined, _logService: ILogService);
+    getChangesForRequest(sessionResource: URI, requestId: string): IObservable<readonly IEditSessionEntryDiff[]> | undefined;
+    getFileEditsForRequest(sessionResource: URI, requestId: string): IObservable<readonly IChatResponseFileEdit[]> | undefined;
+    private _createDiffsObservable;
+    /**
+     * The session-wide branch changeset, exposed as a per-turn fallback but only
+     * for the specific turn recorded as an adopted legacy Copilot CLI session's
+     * final migrated turn. That turn has no per-turn checkpoint, so without this
+     * its committed-on-branch work never appears in the chat editor (#333642).
+     * Every other case — native sessions, earlier turns, and any turn added after
+     * adoption (which has its own real per-turn changeset) — yields an empty list,
+     * so this never alters the changes shown for those turns.
+     */
+    private _createBranchFallbackDiffsObservable;
+    private _createFileEditDiffsObservable;
+    /**
+     * Builds a two-level observable that owns a refcounted subscription to
+     * `component` at the (observable) resource. The outer observable acquires
+     * the subscription against the current resource and releases it when the
+     * resource changes or no one observes; the inner observable tracks the
+     * subscription's value.
+     */
+    private _subscribe;
+    private _responsePartsToEntryDiffs;
+    private _fileEditToEntryDiff;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostResponseFileChanges.js

@@ -0,0 +1,329 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual, getComparisonKey, isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ChangesetKind, buildTurnChangesetUri, buildBranchChangesetUri } from '../../../../../../platform/agentHost/common/changesetUri.js';
+import { normalizeFileEdit } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/fileEditDiff';
+import { toAgentHostUri, toAgentHostContentUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { FileEditKind, StateComponents, readSessionEhcliLastMigratedTurn, buildDefaultChatUri, isHostNoticeTurn } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { AUTHORITATIVE_EMPTY_CHAT_RESPONSE_FILE_CHANGES } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatResponseFileChangesService';
+import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { derivedObservableWithCache, mapObservableArrayCached } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { ChangesetStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { ToolCallStatus, ToolResultContentType, ResponsePartKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+
+const SUBSCRIPTION_OWNER = "AgentHostResponseFileChangesProvider";
+const REQUEST_CACHE_CAPACITY = 1000;
+const EMPTY_RESPONSE_FILE_EDITS = {
+    diffs: [],
+    hasValidEdits: false,
+    isHostNotice: false
+};
+const HOST_NOTICE_RESPONSE_FILE_EDITS = {
+    diffs: [],
+    hasValidEdits: false,
+    isHostNotice: true
+};
+function uriArrayEquals(a, b) {
+    return a.length === b.length && a.every((uri, index) => isEqual(uri, b[index]));
+}
+function getToolCallFileEdits(toolCall) {
+    const edits = [];
+    if (toolCall.status === ToolCallStatus.Running || toolCall.status === ToolCallStatus.Completed || toolCall.status === ToolCallStatus.PendingResultConfirmation) {
+        for (const content of toolCall.content ?? []) {
+            if (content.type === ToolResultContentType.FileEdit) {
+                edits.push(content);
+            }
+        }
+    } else if (toolCall.status === ToolCallStatus.PendingConfirmation) {
+        edits.push(...(toolCall.edits?.items ?? []));
+    }
+    return edits;
+}
+function agentHostChangesetFileToEntryDiff(file, connectionAuthority) {
+    const normalized = normalizeFileEdit(file.edit);
+    if (!normalized) {
+        return undefined;
+    }
+    const modifiedURI = toAgentHostUri(normalized.resource, connectionAuthority);
+    const originalURI = normalized.beforeContentUri ? toAgentHostContentUri(normalized.beforeContentUri, connectionAuthority) : modifiedURI;
+    const modifiedSnapshotURI = normalized.afterContentUri ? toAgentHostContentUri(normalized.afterContentUri, connectionAuthority) : undefined;
+    return {
+        originalURI,
+        modifiedURI,
+        modifiedSnapshotURI,
+        isCreated: normalized.kind === FileEditKind.Create,
+        isDeleted: normalized.kind === FileEditKind.Delete,
+        added: file.edit.diff?.added ?? 0,
+        removed: file.edit.diff?.removed ?? 0,
+        quitEarly: false,
+        identical: false,
+        isFinal: true,
+        isBusy: false
+    };
+}
+class AgentHostResponseFileChangesProvider extends Disposable {
+    constructor(
+        _connection,
+        _connectionAuthority,
+        _resolveBackendSession,
+        _resolveBackendChat,
+        _logService
+    ) {
+        super();
+        this._connection = _connection;
+        this._connectionAuthority = _connectionAuthority;
+        this._resolveBackendSession = _resolveBackendSession;
+        this._resolveBackendChat = _resolveBackendChat;
+        this._logService = _logService;
+        this._perRequest = ( new LRUCache(REQUEST_CACHE_CAPACITY));
+        this._perRequestFileEdits = ( new LRUCache(REQUEST_CACHE_CAPACITY));
+    }
+    getChangesForRequest(sessionResource, requestId) {
+        const backendSession = this._resolveBackendSession(sessionResource);
+        if (!backendSession || !requestId) {
+            return undefined;
+        }
+        const backendChat = this._resolveBackendChat?.(sessionResource);
+        const key = `${( backendSession.toString())}\0${backendChat?.toString() ?? ""}\0${requestId}`;
+        let obs = this._perRequest.get(key);
+        if (!obs) {
+            obs = this._createDiffsObservable(backendSession, backendChat, requestId);
+            this._perRequest.set(key, obs);
+        }
+        return obs;
+    }
+    getFileEditsForRequest(sessionResource, requestId) {
+        const backendSession = this._resolveBackendSession(sessionResource);
+        if (!backendSession || !requestId) {
+            return undefined;
+        }
+        const backendChat = this._resolveBackendChat?.(sessionResource);
+        const key = `${( backendSession.toString())}\0${backendChat?.toString() ?? ""}\0${requestId}`;
+        let obs = this._perRequestFileEdits.get(key);
+        if (!obs) {
+            const fileEdits = this._createFileEditDiffsObservable(backendSession, backendChat, requestId);
+            obs = derived(reader => fileEdits.read(reader).diffs);
+            this._perRequestFileEdits.set(key, obs);
+        }
+        return obs;
+    }
+    _createDiffsObservable(backendSession, backendChat, requestId) {
+        const sessionStateObs = this._subscribe(StateComponents.Session, constObservable(backendSession));
+        const turnChangesetUriObs = derivedOpts({
+            equalsFn: isEqual
+        }, reader => {
+            const sessionState = sessionStateObs.read(reader).read(reader);
+            if (!sessionState || sessionState instanceof Error) {
+                return undefined;
+            }
+            const supportsTurnChangeset = sessionState.changesets?.some(c => c.changeKind === ChangesetKind.Turn);
+            if (!supportsTurnChangeset) {
+                return undefined;
+            }
+            return ( URI.parse(buildTurnChangesetUri(( backendSession.toString()), requestId)));
+        });
+        const changesetStateObs = this._subscribe(StateComponents.Changeset, turnChangesetUriObs);
+        const responseFileEditsObs = this._createFileEditDiffsObservable(backendSession, backendChat, requestId);
+        const branchFallbackObs = this._createBranchFallbackDiffsObservable(backendSession, requestId);
+        let lastSource;
+        const select = (source, diffs, status) => {
+            if (source !== lastSource) {
+                lastSource = source;
+                this._logService.trace(`[AgentHostResponseFileChanges] ${( backendSession.toString())} turn ${requestId}: diffs from '${source}' (files=${diffs.length}, changesetStatus=${status ?? "none"})`);
+            }
+            return diffs;
+        };
+        return derivedObservableWithCache(this, (reader, lastValue) => {
+            const retained = lastValue ?? [];
+            const responseFileEdits = responseFileEditsObs.read(reader);
+            if (responseFileEdits.isHostNotice) {
+                return select("hostNotice", AUTHORITATIVE_EMPTY_CHAT_RESPONSE_FILE_CHANGES);
+            }
+            const turnUri = turnChangesetUriObs.read(reader);
+            const changesetState = turnUri ? changesetStateObs.read(reader).read(reader) : undefined;
+            const changeset = changesetState instanceof Error ? undefined : changesetState;
+            const changesetDiffs = changeset?.files.map(file => agentHostChangesetFileToEntryDiff(file, this._connectionAuthority)).filter(isDefined);
+            if (changesetDiffs?.length) {
+                return select("changeset", changesetDiffs, changeset?.status);
+            }
+            const branchDiffs = branchFallbackObs.read(reader);
+            if (branchDiffs.length) {
+                return select("branchFallback", branchDiffs, changeset?.status);
+            }
+            if (!turnUri) {
+                return select("unsupported", retained);
+            }
+            if (changeset?.status === ChangesetStatus.Ready && retained.length === 0) {
+                return select(
+                    "authoritativeEmpty",
+                    AUTHORITATIVE_EMPTY_CHAT_RESPONSE_FILE_CHANGES,
+                    changeset.status
+                );
+            }
+            return responseFileEdits.hasValidEdits ? select(
+                "response",
+                responseFileEdits.diffs.length > 0 ? responseFileEdits.diffs : AUTHORITATIVE_EMPTY_CHAT_RESPONSE_FILE_CHANGES,
+                changeset?.status
+            ) : select("retained", retained, changeset?.status);
+        });
+    }
+    _createBranchFallbackDiffsObservable(backendSession, requestId) {
+        const sessionStateObs = this._subscribe(StateComponents.Session, constObservable(backendSession));
+        const branchChangesetUriObs = derivedOpts({
+            equalsFn: isEqual
+        }, reader => {
+            const sessionState = sessionStateObs.read(reader).read(reader);
+            if (!sessionState || sessionState instanceof Error) {
+                return undefined;
+            }
+            if (readSessionEhcliLastMigratedTurn(sessionState._meta) !== requestId) {
+                return undefined;
+            }
+            return ( URI.parse(buildBranchChangesetUri(( backendSession.toString()))));
+        });
+        const branchChangesetStateObs = this._subscribe(StateComponents.Changeset, branchChangesetUriObs);
+        return derived(reader => {
+            if (!branchChangesetUriObs.read(reader)) {
+                return [];
+            }
+            const state = branchChangesetStateObs.read(reader).read(reader);
+            const changeset = state instanceof Error ? undefined : state;
+            return changeset?.files.map(file => agentHostChangesetFileToEntryDiff(file, this._connectionAuthority)).filter(isDefined) ?? [];
+        });
+    }
+    _createFileEditDiffsObservable(backendSession, backendChat, requestId) {
+        const sessionStateObs = this._subscribe(StateComponents.Session, constObservable(backendSession));
+        const defaultChatUri = ( URI.parse(buildDefaultChatUri(( backendSession.toString()))));
+        const chatUrisObs = derivedOpts({
+            equalsFn: uriArrayEquals
+        }, reader => {
+            if (backendChat) {
+                return [backendChat];
+            }
+            const sessionState = sessionStateObs.read(reader).read(reader);
+            if (!sessionState || sessionState instanceof Error) {
+                return [defaultChatUri];
+            }
+            const uris = ( new Map());
+            uris.set(( defaultChatUri.toString()), defaultChatUri);
+            for (const chat of sessionState.chats ?? []) {
+                const uri = ( URI.parse(chat.resource));
+                uris.set(( uri.toString()), uri);
+            }
+            return [...( uris.values())];
+        });
+        const chatStateObs = mapObservableArrayCached(this, chatUrisObs, chatUri => {
+            const obs = this._subscribe(StateComponents.Chat, constObservable(chatUri));
+            return derived(reader => obs.read(reader).read(reader));
+        }, chatUri => ( chatUri.toString()));
+        return derived(reader => {
+            const sessionState = sessionStateObs.read(reader).read(reader);
+            const workspaceRoots = [];
+            if (sessionState && !(sessionState instanceof Error)) {
+                const roots = ( new Map());
+                for (const root of [sessionState.project?.uri, ...(sessionState.workingDirectories ?? [])]) {
+                    if (root) {
+                        const uri = ( URI.parse(root));
+                        roots.set(( uri.toString()), uri);
+                    }
+                }
+                workspaceRoots.push(...( roots.values()));
+            }
+            for (const obs of chatStateObs.read(reader)) {
+                const chatState = obs.read(reader);
+                if (!chatState || chatState instanceof Error) {
+                    continue;
+                }
+                const turn = chatState.activeTurn?.id === requestId ? chatState.activeTurn : chatState.turns.find(turn => turn.id === requestId);
+                if (turn) {
+                    if (turn.message?.origin && isHostNoticeTurn(turn)) {
+                        return HOST_NOTICE_RESPONSE_FILE_EDITS;
+                    }
+                    return this._responsePartsToEntryDiffs(turn.responseParts, workspaceRoots);
+                }
+            }
+            return EMPTY_RESPONSE_FILE_EDITS;
+        });
+    }
+    _subscribe(component, resourceObs) {
+        return derived(reader => {
+            const resource = resourceObs.read(reader);
+            if (!resource) {
+                return constObservable(undefined);
+            }
+            const subscriptionRef = reader.store.add(this._connection.getSubscription(component, resource, SUBSCRIPTION_OWNER));
+            return observableFromEvent(
+                this,
+                subscriptionRef.object.onDidChange,
+                () => subscriptionRef.object.value
+            );
+        });
+    }
+    _responsePartsToEntryDiffs(responseParts, workspaceRoots) {
+        const byUri = ( new Map());
+        let hasValidEdits = false;
+        for (const responsePart of responseParts) {
+            if (responsePart.kind !== ResponsePartKind.ToolCall) {
+                continue;
+            }
+            for (const fileEdit of getToolCallFileEdits(responsePart.toolCall)) {
+                const diff = this._fileEditToEntryDiff(fileEdit, workspaceRoots);
+                if (!diff) {
+                    continue;
+                }
+                hasValidEdits = true;
+                const key = getComparisonKey(diff.modifiedURI);
+                const existing = byUri.get(key);
+                if (existing) {
+                    existing.added += diff.added;
+                    existing.removed += diff.removed;
+                    existing.modifiedURI = diff.modifiedURI;
+                    existing.modifiedSnapshotURI = diff.modifiedSnapshotURI;
+                    existing.isDeleted = diff.isDeleted;
+                    if (existing.isCreated && existing.isDeleted) {
+                        byUri.delete(key);
+                    }
+                } else {
+                    byUri.set(key, diff);
+                }
+            }
+        }
+        return {
+            diffs: [...( byUri.values())],
+            hasValidEdits,
+            isHostNotice: false
+        };
+    }
+    _fileEditToEntryDiff(fileEdit, workspaceRoots) {
+        const normalized = normalizeFileEdit(fileEdit);
+        if (!normalized) {
+            return undefined;
+        }
+        const resource = normalized.resource;
+        const modifiedURI = toAgentHostUri(resource, this._connectionAuthority);
+        const originalURI = normalized.kind === FileEditKind.Create || !normalized.beforeContentUri ? modifiedURI : toAgentHostContentUri(normalized.beforeContentUri, this._connectionAuthority);
+        const modifiedSnapshotURI = normalized.afterContentUri ? toAgentHostContentUri(normalized.afterContentUri, this._connectionAuthority) : undefined;
+        return {
+            originalURI,
+            modifiedURI,
+            modifiedSnapshotURI,
+            isCreated: normalized.kind === FileEditKind.Create,
+            isDeleted: normalized.kind === FileEditKind.Delete,
+            added: fileEdit.diff?.added ?? 0,
+            removed: fileEdit.diff?.removed ?? 0,
+            quitEarly: false,
+            identical: false,
+            isFinal: true,
+            isBusy: false,
+            isOutsideWorkspace: !( workspaceRoots.some(root => isEqualOrParent(resource, root)))
+        };
+    }
+}
+
+export { AgentHostResponseFileChangesProvider, agentHostChangesetFileToEntryDiff };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostRootConfigForwarder.d.ts

@@ -0,0 +1,84 @@
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { AgentHostConfigKey } from "../../../../../../platform/agentHost/common/agentHostCustomizationConfig.js";
+import { CopilotCliConfigKey } from "@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/copilotCliConfig";
+/**
+ * A single root-config key managed by an {@link AgentHostRootConfigForwarder}:
+ * says only *what* its value is and *when* to recompute it. The forwarder owns
+ * the schema gate, value-equality guard, dispatch, and hydration retry.
+ */
+export interface IForwardedRootConfigKey {
+    /** The root-config key this descriptor owns. */
+    readonly key: AgentHostConfigKey | CopilotCliConfigKey;
+    /** Compute the desired value; return `undefined` to skip the push. May be async. */
+    computeValue(): unknown | Promise<unknown>;
+    /** Wire up the triggers that should re-push this key; add disposables to `store`, call `push`. */
+    registerTriggers(store: DisposableStore, push: () => void): void;
+}
+/**
+ * Shared engine that forwards VS Code-derived values into the **local** agent
+ * host's root config so the host (and the CLI session launcher) can read them
+ * via `getRootValue`. Not a contribution itself: a workbench contribution
+ * constructs one with its own {@link IForwardedRootConfigKey} table and drives
+ * {@link start} / {@link stop} from its own enablement gate. Shared by
+ * `AgentHostTerminalContribution` and `AgentHostCopilotCliSettingsContribution`
+ * so the three correctness constraints below live in exactly one place.
+ *
+ * The three constraints forwarding into the shared root config requires:
+ *  1. **Schema gate.** A key is dispatched only once the host advertises it in
+ *     its root-config schema - protects older / third-party agent hosts (and an
+ *     older host that advertises only a subset of the keys) from receiving keys
+ *     they don't understand.
+ *  2. **Hydration retry.** The host's `rootState` may hydrate *after* the
+ *     forwarder starts, so a key whose schema isn't present yet is retried when
+ *     the schema first appears (see {@link _onRootStateChanged}).
+ *  3. **Cross-window loop guard.** The local agent host's root config is shared
+ *     across windows, so a key is dispatched only when its value actually
+ *     changes (compared structurally - see {@link _push}). Reacting to a
+ *     value-only change pushed by another window would otherwise start an
+ *     infinite update war, each window forcing its own value back over the
+ *     other's (#314385).
+ *
+ * Local agent host only. Remote agent hosts (via
+ * `IRemoteAgentHostService.connections`) are intentionally not fanned out to:
+ * e.g. a resolved shell path is local-machine-shaped and not necessarily valid
+ * on the remote. Remote operators should configure such values server-side via
+ * the remote's `agent-host-config.json`. See
+ * https://github.com/microsoft/vscode/issues/313160 follow-ups.
+ */
+export declare class AgentHostRootConfigForwarder extends Disposable {
+    private readonly _keys;
+    private readonly _agentHostService;
+    private readonly _listeners;
+    /**
+     * Managed keys whose schema the host has already advertised, so a key is
+     * re-pushed only when its schema *first* appears (see {@link _onRootStateChanged}).
+     */
+    private readonly _schemaSeen;
+    constructor(_keys: readonly IForwardedRootConfigKey[], _agentHostService: IAgentHostService);
+    /**
+     * Begin listening for triggers / agent-host (re)starts / schema hydration and
+     * do the initial push. Idempotent.
+     */
+    start(): void;
+    /** Stop listening and forget advertised-schema state. Idempotent. */
+    stop(): void;
+    /** Push every managed key (e.g. on start and after an agent-host restart). */
+    reconcile(): void;
+    /**
+     * Push managed values only for keys whose schema has just transitioned from
+     * absent to present (host root-config hydration). Value-only changes — e.g.
+     * another window writing a different value — are ignored so windows don't
+     * fight in an infinite loop.
+     */
+    private _onRootStateChanged;
+    private _schemaHasKey;
+    /**
+     * Push pipeline for a managed key: no-op if the schema doesn't advertise it
+     * (retried on hydration); compute the value (`undefined` skips); dispatch only
+     * if the host doesn't already hold a structurally-equal value — which breaks
+     * cross-window loops (#314385) and, being structural not `===`, never
+     * re-dispatches an unchanged object value.
+     */
+    private _push;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostRootConfigForwarder.js

@@ -0,0 +1,96 @@
+
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+
+class AgentHostRootConfigForwarder extends Disposable {
+    constructor(_keys, _agentHostService) {
+        super();
+        this._keys = _keys;
+        this._agentHostService = _agentHostService;
+        this._listeners = this._register(( new MutableDisposable()));
+        this._schemaSeen = ( new Set());
+    }
+    start() {
+        if (this._listeners.value) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        store.add(this._agentHostService.onAgentHostStart(() => this.reconcile()));
+        for (const entry of this._keys) {
+            entry.registerTriggers(store, () => this._push(entry));
+        }
+        store.add(
+            this._agentHostService.rootState.onDidChange(() => this._onRootStateChanged())
+        );
+        this._schemaSeen.clear();
+        for (const entry of this._keys) {
+            if (this._schemaHasKey(entry.key)) {
+                this._schemaSeen.add(entry.key);
+            }
+        }
+        this._listeners.value = store;
+        this.reconcile();
+    }
+    stop() {
+        this._schemaSeen.clear();
+        this._listeners.value = undefined;
+    }
+    reconcile() {
+        for (const entry of this._keys) {
+            this._push(entry);
+        }
+    }
+    _onRootStateChanged() {
+        for (const entry of this._keys) {
+            if (this._schemaHasKey(entry.key)) {
+                if (!( this._schemaSeen.has(entry.key))) {
+                    this._schemaSeen.add(entry.key);
+                    this._push(entry);
+                }
+            } else {
+                this._schemaSeen.delete(entry.key);
+            }
+        }
+    }
+    _schemaHasKey(key) {
+        const rootState = this._agentHostService.rootState.value;
+        if (!rootState || rootState instanceof Error) {
+            return false;
+        }
+        return !!rootState.config?.schema.properties[key];
+    }
+    async _push(entry) {
+        if (!this._schemaHasKey(entry.key)) {
+            return;
+        }
+        let value;
+        try {
+            value = await entry.computeValue();
+        } catch {
+            return;
+        }
+        if (value === undefined) {
+            return;
+        }
+        if (!this._schemaHasKey(entry.key)) {
+            return;
+        }
+        const rootState = this._agentHostService.rootState.value;
+        if (!rootState || rootState instanceof Error || !rootState.config) {
+            return;
+        }
+        if (structuralEquals(rootState.config.values[entry.key], value)) {
+            return;
+        }
+        this._agentHostService.dispatch(ROOT_STATE_URI, {
+            type: ActionType.RootConfigChanged,
+            config: {
+                [entry.key]: value
+            }
+        });
+    }
+}
+
+export { AgentHostRootConfigForwarder };