@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.0

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

@@ -0,0 +1,35 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+export type AhpLogDirection = "c2s" | "s2c";
+export interface IAhpJsonlLoggerOptions {
+    readonly logsHome: URI;
+    readonly connectionId: string;
+    readonly transport: string;
+    readonly maxFileSizeBytes?: number;
+    readonly maxFiles?: number;
+}
+export declare class AhpJsonlLogger extends Disposable {
+    private readonly _options;
+    private readonly _fileService;
+    private readonly _logService;
+    private readonly _directory;
+    private readonly _baseName;
+    private readonly _maxFileSizeBytes;
+    private readonly _maxFiles;
+    private _currentFile;
+    private _currentSize;
+    private _segment;
+    private _queue;
+    private _folderCreated;
+    constructor(_options: IAhpJsonlLoggerOptions, _fileService: IFileService, _logService: ILogService);
+    get resource(): URI;
+    log(message: object, dir: AhpLogDirection, byteLength?: number): void;
+    flush(): Promise<void>;
+    private _appendLine;
+    private _rotate;
+    private _resourceForSegment;
+    private _getFileSize;
+}
+export declare function getAhpLogByteLength(text: string): number;

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

@@ -0,0 +1,106 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+
+const AHP_LOG_DIR = "ahp";
+const DEFAULT_MAX_FILE_SIZE_BYTES = 75 * 1024 * 1024;
+const DEFAULT_MAX_FILES = 5;
+let AhpJsonlLogger = class AhpJsonlLogger extends Disposable {
+    constructor(_options, _fileService, _logService) {
+        super();
+        this._options = _options;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._currentSize = 0;
+        this._segment = 0;
+        this._queue = Promise.resolve();
+        this._directory = joinPath(this._options.logsHome, AHP_LOG_DIR);
+        const safeConnectionId = sanitizeFilePart(this._options.connectionId).slice(0, 64);
+        this._baseName = `ahp-${toFileTimestamp(( new Date()))}-${safeConnectionId}.jsonl`;
+        this._maxFileSizeBytes = this._options.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+        this._maxFiles = this._options.maxFiles ?? DEFAULT_MAX_FILES;
+        this._currentFile = joinPath(this._directory, this._baseName);
+    }
+    get resource() {
+        return this._currentFile;
+    }
+    log(message, dir, byteLength) {
+        const entry = {
+            ...message,
+            _ahpLog: {
+                ts: ( new Date()).toISOString(),
+                dir,
+                connectionId: this._options.connectionId,
+                transport: this._options.transport,
+                ...(typeof byteLength === "number" ? {
+                    byteLength
+                } : {})
+            }
+        };
+        const line = `${JSON.stringify(entry)}\n`;
+        const buffer = VSBuffer.fromString(line);
+        this._queue = this._queue.then(() => this._appendLine(buffer)).catch(error => {
+            this._logService.error("[AHPLog] Failed to write transport log", error);
+        });
+    }
+    async flush() {
+        await this._queue;
+    }
+    async _appendLine(buffer) {
+        if (!this._folderCreated) {
+            this._folderCreated = this._fileService.createFolder(this._directory);
+        }
+        await this._folderCreated;
+        if (this._currentSize === 0) {
+            this._currentSize = await this._getFileSize(this._currentFile);
+        }
+        if (this._currentSize > 0 && this._currentSize + buffer.byteLength > this._maxFileSizeBytes) {
+            await this._rotate();
+        }
+        await this._fileService.writeFile(this._currentFile, buffer, {
+            append: true
+        });
+        this._currentSize += buffer.byteLength;
+    }
+    async _rotate() {
+        this._segment++;
+        const oldSegment = this._segment - this._maxFiles;
+        if (oldSegment >= 0) {
+            await this._fileService.del(this._resourceForSegment(oldSegment)).catch(error => {
+                this._logService.trace("[AHPLog] Failed to delete old transport log", error);
+            });
+        }
+        this._currentFile = this._resourceForSegment(this._segment);
+        this._currentSize = await this._getFileSize(this._currentFile);
+    }
+    _resourceForSegment(segment) {
+        if (segment === 0) {
+            return joinPath(this._directory, this._baseName);
+        }
+        const currentBaseName = this._baseName.slice(0, -".jsonl".length);
+        return joinPath(this._directory, `${currentBaseName}.${segment}.jsonl`);
+    }
+    async _getFileSize(resource) {
+        try {
+            return (await this._fileService.resolve(resource)).size ?? 0;
+        } catch {
+            return 0;
+        }
+    }
+};
+AhpJsonlLogger = ( __decorate([( __param(1, IFileService)), ( __param(2, ILogService))], AhpJsonlLogger));
+function getAhpLogByteLength(text) {
+    return VSBuffer.fromString(text).byteLength;
+}
+function toFileTimestamp(date) {
+    return date.toISOString().replace(/[:.]/g, "-");
+}
+function sanitizeFilePart(value) {
+    return value.replace(/[\\/:\*\?"<>\|\s]+/g, "-").replace(/^-+|-+$/g, "") || "connection";
+}
+
+export { AhpJsonlLogger, getAhpLogByteLength };

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

@@ -1,10 +1,11 @@
 import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IReference } 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 { IActionEnvelope, ISessionAction, IStateAction } from "./sessionActions.js";
-import type { ITerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
-import type { IRootState, ISessionState, ITerminalState } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state";
-import type { IStateSnapshot } from "./sessionProtocol.js";
+import { ActionEnvelope, IRootConfigChangedAction, SessionAction, StateAction } from "./sessionActions.js";
+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";
 /**
  * A read-only subscription to an agent host resource (root, session, or terminal).
@@ -31,9 +32,9 @@ export interface IAgentSubscription<T> {
     /** Fires when {@link value} changes (optimistic or confirmed). */
     readonly onDidChange: Event<T>;
     /** Fires before a server-originated action is applied to this subscription's state. */
-    readonly onWillApplyAction: Event<IActionEnvelope>;
+    readonly onWillApplyAction: Event<ActionEnvelope>;
     /** Fires after a server-originated action is applied to this subscription's state. */
-    readonly onDidApplyAction: Event<IActionEnvelope>;
+    readonly onDidApplyAction: Event<ActionEnvelope>;
 }
 /**
  * Base class for agent subscriptions. Handles envelope reception, confirmed
@@ -48,10 +49,10 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
     private _bufferedEnvelopes;
     protected readonly _onDidChange: Emitter<T>;
     readonly onDidChange: Event<T>;
-    protected readonly _onWillApplyAction: Emitter<IActionEnvelope>;
-    readonly onWillApplyAction: Event<IActionEnvelope>;
-    protected readonly _onDidApplyAction: Emitter<IActionEnvelope>;
-    readonly onDidApplyAction: Event<IActionEnvelope>;
+    protected readonly _onWillApplyAction: Emitter<ActionEnvelope>;
+    readonly onWillApplyAction: Event<ActionEnvelope>;
+    protected readonly _onDidApplyAction: Emitter<ActionEnvelope>;
+    readonly onDidApplyAction: Event<ActionEnvelope>;
     protected readonly _clientId: string;
     protected readonly _log: (msg: string) => void;
     constructor(clientId: string, log: (msg: string) => void);
@@ -69,11 +70,11 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
      * Process an incoming action envelope. The subscription determines
      * whether the action is relevant via {@link _isRelevantAction}.
      */
-    receiveEnvelope(envelope: IActionEnvelope): void;
+    receiveEnvelope(envelope: ActionEnvelope): void;
     /** Apply the reducer to confirmed state. Subclasses must implement. */
-    protected abstract _applyReducer(state: T, action: IStateAction): T;
+    protected abstract _applyReducer(state: T, action: StateAction): T;
     /** Whether the given action targets this subscription. */
-    protected abstract _isRelevantAction(action: IStateAction): boolean;
+    protected abstract _isRelevantAction(action: StateAction): boolean;
     /** Return optimistic state if write-ahead is active, otherwise `undefined`. */
     protected _getOptimisticState(): T | undefined;
     /** Hook called after a snapshot is applied. Replays buffered actions. */
@@ -82,21 +83,21 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
      * Default reconciliation: apply to confirmed, fire change event.
      * Session subscriptions override this for write-ahead.
      */
-    protected _reconcile(envelope: IActionEnvelope, _isOwnAction: boolean): void;
+    protected _reconcile(envelope: ActionEnvelope, _isOwnAction: boolean): void;
 }
 /**
  * Subscription to the root state at `agenthost:/root`.
  * Server-only mutations — no write-ahead.
  */
