@codingame/monaco-vscode-xterm-common 31.0.1 → 32.0.1

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

@@ -36,10 +36,13 @@ var ActionType;
     ActionType["SessionCustomizationToggled"] = "session/customizationToggled";
     ActionType["SessionTruncated"] = "session/truncated";
     ActionType["SessionIsReadChanged"] = "session/isReadChanged";
-    ActionType["SessionIsDoneChanged"] = "session/isDoneChanged";
+    ActionType["SessionIsArchivedChanged"] = "session/isArchivedChanged";
+    ActionType["SessionActivityChanged"] = "session/activityChanged";
     ActionType["SessionDiffsChanged"] = "session/diffsChanged";
     ActionType["SessionConfigChanged"] = "session/configChanged";
+    ActionType["SessionMetaChanged"] = "session/metaChanged";
     ActionType["RootTerminalsChanged"] = "root/terminalsChanged";
+    ActionType["RootConfigChanged"] = "root/configChanged";
     ActionType["TerminalData"] = "terminal/data";
     ActionType["TerminalInput"] = "terminal/input";
     ActionType["TerminalResized"] = "terminal/resized";

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

@@ -1,4 +1,4 @@
-import type { URI, ISessionSummary } from "./state.js";
+import type { URI, SessionSummary } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 /**
  * Reason why authentication is required.
  *
@@ -47,10 +47,10 @@ export declare enum NotificationType {
  * }
  * ```
  */
