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

package/vscode/src/vs/workbench/services/agentEditorComments/browser/agentEditorCommentsOverlayWidget.d.ts

@@ -0,0 +1,30 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+export interface IAgentEditorCommentsOverlayOptions {
+    readonly menuId: MenuId;
+    readonly submitActionId: string;
+    readonly previousActionId: string;
+    readonly nextActionId: string;
+    readonly navigationBearingActionId: string;
+    readonly telemetrySource: string;
+}
+export declare class AgentEditorCommentsOverlayWidget extends Disposable {
+    private readonly _options;
+    private readonly _instantiationService;
+    private readonly _keybindingService;
+    private readonly _domNode;
+    private readonly _toolbarNode;
+    private readonly _showStore;
+    private readonly _navigationBearings;
+    private readonly _commentCount;
+    constructor(_options: IAgentEditorCommentsOverlayOptions, _instantiationService: IInstantiationService, _keybindingService: IKeybindingService);
+    getDomNode(): HTMLElement;
+    show(navigationBearings: {
+        activeIdx: number;
+        totalCount: number;
+    }, commentCount: number, editorGroup?: IEditorGroup): void;
+    hide(): void;
+}

package/vscode/src/vs/workbench/services/agentEditorComments/browser/agentEditorCommentsOverlayWidget.js

@@ -0,0 +1,175 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as agentEditorCommentsOverlayWidget from './media/agentEditorCommentsOverlayWidget.css';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { ActionRunner } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { createElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(agentEditorCommentsOverlayWidget);
+class SubmitCommentsActionRunner extends ActionRunner {
+    constructor(_submitActionId, _editorGroup) {
+        super();
+        this._submitActionId = _submitActionId;
+        this._editorGroup = _editorGroup;
+    }
+    async runAction(action, context) {
+        const editorToClose = action.id === this._submitActionId ? this._editorGroup.activeEditor : undefined;
+        const didSubmit = await action.run(context);
+        if (didSubmit === true && editorToClose) {
+            await this._editorGroup.closeEditor(editorToClose);
+        }
+    }
+}
+class CommentsActionViewItem extends ActionViewItem {
+    constructor(
+        action,
+        options,
+        _overlayOptions,
+        _keybindingService,
+        _commentCount,
+        editorGroup
+    ) {
+        const isIconOnly = action.id === _overlayOptions.previousActionId || action.id === _overlayOptions.nextActionId;
+        super(undefined, action, {
+            ...options,
+            icon: isIconOnly,
+            label: !isIconOnly,
+            keybindingNotRenderedWithLabel: true
+        });
+        this._overlayOptions = _overlayOptions;
+        this._keybindingService = _keybindingService;
+        this._commentCount = _commentCount;
+        if (action.id === _overlayOptions.submitActionId && editorGroup) {
+            this.actionRunner = this._register(( new SubmitCommentsActionRunner(_overlayOptions.submitActionId, editorGroup)));
+        }
+    }
+    render(container) {
+        super.render(container);
+        if (this._action.id === this._overlayOptions.submitActionId) {
+            this.element?.classList.add("primary");
+            this._store.add(autorun(reader => {
+                this._commentCount.read(reader);
+                this.updateLabel();
+                this.updateTooltip();
+            }));
+        }
+    }
+    updateLabel() {
+        if (this._action.id === this._overlayOptions.submitActionId && this.label) {
+            this.label.textContent = ( localize(19096, "Submit {0}", this._commentCount.get()));
+            return;
+        }
+        super.updateLabel();
+    }
+    getTooltip() {
+        const value = this._action.id === this._overlayOptions.submitActionId ? ( localize(19097, "Submit Feedback ({0})", this._commentCount.get())) : super.getTooltip();
+        return value && !this.options.keybinding ? this._keybindingService.appendKeybinding(value, this._action.id) : value;
+    }
+}
+let AgentEditorCommentsOverlayWidget = class AgentEditorCommentsOverlayWidget extends Disposable {
+    constructor(_options, _instantiationService, _keybindingService) {
+        super();
+        this._options = _options;
+        this._instantiationService = _instantiationService;
+        this._keybindingService = _keybindingService;
+        this._showStore = this._register(( new DisposableStore()));
+        this._navigationBearings = observableValue(this, {
+            activeIdx: -1,
+            totalCount: 0
+        });
+        this._commentCount = observableValue(this, 0);
+        this._domNode = createElement("div");
+        this._domNode.classList.add("agent-editor-comments-overlay-widget");
+        this._toolbarNode = createElement("div");
+        this._toolbarNode.classList.add("agent-editor-comments-overlay-toolbar");
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    show(navigationBearings, commentCount, editorGroup) {
+        this._showStore.clear();
+        this._navigationBearings.set(navigationBearings, undefined);
+        this._commentCount.set(commentCount, undefined);
+        if (!this._domNode.contains(this._toolbarNode)) {
+            this._domNode.appendChild(this._toolbarNode);
+        }
+        const toolbar = this._showStore.add(
+            this._instantiationService.createInstance(MenuWorkbenchToolBar, this._toolbarNode, this._options.menuId, {
+                telemetrySource: this._options.telemetrySource,
+                hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                toolbarOptions: {
+                    primaryGroup: () => true,
+                    useSeparatorsInPrimaryActions: true
+                },
+                menuOptions: {
+                    renderShortTitle: true
+                },
+                actionViewItemProvider: (action, options) => {
+                    if (action.id === this._options.navigationBearingActionId) {
+                        const that = this;
+                        return new (class extends ActionViewItem {
+                            constructor() {
+                                super(undefined, action, {
+                                    ...options,
+                                    icon: false,
+                                    label: true,
+                                    keybindingNotRenderedWithLabel: true
+                                });
+                            }
+                            render(container) {
+                                super.render(container);
+                                container.classList.add("label-item");
+                                this._store.add(autorun(reader => {
+                                    if (this.label) {
+                                        const {
+                                            activeIdx,
+                                            totalCount
+                                        } = that._navigationBearings.read(reader);
+                                        this.label.innerText = totalCount > 0 ? ( localize(19098, "{0}/{1}", activeIdx === -1 ? 1 : activeIdx + 1, totalCount)) : ( localize(19099, "0/0"));
+                                    }
+                                }));
+                            }
+                        })();
+                    }
+                    return ( new CommentsActionViewItem(
+                        action,
+                        options,
+                        this._options,
+                        this._keybindingService,
+                        this._commentCount,
+                        editorGroup
+                    ));
+                }
+            })
+        );
+        if (editorGroup) {
+            const activeEditor = editorGroup.activeEditor;
+            toolbar.context = {
+                groupId: editorGroup.id,
+                editorIndex: activeEditor ? editorGroup.getIndexOfEditor(activeEditor) : undefined
+            };
+        }
+        this._showStore.add(toDisposable(() => this._toolbarNode.remove()));
+    }
+    hide() {
+        this._showStore.clear();
+        this._navigationBearings.set({
+            activeIdx: -1,
+            totalCount: 0
+        }, undefined);
+        this._commentCount.set(0, undefined);
+        this._toolbarNode.remove();
+    }
+};
+AgentEditorCommentsOverlayWidget = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IKeybindingService))], AgentEditorCommentsOverlayWidget));
+
+export { AgentEditorCommentsOverlayWidget };

