@codingame/monaco-vscode-chat-service-override 32.0.2 → 33.0.5

package/vscode/src/vs/platform/agentHost/common/agentHostSchema.js

@@ -0,0 +1,257 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { TelemetryLevel, TelemetryConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import { SessionConfigKey } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { ProtocolError } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
+import { JsonRpcErrorCodes } from './state/protocol/errors.js';
+
+function schemaProperty(protocol) {
+    const assertFn = buildAssert(protocol);
+    const assertValid = (value, path = "") => assertFn(value, path);
+    const validate = value => {
+        try {
+            assertFn(value, "");
+            return true;
+        } catch {
+            return false;
+        }
+    };
+    return {
+        protocol,
+        validate,
+        assertValid
+    };
+}
+function createSchema(definition) {
+    return {
+        definition,
+        toProtocol() {
+            const properties = {};
+            for (const key of ( Object.keys(definition))) {
+                properties[key] = definition[key].protocol;
+            }
+            return {
+                type: "object",
+                properties
+            };
+        },
+        values(values) {
+            const raw = values;
+            for (const key of ( Object.keys(definition))) {
+                const value = raw[key];
+                if (value === undefined) {
+                    continue;
+                }
+                const prop = definition[key];
+                prop.assertValid(value, key);
+            }
+            return {
+                ...raw
+            };
+        },
+        validate(key, value) {
+            const prop = definition[key];
+            return prop ? prop.validate(value) : false;
+        },
+        assertValid(key, value) {
+            const prop = definition[key];
+            if (!prop) {
+                throw ( new ProtocolError(JsonRpcErrorCodes.InvalidParams, `Unknown schema key '${key}'`));
+            }
+            const narrowed = prop;
+            narrowed.assertValid(value, key);
+        },
+        validateOrDefault(values, defaults) {
+            const result = {};
+            const raw = values ?? {};
+            for (const key of ( Object.keys(definition))) {
+                const prop = definition[key];
+                const candidate = raw[key];
+                if (candidate !== undefined && prop.validate(candidate)) {
+                    result[key] = candidate;
+                } else if (Object.prototype.hasOwnProperty.call(defaults, key)) {
+                    result[key] = defaults[key];
+                }
+            }
+            return result;
+        }
+    };
+}
+function buildAssert(schema) {
+    if (schema.type === "object" && schema.properties) {
+        const propAsserts = {};
+        for (const key of ( Object.keys(schema.properties))) {
+            propAsserts[key] = buildAssert(schema.properties[key]);
+        }
+        const required = ( new Set(schema.required ?? []));
+        return (value, path) => {
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                throw invalidParams(path, "object", value);
+            }
+            const obj = value;
+            for (const key of ( Object.keys(propAsserts))) {
+                const childPath = joinPath(path, key);
+                if (obj[key] === undefined) {
+                    if (( required.has(key))) {
+                        throw ( new ProtocolError(
+                            JsonRpcErrorCodes.InvalidParams,
+                            `Missing required property at '${childPath}'`
+                        ));
+                    }
+                    continue;
+                }
+                propAsserts[key](obj[key], childPath);
+            }
+        };
+    }
+    if (schema.type === "array" && schema.items) {
+        const itemAssert = buildAssert(schema.items);
+        return (value, path) => {
+            if (!Array.isArray(value)) {
+                throw invalidParams(path, "array", value);
+            }
+            for (let i = 0; i < value.length; i++) {
+                itemAssert(value[i], `${path}[${i}]`);
+            }
+        };
+    }
+    return buildPrimitiveAssert(schema);
+}
+function buildPrimitiveAssert(schema) {
+    const enumDynamic = schema.enumDynamic === true;
+    return (value, path) => {
+        switch (schema.type) {
+        case "string":
+            if (typeof value !== "string") {
+                throw invalidParams(path, "string", value);
+            }
+            break;
+        case "number":
+            if (typeof value !== "number") {
+                throw invalidParams(path, "number", value);
+            }
+            break;
+        case "boolean":
+            if (typeof value !== "boolean") {
+                throw invalidParams(path, "boolean", value);
+            }
+            break;
+        case "array":
+            if (!Array.isArray(value)) {
+                throw invalidParams(path, "array", value);
+            }
+            break;
+        case "object":
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                throw invalidParams(path, "object", value);
+            }
+            break;
+        }
+        if (schema.enum && !enumDynamic && !schema.enum.includes(value)) {
+            throw ( new ProtocolError(
+                JsonRpcErrorCodes.InvalidParams,
+                `Invalid value at '${path || "<root>"}': ${safeStringify(value)} is not one of [${( schema.enum.map(v => JSON.stringify(v))).join(", ")}]`
+            ));
+        }
+    };
+}
+function invalidParams(path, expected, value) {
+    return ( new ProtocolError(
+        JsonRpcErrorCodes.InvalidParams,
+        `Invalid value at '${path || "<root>"}': expected ${expected}, got ${safeStringify(value)}`
+    ));
+}
+function joinPath(parent, key) {
+    return parent ? `${parent}.${key}` : key;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}
+const permissionsProperty = schemaProperty({
+    type: "object",
+    title: ( localize(1820, "Permissions")),
+    description: ( localize(
+        1821,
+        "Per-tool session permissions. Updated automatically when approving a tool \"in this Session\"."
+    )),
+    properties: {
+        allow: {
+            type: "array",
+            title: ( localize(1822, "Allowed tools")),
+            items: {
+                type: "string",
+                title: ( localize(1823, "Tool name"))
+            }
+        },
+        deny: {
+            type: "array",
+            title: ( localize(1824, "Denied tools")),
+            items: {
+                type: "string",
+                title: ( localize(1823, "Tool name"))
+            }
+        }
+    },
+    default: {
+        allow: [],
+        deny: []
+    },
+    sessionMutable: true
+});
+createSchema({
+    [SessionConfigKey.AutoApprove]: schemaProperty({
+        type: "string",
+        title: ( localize(1825, "Approvals")),
+        description: ( localize(1826, "Tool approval behavior for this session")),
+        enum: ["default", "autoApprove", "autopilot"],
+        enumLabels: [( localize(1827, "Default Approvals")), ( localize(1828, "Bypass Approvals")), ( localize(1829, "Autopilot (Preview)"))],
+        enumDescriptions: [( localize(1830, "Copilot uses your configured settings")), ( localize(1831, "All tool calls are auto-approved")), ( localize(1832, "Autonomously iterates from start to finish"))],
+        default: "default",
+        sessionMutable: true
+    }),
+    [SessionConfigKey.Permissions]: permissionsProperty,
+    [SessionConfigKey.Mode]: schemaProperty({
+        type: "string",
+        title: ( localize(1833, "Agent Mode")),
+        description: ( localize(1834, "How the agent should approach this turn")),
+        enum: ["interactive", "plan"],
+        enumLabels: [( localize(1835, "Interactive")), ( localize(1836, "Plan"))],
+        enumDescriptions: [( localize(1837, "Ask for input and approval for each action")), ( localize(1838, "Generate a plan first, then choose how to execute it"))],
+        default: "interactive",
+        sessionMutable: true
+    })
+});
+const AgentHostTelemetryLevelConfigKey = "telemetryLevel";
+function telemetryLevelToAgentHostConfigValue(telemetryLevel) {
+    switch (telemetryLevel) {
+    case TelemetryLevel.NONE:
+        return TelemetryConfiguration.OFF;
+    case TelemetryLevel.CRASH:
+        return TelemetryConfiguration.CRASH;
+    case TelemetryLevel.ERROR:
+        return TelemetryConfiguration.ERROR;
+    case TelemetryLevel.USAGE:
+        return TelemetryConfiguration.ON;
+    }
+}
+createSchema({
+    [SessionConfigKey.Permissions]: permissionsProperty,
+    [AgentHostTelemetryLevelConfigKey]: schemaProperty({
+        type: "string",
+        title: ( localize(1839, "Telemetry Level")),
+        description: ( localize(1840, "Most restrictive telemetry level requested by connected clients.")),
+        enum: [
+            TelemetryConfiguration.ON,
+            TelemetryConfiguration.ERROR,
+            TelemetryConfiguration.CRASH,
+            TelemetryConfiguration.OFF
+        ],
+        default: TelemetryConfiguration.ON
+    })
+});
+
+export { AgentHostTelemetryLevelConfigKey, createSchema, schemaProperty, telemetryLevelToAgentHostConfigValue };

