@codingame/monaco-vscode-xterm-common 30.0.0 → 31.0.0

package/vscode/src/vs/platform/agentHost/common/state/protocol/state.js

@@ -0,0 +1,118 @@
+
+
+var PolicyState;
+(function (PolicyState) {
+    PolicyState["Enabled"] = "enabled";
+    PolicyState["Disabled"] = "disabled";
+    PolicyState["Unconfigured"] = "unconfigured";
+})(PolicyState || (PolicyState = {}));
+var PendingMessageKind;
+(function (PendingMessageKind) {
+    PendingMessageKind["Steering"] = "steering";
+    PendingMessageKind["Queued"] = "queued";
+})(PendingMessageKind || (PendingMessageKind = {}));
+var SessionLifecycle;
+(function (SessionLifecycle) {
+    SessionLifecycle["Creating"] = "creating";
+    SessionLifecycle["Ready"] = "ready";
+    SessionLifecycle["CreationFailed"] = "creationFailed";
+})(SessionLifecycle || (SessionLifecycle = {}));
+var SessionStatus;
+(function (SessionStatus) {
+    SessionStatus[SessionStatus["Idle"] = 1] = "Idle";
+    SessionStatus[SessionStatus["Error"] = 2] = "Error";
+    SessionStatus[SessionStatus["InProgress"] = 8] = "InProgress";
+    SessionStatus[SessionStatus["InputNeeded"] = 24] = "InputNeeded";
+})(SessionStatus || (SessionStatus = {}));
+var SessionInputResponseKind;
+(function (SessionInputResponseKind) {
+    SessionInputResponseKind["Accept"] = "accept";
+    SessionInputResponseKind["Decline"] = "decline";
+    SessionInputResponseKind["Cancel"] = "cancel";
+})(SessionInputResponseKind || (SessionInputResponseKind = {}));
+var SessionInputQuestionKind;
+(function (SessionInputQuestionKind) {
+    SessionInputQuestionKind["Text"] = "text";
+    SessionInputQuestionKind["Number"] = "number";
+    SessionInputQuestionKind["Integer"] = "integer";
+    SessionInputQuestionKind["Boolean"] = "boolean";
+    SessionInputQuestionKind["SingleSelect"] = "single-select";
+    SessionInputQuestionKind["MultiSelect"] = "multi-select";
+})(SessionInputQuestionKind || (SessionInputQuestionKind = {}));
+var SessionInputAnswerValueKind;
+(function (SessionInputAnswerValueKind) {
+    SessionInputAnswerValueKind["Text"] = "text";
+    SessionInputAnswerValueKind["Number"] = "number";
+    SessionInputAnswerValueKind["Boolean"] = "boolean";
+    SessionInputAnswerValueKind["Selected"] = "selected";
+    SessionInputAnswerValueKind["SelectedMany"] = "selected-many";
+})(SessionInputAnswerValueKind || (SessionInputAnswerValueKind = {}));
+var SessionInputAnswerState;
+(function (SessionInputAnswerState) {
+    SessionInputAnswerState["Draft"] = "draft";
+    SessionInputAnswerState["Submitted"] = "submitted";
+    SessionInputAnswerState["Skipped"] = "skipped";
+})(SessionInputAnswerState || (SessionInputAnswerState = {}));
+var TurnState;
+(function (TurnState) {
+    TurnState["Complete"] = "complete";
+    TurnState["Cancelled"] = "cancelled";
+    TurnState["Error"] = "error";
+})(TurnState || (TurnState = {}));
+var AttachmentType;
+(function (AttachmentType) {
+    AttachmentType["File"] = "file";
+    AttachmentType["Directory"] = "directory";
+    AttachmentType["Selection"] = "selection";
+})(AttachmentType || (AttachmentType = {}));
+var ResponsePartKind;
+(function (ResponsePartKind) {
+    ResponsePartKind["Markdown"] = "markdown";
+    ResponsePartKind["ContentRef"] = "contentRef";
+    ResponsePartKind["ToolCall"] = "toolCall";
+    ResponsePartKind["Reasoning"] = "reasoning";
+})(ResponsePartKind || (ResponsePartKind = {}));
+var ToolCallStatus;
+(function (ToolCallStatus) {
+    ToolCallStatus["Streaming"] = "streaming";
+    ToolCallStatus["PendingConfirmation"] = "pending-confirmation";
+    ToolCallStatus["Running"] = "running";
+    ToolCallStatus["PendingResultConfirmation"] = "pending-result-confirmation";
+    ToolCallStatus["Completed"] = "completed";
+    ToolCallStatus["Cancelled"] = "cancelled";
+})(ToolCallStatus || (ToolCallStatus = {}));
+var ToolCallConfirmationReason;
+(function (ToolCallConfirmationReason) {
+    ToolCallConfirmationReason["NotNeeded"] = "not-needed";
+    ToolCallConfirmationReason["UserAction"] = "user-action";
+    ToolCallConfirmationReason["Setting"] = "setting";
+})(ToolCallConfirmationReason || (ToolCallConfirmationReason = {}));
+var ToolCallCancellationReason;
+(function (ToolCallCancellationReason) {
+    ToolCallCancellationReason["Denied"] = "denied";
+    ToolCallCancellationReason["Skipped"] = "skipped";
+    ToolCallCancellationReason["ResultDenied"] = "result-denied";
+})(ToolCallCancellationReason || (ToolCallCancellationReason = {}));
+var ToolResultContentType;
+(function (ToolResultContentType) {
+    ToolResultContentType["Text"] = "text";
+    ToolResultContentType["EmbeddedResource"] = "embeddedResource";
+    ToolResultContentType["Resource"] = "resource";
+    ToolResultContentType["FileEdit"] = "fileEdit";
+    ToolResultContentType["Terminal"] = "terminal";
+    ToolResultContentType["Subagent"] = "subagent";
+})(ToolResultContentType || (ToolResultContentType = {}));
+var CustomizationStatus;
+(function (CustomizationStatus) {
+    CustomizationStatus["Loading"] = "loading";
+    CustomizationStatus["Loaded"] = "loaded";
+    CustomizationStatus["Degraded"] = "degraded";
+    CustomizationStatus["Error"] = "error";
+})(CustomizationStatus || (CustomizationStatus = {}));
+var TerminalClaimKind;
+(function (TerminalClaimKind) {
+    TerminalClaimKind["Client"] = "client";
+    TerminalClaimKind["Session"] = "session";
+})(TerminalClaimKind || (TerminalClaimKind = {}));
+
+export { AttachmentType, CustomizationStatus, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, TerminalClaimKind, ToolCallCancellationReason, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType, TurnState };

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