package/vscode/src/vs/workbench/services/agentEditorComments/browser/media/agentEditorCommentsOverlayWidget.css

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.agent-feedback-editor-overlay-host {
+	position: relative;
+}
+
+.agent-editor-comments-overlay-widget {
+	padding: 2px 4px;
+	color: var(--vscode-foreground);
+	background-color: var(--vscode-editorWidget-background);
+	border-radius: var(--vscode-cornerRadius-medium);
+	border: var(--vscode-strokeThickness) solid var(--vscode-editorHoverWidget-border);
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 4px;
+	z-index: 10;
+	box-shadow: var(--vscode-shadow-lg);
+	overflow: hidden;
+}
+
+.agent-editor-comments-overlay-widget .action-item > .action-label {
+	padding: 4px 6px;
+	font-size: var(--vscode-fontSize-body2);
+	line-height: 14px;
+	border-radius: var(--vscode-cornerRadius-small);
+}
+
+.agent-editor-comments-overlay-widget .monaco-action-bar .actions-container {
+	gap: 4px;
+}
+
+.agent-editor-comments-overlay-widget .action-item.primary > .action-label {
+	background-color: var(--vscode-button-background);
+	color: var(--vscode-button-foreground);
+}
+
+.monaco-workbench .agent-editor-comments-overlay-widget .monaco-action-bar .action-item.primary > .action-label:hover {
+	background-color: var(--vscode-button-hoverBackground);
+}
+
+.agent-editor-comments-overlay-widget .action-item > .action-label.codicon:not(.separator) {
+	color: var(--vscode-foreground);
+	width: 22px;
+	height: 22px;
+	padding: 0;
+	font-size: var(--vscode-codiconFontSize);
+	line-height: 22px;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+}
+
+.agent-editor-comments-overlay-widget .action-item.label-item {
+	font-variant-numeric: tabular-nums;
+}
+
+.agent-editor-comments-overlay-widget .monaco-action-bar .action-item.label-item > .action-label,
+.agent-editor-comments-overlay-widget .monaco-action-bar .action-item.label-item > .action-label:hover {
+	color: var(--vscode-foreground);
+	opacity: 1;
+}