-export interface ISessionAddedNotification {
+export interface SessionAddedNotification {
     type: NotificationType.SessionAdded;
     /** Summary of the new session */
-    summary: ISessionSummary;
+    summary: SessionSummary;
 }
 /**
  * Broadcast to all connected clients when a session is disposed.
@@ -71,7 +71,7 @@ export interface ISessionAddedNotification {
  * }
  * ```
  */
-export interface ISessionRemovedNotification {
+export interface SessionRemovedNotification {
     type: NotificationType.SessionRemoved;
     /** URI of the removed session */
     session: URI;
@@ -99,7 +99,7 @@ export interface ISessionRemovedNotification {
  *   replayed on reconnect. On reconnect, clients should re-fetch the full
  *   catalog via `listSessions()` as usual.
  * - The server SHOULD emit this notification whenever any mutable field on
- *   {@link ISessionSummary | `ISessionSummary`} changes for a session the
+ *   {@link SessionSummary | `SessionSummary`} changes for a session the
  *   server has surfaced via `listSessions()` or `notify/sessionAdded`.
  *   Servers MAY coalesce or debounce updates for noisy fields (for example,
  *   `modifiedAt` bumps while a turn is streaming, or rapidly changing
@@ -128,7 +128,7 @@ export interface ISessionRemovedNotification {
  * }
  * ```
  */
-export interface ISessionSummaryChangedNotification {
+export interface SessionSummaryChangedNotification {
     type: NotificationType.SessionSummaryChanged;
     /** URI of the session whose summary changed */
     session: URI;
@@ -138,7 +138,7 @@ export interface ISessionSummaryChangedNotification {
      * Identity fields (`resource`, `provider`, `createdAt`) never change and
      * MUST be omitted by senders; receivers SHOULD ignore them if present.
      */
-    changes: Partial<ISessionSummary>;
+    changes: Partial<SessionSummary>;
 }
 /**
  * Sent by the server when a protected resource requires (re-)authentication.
@@ -166,7 +166,7 @@ export interface ISessionSummaryChangedNotification {
  * }
  * ```
  */
-export interface IAuthRequiredNotification {
+export interface AuthRequiredNotification {
     type: NotificationType.AuthRequired;
     /** The protected resource identifier that requires authentication */
     resource: string;
@@ -176,4 +176,4 @@ export interface IAuthRequiredNotification {
 /**
  * Discriminated union of all protocol notifications.
  */
-export type IProtocolNotification = ISessionAddedNotification | ISessionRemovedNotification | ISessionSummaryChangedNotification | IAuthRequiredNotification;
+export type ProtocolNotification = SessionAddedNotification | SessionRemovedNotification | SessionSummaryChangedNotification | AuthRequiredNotification;

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

@@ -1,8 +1,9 @@
-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";
+import { URI as ResourceURI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ToolResultFileEditContent, type ActiveTurn, type RootState, type SessionState, type SessionSummary, type ToolCallCancelledState, type ToolCallCompletedState, type ToolCallResult, type ToolCallState, type ToolResultContent, type ToolResultSubagentContent, type URI as ProtocolURI, type UserMessage, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+export { type ActiveTurn, type AgentInfo, type ConfigPropertySchema, type ConfigSchema, type ContentRef, type ErrorInfo, type ProjectInfo, type MarkdownResponsePart, type MessageAttachment, type MessageResourceAttachment, type ReasoningResponsePart, type ResponsePart, type RootState, type SessionActiveClient, type SessionConfigState, type FileEdit as ISessionFileDiff, type ModelSelection, type SessionModelInfo, type SessionState, type SessionSummary, type Snapshot, type TerminalState, type ToolAnnotations, type ToolCallCancelledState, type ToolCallCompletedState, type ToolCallPendingConfirmationState, type ToolCallPendingResultConfirmationState, type ToolCallResponsePart, type ToolCallResult, type ToolCallRunningState, type ToolCallState, type ToolCallStreamingState, type ToolDefinition, type CustomizationRef, type SessionCustomization, type ToolResultEmbeddedResourceContent as IToolResultBinaryContent, type ToolResultContent, type ToolResultFileEditContent, type ToolResultSubagentContent, type ToolResultTextContent, type Turn, type UsageInfo, type UserMessage, type PendingMessage, type StringOrMarkdown, type URI, type SessionInputRequest, type SessionInputQuestion, type SessionInputAnswer, type SessionInputOption, CustomizationStatus, MessageAttachmentKind, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, ToolCallConfirmationReason, ToolCallCancellationReason, ToolCallStatus, ToolResultContentType, TurnState, } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 /**
  * The kind of file edit operation. Derived from the presence/absence of
- * `before`/`after` in {@link IToolResultFileEditContent}.
+ * `before`/`after` in {@link ToolResultFileEditContent}.
  */
 export declare enum FileEditKind {
     /** Content edit (same file URI, different content). */
@@ -19,58 +20,120 @@ export declare const ROOT_STATE_URI = "agenthost:/root";
 /**
  * A tool call in a terminal state, stored in completed turns.
  */
-export type ICompletedToolCall = IToolCallCompletedState | IToolCallCancelledState;
+export type ICompletedToolCall = ToolCallCompletedState | ToolCallCancelledState;
 /**
  * Derived status type for the tool call lifecycle.
  */
-export type ToolCallStatusString = IToolCallState["status"];
+export type ToolCallStatusString = ToolCallState["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;
+export declare function getToolOutputText(result: ToolCallResult): 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[];
+export declare function getToolFileEdits(result: ToolCallResult): ToolResultFileEditContent[];
 /**
  * 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;
+    content?: readonly ToolResultContent[];
+}): ToolResultSubagentContent | 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;
+export declare function buildSubagentSessionUri(parentSession: ProtocolURI | ResourceURI, 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;
+export declare function parseSubagentSessionUri(uri: ProtocolURI | ResourceURI): {
+    parentSession: ResourceURI;
     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 function isSubagentSession(uri: ProtocolURI | ResourceURI): boolean;
+/**
+ * Builds the string prefix used by the state manager for cached subagent sessions.
+ */
+export declare function buildSubagentSessionUriPrefix(parentSession: ProtocolURI | ResourceURI): string;
+export declare function createRootState(): RootState;
+export declare function createSessionState(summary: SessionSummary): SessionState;
+export declare function createActiveTurn(id: string, userMessage: UserMessage): ActiveTurn;
 export declare enum StateComponents {
     Root = 0,
     Session = 1,
     Terminal = 2
 }
 export type ComponentToState = {
-    [StateComponents.Root]: IRootState;
-    [StateComponents.Session]: ISessionState;
-    [StateComponents.Terminal]: ITerminalState;
+    [StateComponents.Root]: RootState;
+    [StateComponents.Session]: SessionState;
+    [StateComponents.Terminal]: TerminalState;
 };
+/**
+ * VS Code-side alias for the protocol's open `_meta` property bag on
+ * {@link SessionState}. Keys SHOULD be namespaced (e.g. `git`, `vscode.foo`)
+ * to avoid collisions; values MUST be JSON-serializable.
+ */
+export type SessionMeta = Record<string, unknown>;
+/**
+ * Reserved key under {@link SessionMeta} for the well-known git-state
+ * payload. Value at this key, when present, MUST be shaped like
+ * {@link ISessionGitState}. This is a VS Code-specific convention layered
+ * on top of the protocol's generic `_meta` bag — the protocol itself does
+ * not know about git state.
+ */
+export declare const SESSION_META_GIT_KEY = "git";
+/**
+ * Git state of a session's working directory, carried under
+ * {@link SessionMeta} at {@link SESSION_META_GIT_KEY}. Used by clients to
+ * drive source-control affordances (e.g. PR/merge buttons in the Agents
+ * app).
+ *
+ * All fields are optional — agents that do not track a particular field
+ * should omit it rather than send a placeholder, so clients can distinguish
+ * "unknown" from "known to be zero".
+ */
+export interface ISessionGitState {
+    /** Whether the working directory has a `github.com` git remote. */
+    readonly hasGitHubRemote?: boolean;
+    /** Current branch name. */
+    readonly branchName?: string;
+    /** Base branch the work targets (e.g. `main`). */
+    readonly baseBranchName?: string;
+    /** Upstream tracking branch (e.g. `origin/feature`). */
+    readonly upstreamBranchName?: string;
+    /** Number of commits the upstream branch has ahead of the local branch. */
+    readonly incomingChanges?: number;
+    /** Number of commits the local branch has ahead of the upstream branch. */
+    readonly outgoingChanges?: number;
+    /** Number of files with uncommitted changes. */
+    readonly uncommittedChanges?: number;
+    /** GitHub repository owner parsed from the working copy's GitHub remote (preferring `origin`, falling back to the first GitHub remote). */
+    readonly githubOwner?: string;
+    /** GitHub repository name parsed from the working copy's GitHub remote (preferring `origin`, falling back to the first GitHub remote). */
+    readonly githubRepo?: string;
+}
+/**
+ * Reads the well-known git-state payload from {@link SessionMeta}, if
+ * present. Returns `undefined` when the meta bag is absent or the value at
+ * the git key is not a plain object (e.g. an array or a primitive).
+ * Individual fields with wrong types are silently dropped so partial state
+ * still propagates.
+ */
+export declare function readSessionGitState(meta: SessionMeta | undefined): ISessionGitState | undefined;
+/**
+ * Returns a new {@link SessionMeta} with the git-state payload set to
+ * `gitState`, or with the git slot removed if `gitState` is `undefined`.
+ * Returns `undefined` if the result would be empty.
+ */
+export declare function withSessionGitState(meta: SessionMeta | undefined, gitState: ISessionGitState | undefined): SessionMeta | undefined;

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

@@ -1,6 +1,10 @@
 
 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';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+export { CustomizationStatus, MessageAttachmentKind, PendingMessageKind, PolicyState, ResponsePartKind, SessionInputAnswerState, SessionInputAnswerValueKind, SessionInputQuestionKind, SessionInputResponseKind, SessionLifecycle, SessionStatus, ToolCallCancellationReason, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType, TurnState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state';
 
 var FileEditKind;
 (function(FileEditKind) {

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

@@ -54,7 +54,7 @@ export declare function getAhpCommandMarkId(commandId: string, kind: AhpCommandM
  *   shutdown()      →  disposeTerminal command
  */
 export declare class AgentHostPty extends BasePty implements ITerminalChildProcess {
-    private readonly _connection;
+    private _connection;
     private readonly _terminalUri;
     private readonly _options?;
     private readonly _startBarrier;
@@ -102,5 +102,16 @@ export declare class AgentHostPty extends BasePty implements ITerminalChildProce
     sendSignal(_signal: string): void;
     refreshProperty<T extends ProcessPropertyType>(type: T): Promise<IProcessPropertyMap[T]>;
     updateProperty<T extends ProcessPropertyType>(_type: T, _value: IProcessPropertyMap[T]): Promise<void>;
+    /**
+     * Reconnect this pty to a new agent host connection. Tears down the
+     * old subscription and re-subscribes with the new connection, replaying
+     * content from the server-side snapshot. Terminal output during the
+     * disconnect gap is a stream (not state), so some loss is expected.
+     *
+     * @returns `true` if reconnection succeeded, `false` otherwise.
+     */
+    reconnect(newConnection: IAgentConnection): Promise<boolean>;
+    /** The terminal URI this pty is subscribed to. */
+    get terminalUri(): URI;
     dispose(): void;
 }

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

@@ -6,7 +6,7 @@ import { ProcessPropertyType } from '@codingame/monaco-vscode-api/vscode/vs/plat
 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 { TerminalClaimKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state';
 import { StateComponents } from '../../../../platform/agentHost/common/state/sessionState.js';
 import { BasePty } from '../common/basePty.js';
 
@@ -266,6 +266,57 @@ class AgentHostPty extends BasePty {
         return this._properties[type];
     }
     async updateProperty(_type, _value) {}
+    async reconnect(newConnection) {
+        this._subscriptionDisposables.clear();
+        this._subscriptionRef?.dispose();
+        this._subscriptionRef = undefined;
+        this._connection = newConnection;
+        try {
+            this._subscriptionRef = this._connection.getSubscription(StateComponents.Terminal, this._terminalUri);
+            const subscription = this._subscriptionRef.object;
+            if (subscription.value === undefined) {
+                const RECONNECT_HYDRATE_TIMEOUT_MS = 10_000;
+                await ( new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => {
+                        listener.dispose();
+                        reject(( new Error("Reconnect hydration timed out")));
+                    }, RECONNECT_HYDRATE_TIMEOUT_MS);
+                    const listener = subscription.onDidChange(() => {
+                        clearTimeout(timer);
+                        listener.dispose();
+                        resolve();
+                    });
+                    this._subscriptionDisposables.add(listener);
+                }));
+            }
+            const state = subscription.value;
+            if (state.supportsCommandDetection && !this._supportsCommandDetection) {
+                this._supportsCommandDetection = true;
+                this._onSupportsCommandDetection.fire();
+            }
+            this.handleData("\u001b[2J\u001b[3J\u001b[H");
+            this._replayContent(state.content);
+            if (state.cwd) {
+                this._properties.cwd = ( state.cwd.toString());
+            }
+            if (state.title) {
+                this._properties.title = state.title;
+            }
+            this._subscriptionDisposables.add(subscription.onDidApplyAction(envelope => {
+                this._handleAction(envelope);
+            }));
+            return true;
+        } catch (err) {
+            console.warn(
+                "[AgentHostPty] Reconnection failed:",
+                err instanceof Error ? err.message : String(err)
+            );
+            return false;
+        }
+    }
+    get terminalUri() {
+        return this._terminalUri;
+    }
     dispose() {
         this._subscriptionRef?.dispose();
         this._subscriptionRef = undefined;

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

@@ -44,6 +44,12 @@ export declare class AgentHostTerminalService extends Disposable implements IAge
     private _defaultCwd;
     /** Revived terminal instances, keyed by terminal URI string. */
     private readonly _revivedInstances;
+    /**
+     * Active AgentHostPty instances with their owning connection clientId,
+     * keyed by terminal URI string. Used for reconnection scoping.
+     */
+    private readonly _activePtys;
+    private readonly _reviveSequencer;
     constructor(_terminalService: ITerminalService, _terminalChatService: ITerminalChatService, _terminalProfileService: ITerminalProfileService, _quickInputService: IQuickInputService);
     registerEntry(entry: IAgentHostEntry): IDisposable;
     getProfileForConnection(address: string): IAgentHostTerminalProfileInfo | undefined;
@@ -53,4 +59,9 @@ export declare class AgentHostTerminalService extends Disposable implements IAge
     createTerminalForEntry(address: string, options?: IAgentHostTerminalCreateOptions): Promise<ITerminalInstance | undefined>;
     createTerminal(connection: IAgentConnection, options?: IAgentHostTerminalCreateOptions): Promise<ITerminalInstance>;
     reviveTerminal(connection: IAgentConnection, terminalUri: URI, terminalToolSessionId: string): Promise<ITerminalInstance>;
+    private _doReviveTerminal;
+    reconnectTerminals(newConnection: IAgentConnection, oldClientId: string): Promise<{
+        recovered: number;
+        total: number;
+    }>;
 }

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

@@ -1,5 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { SequencerByKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Disposable, DisposableMap, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -32,6 +33,8 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
         this._profiles = observableValue("agentHostTerminalProfiles", []);
         this.profiles = this._profiles;
         this._revivedInstances = ( new Map());
+        this._activePtys = ( new Map());
+        this._reviveSequencer = ( new SequencerByKey());
     }
     registerEntry(entry) {
         this._entries.push(entry);
@@ -80,7 +83,7 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
                 }
             } else if (displaying < entries.length) {
                 desiredProfiles.set("__quickpick__", {
-                    name: ( localize(13463, "Agent Host…")),
+                    name: ( localize(13777, "Agent Host…")),
                     address: "__quickpick__",
                     getConnection: () => undefined
                 });
@@ -101,7 +104,7 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
             infos.push({
                 extensionIdentifier: AGENT_HOST_PROFILE_EXT_ID,
                 profileId: key,
-                title: key === "__quickpick__" ? ( localize(13463, "Agent Host…")) : ( localize(13464, "Agent Host ({0})", desiredProfiles.get(key).name)),
+                title: key === "__quickpick__" ? ( localize(13777, "Agent Host…")) : ( localize(13778, "Agent Host ({0})", desiredProfiles.get(key).name)),
                 address: key
             });
         }
@@ -116,12 +119,12 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
                 let displayName = entry.name;
                 if (key === "__quickpick__") {
                     const picks = ( allEntries.map(e => ({
-                        label: ( localize(13464, "Agent Host ({0})", e.name)),
+                        label: ( localize(13778, "Agent Host ({0})", e.name)),
                         address: e.address,
                         hostName: e.name
                     })));
                     const pick = await this._quickInputService.pick(picks, {
-                        placeHolder: ( localize(13465, "Select an agent host to open a terminal on"))
+                        placeHolder: ( localize(13779, "Select an agent host to open a terminal on"))
                     });
                     if (!pick) {
                         return;
@@ -137,13 +140,13 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
                     return;
                 }
                 await this.createTerminal(connection, {
-                    name: ( localize(13464, "Agent Host ({0})", displayName)),
+                    name: ( localize(13778, "Agent Host ({0})", displayName)),
                     cwd: options.cwd ? (typeof options.cwd === "string" ? URI.file(options.cwd) : options.cwd) : this._defaultCwd,
                     location: options.location
                 });
             }
         };
-        const title = key === "__quickpick__" ? ( localize(13463, "Agent Host…")) : ( localize(13464, "Agent Host ({0})", entry.name));
+        const title = key === "__quickpick__" ? ( localize(13777, "Agent Host…")) : ( localize(13778, "Agent Host ({0})", entry.name));
         const store = ( new DisposableStore());
         store.add(
             this._terminalProfileService.registerTerminalProfileProvider(AGENT_HOST_PROFILE_EXT_ID, key, provider)
@@ -172,8 +175,9 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
             scheme: "agenthost-terminal",
             path: `/${generateUuid()}`
         }));
-        const name = options?.name ?? ( localize(13466, "Agent Host Terminal"));
-        return this._terminalService.createTerminal({
+        const name = options?.name ?? ( localize(13780, "Agent Host Terminal"));
+        const key = ( terminalUri.toString());
+        const instance = await this._terminalService.createTerminal({
             config: {
                 customPtyImplementation: (id, cols, rows) => {
                     const pty = ( new AgentHostPty(id, connection, terminalUri, {
@@ -183,6 +187,10 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
                     if (cols > 0 && rows > 0) {
                         pty.resize(cols, rows);
                     }
+                    this._activePtys.set(key, {
+                        pty,
+                        clientId: connection.clientId
+                    });
                     return pty;
                 },
                 name,
@@ -193,9 +201,19 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
             },
             location: options?.location
         });
+        this._register(instance.onDisposed(() => {
+            this._activePtys.delete(key);
+        }));
+        return instance;
     }
     async reviveTerminal(connection, terminalUri, terminalToolSessionId) {
         const key = ( terminalUri.toString());
+        return this._reviveSequencer.queue(
+            key,
+            () => this._doReviveTerminal(connection, terminalUri, terminalToolSessionId, key)
+        );
+    }
+    async _doReviveTerminal(connection, terminalUri, terminalToolSessionId, key) {
         const existing = this._revivedInstances.get(key);
         if (existing) {
             return existing;
@@ -217,10 +235,15 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
                     if (!store.isDisposed) {
                         commandSource.connect(instance, pty);
                     }
+                    this._activePtys.set(key, {
+                        pty,
+                        clientId: connection.clientId
+                    });
                     return pty;
                 },
-                name: ( localize(13467, "Agent Host Terminal")),
-                isFeatureTerminal: true
+                name: ( localize(13781, "Agent Host Terminal")),
+                isFeatureTerminal: true,
+                hideFromUser: true
             }
         });
         this._terminalChatService.registerTerminalInstanceWithToolSession(terminalToolSessionId, instance);
@@ -228,9 +251,31 @@ let AgentHostTerminalService = class AgentHostTerminalService extends Disposable
         instance.store.add(store);
         this._register(instance.onDisposed(() => {
             this._revivedInstances.delete(key);
+            this._activePtys.delete(key);
         }));
         return instance;
     }
+    async reconnectTerminals(newConnection, oldClientId) {
+        const entries = [...this._activePtys.entries()].filter(([, entry]) => entry.clientId === oldClientId);
+        const total = entries.length;
+        let recovered = 0;
+        const promises = [];
+        for (const [key, entry] of entries) {
+            promises.push(entry.pty.reconnect(newConnection).then(success => {
+                if (success) {
+                    recovered++;
+                    entry.clientId = newConnection.clientId;
+                } else {
+                    console.warn(`[AgentHostTerminalService] Failed to reconnect terminal: ${key}`);
+                }
+            }));
+        }
+        await Promise.all(promises);
+        return {
+            recovered,
+            total
+        };
+    }
 };
 AgentHostTerminalService = ( __decorate([( __param(0, ITerminalService)), ( __param(1, ITerminalChatService)), ( __param(2, ITerminalProfileService)), ( __param(3, IQuickInputService))], AgentHostTerminalService));
 

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

@@ -24,7 +24,7 @@ let EnvironmentVariableInfoStale = class EnvironmentVariableInfoStale {
         addExtensionIdentifiers(extSet, ( this._diff.removed.values()));
         addExtensionIdentifiers(extSet, ( this._diff.changed.values()));
         let message = ( localize(
-            13472,
+            13786,
             "The following extensions want to relaunch the terminal to contribute to its environment:"
         ));
         message += getMergedDescription(this._collection, scope, this._extensionService, extSet);
@@ -32,7 +32,7 @@ let EnvironmentVariableInfoStale = class EnvironmentVariableInfoStale {
     }
     _getActions() {
         return [{
-            label: ( localize(13473, "Relaunch Terminal")),
+            label: ( localize(13787, "Relaunch Terminal")),
             run: () => this._terminalService.getInstanceFromId(this._terminalId)?.relaunch(),
             commandId: TerminalCommandId.Relaunch
         }];
@@ -59,7 +59,7 @@ let EnvironmentVariableInfoChangesActive = class EnvironmentVariableInfoChangesA
         const extSet = ( new Set());
         addExtensionIdentifiers(extSet, ( this._collection.getVariableMap(scope).values()));
         let message = ( localize(
-            13474,
+            13788,
             "The following extensions have contributed to this terminal's environment:"
         ));
         message += getMergedDescription(this._collection, scope, this._extensionService, extSet);
@@ -67,7 +67,7 @@ let EnvironmentVariableInfoChangesActive = class EnvironmentVariableInfoChangesA
     }
     _getActions(scope) {
         return [{
-            label: ( localize(13475, "Show Environment Contributions")),
+            label: ( localize(13789, "Show Environment Contributions")),
             run: () => this._commandService.executeCommand(TerminalCommandId.ShowEnvironmentContributions, scope),
             commandId: TerminalCommandId.ShowEnvironmentContributions
         }];
@@ -95,7 +95,7 @@ function getMergedDescription(collection, scope, extensionService, extSet) {
         }
         const workspaceDescription = workspaceDescriptions.get(ext);
         if (workspaceDescription) {
-            const workspaceSuffix = globalDescription ? ` (${( localize(13476, "workspace"))})` : "";
+            const workspaceSuffix = globalDescription ? ` (${( localize(13790, "workspace"))})` : "";
             message.push(`\n- \`${getExtensionName(ext, extensionService)}${workspaceSuffix}\``);
             message.push(`: ${workspaceDescription}`);
         }