@@ -0,0 +1,76 @@
+import { IToolResultFileEditContent, type IActiveTurn, type IRootState, type ISessionState, type ISessionSummary, type IToolCallCancelledState, type IToolCallCompletedState, type IToolCallResult, type IToolCallState, type IToolResultContent, type IToolResultSubagentContent, type IUserMessage, ITerminalState } from "./protocol/state.js";
+export { type IActiveTurn, type IAgentInfo, type IConfigPropertySchema, type IConfigSchema, type IContentRef, type IErrorInfo, type IProjectInfo, type IMarkdownResponsePart, type IMessageAttachment, type IReasoningResponsePart, type IResponsePart, type IRootState, type ISessionActiveClient, type ISessionConfigState, type IFileEdit as ISessionFileDiff, type IModelSelection, type ISessionModelInfo, type ISessionState, type ISessionSummary, type ISnapshot, type ITerminalState, type IToolAnnotations, type IToolCallCancelledState, type IToolCallCompletedState, type IToolCallPendingConfirmationState, type IToolCallPendingResultConfirmationState, type IToolCallResponsePart, type IToolCallResult, type IToolCallRunningState, type IToolCallState, type IToolCallStreamingState, type IToolDefinition, type ICustomizationRef, type ISessionCustomization, type IToolResultEmbeddedResourceContent as IToolResultBinaryContent, type IToolResultContent, type IToolResultFileEditContent, type IToolResultSubagentContent, type IToolResultTextContent, type ITurn, type IUsageInfo, type IUserMessage, type IPendingMessage, type StringOrMarkdown, type URI, type ISessionInputRequest, type ISessionInputQuestion, type ISessionInputAnswer, type ISessionInputOption, AttachmentType, CustomizationStatus, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, ToolCallConfirmationReason, ToolCallCancellationReason, ToolCallStatus, ToolResultContentType, TurnState, } from "./protocol/state.js";
+/**
+ * The kind of file edit operation. Derived from the presence/absence of
+ * `before`/`after` in {@link IToolResultFileEditContent}.
+ */
+export declare enum FileEditKind {
+    /** Content edit (same file URI, different content). */
+    Edit = "edit",
+    /** File creation (no before state). */
+    Create = "create",
+    /** File deletion (no after state). */
+    Delete = "delete",
+    /** File rename/move (different before and after URIs). */
+    Rename = "rename"
+}
+/** URI for the root state subscription. */
+export declare const ROOT_STATE_URI = "agenthost:/root";
+/**
+ * A tool call in a terminal state, stored in completed turns.
+ */
+export type ICompletedToolCall = IToolCallCompletedState | IToolCallCancelledState;
+/**
+ * Derived status type for the tool call lifecycle.
+ */
+export type ToolCallStatusString = IToolCallState["status"];
+/**
+ * Extracts a plain-text tool output string from a tool call result's `content`
+ * array. Joins all text-type content parts into a single string.
+ *
+ * Returns `undefined` if there are no text content parts.
+ */
+export declare function getToolOutputText(result: IToolCallResult): string | undefined;
+/**
+ * Extracts file edit content entries from a tool call result's `content` array.
+ * Returns an empty array if there are no file edit content parts.
+ */
+export declare function getToolFileEdits(result: IToolCallResult): IToolResultFileEditContent[];
+/**
+ * Extracts the first subagent content entry from a tool call's `content` array.
+ * Works with both completed tool call results and running tool call states.
+ * Returns `undefined` if there are no subagent content parts.
+ */
+export declare function getToolSubagentContent(result: {
+    content?: readonly IToolResultContent[];
+}): IToolResultSubagentContent | undefined;
+/**
+ * Builds a subagent session URI from a parent session URI and tool call ID.
+ * Convention: `{parentSessionUri}/subagent/{toolCallId}`
+ */
+export declare function buildSubagentSessionUri(parentSession: string, toolCallId: string): string;
+/**
+ * Parses a subagent session URI into its parent session URI and tool call ID.
+ * Returns `undefined` if the URI does not follow the subagent convention.
+ */
+export declare function parseSubagentSessionUri(uri: string): {
+    parentSession: string;
+    toolCallId: string;
+} | undefined;
+/**
+ * Returns whether a session URI represents a subagent session.
+ */
+export declare function isSubagentSession(uri: string): boolean;
+export declare function createRootState(): IRootState;
+export declare function createSessionState(summary: ISessionSummary): ISessionState;
+export declare function createActiveTurn(id: string, userMessage: IUserMessage): IActiveTurn;
+export declare enum StateComponents {
+    Root = 0,
+    Session = 1,
+    Terminal = 2
+}
+export type ComponentToState = {
+    [StateComponents.Root]: IRootState;
+    [StateComponents.Session]: ISessionState;
+    [StateComponents.Terminal]: ITerminalState;
+};