package/vscode/src/vs/workbench/services/agentHost/browser/agentSdkSetupService.d.ts

@@ -0,0 +1,47 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentSdkSetupInfo } from "../../../../platform/agentHost/common/agentSdkSetup.js";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { ICodexAccountService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/browser/codexAccountService.service";
+import { IAgentSdkSetupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/browser/agentSdkSetupService.service";
+/**
+ * Where the user stands with one agent's setup: the download is on offer, the
+ * SDK is on disk and found no account, or the agent has models. Every other
+ * case — the feature not applying, a fetch in flight — is `undefined`.
+ */
+export type AgentSdkSetupState = "downloadOffered" | "noAccount" | "resolved";
+export declare class AgentSdkSetupService extends Disposable implements IAgentSdkSetupService {
+    private readonly _agentHostService;
+    private readonly _telemetryService;
+    private readonly _logService;
+    private readonly _openerService;
+    private readonly _commandService;
+    private readonly _codexAccountService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeSetups;
+    readonly onDidChangeSetups: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<readonly IAgentSdkSetupInfo[]>;
+    private _setups;
+    /**
+     * Agents we have asked to fetch and the host has not answered yet. Cleared on
+     * that answer rather than on success, so a failed download — which republishes
+     * `notDownloaded` after the `downloading` we cleared on — re-offers the button.
+     */
+    private readonly _pendingRequests;
+    get setups(): readonly IAgentSdkSetupInfo[];
+    constructor(_agentHostService: IAgentHostService, _telemetryService: ITelemetryService, _logService: ILogService, _openerService: IOpenerService, _commandService: ICommandService, _codexAccountService: ICodexAccountService);
+    requestDownload(agent: string): void;
+    openSetupDocs(agent: string): void;
+    requestReload(agent: string): void;
+    signInToGitHub(agent: string): void;
+    signIn(agent: string): void;
+    reportSetupState(agent: string, state: AgentSdkSetupState): void;
+    isDownloadPending(agent: string): boolean;
+    private _reportStep;
+    private _getSetup;
+    private _dispatchDownloadRequest;
+    private _dispatchRequest;
+    private _updateSetups;
+}

package/vscode/src/vs/workbench/services/agentHost/browser/agentSdkSetupService.js

@@ -0,0 +1,129 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { readAgentSdkSetupInfos, AGENT_SDK_SETUP_RELOAD_REQUEST_KEY, AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY } from '../../../../platform/agentHost/common/agentSdkSetup.js';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
+import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ICodexAccountService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/browser/codexAccountService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const CHAT_SETUP_COMMAND_ID = "workbench.action.chat.triggerSetup";
+let AgentSdkSetupService = class AgentSdkSetupService extends Disposable {
+    get setups() {
+        return this._setups;
+    }
+    constructor(
+        _agentHostService,
+        _telemetryService,
+        _logService,
+        _openerService,
+        _commandService,
+        _codexAccountService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this._openerService = _openerService;
+        this._commandService = _commandService;
+        this._codexAccountService = _codexAccountService;
+        this._onDidChangeSetups = this._register(( new Emitter()));
+        this.onDidChangeSetups = this._onDidChangeSetups.event;
+        this._setups = [];
+        this._pendingRequests = ( new Set());
+        const rootStateListeners = this._register(( new DisposableStore()));
+        const bindRootState = () => {
+            rootStateListeners.clear();
+            rootStateListeners.add(
+                this._agentHostService.rootState.onDidChange(state => this._updateSetups(readAgentSdkSetupInfos(state)))
+            );
+            this._pendingRequests.clear();
+            const state = this._agentHostService.rootState.value;
+            this._updateSetups(readAgentSdkSetupInfos(state instanceof Error ? undefined : state));
+        };
+        bindRootState();
+        this._register(this._agentHostService.onAgentHostStart(bindRootState));
+    }
+    requestDownload(agent) {
+        this._reportStep(agent, "downloadClicked");
+        this._dispatchDownloadRequest(agent);
+    }
+    openSetupDocs(agent) {
+        const url = this._getSetup(agent)?.setupDocsUrl;
+        if (!url) {
+            return;
+        }
+        this._reportStep(agent, "docsClicked");
+        void this._openerService.open(url, {
+            openExternal: true
+        });
+    }
+    requestReload(agent) {
+        this._reportStep(agent, "reloadClicked");
+        this._dispatchRequest(AGENT_SDK_SETUP_RELOAD_REQUEST_KEY, agent);
+    }
+    signInToGitHub(agent) {
+        this._reportStep(agent, "gitHubSignInClicked");
+        void this._commandService.executeCommand(CHAT_SETUP_COMMAND_ID);
+    }
+    signIn(agent) {
+        if (agent !== this._codexAccountService.agent) {
+            return;
+        }
+        this._reportStep(agent, "signInClicked");
+        this._codexAccountService.signIn();
+    }
+    reportSetupState(agent, state) {
+        this._reportStep(agent, state);
+    }
+    isDownloadPending(agent) {
+        return ( this._pendingRequests.has(agent));
+    }
+    _reportStep(agent, step) {
+        this._telemetryService.publicLog2("agentHost.agentSdkSetup", {
+            agent,
+            step
+        });
+        this._logService.trace(`[AgentSdkSetup] ${agent}: ${step}`);
+    }
+    _getSetup(agent) {
+        return this._setups.find(setup => setup.agent === agent);
+    }
+    _dispatchDownloadRequest(agent) {
+        this._pendingRequests.add(agent);
+        this._dispatchRequest(AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY, agent);
+        this._onDidChangeSetups.fire(this._setups);
+    }
+    _dispatchRequest(key, agent) {
+        this._agentHostService.dispatch(ROOT_STATE_URI, {
+            type: ActionType.RootConfigChanged,
+            config: {
+                [key]: {
+                    agent,
+                    request: generateUuid()
+                }
+            }
+        });
+    }
+    _updateSetups(setups) {
+        this._setups = setups;
+        for (const setup of setups) {
+            if (setup.download !== "notDownloaded") {
+                this._pendingRequests.delete(setup.agent);
+            }
+        }
+        this._onDidChangeSetups.fire(setups);
+    }
+};
+AgentSdkSetupService = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, ITelemetryService)), ( __param(2, ILogService)), ( __param(3, IOpenerService)), ( __param(4, ICommandService)), ( __param(5, ICodexAccountService))], AgentSdkSetupService));
+
+export { AgentSdkSetupService };

