@codingame/monaco-vscode-chat-service-override 37.3.3 → 37.3.5

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxReadOnlySessionHandler.d.ts

@@ -1,45 +0,0 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ICloudSandboxApiService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service";
-import { IReplayedTaskHistory } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/taskEventReplay";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IChatSession, IChatSessionContentProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
-export interface ICloudSandboxReadOnlyConfig {
-    /** Mission Control task owning the session, which is what persisted history is addressed by. */
-    readonly taskId: string;
-    /** Chat participant id. Matches the live handler, where `agentId === sessionType`. */
-    readonly agentId: string;
-    /** Sanitized agent-host authority used to rewrite resource URIs in history. */
-    readonly connectionAuthority: string;
-    /**
-     * History already in flight, so the first open does not repeat a fetch running alongside the
-     * connect. Consumed once; later opens read afresh so a stale prefetch cannot pin the transcript.
-     */
-    readonly prefetchedHistory?: Promise<IReplayedTaskHistory | undefined>;
-}
-/**
- * Content provider for cloud sandbox sessions served from Mission Control's persisted history
- * rather than a live host — a dormant environment, or one whose connect failed.
- *
- * Registered only while no connection exists, and disposed as soon as one is established, so it
- * never shadows the live handler.
- */
-export declare class CloudSandboxReadOnlySessionHandler extends Disposable implements IChatSessionContentProvider {
-    private readonly _config;
-    private readonly _apiService;
-    private readonly _logService;
-    /** Cleared on first use, so only the opening read benefits from work already in flight. */
-    private _prefetchedHistory;
-    /**
-     * Starts `false`: an environment that goes on to wake must not have been shown as read-only.
-     * Observable so an already-rendered session can be settled in place by {@link markReadOnly}.
-     */
-    private readonly _isReadOnly;
-    constructor(_config: ICloudSandboxReadOnlyConfig, _apiService: ICloudSandboxApiService, _logService: ILogService);
-    /** Settle as read-only once the connect has failed; open sessions disable their composer. */
-    markReadOnly(): void;
-    /** Persisted history, preferring a prefetch already in flight over a fresh read. */
-    private _readHistory;
-    provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
-}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxReadOnlySessionHandler.js