package/vscode/src/vs/platform/agentHost/common/state/sessionState.js

@@ -0,0 +1,20 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+export { AttachmentType, CustomizationStatus, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, ToolCallCancellationReason, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType, TurnState } from './protocol/state.js';
+
+var FileEditKind;
+(function(FileEditKind) {
+    FileEditKind["Edit"] = "edit";
+    FileEditKind["Create"] = "create";
+    FileEditKind["Delete"] = "delete";
+    FileEditKind["Rename"] = "rename";
+})(FileEditKind || (FileEditKind = {}));
+const ROOT_STATE_URI = "agenthost:/root";
+var StateComponents;
+(function(StateComponents) {
+    StateComponents[StateComponents["Root"] = 0] = "Root";
+    StateComponents[StateComponents["Session"] = 1] = "Session";
+    StateComponents[StateComponents["Terminal"] = 2] = "Terminal";
+})(StateComponents || (StateComponents = {}));
+
+export { FileEditKind, ROOT_STATE_URI, StateComponents };

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostPty.d.ts

@@ -0,0 +1,106 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IProcessPropertyMap, ITerminalChildProcess, ITerminalLaunchError, ITerminalLaunchResult, ProcessPropertyType } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import { IAgentConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { BasePty } from "../common/basePty.js";
+/**
+ * Options for creating a new terminal on an agent host.
+ */
+export interface IAgentHostPtyOptions {
+    /** Human-readable terminal name. */
+    readonly name?: string;
+    /** Initial working directory URI. */
+    readonly cwd?: URI;
+    /**
+     * When true, attach to an existing terminal on the agent host instead of
+     * creating a new one. The terminal must already exist server-side (e.g.
+     * created by a tool). The pty will subscribe to its state and replay
+     * content without calling `createTerminal`.
+     */
+    readonly attachOnly?: boolean;
+}
+export interface IAgentHostPtyCommandExecutedEvent {
+    readonly commandId: string;
+    readonly commandLine: string;
+    readonly timestamp: number;
+    /** The stored VT output for this command (present during content replay). */
+    readonly storedOutput?: string;
+}
+export interface IAgentHostPtyCommandFinishedEvent {
+    readonly commandId: string;
+    readonly exitCode?: number;
+    readonly durationMs?: number;
+}
+export declare enum AhpCommandMarkKind {
+    Executed = "s",
+    End = "e"
+}
+/**
+ * Generates the mark ID used to correlate SetMark VT codes with xterm markers
+ * via {@link IBufferMarkCapability.getMark}.
+ */
+export declare function getAhpCommandMarkId(commandId: string, kind: AhpCommandMarkKind): string;
+/**
+ * A pseudo-terminal backed by an Agent Host Protocol terminal subscription.
+ *
+ * Uses `customPtyImplementation` on `IShellLaunchConfig` so the
+ * `TerminalProcessManager` bypasses the pty host backend entirely.
+ *
+ * Data flow:
+ *   terminal/data   →  onProcessData
+ *   terminal/exited →  onProcessExit
+ *   input(data)     →  dispatch terminal/input
+ *   resize(c,r)     →  dispatch terminal/resized
+ *   shutdown()      →  disposeTerminal command
+ */
+export declare class AgentHostPty extends BasePty implements ITerminalChildProcess {
+    private readonly _connection;
+    private readonly _terminalUri;
+    private readonly _options?;
+    private readonly _startBarrier;
+    private readonly _subscriptionDisposables;
+    private _subscriptionRef;
+    private _initialCwd;
+    private readonly _onCommandExecuted;
+    readonly onCommandExecuted: Event<IAgentHostPtyCommandExecutedEvent>;
+    private readonly _onCommandFinished;
+    readonly onCommandFinished: Event<IAgentHostPtyCommandFinishedEvent>;
+    private readonly _onSupportsCommandDetection;
+    readonly onSupportsCommandDetection: Event<void>;
+    private _supportsCommandDetection;
+    get supportsCommandDetection(): boolean;
+    /**
+     * Command IDs for sentinel commands that should be suppressed from shell
+     * integration events. When the copilot shell tools fall back to sentinel-
+     * based exit code detection, shell integration may also detect the sentinel
+     * echo as a real command — we filter those out here.
+     */
+    private readonly _suppressedCommandIds;
+    constructor(id: number, _connection: IAgentConnection, _terminalUri: URI, _options?: IAgentHostPtyOptions | undefined);
+    start(): Promise<ITerminalLaunchError | ITerminalLaunchResult | undefined>;
+    private _handleAction;
+    /**
+     * Replays structured terminal content parts from the initial state snapshot.
+     * Emits command lifecycle events for command parts so that consumers
+     * (e.g. {@link AhpTerminalCommandSource}) can reconstruct command history.
+     */
+    private _replayContent;
+    /**
+     * Resolves a cwd URI for sending over the protocol. Agent-host URIs
+     * are unwrapped to their original URI via {@link fromAgentHostUri}.
+     */
+    private _resolveCwdForProtocol;
+    input(data: string): void;
+    resize(cols: number, rows: number): void;
+    shutdown(_immediate: boolean): void;
+    getInitialCwd(): Promise<string>;
+    getCwd(): Promise<string>;
+    clearBuffer(): Promise<void>;
+    acknowledgeDataEvent(_charCount: number): void;
+    setUnicodeVersion(_version: "6" | "11"): Promise<void>;
+    processBinary(_data: string): Promise<void>;
+    sendSignal(_signal: string): void;
+    refreshProperty<T extends ProcessPropertyType>(type: T): Promise<IProcessPropertyMap[T]>;
+    updateProperty<T extends ProcessPropertyType>(_type: T, _value: IProcessPropertyMap[T]): Promise<void>;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostPty.js

@@ -0,0 +1,276 @@
+
+import { Barrier } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ProcessPropertyType } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { AGENT_HOST_SCHEME, fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { ActionType } from '../../../../platform/agentHost/common/state/protocol/actions.js';
+import '../../../../platform/agentHost/common/state/protocol/notifications.js';
+import { TerminalClaimKind } from '../../../../platform/agentHost/common/state/protocol/state.js';
+import { StateComponents } from '../../../../platform/agentHost/common/state/sessionState.js';
+import { BasePty } from '../common/basePty.js';
+
+var AhpCommandMarkKind;
+(function(AhpCommandMarkKind) {
+    AhpCommandMarkKind["Executed"] = "s";
+    AhpCommandMarkKind["End"] = "e";
+})(AhpCommandMarkKind || (AhpCommandMarkKind = {}));
+function getAhpCommandMarkId(commandId, kind) {
+    return `ahp-${commandId}-${kind}`;
+}
+function getAhpCommandMarkCode(commandId, kind) {
+    return `\x1b]633;SetMark;Id=${getAhpCommandMarkId(commandId, kind)};Hidden\x07`;
+}
+const COPILOT_SENTINEL_PREFIX = "<<<COPILOT_SENTINEL_";
+function isCopilotSentinelCommand(commandLine) {
+    return commandLine.includes(COPILOT_SENTINEL_PREFIX);
+}
+class AgentHostPty extends BasePty {
+    get supportsCommandDetection() {
+        return this._supportsCommandDetection;
+    }
+    constructor(id, _connection, _terminalUri, _options) {
+        super(id,  false);
+        this._connection = _connection;
+        this._terminalUri = _terminalUri;
+        this._options = _options;
+        this._startBarrier = ( new Barrier());
+        this._subscriptionDisposables = this._register(( new DisposableStore()));
+        this._initialCwd = "";
+        this._onCommandExecuted = this._register(( new Emitter()));
+        this.onCommandExecuted = this._onCommandExecuted.event;
+        this._onCommandFinished = this._register(( new Emitter()));
+        this.onCommandFinished = this._onCommandFinished.event;
+        this._onSupportsCommandDetection = this._register(( new Emitter()));
+        this.onSupportsCommandDetection = this._onSupportsCommandDetection.event;
+        this._supportsCommandDetection = false;
+        this._suppressedCommandIds = ( new Set());
+    }
+    async start() {
+        try {
+            if (!this._options?.attachOnly) {
+                await this._connection.createTerminal({
+                    terminal: ( this._terminalUri.toString()),
+                    claim: {
+                        kind: TerminalClaimKind.Client,
+                        clientId: this._connection.clientId
+                    },
+                    name: this._options?.name,
+                    cwd: this._resolveCwdForProtocol(this._options?.cwd),
+                    cols: this._lastDimensions.cols > 0 ? this._lastDimensions.cols : undefined,
+                    rows: this._lastDimensions.rows > 0 ? this._lastDimensions.rows : undefined
+                });
+            }
+            this._subscriptionRef = this._connection.getSubscription(StateComponents.Terminal, this._terminalUri);
+            const subscription = this._subscriptionRef.object;
+            if (subscription.value === undefined) {
+                await ( new Promise(resolve => {
+                    const listener = subscription.onDidChange(() => {
+                        listener.dispose();
+                        resolve();
+                    });
+                    this._subscriptionDisposables.add(listener);
+                }));
+            }
+            const state = subscription.value;
+            if (state.supportsCommandDetection) {
+                this._supportsCommandDetection = true;
+                this._onSupportsCommandDetection.fire();
+            }
+            this._replayContent(state.content);
+            this._initialCwd = state.cwd?.toString() ?? "";
+            this._properties.cwd = this._initialCwd;
+            this._properties.initialCwd = this._initialCwd;
+            if (state.title) {
+                this._properties.title = state.title;
+            }
+            this._subscriptionDisposables.add(subscription.onDidApplyAction(envelope => {
+                this._handleAction(envelope);
+            }));
+            this._startBarrier.open();
+            this.handleReady({
+                pid: -1,
+                cwd: this._initialCwd,
+                windowsPty: undefined
+            });
+            return undefined;
+        } catch (err) {
+            this._startBarrier.open();
+            return {
+                message: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    _handleAction(envelope) {
+        const action = envelope.action;
+        switch (action.type) {
+        case ActionType.TerminalData:
+            this.handleData(action.data);
+            break;
+        case ActionType.TerminalExited:
+            this.handleExit(action.exitCode);
+            break;
+        case ActionType.TerminalCwdChanged:
+            this._properties.cwd = ( action.cwd.toString());
+            this.handleDidChangeProperty({
+                type: ProcessPropertyType.Cwd,
+                value: ( action.cwd.toString())
+            });
+            break;
+        case ActionType.TerminalTitleChanged:
+            this._properties.title = action.title;
+            this.handleDidChangeProperty({
+                type: ProcessPropertyType.Title,
+                value: action.title
+            });
+            break;
+        case ActionType.TerminalResized:
+            if (envelope.origin?.clientId !== this._connection.clientId) {
+                this.handleDidChangeProperty({
+                    type: ProcessPropertyType.OverrideDimensions,
+                    value: {
+                        cols: action.cols,
+                        rows: action.rows
+                    }
+                });
+            }
+            break;
+        case ActionType.TerminalCommandDetectionAvailable:
+            if (!this._supportsCommandDetection) {
+                this._supportsCommandDetection = true;
+                this._onSupportsCommandDetection.fire();
+            }
+            break;
+        case ActionType.TerminalCommandExecuted:
+            if (isCopilotSentinelCommand(action.commandLine)) {
+                this._suppressedCommandIds.add(action.commandId);
+                break;
+            }
+            this.handleData(getAhpCommandMarkCode(action.commandId, AhpCommandMarkKind.Executed));
+            this._onCommandExecuted.fire({
+                commandId: action.commandId,
+                commandLine: action.commandLine,
+                timestamp: action.timestamp
+            });
+            break;
+        case ActionType.TerminalCommandFinished:
+            if (this._suppressedCommandIds.delete(action.commandId)) {
+                break;
+            }
+            this.handleData(getAhpCommandMarkCode(action.commandId, AhpCommandMarkKind.End));
+            this._onCommandFinished.fire({
+                commandId: action.commandId,
+                exitCode: action.exitCode,
+                durationMs: action.durationMs
+            });
+            break;
+        }
+    }
+    _replayContent(content) {
+        for (const part of content) {
+            if (part.type === "unclassified") {
+                if (part.value) {
+                    this.handleData(part.value);
+                }
+            } else if (part.type === "command") {
+                if (isCopilotSentinelCommand(part.commandLine)) {
+                    continue;
+                }
+                this.handleData(getAhpCommandMarkCode(part.commandId, AhpCommandMarkKind.Executed));
+                this._onCommandExecuted.fire({
+                    commandId: part.commandId,
+                    commandLine: part.commandLine,
+                    timestamp: part.timestamp,
+                    storedOutput: part.output
+                });
+                if (part.output) {
+                    this.handleData(part.output);
+                }
+                if (part.isComplete) {
+                    this.handleData(getAhpCommandMarkCode(part.commandId, AhpCommandMarkKind.End));
+                    this._onCommandFinished.fire({
+                        commandId: part.commandId,
+                        exitCode: part.exitCode,
+                        durationMs: part.durationMs
+                    });
+                }
+            }
+        }
+    }
+    _resolveCwdForProtocol(cwd) {
+        if (!cwd) {
+            return undefined;
+        }
+        if (cwd.scheme === AGENT_HOST_SCHEME) {
+            return ( fromAgentHostUri(cwd).toString());
+        }
+        return ( cwd.toString());
+    }
+    input(data) {
+        if (this._inReplay) {
+            return;
+        }
+        this._startBarrier.wait().then(() => {
+            this._connection.dispatch({
+                type: ActionType.TerminalInput,
+                terminal: ( this._terminalUri.toString()),
+                data
+            });
+        });
+    }
+    resize(cols, rows) {
+        if (this._inReplay || (this._lastDimensions.cols === cols && this._lastDimensions.rows === rows)) {
+            return;
+        }
+        this._lastDimensions.cols = cols;
+        this._lastDimensions.rows = rows;
+        this._startBarrier.wait().then(() => {
+            this._connection.dispatch({
+                type: ActionType.TerminalResized,
+                terminal: ( this._terminalUri.toString()),
+                cols,
+                rows
+            });
+        });
+    }
+    shutdown(_immediate) {
+        this._startBarrier.wait().then(() => {
+            if (!this._options?.attachOnly) {
+                this._connection.disposeTerminal(this._terminalUri);
+            }
+            this._subscriptionRef?.dispose();
+            this._subscriptionRef = undefined;
+            this._subscriptionDisposables.clear();
+            this.handleExit(undefined);
+        });
+    }
+    async getInitialCwd() {
+        return this._initialCwd;
+    }
+    async getCwd() {
+        return this._properties.cwd || this._initialCwd;
+    }
+    async clearBuffer() {
+        this._connection.dispatch({
+            type: ActionType.TerminalCleared,
+            terminal: ( this._terminalUri.toString())
+        });
+    }
+    acknowledgeDataEvent(_charCount) {}
+    async setUnicodeVersion(_version) {}
+    processBinary(_data) {
+        return Promise.resolve();
+    }
+    sendSignal(_signal) {}
+    async refreshProperty(type) {
+        return this._properties[type];
+    }
+    async updateProperty(_type, _value) {}
+    dispose() {
+        this._subscriptionRef?.dispose();
+        this._subscriptionRef = undefined;
+        super.dispose();
+    }
+}
+
+export { AgentHostPty, AhpCommandMarkKind, getAhpCommandMarkId };

package/vscode/src/vs/workbench/contrib/terminal/browser/agentHostTerminalService.d.ts

@@ -0,0 +1,56 @@
+import { Disposable, IDisposable } 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-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { ITerminalInstance, ITerminalLocationOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
+import { IAgentHostTerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service";
+export interface IAgentHostTerminalCreateOptions {
+    /** Human-readable terminal name. */
+    readonly name?: string;
+    /** Initial working directory. */
+    readonly cwd?: URI;
+    /** Terminal location (panel, editor, split, etc.). */
+    readonly location?: ITerminalLocationOptions;
+}
+export interface IAgentHostEntry {
+    /** Display name for the profile. */
+    readonly name: string;
+    /** Address or identifier for the host. */
+    readonly address: string;
+    /** Getter for the connection (may be lazily resolved). */
+    readonly getConnection: () => IAgentConnection | undefined;
+}
+export interface IAgentHostTerminalProfileInfo {
+    readonly extensionIdentifier: string;
+    readonly profileId: string;
+    readonly title: string;
+    readonly address: string;
+}
+export declare class AgentHostTerminalService extends Disposable implements IAgentHostTerminalService {
+    private readonly _terminalService;
+    private readonly _terminalChatService;
+    private readonly _terminalProfileService;
+    private readonly _quickInputService;
+    readonly _serviceBrand: undefined;
+    private readonly _entries;
+    private readonly _usedHosts;
+    private readonly _profileRegistrations;
+    private readonly _profiles;
+    readonly profiles: IObservable<readonly IAgentHostTerminalProfileInfo[]>;
+    private _defaultCwd;
+    /** Revived terminal instances, keyed by terminal URI string. */
+    private readonly _revivedInstances;
+    constructor(_terminalService: ITerminalService, _terminalChatService: ITerminalChatService, _terminalProfileService: ITerminalProfileService, _quickInputService: IQuickInputService);
+    registerEntry(entry: IAgentHostEntry): IDisposable;
+    getProfileForConnection(address: string): IAgentHostTerminalProfileInfo | undefined;
+    setDefaultCwd(cwd: URI | undefined): void;
+    private _reconcile;
+    private _registerProfile;
+    createTerminalForEntry(address: string, options?: IAgentHostTerminalCreateOptions): Promise<ITerminalInstance | undefined>;
+    createTerminal(connection: IAgentConnection, options?: IAgentHostTerminalCreateOptions): Promise<ITerminalInstance>;
+    reviveTerminal(connection: IAgentConnection, terminalUri: URI, terminalToolSessionId: string): Promise<ITerminalInstance>;
+}