package/vscode/src/vs/platform/agentHost/common/agentService.d.ts

@@ -8,14 +8,20 @@ import type { CompletionsParams, CompletionsResult, CreateTerminalParams, Resolv
 import { ProtectedResourceMetadata, type ConfigSchema, type FileEdit, type MessageAttachment, type ModelSelection, type SessionActiveClient, type ToolCallPendingConfirmationState, type ToolDefinition } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 import type { ActionEnvelope, INotification, IRootConfigChangedAction, SessionAction, TerminalAction } from "./state/sessionActions.js";
 import type { ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
-import { ComponentToState, SessionInputResponseKind, SessionStatus, StateComponents, type CustomizationRef, type PendingMessage, type RootState, type SessionCustomization, type SessionInputAnswer, type SessionMeta, type ToolCallResult, type Turn, type PolicyState } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+import { ComponentToState, SessionInputResponseKind, SessionStatus, StateComponents, type CustomizationRef, type PendingMessage, type RootState, type SessionCustomization, type SessionInputAnswer, type SessionMeta, type ToolCallResult, type Turn, type PolicyState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 export declare enum AgentHostIpcChannels {
     /** Channel for the agent host service on the main-process side */
     AgentHost = "agentHost",
     /** Channel for log forwarding from the agent host process */
     Logger = "agentHostLogger",
     /** Channel for WebSocket client connection count (server process management only) */
-    ConnectionTracker = "agentHostConnectionTracker"
+    ConnectionTracker = "agentHostConnectionTracker",
+    /**
+     * Channel registered by the remote server that proxies AHP JSON-RPC
+     * frames between a renderer and the agent host running on the server.
+     * Pairs with `AgentHostIpcChannelTransport` on the renderer side.
+     */
+    RemoteProxy = "agentHostProxy"
 }
 /** Configuration key that controls whether the local agent host process is spawned. */
 export declare const AgentHostEnabledSettingId = "chat.agentHost.enabled";
@@ -23,6 +29,8 @@ export declare const AgentHostEnabledSettingId = "chat.agentHost.enabled";
 export declare const AgentHostIpcLoggingSettingId = "chat.agentHost.ipcLoggingEnabled";
 /** Configuration key that controls whether AHP JSONL logs are written for agent host transports. */
 export declare const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
+/** Configuration key that controls whether Agent Host uses its terminal tool override for Copilot SDK sessions. */
+export declare const AgentHostCustomTerminalToolEnabledSettingId = "chat.agentHost.customTerminalTool.enabled";
 /**
  * Configuration key that holds the absolute path to a locally-installed
  * `@anthropic-ai/claude-agent-sdk` package. When non-empty, the Claude agent
@@ -43,6 +51,67 @@ export declare const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.clau
  * by developers as an override.
  */
 export declare const AgentHostClaudeSdkPathEnvVar = "VSCODE_AGENT_HOST_CLAUDE_SDK_PATH";
+/** Master toggle for agent-host OTel. Explicit opt-in; other settings imply this when set. */
+export declare const AgentHostOTelEnabledSettingId = "chat.agentHost.otel.enabled";
+/** Exporter type for the SDK's OTel pipeline. One of: `otlp-http`, `otlp-grpc`, `console`, `file`. */
+export declare const AgentHostOTelExporterTypeSettingId = "chat.agentHost.otel.exporterType";
+/** OTLP endpoint URL when `exporterType` is `otlp-http` or `otlp-grpc`. */
+export declare const AgentHostOTelOtlpEndpointSettingId = "chat.agentHost.otel.otlpEndpoint";
+/** Whether to include prompt/response content in span attributes (privacy-sensitive). */
+export declare const AgentHostOTelCaptureContentSettingId = "chat.agentHost.otel.captureContent";
+/** Output path when `exporterType` is `file`. */
+export declare const AgentHostOTelOutfileSettingId = "chat.agentHost.otel.outfile";
+/** When true, ALL spans are persisted to a local SQLite store regardless of `exporterType`. */
+export declare const AgentHostOTelDbSpanExporterEnabledSettingId = "chat.agentHost.otel.dbSpanExporter.enabled";
+/**
+ * Path of the local SQLite span database, relative to `INativeEnvironmentService.userDataPath`.
+ * Kept here so both the renderer-side export action and the agent-host-side service
+ * use the same on-disk location.
+ */
+export declare const AgentHostOTelSpansDbSubPath = "agent-host/otel/agent-host-traces.db";
+/**
+ * Environment variables consumed by `AgentHostOTelService` inside the agent host
+ * process. The workbench-side agent-host starters translate the corresponding
+ * `chat.agentHost.otel.*` settings into these variables (settings → env), while
+ * any value already present on the parent process's env wins (developer override).
+ *
+ * These names match the conventions documented in
+ * `extensions/copilot/docs/monitoring/agent_monitoring.md` so the same external
+ * tooling and `OTEL_EXPORTER_OTLP_*` config recipes work unchanged.
+ */
+export declare const AgentHostOTelEnvVars: Readonly<{
+    readonly Enabled: "COPILOT_OTEL_ENABLED";
+    readonly ExporterType: "COPILOT_OTEL_EXPORTER_TYPE";
+    readonly OtlpEndpoint: "OTEL_EXPORTER_OTLP_ENDPOINT";
+    readonly OtlpEndpointAlt: "COPILOT_OTEL_ENDPOINT";
+    readonly OtlpProtocol: "OTEL_EXPORTER_OTLP_PROTOCOL";
+    readonly OtlpHeaders: "OTEL_EXPORTER_OTLP_HEADERS";
+    readonly CaptureContent: "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+    readonly FilePath: "COPILOT_OTEL_FILE_EXPORTER_PATH";
+    readonly SourceName: "COPILOT_OTEL_SOURCE_NAME";
+    readonly DbSpanExporterEnabled: "COPILOT_OTEL_DB_SPAN_EXPORTER_ENABLED";
+}>;
+/**
+ * Snapshot of the `chat.agentHost.otel.*` settings; produced by the workbench-side
+ * starters and merged with the parent process's env (env wins on key collision).
+ */
+export interface IAgentHostOTelSettings {
+    readonly enabled?: boolean;
+    readonly exporterType?: string;
+    readonly otlpEndpoint?: string;
+    readonly captureContent?: boolean;
+    readonly outfile?: string;
+    readonly dbSpanExporterEnabled?: boolean;
+}
+/**
+ * Build the env-var overlay for the agent host process from user settings and
+ * inherited env. Settings are translated to env vars, but if the same env var is
+ * already present on `inheritedEnv` it wins (developer override).
+ *
+ * Only sets a key when the underlying setting was explicitly configured — empty
+ * string / undefined settings are dropped so they don't shadow inherited env.
+ */
+export declare function buildAgentHostOTelEnv(settings: IAgentHostOTelSettings, inheritedEnv: Readonly<Record<string, string | undefined>>): Record<string, string>;
 /** Result of starting the agent host WebSocket server on-demand. */
 export interface IAgentHostSocketInfo {
     readonly socketPath: string;
@@ -223,7 +292,7 @@ export interface IAgentModelInfo {
  * acknowledgment) remain as discriminated non-action signals so the host
  * can perform side effects before — or instead of — dispatching an action.
  */
-export type AgentSignal = IAgentActionSignal | IAgentToolPendingConfirmationSignal | IAgentSubagentStartedSignal | IAgentSteeringConsumedSignal;
+export type AgentSignal = IAgentActionSignal | IAgentToolPendingConfirmationSignal | IAgentSubagentStartedSignal | IAgentSubagentCompletedSignal | IAgentSteeringConsumedSignal;
 /**
  * Carries a protocol {@link SessionAction} produced by an agent. The host
  * dispatches the action through the state manager after routing via
@@ -288,6 +357,18 @@ export interface IAgentSubagentStartedSignal {
     readonly agentDisplayName: string;
     readonly agentDescription?: string;
 }
+/**
+ * A subagent has finished — either successfully or with an error. The host
+ * uses this to tear down the child session after all of its events have been
+ * routed. The parent tool call completing is not a reliable signal for this
+ * because background subagents (e.g. Copilot's `mode: background` task) keep
+ * emitting events after their parent tool call returns immediately.
+ */
+export interface IAgentSubagentCompletedSignal {
+    readonly kind: "subagent_completed";
+    readonly session: URI;
+    readonly toolCallId: string;
+}
 /** A steering message was consumed (sent to the model). */
 export interface IAgentSteeringConsumedSignal {
     readonly kind: "steering_consumed";

package/vscode/src/vs/platform/agentHost/common/agentService.js

@@ -6,11 +6,19 @@ var AgentHostIpcChannels;
     AgentHostIpcChannels["AgentHost"] = "agentHost";
     AgentHostIpcChannels["Logger"] = "agentHostLogger";
     AgentHostIpcChannels["ConnectionTracker"] = "agentHostConnectionTracker";
+    AgentHostIpcChannels["RemoteProxy"] = "agentHostProxy";
 })(AgentHostIpcChannels || (AgentHostIpcChannels = {}));
 const AgentHostEnabledSettingId = "chat.agentHost.enabled";
 const AgentHostIpcLoggingSettingId = "chat.agentHost.ipcLoggingEnabled";
 const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
+const AgentHostCustomTerminalToolEnabledSettingId = "chat.agentHost.customTerminalTool.enabled";
 const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.claudeAgent.path";
+const AgentHostOTelEnabledSettingId = "chat.agentHost.otel.enabled";
+const AgentHostOTelExporterTypeSettingId = "chat.agentHost.otel.exporterType";
+const AgentHostOTelOtlpEndpointSettingId = "chat.agentHost.otel.otlpEndpoint";
+const AgentHostOTelCaptureContentSettingId = "chat.agentHost.otel.captureContent";
+const AgentHostOTelOutfileSettingId = "chat.agentHost.otel.outfile";
+const AgentHostOTelDbSpanExporterEnabledSettingId = "chat.agentHost.otel.dbSpanExporter.enabled";
 var AgentSession;
 (function(AgentSession) {
     function uri(provider, rawSessionId) {
@@ -32,4 +40,4 @@ var AgentSession;
     AgentSession.provider = provider;
 })(AgentSession || (AgentSession = {}));
 
-export { AgentHostAhpJsonlLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostIpcLoggingSettingId, AgentSession };
+export { AgentHostAhpJsonlLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostCustomTerminalToolEnabledSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostIpcLoggingSettingId, AgentHostOTelCaptureContentSettingId, AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelEnabledSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelOutfileSettingId, AgentSession };

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

@@ -6,7 +6,7 @@ import { ActionEnvelope, IRootConfigChangedAction, SessionAction, StateAction }
 import type { TerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
 import type { RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 import type { IStateSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
-import { StateComponents } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+import { StateComponents } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 /**
  * A read-only subscription to an agent host resource (root, session, or terminal).
  *
@@ -93,6 +93,14 @@ export declare class RootStateSubscription extends BaseAgentSubscription<RootSta
     protected _applyReducer(state: RootState, action: StateAction): RootState;
     protected _isRelevantAction(action: StateAction): boolean;
 }
+interface IPendingAction {
+    readonly clientSeq: number;
+    readonly action: SessionAction;
+}
+export interface IPendingSessionAction extends IPendingAction {
+    /** URI of the session this action targets, as stored on the subscription. */
+    readonly sessionUri: string;
+}
 /**
  * Subscription to a session at `copilot:/<uuid>`.
  * Supports write-ahead reconciliation for client-dispatchable actions.
@@ -119,6 +127,20 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<Sess
      * Clear pending actions for this session (e.g., on unsubscribe).
      */
     clearPending(): void;
+    /**
+     * Snapshot of the currently-pending optimistic actions, with the session
+     * URI included so callers can re-issue them across a reconnect. The
+     * actions remain in the subscription so the optimistic state continues
+     * to reflect them — the client must explicitly drop entries echoed back
+     * by the server.
+     */
+    getPendingActions(): IPendingSessionAction[];
+    /**
+     * Drop the pending entry whose `clientSeq` matches the supplied value.
+     * Used during reconnect to evict actions the server already echoed back
+     * in the replay buffer so they're not resent.
+     */
+    dropPendingByClientSeq(clientSeq: number): boolean;
 }
 /**
  * Subscription to a terminal at an agent-host terminal URI.
@@ -176,6 +198,44 @@ export declare class AgentSubscriptionManager extends Disposable {
      * subscription if applicable, then returns the clientSeq.
      */
     dispatchOptimistic(action: SessionAction | TerminalAction | IRootConfigChangedAction): number;
+    /**
+     * URIs currently subscribed to via {@link getSubscription}. Used to
+     * build the `subscriptions` payload for a `reconnect` RPC so the
+     * server can restore them in one round-trip.
+     *
+     * Does NOT include the always-live root state, which the protocol
+     * client manages separately.
+     */
+    currentSubscriptionUris(): URI[];
+    /**
+     * Snapshot of every pending optimistic action across all session
+     * subscriptions. Callers use this to replay actions after a transport
+     * reconnect; entries are kept on their subscriptions until they're
+     * either echoed back by the server or explicitly dropped via
+     * {@link dropPendingSessionAction}.
+     */
+    getPendingSessionActions(): IPendingSessionAction[];
+    /**
+     * Remove a single pending optimistic action for a session by its
+     * `clientSeq`. Used during reconnect to evict actions the server
+     * already processed (and replayed back to us) so they're not resent.
+     */
+    dropPendingSessionAction(sessionUri: string, clientSeq: number): void;
+    /**
+     * Apply a fresh snapshot to a subscribed resource — used when the server
+     * responds to a `reconnect` request with `type: 'snapshot'` because the
+     * replay buffer no longer covers the client's gap. Routes to the root
+     * subscription when {@link ROOT_STATE_URI} matches, otherwise reseats the
+     * matching entry in {@link _subscriptions}. Unknown resources are ignored.
+     */
+    applyReconnectSnapshot(resource: URI, state: unknown, fromSeq: number): void;
+    /**
+     * Mark a set of subscriptions as no longer resumable on the server
+     * (reported via `ReconnectReplayResult.missing`). The subscriptions
+     * themselves stay alive so consumers continue to hold valid references,
+     * but their value transitions to an `Error` until they're recreated.
+     */
+    markSubscriptionsMissing(missing: readonly URI[]): void;
     private _createSubscription;
     private _releaseSubscription;
     dispose(): void;

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

@@ -6,7 +6,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { isSessionAction } from './sessionActions.js';
 import { rootReducer, sessionReducer, terminalReducer } from './protocol/reducers.js';
-import { StateComponents } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState';
+import { ROOT_STATE_URI, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
 class BaseAgentSubscription extends Disposable {
     constructor(clientId, log) {
@@ -160,6 +160,21 @@ class SessionStateSubscription extends BaseAgentSubscription {
         this._pendingActions.length = 0;
         this._optimisticState = undefined;
     }
+    getPendingActions() {
+        return ( this._pendingActions.map(p => ({
+            clientSeq: p.clientSeq,
+            action: p.action,
+            sessionUri: this._sessionUri
+        })));
+    }
+    dropPendingByClientSeq(clientSeq) {
+        const idx = this._pendingActions.findIndex(p => p.clientSeq === clientSeq);
+        if (idx === -1) {
+            return false;
+        }
+        this._pendingActions.splice(idx, 1);
+        return true;
+    }
 }
 class TerminalStateSubscription extends BaseAgentSubscription {
     constructor(terminalUri, clientId, log) {
@@ -241,6 +256,51 @@ class AgentSubscriptionManager extends Disposable {
         }
         return this._seqAllocator();
     }
+    currentSubscriptionUris() {
+        return [...( this._subscriptions.keys())];
+    }
+    getPendingSessionActions() {
+        const out = [];
+        for (const {
+            sub
+        } of ( this._subscriptions.values())) {
+            if (sub instanceof SessionStateSubscription) {
+                out.push(...sub.getPendingActions());
+            }
+        }
+        return out;
+    }
+    dropPendingSessionAction(sessionUri, clientSeq) {
+        const entry = this._subscriptions.get(( URI.parse(sessionUri)));
+        if (entry?.sub instanceof SessionStateSubscription) {
+            entry.sub.dropPendingByClientSeq(clientSeq);
+        }
+    }
+    applyReconnectSnapshot(resource, state, fromSeq) {
+        if (( resource.toString()) === ROOT_STATE_URI) {
+            this._rootState.handleSnapshot(state, fromSeq);
+            return;
+        }
+        const entry = this._subscriptions.get(resource);
+        if (!entry) {
+            return;
+        }
+        if (entry.sub instanceof SessionStateSubscription) {
+            entry.sub.clearPending();
+        }
+        entry.sub.handleSnapshot(state, fromSeq);
+    }
+    markSubscriptionsMissing(missing) {
+        for (const resource of missing) {
+            const entry = this._subscriptions.get(resource);
+            if (entry) {
+                if (entry.sub instanceof SessionStateSubscription) {
+                    entry.sub.clearPending();
+                }
+                entry.sub.setError(( new Error(`Subscription no longer available after reconnect: ${( resource.toString())}`)));
+            }
+        }
+    }
     _createSubscription(kind, key) {
         switch (kind) {
         case StateComponents.Session:

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

@@ -1,9 +1,11 @@
 
 
+const JsonRpcErrorCodes = {
+    InvalidParams: -32602};
 const AhpErrorCodes = {
     NotFound: -32008,
     PermissionDenied: -32009,
     AlreadyExists: -32010,
 };
 
-export { AhpErrorCodes };
+export { AhpErrorCodes, JsonRpcErrorCodes };

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

@@ -1,5 +1,5 @@
 
-import { ActionType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
 import { ResponsePartKind, ToolCallStatus, SessionStatus, ToolCallCancellationReason, PendingMessageKind, TurnState, SessionLifecycle } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state';
 
 function softAssertNever(value, log) {

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

@@ -1,4 +1,4 @@
-import { type StateAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import { type StateAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
 import { type ProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
 /**
  * The current protocol version that new code speaks.

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

@@ -1,5 +1,5 @@
 
-import '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
 import '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications';
 
 const PROTOCOL_VERSION = "0.1.0";

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

@@ -1,6 +1,6 @@
-export { ActionType, type ActionEnvelope, type ActionOrigin, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type SessionCreationFailedAction, type SessionDeltaAction, type SessionDiffsChangedAction, type SessionErrorAction, type SessionModelChangedAction, type SessionReadyAction, type SessionReasoningAction, type SessionResponsePartAction, type SessionToolCallCompleteAction, type SessionToolCallConfirmedAction, type SessionToolCallApprovedAction, type SessionToolCallDeniedAction, type SessionToolCallDeltaAction, type SessionToolCallReadyAction, type SessionToolCallResultConfirmedAction, type SessionToolCallStartAction, type SessionTitleChangedAction, type SessionTurnCancelledAction, type SessionTurnCompleteAction, type SessionTurnStartedAction, type SessionUsageAction, type SessionServerToolsChangedAction, type SessionActiveClientChangedAction, type SessionActiveClientToolsChangedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionPendingMessageSetAction, type SessionPendingMessageRemovedAction, type SessionQueuedMessagesReorderedAction, type SessionInputRequestedAction, type SessionInputCompletedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionToolCallContentChangedAction, type StateAction, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+export { ActionType, type ActionEnvelope, type ActionOrigin, type RootAgentsChangedAction, type RootActiveSessionsChangedAction, type SessionCreationFailedAction, type SessionDeltaAction, type SessionDiffsChangedAction, type SessionErrorAction, type SessionModelChangedAction, type SessionReadyAction, type SessionReasoningAction, type SessionResponsePartAction, type SessionToolCallCompleteAction, type SessionToolCallConfirmedAction, type SessionToolCallApprovedAction, type SessionToolCallDeniedAction, type SessionToolCallDeltaAction, type SessionToolCallReadyAction, type SessionToolCallResultConfirmedAction, type SessionToolCallStartAction, type SessionTitleChangedAction, type SessionTurnCancelledAction, type SessionTurnCompleteAction, type SessionTurnStartedAction, type SessionUsageAction, type SessionServerToolsChangedAction, type SessionActiveClientChangedAction, type SessionActiveClientToolsChangedAction, type SessionCustomizationsChangedAction, type SessionCustomizationToggledAction, type SessionPendingMessageSetAction, type SessionPendingMessageRemovedAction, type SessionQueuedMessagesReorderedAction, type SessionInputRequestedAction, type SessionInputCompletedAction, type SessionIsReadChangedAction, type SessionIsArchivedChangedAction, type SessionToolCallContentChangedAction, type StateAction, } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
 export { NotificationType, AuthRequiredReason, type SessionAddedNotification, type SessionRemovedNotification, type AuthRequiredNotification, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
-import type { RootAgentsChangedAction, RootActiveSessionsChangedAction, SessionDeltaAction, SessionModelChangedAction, SessionReasoningAction, SessionResponsePartAction, SessionToolCallApprovedAction, SessionToolCallCompleteAction, SessionToolCallConfirmedAction, SessionToolCallDeniedAction, SessionToolCallDeltaAction, SessionToolCallReadyAction, SessionToolCallResultConfirmedAction, SessionToolCallStartAction, SessionTitleChangedAction, SessionTurnCancelledAction, SessionTurnCompleteAction, SessionTurnStartedAction, SessionUsageAction, StateAction, SessionPendingMessageSetAction, SessionPendingMessageRemovedAction, SessionQueuedMessagesReorderedAction, SessionIsReadChangedAction, SessionIsArchivedChangedAction, RootConfigChangedAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import type { RootAgentsChangedAction, RootActiveSessionsChangedAction, SessionDeltaAction, SessionModelChangedAction, SessionReasoningAction, SessionResponsePartAction, SessionToolCallApprovedAction, SessionToolCallCompleteAction, SessionToolCallConfirmedAction, SessionToolCallDeniedAction, SessionToolCallDeltaAction, SessionToolCallReadyAction, SessionToolCallResultConfirmedAction, SessionToolCallStartAction, SessionTitleChangedAction, SessionTurnCancelledAction, SessionTurnCompleteAction, SessionTurnStartedAction, SessionUsageAction, StateAction, SessionPendingMessageSetAction, SessionPendingMessageRemovedAction, SessionQueuedMessagesReorderedAction, SessionIsReadChangedAction, SessionIsArchivedChangedAction, RootConfigChangedAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions";
 import type { ProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
 import type { RootAction as IRootAction_, SessionAction as ISessionAction_, ClientSessionAction as IClientSessionAction_, ServerSessionAction as IServerSessionAction_, TerminalAction as ITerminalAction_, ClientTerminalAction as IClientTerminalAction_ } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
 export type RootAction = IRootAction_;
@@ -29,8 +29,8 @@ export type ITitleChangedAction = SessionTitleChangedAction;
 export type IUsageAction = SessionUsageAction;
 export type IReasoningAction = SessionReasoningAction;
 export type IModelChangedAction = SessionModelChangedAction;
-export type ICustomizationsChangedAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationsChangedAction;
-export type ICustomizationToggledAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationToggledAction;
+export type ICustomizationsChangedAction = import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationsChangedAction;
+export type ICustomizationToggledAction = import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions").SessionCustomizationToggledAction;
 export type IPendingMessageSetAction = SessionPendingMessageSetAction;
 export type IPendingMessageRemovedAction = SessionPendingMessageRemovedAction;
 export type IQueuedMessagesReorderedAction = SessionQueuedMessagesReorderedAction;

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

@@ -1,5 +1,5 @@
 
-export { ActionType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions';
+export { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
 export { AuthRequiredReason, NotificationType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications';
 
 function isSessionAction(action) {