package/vscode/src/vs/workbench/services/agentHost/browser/editorRemoteAgentHostServiceClient.d.ts

@@ -2,19 +2,23 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { Disposable, IReference } 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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IAgentCreateChatOptions, IAgentCreateSessionConfig, IAgentHostInspectInfo, IAgentHostSocketInfo, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult, IMcpNotification } from "../../../../platform/agentHost/common/agentService.js";
+import { IAgentCreateChatRequestOptions, IAgentCreateSessionConfig, IAgentHostInspectInfo, IAgentHostManagedSettingsDiagnostics, IAgentHostNetworkDiagnosticsInfo, IAgentHostNetworkFetchResult, IAgentHostSocketInfo, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IAgentSessionMetadata, AuthenticateParams, AuthenticateResult, IMcpNotification, type AgentHostDebugLogsArtifactKind, type IAgentHostDebugLogsArtifact, type IAgentHostDebugLogsChunk } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
 import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
 import type { IActiveSubscriptionInfo, IAgentSubscription } from "../../../../platform/agentHost/common/state/agentSubscription.js";
-import type { CompletionsParams, CompletionsResult, CreateTerminalParams, ResolveSessionConfigResult, SessionConfigCompletionsResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import type { CompletionsParams, CompletionsResult, ContentEncoding, CreateTerminalParams, ResolveSessionConfigResult, SessionConfigCompletionsResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands";
-import type { ActionEnvelope, INotification, IRootConfigChangedAction, SessionAction, TerminalAction, ClientAnnotationsAction } from "../../../../platform/agentHost/common/state/sessionActions.js";
+import type { FetchAutomationRunsParams, FetchAutomationRunsResult, ListAutomationTriggerDefinitionsParams, ListAutomationTriggerDefinitionsResult, RunAutomationParams, RunAutomationResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/commands";
+import type { ActionEnvelope, ChatAction, ClientAnnotationsAction, ClientAutomationAction, ClientAutomationRunAction, ClientChangesetAction, INotification, IRootConfigChangedAction, SessionAction, TerminalAction } from "../../../../platform/agentHost/common/state/sessionActions.js";
 import type { IRemoteWatchHandle } from "../../../../platform/agentHost/common/agentHostFileSystemProvider.js";
 import type { CreateResourceWatchParams, CreateResourceWatchResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMkdirParams, ResourceMkdirResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceResolveParams, ResourceResolveResult, ResourceWriteParams, ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
 import { ComponentToState, RootState, StateComponents } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import type { InitializeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
 import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IAgentHostFileSystemService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service";
 /**
  * Connects the renderer to the agent host that the remote server has
  * already started, by proxying AHP frames over the remote agent's IPC pipe.
@@ -24,6 +28,7 @@ import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/work
  * the agent host is owned by whoever spawned it on the remote.
  */
 export declare class EditorRemoteAgentHostServiceClient extends Disposable implements IAgentHostService {
+    private readonly _remoteAgentService;
     private readonly _logService;
     readonly _serviceBrand: undefined;
     private readonly _onAgentHostExit;
@@ -34,16 +39,19 @@ export declare class EditorRemoteAgentHostServiceClient extends Disposable imple
     readonly authenticationPending: IObservable<boolean>;
     private _authenticationSettled;
     private readonly _protocolClient;
+    get resourceUris(): import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri").IAgentHostResourceUriMapper;
     private readonly _noopRootState;
     private _connectStarted;
-    constructor(remoteAgentService: IRemoteAgentService, configurationService: IConfigurationService, instantiationService: IInstantiationService, _logService: ILogService);
+    constructor(_remoteAgentService: IRemoteAgentService, agentHostEnablementService: IAgentHostEnablementService, instantiationService: IInstantiationService, _logService: ILogService, environmentService: IWorkbenchEnvironmentService, agentHostFileSystemService: IAgentHostFileSystemService);
     private _connect;
     private _requireClient;
     setAuthenticationPending(pending: boolean): void;
+    startAgentHost(): void;
     restartAgentHost(): Promise<void>;
     startWebSocketServer(): Promise<IAgentHostSocketInfo>;
     getInspectInfo(_tryEnable: boolean): Promise<IAgentHostInspectInfo | undefined>;
     get clientId(): string;
+    get initializeResult(): IObservable<InitializeResult | undefined>;
     get rootState(): IAgentSubscription<RootState>;
     get onDidNotification(): Event<INotification>;
     get onDidAction(): Event<ActionEnvelope>;
@@ -52,23 +60,33 @@ export declare class EditorRemoteAgentHostServiceClient extends Disposable imple
     getSubscriptionUnmanaged<T extends StateComponents>(kind: T, resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
     getInflightSessionCreate(resource: URI): Promise<unknown> | undefined;
     getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
-    dispatch(channel: string, action: SessionAction | TerminalAction | ClientAnnotationsAction | IRootConfigChangedAction): void;
+    dispatch(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | ClientAutomationAction | ClientAutomationRunAction | IRootConfigChangedAction): void;
     authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
+    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>;
+    /** Unwraps the shared client's resource URIs to retain the translated remote workspace identities. */
     listSessions(): Promise<IAgentSessionMetadata[]>;
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
     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>;
     getCompletionTriggerCharacters(): Promise<readonly string[]>;
     disposeSession(session: URI): Promise<void>;
-    createChat(session: URI, chat: URI, options?: IAgentCreateChatOptions): Promise<void>;
+    createChat(session: URI, chat: URI, options?: IAgentCreateChatRequestOptions): Promise<void>;
     disposeChat(chat: URI): Promise<void>;
     createTerminal(params: CreateTerminalParams): Promise<void>;
     disposeTerminal(terminal: URI): Promise<void>;
     invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
     handleMcpRequest(channel: string, method: string, params: Record<string, unknown> | undefined): Promise<unknown>;
     resourceList(uri: URI): Promise<ResourceListResult>;
-    resourceRead(uri: URI): Promise<ResourceReadResult>;
+    resourceRead(uri: URI, encoding?: ContentEncoding): Promise<ResourceReadResult>;
     resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
     resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
     resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;