-export declare class RootStateSubscription extends BaseAgentSubscription<IRootState> {
-    protected _applyReducer(state: IRootState, action: IStateAction): IRootState;
-    protected _isRelevantAction(action: IStateAction): boolean;
+export declare class RootStateSubscription extends BaseAgentSubscription<RootState> {
+    protected _applyReducer(state: RootState, action: StateAction): RootState;
+    protected _isRelevantAction(action: StateAction): boolean;
 }
 /**
  * Subscription to a session at `copilot:/<uuid>`.
  * Supports write-ahead reconciliation for client-dispatchable actions.
  */
-export declare class SessionStateSubscription extends BaseAgentSubscription<ISessionState> {
+export declare class SessionStateSubscription extends BaseAgentSubscription<SessionState> {
     private readonly _pendingActions;
     private _optimisticState;
     private readonly _sessionUri;
@@ -106,12 +107,12 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<ISes
      * Optimistically apply a session action. Returns the clientSeq to send
      * to the server so it can echo back for reconciliation.
      */
-    applyOptimistic(action: ISessionAction): number;
-    protected _getOptimisticState(): ISessionState | undefined;
-    protected _applyReducer(state: ISessionState, action: IStateAction): ISessionState;
-    protected _isRelevantAction(action: IStateAction): boolean;
+    applyOptimistic(action: SessionAction): number;
+    protected _getOptimisticState(): SessionState | undefined;
+    protected _applyReducer(state: SessionState, action: StateAction): SessionState;
+    protected _isRelevantAction(action: StateAction): boolean;
     protected _onSnapshotApplied(fromSeq: number): void;
-    protected _reconcile(envelope: IActionEnvelope, isOwnAction: boolean): void;
+    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
     private _confirmedApply;
     private _recomputeOptimistic;
     /**
@@ -123,11 +124,11 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<ISes
  * Subscription to a terminal at an agent-host terminal URI.
  * Server-only mutations — no write-ahead (terminal I/O is side-effect-only).
  */
-export declare class TerminalStateSubscription extends BaseAgentSubscription<ITerminalState> {
+export declare class TerminalStateSubscription extends BaseAgentSubscription<TerminalState> {
     private readonly _terminalUri;
     constructor(terminalUri: string, clientId: string, log: (msg: string) => void);
-    protected _applyReducer(state: ITerminalState, action: IStateAction): ITerminalState;
-    protected _isRelevantAction(action: IStateAction): boolean;
+    protected _applyReducer(state: TerminalState, action: StateAction): TerminalState;
+    protected _isRelevantAction(action: StateAction): boolean;
 }
 /**
  * Manages the lifecycle of resource subscriptions for an agent connection.
@@ -149,12 +150,12 @@ export declare class AgentSubscriptionManager extends Disposable {
     private readonly _unsubscribe;
     constructor(clientId: string, seqAllocator: () => number, log: (msg: string) => void, subscribe: (resource: URI) => Promise<IStateSnapshot>, unsubscribe: (resource: URI) => void);
     /** The always-live root state subscription. */
-    get rootState(): IAgentSubscription<IRootState>;
+    get rootState(): IAgentSubscription<RootState>;
     /**
      * Initialize the root state from a snapshot received during the
      * connection handshake.
      */
-    handleRootSnapshot(state: IRootState, fromSeq: number): void;
+    handleRootSnapshot(state: RootState, fromSeq: number): void;
     /**
      * Returns an existing subscription without affecting its refcount.
      * Returns `undefined` if no subscription is active for the given resource.
@@ -169,14 +170,21 @@ export declare class AgentSubscriptionManager extends Disposable {
     /**
      * Route an incoming action envelope to all active subscriptions.
      */
-    receiveEnvelope(envelope: IActionEnvelope): void;
+    receiveEnvelope(envelope: ActionEnvelope): void;
     /**
      * Dispatch a client action. Applies optimistically to the relevant
      * subscription if applicable, then returns the clientSeq.
      */
-    dispatchOptimistic(action: ISessionAction | ITerminalAction): number;
+    dispatchOptimistic(action: SessionAction | TerminalAction | IRootConfigChangedAction): number;
     private _createSubscription;
     private _releaseSubscription;
     dispose(): void;
 }
+/**
+ * Adapts an {@link IAgentSubscription} into an {@link IObservable} of the
+ * subscription's value. Errors and the pre-snapshot phase are surfaced as
+ * `undefined`; consumers that need the error itself should read
+ * {@link IAgentSubscription.value} directly.
+ */
+export declare function observableFromSubscription<T>(owner: object | undefined, sub: IAgentSubscription<T>): IObservable<T | undefined>;
 export {};

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

@@ -2,6 +2,7 @@
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 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';
@@ -234,7 +235,7 @@ class AgentSubscriptionManager extends Disposable {
     dispatchOptimistic(action) {
         if (isSessionAction(action)) {
             const entry = this._subscriptions.get(( URI.parse(action.session)));
-            if (entry && entry.sub instanceof SessionStateSubscription) {
+            if (entry?.sub instanceof SessionStateSubscription) {
                 return entry.sub.applyOptimistic(action);
             }
         }

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

@@ -1,3 +1,5 @@
+import type { ProtectedResourceMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { ResourceRequestParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 /**
  * Standard JSON-RPC 2.0 error codes.
  *
@@ -30,15 +32,20 @@ export declare const AhpErrorCodes: {
     readonly SessionAlreadyExists: -32003;
     /** The operation requires no active turn, but one is in progress */
     readonly TurnInProgress: -32004;
-    /** The client's protocol version is not supported by the server */
+    /**
+     * The server cannot speak any of the protocol versions offered by the
+     * client in `InitializeParams.protocolVersions`. The `data` field of the
+     * JSON-RPC error MAY be an `UnsupportedProtocolVersionErrorData` advertising
+     * the protocol versions the server is willing to speak.
+     */
     readonly UnsupportedProtocolVersion: -32005;
     /** The requested content URI does not exist */
     readonly ContentNotFound: -32006;
     /**
      * A command failed because the client has not authenticated for a required
-     * protected resource. The `data` field of the JSON-RPC error SHOULD contain
-     * an `IProtectedResourceMetadata[]` array describing the resources that
-     * require authentication.
+     * protected resource. The `data` field of the JSON-RPC error MUST be an
+     * `AuthRequiredErrorData` describing the resources that require
+     * authentication.
      *
      * @see {@link /specification/authentication | Authentication}
      */
@@ -51,6 +58,10 @@ export declare const AhpErrorCodes: {
      * Servers SHOULD return this when a client attempts to read or browse
      * a path outside the allowed set (e.g. outside the session's working
      * directory or workspace roots).
+     *
+     * The `data` field of the JSON-RPC error MAY be a
+     * `PermissionDeniedErrorData` advertising a `resourceRequest` that, if
+     * granted, would unlock the operation.
      */
     readonly PermissionDenied: -32009;
     /**
@@ -63,3 +74,102 @@ export declare const AhpErrorCodes: {
 export type AhpErrorCode = (typeof AhpErrorCodes)[keyof typeof AhpErrorCodes];
 /** Union type of all JSON-RPC error codes. */
 export type JsonRpcErrorCode = (typeof JsonRpcErrorCodes)[keyof typeof JsonRpcErrorCodes];
+/**
+ * Details carried in the `data` field of an `AuthRequired` (-32007) error.
+ *
+ * Wraps the protected resource list in `{ resources: [...] }` rather than
+ * returning a bare array, so additional fields can be added in future
+ * versions without breaking the wire shape.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface AuthRequiredErrorData {
+    /** Protected resources that require authentication. */
+    resources: ProtectedResourceMetadata[];
+}
+/**
+ * Details carried in the `data` field of a `PermissionDenied` (-32009) error.
+ *
+ * The receiver MAY advertise a `resourceRequest` payload describing the
+ * access that, if granted, would unlock the operation. The caller MAY then
+ * issue `resourceRequest` with that payload to negotiate access.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface PermissionDeniedErrorData {
+    /**
+     * The resource access that, if granted via `resourceRequest`, would unlock
+     * the operation. Omitted when no specific access grant would resolve the
+     * denial (for example, when the resource is fundamentally inaccessible).
+     */
+    request?: ResourceRequestParams;
+}
+/**
+ * Details carried in the `data` field of an `UnsupportedProtocolVersion`
+ * (-32005) error.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface UnsupportedProtocolVersionErrorData {
+    /**
+     * Protocol versions the server is willing to speak.
+     *
+     * Each entry is either a [SemVer](https://semver.org) `MAJOR.MINOR.PATCH`
+     * string (e.g. `"0.1.0"`) or a [SemVer range](https://semver.org/#spec-item-11)
+     * constraint (e.g. `">=0.1.0 <0.3.0"` or `"^0.2.0"`).
+     */
+    supportedVersions: string[];
+}
+/**
+ * Maps each AHP error code that carries structured `data` to the type of
+ * that data.
+ *
+ * Error codes not present in this map either have no `data` payload or
+ * carry an unspecified payload that callers SHOULD treat as `unknown`.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface AhpErrorDetailsMap {
+    [AhpErrorCodes.AuthRequired]: AuthRequiredErrorData;
+    [AhpErrorCodes.PermissionDenied]: PermissionDeniedErrorData;
+    [AhpErrorCodes.UnsupportedProtocolVersion]: UnsupportedProtocolVersionErrorData;
+}
+/** AHP error codes that carry a structured `data` payload. */
+export type AhpErrorCodeWithData = keyof AhpErrorDetailsMap;
+/**
+ * A typed JSON-RPC error object whose `data` is narrowed by `code`.
+ *
+ * Distributes over the `AhpErrorCode` union so narrowing on `code` reveals
+ * the precise `data` type. For codes listed in {@link AhpErrorDetailsMap}
+ * `data` is required; for all other codes `data` is an optional `unknown`.
+ *
+ * ```ts
+ * function handle(err: AhpError) {
+ *   if (err.code === AhpErrorCodes.PermissionDenied) {
+ *     err.data.request; // typed as ResourceRequestParams | undefined
+ *   }
+ * }
+ * ```
+ *
+ * @category Error Details
+ * @version 1
+ */
+export type AhpError<C extends AhpErrorCode = AhpErrorCode> = C extends AhpErrorCode ? C extends keyof AhpErrorDetailsMap ? {
+    /** The error code. */
+    readonly code: C;
+    /** Human-readable error message. */
+    readonly message: string;
+    /** Structured detail payload mandated by `AhpErrorDetailsMap`. */
+    readonly data: AhpErrorDetailsMap[C];
+} : {
+    /** The error code. */
+    readonly code: C;
+    /** Human-readable error message. */
+    readonly message: string;
+    /** Optional, unspecified detail payload. */
+    readonly data?: unknown;
+} : never;

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

@@ -1,5 +1,5 @@
-import { type IRootState, type ISessionState, type ITerminalState } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state";
-import { type IRootAction, type ISessionAction, type IClientSessionAction, type ITerminalAction, type IClientTerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+import { type RootState, type SessionState, type TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { type RootAction, type ClientRootAction, type SessionAction, type ClientSessionAction, type TerminalAction, type ClientTerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
 /**
  * Soft assertion for exhaustiveness checking. Place in the `default` branch of
  * a switch on a discriminated union so the compiler errors when a new variant
@@ -10,21 +10,21 @@ import { type IRootAction, type ISessionAction, type IClientSessionAction, type
  */
 export declare function softAssertNever(value: never, log?: (msg: string) => void): void;
 /**
- * Pure reducer for root state. Handles all {@link IRootAction} variants.
+ * Pure reducer for root state. Handles all {@link RootAction} variants.
  */
-export declare function rootReducer(state: IRootState, action: IRootAction, log?: (msg: string) => void): IRootState;
+export declare function rootReducer(state: RootState, action: RootAction, log?: (msg: string) => void): RootState;
 /**
- * Pure reducer for session state. Handles all {@link ISessionAction} variants.
+ * Pure reducer for session state. Handles all {@link SessionAction} variants.
  */
-export declare function sessionReducer(state: ISessionState, action: ISessionAction, log?: (msg: string) => void): ISessionState;
+export declare function sessionReducer(state: SessionState, action: SessionAction, log?: (msg: string) => void): SessionState;
 /**
- * Pure reducer for terminal state. Handles all {@link ITerminalAction} variants.
+ * Pure reducer for terminal state. Handles all {@link TerminalAction} variants.
  */
-export declare function terminalReducer(state: ITerminalState, action: ITerminalAction, log?: (msg: string) => void): ITerminalState;
+export declare function terminalReducer(state: TerminalState, action: TerminalAction, log?: (msg: string) => void): TerminalState;
 /**
- * Type guard that checks whether a session action may be dispatched by a client.
+ * Type guard that checks whether an action may be dispatched by a client.
  *
  * Servers SHOULD call this to validate incoming `dispatchAction` requests
  * and reject any action the client is not allowed to originate.
  */
-export declare function isClientDispatchable(action: ISessionAction | ITerminalAction): action is IClientSessionAction | IClientTerminalAction;
+export declare function isClientDispatchable(action: RootAction | SessionAction | TerminalAction): action is ClientRootAction | ClientSessionAction | ClientTerminalAction;

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

@@ -1,6 +1,6 @@
 
 import { ActionType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions';
-import { ResponsePartKind, ToolCallStatus, SessionStatus, ToolCallCancellationReason, PendingMessageKind, TurnState, SessionLifecycle } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state';
+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) {
     const msg = `Unhandled action type: ${JSON.stringify(value)}`;
@@ -23,17 +23,21 @@ function hasPendingToolCallConfirmation(state) {
         part => part.kind === ResponsePartKind.ToolCall && (part.toolCall.status === ToolCallStatus.PendingConfirmation || part.toolCall.status === ToolCallStatus.PendingResultConfirmation)
     ));
 }
+function withStatusFlag(status, flag, set) {
+    return set ? status | flag : status & ~flag;
+}
 function summaryStatus(state, terminalStatus) {
+    let activity;
     if (terminalStatus) {
-        return terminalStatus;
-    }
-    if ((state.inputRequests?.length ?? 0) > 0 || hasPendingToolCallConfirmation(state)) {
-        return SessionStatus.InputNeeded;
-    }
-    if (state.activeTurn) {
-        return SessionStatus.InProgress;
+        activity = terminalStatus;
+    } else if ((state.inputRequests?.length ?? 0) > 0 || hasPendingToolCallConfirmation(state)) {
+        activity = SessionStatus.InputNeeded;
+    } else if (state.activeTurn) {
+        activity = SessionStatus.InProgress;
+    } else {
+        activity = SessionStatus.Idle;
     }
-    return SessionStatus.Idle;
+    return state.summary.status & -32 | activity;
 }
 function refreshSummaryStatus(state) {
     const status = summaryStatus(state);
@@ -119,9 +123,8 @@ function upsertInputRequest(state, request) {
         ...next,
         summary: {
             ...next.summary,
-            status: summaryStatus(next),
-            modifiedAt: Date.now(),
-            isRead: false
+            status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
+            modifiedAt: Date.now()
         }
     };
 }
@@ -160,6 +163,22 @@ function rootReducer(state, action, log) {
             ...state,
             terminals: action.terminals
         };
+    case ActionType.RootConfigChanged:
+        if (!state.config) {
+            return state;
+        }
+        return {
+            ...state,
+            config: {
+                ...state.config,
+                values: action.replace ? {
+                    ...action.config
+                } : {
+                    ...state.config.values,
+                    ...action.config
+                }
+            }
+        };
     default:
         softAssertNever(action, log);
         return state;
@@ -197,9 +216,8 @@ function sessionReducer(state, action, log) {
                 ...next,
                 summary: {
                     ...next.summary,
-                    status: summaryStatus(next),
-                    modifiedAt: Date.now(),
-                    isRead: false
+                    status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
+                    modifiedAt: Date.now()
                 }
             };
             if (action.queuedMessageId) {
@@ -307,15 +325,23 @@ function sessionReducer(state, action, log) {
             ...state,
             summary: {
                 ...state.summary,
-                isRead: action.isRead
+                status: withStatusFlag(state.summary.status, SessionStatus.IsRead, action.isRead)
             }
         };
-    case ActionType.SessionIsDoneChanged:
+    case ActionType.SessionIsArchivedChanged:
         return {
             ...state,
             summary: {
                 ...state.summary,
-                isDone: action.isDone
+                status: withStatusFlag(state.summary.status, SessionStatus.IsArchived, action.isArchived)
+            }
+        };
+    case ActionType.SessionActivityChanged:
+        return {
+            ...state,
+            summary: {
+                ...state.summary,
+                activity: action.activity
             }
         };
     case ActionType.SessionDiffsChanged:
@@ -334,7 +360,9 @@ function sessionReducer(state, action, log) {
             ...state,
             config: {
                 ...state.config,
-                values: {
+                values: action.replace ? {
+                    ...action.config
+                } : {
                     ...state.config.values,
                     ...action.config
                 }
@@ -344,6 +372,11 @@ function sessionReducer(state, action, log) {
                 modifiedAt: Date.now()
             }
         };
+    case ActionType.SessionMetaChanged:
+        return {
+            ...state,
+            _meta: action._meta
+        };
     case ActionType.SessionServerToolsChanged:
         return {
             ...state,