@@ -1,109 +0,0 @@
-
-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 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
-import { ICloudSandboxApiService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost.service';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { turnsToHistory, messageToRequestOrigin, messageToVariableData, activeTurnToProgress } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/stateToProgressAdapter';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-
-const LOG_PREFIX = "[CloudSandboxReadOnly]";
-class ReadOnlyChatSession extends Disposable {
-    constructor(sessionResource, history, title, isReadOnly) {
-        super();
-        this.sessionResource = sessionResource;
-        this.history = history;
-        this.title = title;
-        this.isReadOnly = isReadOnly;
-        this._onWillDispose = this._register(( new Emitter()));
-        this.onWillDispose = this._onWillDispose.event;
-    }
-    dispose() {
-        this._onWillDispose.fire();
-        super.dispose();
-    }
-}
-let CloudSandboxReadOnlySessionHandler = class CloudSandboxReadOnlySessionHandler extends Disposable {
-    constructor(_config, _apiService, _logService) {
-        super();
-        this._config = _config;
-        this._apiService = _apiService;
-        this._logService = _logService;
-        this._isReadOnly = observableValue("cloudSandboxReadOnly", false);
-        this._prefetchedHistory = _config.prefetchedHistory;
-    }
-    markReadOnly() {
-        this._isReadOnly.set(true, undefined);
-    }
-    async _readHistory(token) {
-        const prefetched = this._prefetchedHistory;
-        this._prefetchedHistory = undefined;
-        if (prefetched) {
-            const replayed = await prefetched;
-            if (replayed) {
-                return replayed;
-            }
-        }
-        return this._apiService.getSessionHistory(this._config.taskId, token);
-    }
-    async provideChatSessionContent(sessionResource, token) {
-        const sessionId = AgentSession.id(sessionResource);
-        const replayed = await this._readHistory(token);
-        const session = replayed?.sessions.find(s => AgentSession.id(( URI.parse(s.session))) === sessionId);
-        if (!session) {
-            this._logService.warn(
-                `${LOG_PREFIX} No persisted history for session ${sessionId} in task ${this._config.taskId} (replayed sessions: [${replayed?.sessions.map(s => s.session).join(", ") ?? "none"}]); opening an empty read-only session.`
-            );
-            return ( new ReadOnlyChatSession(sessionResource, [], undefined, this._isReadOnly));
-        }
-        const chat = session.chats.get(session.defaultChat) ?? [...( session.chats.values())][0];
-        const history = chat ? turnsToHistory(( URI.parse(session.session)), chat.turns, this._config.agentId, this._config.connectionAuthority, undefined, undefined, undefined, undefined, this._config.agentId) : [];
-        const active = chat?.activeTurn;
-        if (active) {
-            history.push({
-                id: active.id,
-                type: "request",
-                prompt: active.message.text,
-                participant: this._config.agentId,
-                variableData: messageToVariableData(active.message, this._config.connectionAuthority),
-                origin: messageToRequestOrigin(( URI.parse(session.session)), active.message, this._config.agentId, this._config.agentId)
-            });
-            history.push({
-                type: "response",
-                parts: activeTurnToProgress(( URI.parse(session.session)), active, this._config.connectionAuthority, sessionResource.authority),
-                participant: this._config.agentId
-            });
-        }
-        if (replayed?.truncated) {
-            this._logService.warn(
-                `${LOG_PREFIX} History for task ${this._config.taskId} is truncated; the final exchange may be incomplete.`
-            );
-            history.push({
-                type: "response",
-                parts: [{
-                    kind: "warning",
-                    content: ( new MarkdownString(( localize(
-                        4265,
-                        "This conversation is incomplete. Its recorded history ends mid-response, so the last exchange may be missing."
-                    ))))
-                }],
-                participant: this._config.agentId
-            });
-        }
-        this._logService.info(`${LOG_PREFIX} Opened ${( sessionResource.toString())} read-only with ${history.length} history item(s) from ${chat?.turns.length ?? 0} turn(s); chats=[${[...( session.chats.keys())].join(", ")}], default=${session.defaultChat}.`);
-        return ( new ReadOnlyChatSession(
-            sessionResource,
-            history,
-            session.state.title || undefined,
-            this._isReadOnly
-        ));
-    }
-};
-CloudSandboxReadOnlySessionHandler = ( __decorate([( __param(1, ICloudSandboxApiService)), ( __param(2, ILogService))], CloudSandboxReadOnlySessionHandler));
-
-export { CloudSandboxReadOnlySessionHandler };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxSessionsProvider.d.ts

@@ -1,49 +0,0 @@
-import { type IAgentSessionMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
-import type { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
-import { RemoteAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider";
-/**
- * Sessions provider for a Copilot cloud sandbox.
- *
- * Adds the handling for sessions this client provisioned but the host has not materialized yet:
- * Mission Control mints the session id and returns it before the sandbox is even awake, so such a
- * session is real, addressable, and unknown to the host all at once.
- */
-export declare class CloudSandboxSessionsProvider extends RemoteAgentHostSessionsProvider {
-    /**
-     * Provisional sessions kept out of {@link getSessions} because the caller is still showing a
-     * placeholder row for them. They stay reachable by resource, so opening one still works.
-     */
-    private readonly _withheldSessions;
-    /**
-     * Raw id → deadline after which eviction resumes, or `undefined` while the clock has not
-     * started. It starts when a connected host first omits the session, not at seed time, because
-     * waking a sandbox can take minutes.
-     */
-    private readonly _provisionalSessions;
-    /** How long a provisional session resists eviction after the host first omits it. */
-    static readonly PROVISIONAL_GRACE_MS: number;
-    /**
-     * Seed a session this client just provisioned. It is cached so a later discovery pass
-     * reconciles against it rather than adding a second entry, but stays out of the sessions list
-     * until {@link publishWithheldSession} and resists eviction until the host lists it.
-     */
-    seedProvisionalSession(rawMeta: IAgentSessionMetadata): void;
-    /**
-     * Reveal a session seeded by {@link seedProvisionalSession}, so {@link getSessions} returns it.
-     *
-     * Pass `announce: false` when the caller immediately fires its own change event covering this
-     * session: the list re-reads {@link getSessions} on any change, so a single event can both drop
-     * a placeholder row and reveal this one.
-     */
-    publishWithheldSession(rawId: string, options?: {
-        announce?: boolean;
-    }): void;
-    /**
-     * Look up a cached session by raw id, **including** ones withheld from {@link getSessions},
-     * which callers that seeded a session need before it is listed.
-     */
-    getCachedSession(rawId: string): ISession | undefined;
-    getSessions(): ISession[];
-    protected _isSessionEvictable(rawId: string): boolean;
-    protected _onHostListedSessions(rawIds: ReadonlySet<string>): void;
-}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/cloudSandboxSessionsProvider.js

@@ -1,69 +0,0 @@
-
-import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
-import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
-
-class CloudSandboxSessionsProvider extends RemoteAgentHostSessionsProvider {
-    constructor() {
-        super(...arguments);
-        this._withheldSessions = ( new Set());
-        this._provisionalSessions = ( new Map());
-    }
-    static {
-        this.PROVISIONAL_GRACE_MS = 2 * 60_000;
-    }
-    seedProvisionalSession(rawMeta) {
-        const meta = this._adoptSessionMeta(rawMeta);
-        const rawId = AgentSession.id(meta.session);
-        if (( this._sessionCache.has(rawId))) {
-            return;
-        }
-        this._sessionCache.set(rawId, this.createAdapter(meta));
-        this._withheldSessions.add(rawId);
-        this._provisionalSessions.set(rawId, undefined);
-    }
-    publishWithheldSession(rawId, options) {
-        if (!this._withheldSessions.delete(rawId)) {
-            return;
-        }
-        const session = this._sessionCache.get(rawId);
-        if (session && options?.announce !== false) {
-            this._onDidChangeSessions.fire({
-                added: [session],
-                removed: [],
-                changed: []
-            });
-        }
-    }
-    getCachedSession(rawId) {
-        return this._sessionCache.get(rawId);
-    }
-    getSessions() {
-        const sessions = super.getSessions();
-        return this._withheldSessions.size === 0 ? sessions : sessions.filter(session => !( this._withheldSessions.has(AgentSession.id(session.resource))));
-    }
-    _isSessionEvictable(rawId) {
-        if (!( this._provisionalSessions.has(rawId))) {
-            return true;
-        }
-        const deadline = this._provisionalSessions.get(rawId);
-        if (deadline === undefined || Date.now() < deadline) {
-            return false;
-        }
-        this._provisionalSessions.delete(rawId);
-        return true;
-    }
-    _onHostListedSessions(rawIds) {
-        if (this._provisionalSessions.size === 0) {
-            return;
-        }
-        for (const [rawId, deadline] of [...this._provisionalSessions]) {
-            if (( rawIds.has(rawId))) {
-                this._provisionalSessions.delete(rawId);
-            } else if (deadline === undefined) {
-                this._provisionalSessions.set(rawId, Date.now() + CloudSandboxSessionsProvider.PROVISIONAL_GRACE_MS);
-            }
-        }
-    }
-}
-
-export { CloudSandboxSessionsProvider };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.d.ts

@@ -1,112 +0,0 @@
-import { type VSBufferReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
-import { type IAgentHostDebugLogsArtifact, type IAgentHostDebugLogsChunk } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
-import { type SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
-import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
-import { IFileDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { ServicesAccessor } 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 { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
-import { IAgentHostDebugLogsExportService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/exportAgentHostDebugLogsAction.service";
-/**
- * Description of the agent-host session whose logs should be exported. If
- * not provided, the action exports all agent-host-related logs for the
- * current window (no session-specific scoping or events file).
- */
-export interface IActiveAgentHostSessionForExport {
-    /** The chat session resource. */
-    readonly resource: URI;
-    /** Optional owning-session title used to namespace the default zip filename. */
-    readonly sessionTitle: string | undefined;
-    /** Optional active-chat title used to derive the default zip filename. */
-    readonly chatTitle: string | undefined;
-    /** True for local agent-host sessions (`agent-host-*` scheme). */
-    readonly isLocal: boolean;
-    /** Backend chat identifier selected within the session. */
-    readonly chatId: string;
-    /** Exact host-published backend chat resource, when already resolved by the provider. */
-    readonly backendChatResource: URI | undefined;
-}
-export type IAgentHostDebugLogFile = {
-    readonly path: string;
-    readonly contents: string;
-    readonly size: number;
-} | {
-    readonly path: string;
-    readonly resource: URI;
-    readonly size: number;
-};
-export interface IAgentHostDebugLogsExport {
-    readonly files: IAgentHostDebugLogFile[];
-    readonly hostArtifact: IAgentHostDebugLogsHostArtifact | undefined;
-}
-/**
- * A debug-log artifact produced by an agent host, paired with the means to read
- * its bytes. For a remote host the artifact lives on the remote disk, so
- * {@link readChunk} streams it over AHP in bounded slices instead of
- * materializing the whole archive in one protocol message.
- */
-export interface IAgentHostDebugLogsHostArtifact {
-    readonly artifact: IAgentHostDebugLogsArtifact;
-    readonly readChunk: (resource: URI, position: number) => Promise<IAgentHostDebugLogsChunk>;
-}
-export declare class BrowserAgentHostDebugLogsExportService implements IAgentHostDebugLogsExportService {
-    private readonly fileDialogService;
-    private readonly fileService;
-    private readonly logService;
-    readonly _serviceBrand: undefined;
-    readonly hostArtifactKind = "directory";
-    constructor(fileDialogService: IFileDialogService, fileService: IFileService, logService: ILogService);
-    selectDestination(exportName: string): Promise<URI | undefined>;
-    save(destination: URI, files: readonly IAgentHostDebugLogFile[], hostArtifact: IAgentHostDebugLogsHostArtifact | undefined): Promise<void>;
-}
-export declare function resolveAgentHostDebugLogsChat(activeSession: Pick<IActiveAgentHostSessionForExport, "backendChatResource" | "chatId" | "sessionTitle">, state: SessionState | Error | undefined): {
-    backendChat: URI | undefined;
-    sessionTitle: string | undefined;
-};
-/**
- * Streams a host-owned artifact by repeatedly calling `readChunk`. The stream
- * fails if the host overruns or underruns the size it declared, so a
- * truncated or runaway transfer can never be silently zipped up.
- */
-export declare function createHostArtifactStream(artifact: IAgentHostDebugLogsArtifact, readChunk: (position: number) => Promise<IAgentHostDebugLogsChunk>): VSBufferReadableStream;
-/**
- * Shared implementation of "Export Agent Host Debug Logs". Collects the
- * Agent Host's own debug-log bundle (collected and packaged by the host), plus
- * the logs this side owns: the window/shared-process output channels, remote
- * forwarded logs, the AHP transport JSONL logs, and the client-local capture
- * sidecars.
- *
- * Both the workbench-side action (resolves the active session via
- * `IChatWidgetService`) and the sessions-app-side action (resolves it via
- * `ISessionsManagementService`) call into this helper.
- */
-export declare function collectAgentHostDebugLogs(accessor: ServicesAccessor, activeSession: IActiveAgentHostSessionForExport | undefined, onDidCreateHostArtifact: (artifact: IAgentHostDebugLogsArtifact) => void): Promise<IAgentHostDebugLogsExport>;
-export declare function getAgentHostDebugLogsExportName(sessionTitle: string | undefined, chatTitle: string | undefined, isPrimaryChat: boolean): string;
-export declare function prepareAgentHostDebugLogsExport(selectDestination: () => Promise<URI | undefined>, collectLogs: () => Promise<IAgentHostDebugLogsExport>): Promise<[
-    PromiseSettledResult<IAgentHostDebugLogsExport>,
-    PromiseSettledResult<URI | undefined>
-]>;
-export declare function exportAgentHostDebugLogs(accessor: ServicesAccessor, activeSession: IActiveAgentHostSessionForExport | undefined): Promise<void>;
-export declare function notifyAgentHostDebugLogsExported(notificationService: INotificationService, clipboardService: IClipboardService, isInternal: boolean, savedResource: URI): void;
-/**
- * Workbench-side action. Uses the last-focused chat widget's view model to
- * find the active Copilot CLI chat session. Suitable for vscode where the
- * agents-window-specific `ISessionsManagementService` is not present.
- */
-export declare class ExportAgentHostDebugLogsAction extends Action2 {
-    static readonly ID = "workbench.action.chat.exportAgentHostDebugLogs";
-    constructor();
-    run(accessor: ServicesAccessor): Promise<void>;
-}
-/**
- * Translates a chat session URI scheme into an agent-host session context,
- * or `undefined` if the scheme does not belong to a Copilot CLI agent-host
- * session (i.e. local AH or remote AH; the EH CLI extension's own
- * `copilotcli:` sessions are excluded).
- */
-export declare function toActiveAgentHostSession(resource: URI, chatTitle: string | undefined, sessionTitle?: string): IActiveAgentHostSessionForExport | undefined;
-export declare function collectRotatedLogFiles(path: string, current: URI, fileService: IFileService, maxInlineSize?: number): Promise<IAgentHostDebugLogFile[]>;
-export declare function findOutputChannelLogFiles(windowLogsPath: URI, fileNames: ReadonlySet<string>, fileService: IFileService): Promise<URI[]>;