@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionService.js

@@ -0,0 +1,400 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAgentHostConnectionsService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service';
+import { remoteAgentHostSessionTypeId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
+import { agentHostAuthority, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { readAgentHostResources } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/vscode/agentHostResources';
+import { supportsRemoteSessions, withRemoteSessionOrigin, toRemoteSessionMessageMetadata } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/vscode/agentRemoteSessionMeta';
+import { buildOpenSessionLinkUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/openSessionLink';
+import { PolicyState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import { withSessionCreationReference } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+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 { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { getRegisteredLanguageModels, getVisibleLanguageModelsForTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/modelSelection';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { SessionTypeAuthRequirement } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { areRemoteSessionToolsEnabled, remoteSessionHostRejections } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions';
+import { resolveRemoteSessionSource, assertRemoteSessionSource } from './remoteSessionSource.js';
+import { IRemoteSessionChatService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/browser/remoteSessionChatService.service';
+
+const maxRemoteSessionCreations = 500;
+const maxRemoteSessionDepth = 10;
+let RemoteSessionService = class RemoteSessionService {
+    constructor(
+        providersService,
+        sessionsService,
+        connectionsService,
+        configurationService,
+        fileService,
+        workspaceTrustService,
+        logService,
+        backgroundChats,
+        languageModelsService,
+        chatSessionsService
+    ) {
+        this.providersService = providersService;
+        this.sessionsService = sessionsService;
+        this.connectionsService = connectionsService;
+        this.configurationService = configurationService;
+        this.fileService = fileService;
+        this.workspaceTrustService = workspaceTrustService;
+        this.logService = logService;
+        this.backgroundChats = backgroundChats;
+        this.languageModelsService = languageModelsService;
+        this.chatSessionsService = chatSessionsService;
+        this.pendingCreations = ( new Map());
+        this.lastSelected = ( new Map());
+        this.requests = ( new Map());
+        this.selectionSequence = 0;
+    }
+    listHosts() {
+        this.checkEnabled();
+        return this.remoteProviders().map(provider => this.describeHost(provider));
+    }
+    createSession(options, source, requestId, token) {
+        this.checkEnabled();
+        const key = JSON.stringify([( source.toString()), requestId]);
+        const input = JSON.stringify(options);
+        const previous = this.requests.get(key);
+        if (previous) {
+            if (previous.input !== input) {
+                throw ( new Error(( localize(
+                    5566,
+                    "A remote session creation request cannot be retried with different arguments."
+                ))));
+            }
+            return previous.result;
+        }
+        if (this.requests.size >= maxRemoteSessionCreations) {
+            throw ( new Error(( localize(
+                5567,
+                "Remote session creation limit reached ({0} requests per window).",
+                maxRemoteSessionCreations
+            ))));
+        }
+        const result = this.doCreateSession(options, source, token);
+        this.requests.set(key, {
+            input,
+            result
+        });
+        return result;
+    }
+    checkEnabled() {
+        if (!areRemoteSessionToolsEnabled(this.configurationService)) {
+            throw ( new Error(( localize(5568, "Remote session tools are disabled."))));
+        }
+    }
+    remoteProviders() {
+        return this.providersService.getProviders().filter(isAgentHostProvider).filter(provider => provider.remoteAddress !== undefined);
+    }
+    describeHost(provider) {
+        const status = provider.connectionStatus?.get().kind ?? "disconnected";
+        const root = status === "connected" ? provider.getRootState() : undefined;
+        const agents = root?.agents.filter(agent => ( provider.sessionTypes.some(
+            type => type.chatSessionType === remoteAgentHostSessionTypeId(agentHostAuthority(provider.remoteAddress), agent.provider) && type.authRequirement !== SessionTypeAuthRequirement.Unusable
+        ))) ?? [];
+        const allModels = getRegisteredLanguageModels(this.languageModelsService);
+        const workspaces = ( new Map());
+        for (const session of provider.getSessions()) {
+            const workspace = session.workspace.get();
+            if (workspace) {
+                workspaces.set(( workspace.uri.toString()), {
+                    uri: ( workspace.uri.toString()),
+                    label: workspace.label
+                });
+            }
+        }
+        return {
+            id: provider.id,
+            label: provider.label,
+            status,
+            supportsRemoteSessions: root ? supportsRemoteSessions(root) : null,
+            resources: readAgentHostResources(root),
+            runningSessions: root?.activeSessions !== undefined && Number.isSafeInteger(root.activeSessions) && root.activeSessions >= 0 ? root.activeSessions : undefined,
+            pendingCreations: this.pendingCreations.get(provider.id) ?? 0,
+            agents: agents.map(agent => {
+                const target = remoteAgentHostSessionTypeId(agentHostAuthority(provider.remoteAddress), agent.provider);
+                const visibleModels = ( new Set(
+                    getVisibleLanguageModelsForTarget(allModels, target, this.languageModelsService).map(model => model.identifier)
+                ));
+                return {
+                    provider: agent.provider,
+                    models: agent.models.filter(model => model.policyState !== PolicyState.Disabled && ( visibleModels.has(`${target}:${model.id}`))).map(model => ({
+                        id: model.id,
+                        name: model.name
+                    }))
+                };
+            }),
+            workspaces: [...( workspaces.values())]
+        };
+    }
+    getCandidate(provider, options) {
+        const connection = this.connectionsService.getConnectionByAddress(provider.remoteAddress);
+        const host = this.describeHost(provider);
+        const reasons = remoteSessionHostRejections(host, options);
+        if (reasons.length) {
+            return {
+                reasons
+            };
+        }
+        if (!connection) {
+            reasons.push(( localize(5569, "The host connection is not available.")));
+        }
+        if (provider.hostGroup?.connectable === false) {
+            reasons.push(( localize(5570, "This host is dedicated to an existing session.")));
+        }
+        const authority = agentHostAuthority(provider.remoteAddress);
+        const workspace = options.workspace?.uri.scheme === AGENT_HOST_SCHEME ? options.workspace.uri : options.workspace ? provider.mapAgentHostResource(options.workspace.uri) : undefined;
+        if (workspace && workspace.authority !== authority) {
+            reasons.push(( localize(5571, "The workspace belongs to a different host.")));
+        }
+        if (!workspace && !provider.supportsQuickChats) {
+            reasons.push(( localize(5572, "The host does not support workspace-less sessions.")));
+        }
+        const types = workspace ? provider.getSessionTypes(workspace) : provider.sessionTypes;
+        const agent = host.agents.find(agent => {
+            const target = remoteAgentHostSessionTypeId(authority, agent.provider);
+            return (options.model === undefined || options.model.provider === agent.provider) && (agent.models.length > 0 || this.chatSessionsService.supportsAutoModelForSessionType(target)) && ( types.some(
+                type => type.chatSessionType === target && (!workspace || type.supportsWorktreeConfiguration === true)
+            ));
+        });
+        const sessionType = agent && types.find(
+            type => type.chatSessionType === remoteAgentHostSessionTypeId(authority, agent.provider)
+        );
+        if (!sessionType) {
+            reasons.push(( localize(
+                5573,
+                "No agent supports the requested workspace and isolation with an available model or Auto fallback."
+            )));
+        }
+        if (reasons.length || !sessionType || !agent || !connection) {
+            return {
+                reasons
+            };
+        }
+        return {
+            candidate: {
+                provider,
+                connection,
+                clientId: connection.clientId,
+                host,
+                sessionType,
+                agentProvider: agent.provider,
+                workspace,
+                modelIdentifier: options.model ? `${remoteAgentHostSessionTypeId(authority, agent.provider)}:${options.model.id}` : undefined
+            },
+            reasons
+        };
+    }
+    assertTargetConnection(candidate) {
+        const connection = this.connectionsService.getConnectionByAddress(candidate.provider.remoteAddress);
+        if (!this.remoteProviders().includes(candidate.provider) || candidate.provider.connectionStatus?.get().kind !== "connected" || connection !== candidate.connection || connection?.clientId !== candidate.clientId) {
+            throw ( new Error(( localize(
+                5574,
+                "Remote agent host {0} connection changed during session creation.",
+                candidate.host.label
+            ))));
+        }
+    }
+    async candidates(options, token) {
+        const rejected = [];
+        const candidates = await Promise.all(this.remoteProviders().map(async provider => {
+            const {
+                candidate,
+                reasons
+            } = this.getCandidate(provider, options);
+            if (candidate?.workspace) {
+                try {
+                    const [stat, trust] = await raceCancellationError(Promise.all([
+                        this.fileService.stat(candidate.workspace),
+                        this.workspaceTrustService.getUriTrustInfo(candidate.workspace)
+                    ]), token);
+                    if (!stat.isDirectory) {
+                        reasons.push(( localize(5575, "The workspace is not a directory.")));
+                    }
+                    if (!trust.trusted) {
+                        reasons.push(( localize(
+                            5576,
+                            "The workspace is not trusted. Trust it before starting an unattended session."
+                        )));
+                    }
+                } catch (error) {
+                    if (token.isCancellationRequested) {
+                        throw ( new CancellationError());
+                    }
+                    this.logService.warn(`[RemoteSessions] Could not inspect workspace on ${provider.id}`, error);
+                    reasons.push(( localize(5577, "Workspace inspection failed: {0}", toErrorMessage(error))));
+                }
+            }
+            if (reasons.length || !candidate) {
+                rejected.push({
+                    hostId: provider.id,
+                    reasons
+                });
+                return undefined;
+            }
+            return candidate;
+        }));
+        const eligible = candidates.filter(candidate => candidate !== undefined);
+        if (!eligible.length) {
+            throw ( new Error(( localize(
+                5578,
+                "No connected remote agent host matches this request. {0}",
+                JSON.stringify(rejected)
+            ))));
+        }
+        return eligible;
+    }
+    async doCreateSession(options, sourceResource, token) {
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        const source = await resolveRemoteSessionSource(sourceResource, this.sessionsService, this.connectionsService, token);
+        const depth = source.depth + 1;
+        if (depth > maxRemoteSessionDepth) {
+            throw ( new Error(( localize(
+                5579,
+                "Remote session recursion limit reached (maximum depth {0}).",
+                maxRemoteSessionDepth
+            ))));
+        }
+        const candidates = await this.candidates(options, token);
+        this.checkEnabled();
+        assertRemoteSessionSource(source, this.sessionsService, this.connectionsService);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        const load = candidate => (candidate.provider.getRootState()?.activeSessions ?? Number.POSITIVE_INFINITY) + (this.pendingCreations.get(candidate.host.id) ?? 0);
+        candidates.sort(
+            (a, b) => load(a) - load(b) || (this.lastSelected.get(a.host.id) ?? 0) - (this.lastSelected.get(b.host.id) ?? 0) || a.host.id.localeCompare(b.host.id)
+        );
+        const selected = candidates[0];
+        this.assertTargetConnection(selected);
+        const {
+            candidate: target,
+            reasons
+        } = this.getCandidate(selected.provider, options);
+        if (!target) {
+            throw ( new Error(( localize(
+                5580,
+                "Remote agent host {0} no longer matches this request. {1}",
+                selected.host.label,
+                JSON.stringify(reasons)
+            ))));
+        }
+        if (!isEqual(target.workspace, selected.workspace)) {
+            throw ( new Error(( localize(
+                5581,
+                "Remote agent host {0} workspace changed during session creation.",
+                target.host.label
+            ))));
+        }
+        const pendingCreations = this.pendingCreations.get(target.host.id) ?? 0;
+        const runningSessions = target.host.runningSessions;
+        if (runningSessions === undefined) {
+            throw ( new Error(( localize(
+                5582,
+                "Remote agent host {0} no longer reports its workload.",
+                target.host.label
+            ))));
+        }
+        this.pendingCreations.set(target.host.id, pendingCreations + 1);
+        this.lastSelected.set(target.host.id, ++this.selectionSequence);
+        let background;
+        try {
+            const origin = {
+                session: ( source.session.resource.toString()),
+                chat: ( source.chat.resource.toString()),
+                depth
+            };
+            const metadata = withSessionCreationReference(withRemoteSessionOrigin(undefined, origin), {
+                session: origin.session,
+                chat: origin.chat
+            });
+            const createOptions = {
+                providerId: target.provider.id,
+                sessionTypeId: target.sessionType.id,
+                modelId: target.modelIdentifier,
+                metadata,
+                onSessionCreated: async session => {
+                    background = await this.backgroundChats.acquire(session.mainChat.get().resource, token);
+                    this.checkEnabled();
+                    assertRemoteSessionSource(source, this.sessionsService, this.connectionsService);
+                    this.assertTargetConnection(target);
+                },
+                ...(options.workspace ? {
+                    isolationMode: options.workspace.isolation === "folder" ? "workspace" : "worktree",
+                    branch: options.workspace.branch
+                } : {})
+            };
+            const request = {
+                query: options.prompt,
+                metadata: toRemoteSessionMessageMetadata(origin),
+                title: options.title,
+                background: true
+            };
+            const created = target.workspace ? await this.sessionsService.createAndSendNewChatRequest(target.workspace, request, createOptions, token) : await this.sessionsService.createAndSendQuickChatRequest(request, createOptions, token);
+            if (!created) {
+                throw ( new Error(( localize(
+                    5583,
+                    "Remote session creation ended without a committed session. Do not retry automatically."
+                ))));
+            }
+            background?.releaseWhenIdle();
+            background = undefined;
+            const chat = created.mainChat.get();
+            const worktreePending = created.worktreePending?.get() === true;
+            const folder = created.workspace.get()?.folders[0];
+            const selectedModelId = chat.modelId.get() ?? created.modelId.get();
+            const modelId = options.model?.id ?? (selectedModelId ? target.provider.getModelsSnapshot(created.sessionId).models.find(model => model.identifier === selectedModelId)?.metadata.id : undefined);
+            return {
+                status: "started",
+                session: ( created.resource.toString()),
+                chat: ( chat.resource.toString()),
+                openLink: buildOpenSessionLinkUri(created.resource, chat.resource.fragment),
+                host: {
+                    id: target.host.id,
+                    label: target.host.label
+                },
+                model: {
+                    provider: target.agentProvider,
+                    id: modelId ?? null
+                },
+                workspace: target.workspace && options.workspace ? {
+                    requestedUri: ( target.workspace.toString()),
+                    uri: !worktreePending && folder ? ( folder.workingDirectory.toString()) : null,
+                    isolation: options.workspace.isolation,
+                    branch: !worktreePending ? folder?.gitRepository?.branchName : undefined,
+                    baseBranch: !worktreePending ? folder?.gitRepository?.baseBranchName : undefined,
+                    worktreePending
+                } : null,
+                placement: {
+                    runningSessions,
+                    pendingCreations
+                }
+            };
+        } finally {
+            background?.dispose();
+            const remaining = (this.pendingCreations.get(target.host.id) ?? 1) - 1;
+            if (remaining) {
+                this.pendingCreations.set(target.host.id, remaining);
+            } else {
+                this.pendingCreations.delete(target.host.id);
+            }
+        }
+    }
+};
+RemoteSessionService = ( __decorate([( __param(0, ISessionsProvidersService)), ( __param(1, ISessionsManagementService)), ( __param(2, IAgentHostConnectionsService)), ( __param(3, IConfigurationService)), ( __param(4, IFileService)), ( __param(5, IWorkspaceTrustManagementService)), ( __param(6, ILogService)), ( __param(7, IRemoteSessionChatService)), ( __param(8, ILanguageModelsService)), ( __param(9, IChatSessionsService))], RemoteSessionService));
+
+export { RemoteSessionService };

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionSource.d.ts

@@ -0,0 +1,28 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostSessionIdentity, IAgentHostSessionResolution } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { IRemoteSessionOrigin } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/agentRemoteSessionMeta";
+import { IAgentSubscription } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/agentSubscription";
+import { IChat, ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+export interface IRemoteSessionChat {
+    readonly session: ISession;
+    readonly chat: IChat;
+    readonly host: IAgentHostSessionResolution;
+    readonly clientId: string;
+}
+export interface IRemoteSessionSource extends IRemoteSessionChat {
+    readonly depth: number;
+    readonly origin: IRemoteSessionOrigin | undefined;
+}
+export declare function assertRemoteSessionCaller(resource: URI): void;
+export declare function resolveRemoteSessionReference(reference: string, connectionsService: IAgentHostConnectionsService): {
+    resource: URI;
+    identity: IAgentHostSessionIdentity;
+};
+export declare function resolveRemoteSessionChat(resource: URI, sessionsService: ISessionsManagementService, connectionsService: IAgentHostConnectionsService): IRemoteSessionChat;
+export declare function assertRemoteSessionSource(source: IRemoteSessionChat, sessionsService: ISessionsManagementService, connectionsService: IAgentHostConnectionsService): void;
+/** Resolves the caller's exact chat and persisted cumulative depth without retaining a subscription. */
+export declare function resolveRemoteSessionSource(sourceResource: URI, sessionsService: ISessionsManagementService, connectionsService: IAgentHostConnectionsService, token: CancellationToken): Promise<IRemoteSessionSource>;
+export declare function readRemoteSessionState<T>(subscription: IAgentSubscription<T>, token: CancellationToken, verifiedOnly?: boolean): Promise<T>;

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionSource.js

@@ -0,0 +1,178 @@
+
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { readRemoteSessionOrigin, readRemoteSessionDepth } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/meta/vscode/agentRemoteSessionMeta';
+import { AGENT_HOST_SESSION_LINK_SCHEME, parseOpenSessionLinkUri, parseOpenSessionLinkChatId, parseOpenSessionLinkConnectionAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/openSessionLink';
+import { DEFAULT_CHAT_ID, StateComponents, getSessionChatResource, parseChatUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { isAgentHostSessionResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+function assertRemoteSessionCaller(resource) {
+    if (!isAgentHostSessionResource(resource)) {
+        throw ( new Error(( localize(
+            5584,
+            "Remote delegation requires an originating chat on an Agent Host. Other chat providers are not supported."
+        ))));
+    }
+}
+function resolveRemoteSessionReference(reference, connectionsService) {
+    let resource = ( URI.parse(reference, true));
+    if (resource.scheme === AGENT_HOST_SESSION_LINK_SCHEME) {
+        const session = parseOpenSessionLinkUri(resource);
+        const chatId = parseOpenSessionLinkChatId(resource);
+        const parameters = ( new URLSearchParams(resource.query));
+        if (!session || resource.fragment || parameters.getAll("chat").length > 1 || ( [...( parameters.keys())].some(
+            key => key !== "chat" && key !== "turn" && key !== "session" && key !== "connectionAuthority"
+        )) || (( parameters.has("chat")) && !chatId && parameters.get("chat") !== DEFAULT_CHAT_ID)) {
+            throw ( new Error(( localize(5585, "The remote session link is invalid."))));
+        }
+        const authority = parseOpenSessionLinkConnectionAuthority(resource);
+        const qualified = authority ? connectionsService.findSessionResource(session, authority) : session;
+        if (!qualified) {
+            throw ( new Error(( localize(
+                5586,
+                "Use an exact host-qualified session or chat reference returned by the remote session tools."
+            ))));
+        }
+        resource = qualified.with({
+            fragment: chatId ?? ""
+        });
+    }
+    const identity = connectionsService.resolveSessionResourceIdentity(resource.with({
+        fragment: ""
+    }));
+    if (!resource.path.startsWith("/") || resource.path.length === 1 || !identity || ((resource.authority || resource.query) && !identity.backendSessionIsAdvertised)) {
+        throw ( new Error(( localize(
+            5586,
+            "Use an exact host-qualified session or chat reference returned by the remote session tools."
+        ))));
+    }
+    return {
+        resource: resource.fragment === DEFAULT_CHAT_ID ? resource.with({
+            fragment: ""
+        }) : resource,
+        identity
+    };
+}
+function resolveRemoteSessionChat(resource, sessionsService, connectionsService) {
+    const context = sessionsService.getSessionForChatResource(resource);
+    const session = context?.session ?? (!resource.fragment ? sessionsService.getSession(resource) : undefined);
+    const chat = context?.chat ?? session?.mainChat.get();
+    if (!session || !chat) {
+        throw ( new Error(( localize(
+            5587,
+            "The exact session or chat is no longer available: {0}",
+            (resource.toString())
+        ))));
+    }
+    const host = connectionsService.resolveSessionResource(session.resource);
+    const root = host?.connection.rootState.value;
+    if (!host || !root || root instanceof Error) {
+        throw ( new Error(( localize(
+            5588,
+            "The agent host for {0} is not registered and connected in this Agents window.",
+            (resource.toString())
+        ))));
+    }
+    return {
+        session,
+        chat,
+        host,
+        clientId: host.connection.clientId
+    };
+}
+function assertRemoteSessionSource(source, sessionsService, connectionsService) {
+    const current = resolveRemoteSessionChat(source.chat.resource, sessionsService, connectionsService);
+    if (current.host.connection !== source.host.connection || current.clientId !== source.clientId || current.host.connectionAuthority !== source.host.connectionAuthority || !isEqual(current.host.backendSession, source.host.backendSession) || !isEqual(current.chat.resource, source.chat.resource)) {
+        throw ( new Error(( localize(5589, "The originating chat or agent host connection changed."))));
+    }
+}
+async function resolveRemoteSessionSource(sourceResource, sessionsService, connectionsService, token) {
+    if (token.isCancellationRequested) {
+        throw ( new CancellationError());
+    }
+    assertRemoteSessionCaller(sourceResource);
+    const source = resolveRemoteSessionChat(sourceResource, sessionsService, connectionsService);
+    const store = ( new DisposableStore());
+    let failure;
+    try {
+        const cancellation = store.add(( new CancellationTokenSource(token)));
+        store.add(disposableTimeout(() => {
+            failure = ( new Error(( localize(5590, "Timed out reading the originating session's state."))));
+            cancellation.cancel();
+        }, 10_000));
+        const checkSource = () => assertRemoteSessionSource(source, sessionsService, connectionsService);
+        store.add(connectionsService.onDidChangeConnections(() => {
+            try {
+                checkSource();
+            } catch (error) {
+                failure = error instanceof Error ? error : ( new Error(toErrorMessage(error)));
+                cancellation.cancel();
+            }
+        }));
+        const subscription = store.add(
+            source.host.connection.getSubscription(StateComponents.Session, source.host.backendSession, "RemoteSessionSource")
+        );
+        const state = await readRemoteSessionState(subscription.object, cancellation.token);
+        if (cancellation.token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        checkSource();
+        const chatResource = getSessionChatResource(state, source.chat.resource.fragment || DEFAULT_CHAT_ID);
+        const identity = chatResource ? parseChatUri(chatResource) : undefined;
+        if (!identity || !isEqual(( URI.parse(identity.session)), source.host.backendSession)) {
+            throw ( new Error(( localize(5591, "The exact originating chat no longer exists on its agent host."))));
+        }
+        return {
+            ...source,
+            depth: readRemoteSessionDepth(state),
+            origin: readRemoteSessionOrigin(state)
+        };
+    } catch (error) {
+        throw failure ?? error;
+    } finally {
+        store.dispose();
+    }
+}
+function readRemoteSessionState(subscription, token, verifiedOnly = false) {
+    if (token.isCancellationRequested) {
+        return Promise.reject(( new CancellationError()));
+    }
+    const read = () => subscription.value instanceof Error ? subscription.value : verifiedOnly ? subscription.verifiedValue : subscription.value;
+    const value = read();
+    if (value !== undefined) {
+        return value instanceof Error ? Promise.reject(value) : Promise.resolve(value);
+    }
+    const changed = Event.any(
+        Event.map(subscription.onDidChange, () => undefined),
+        Event.map(subscription.onDidError ?? Event.None, () => undefined)
+    );
+    return ( new Promise((resolve, reject) => {
+        const store = ( new DisposableStore());
+        const check = () => {
+            const value = read();
+            if (token.isCancellationRequested) {
+                store.dispose();
+                reject(( new CancellationError()));
+            } else if (value !== undefined) {
+                store.dispose();
+                if (value instanceof Error) {
+                    reject(value);
+                } else {
+                    resolve(value);
+                }
+            }
+        };
+        store.add(changed(check));
+        store.add(token.onCancellationRequested(check));
+        check();
+    }));
+}
+
+export { assertRemoteSessionCaller, assertRemoteSessionSource, readRemoteSessionState, resolveRemoteSessionChat, resolveRemoteSessionReference, resolveRemoteSessionSource };

package/vscode/src/vs/sessions/contrib/remoteSessions/browser/remoteSessionTools.d.ts

@@ -0,0 +1,17 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { IRemoteSessionService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/remoteSessions/common/remoteSessions.service";
+export declare class ListAgentHostsTool implements IToolImpl {
+    private readonly remoteSessionsService;
+    constructor(remoteSessionsService: IRemoteSessionService);
+    getToolData(): IToolData;
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation>;
+    invoke(_invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}
+export declare class CreateRemoteSessionTool implements IToolImpl {
+    private readonly remoteSessionsService;
+    constructor(remoteSessionsService: IRemoteSessionService);
+    getToolData(): IToolData;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}