@codingame/monaco-vscode-chat-service-override 33.0.8 → 34.0.0

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/reducer.d.ts

@@ -0,0 +1,12 @@
+import { type ChangesetState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state";
+import type { ChangesetAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for changeset state. Handles all {@link ChangesetAction}
+ * variants.
+ *
+ * Per the spec, every changeset action is server-only; the reducer
+ * preserves a stable file order by appending new files via
+ * {@link ActionType.ChangesetFileSet} when the id is unknown, and
+ * replacing in place when it matches an existing entry.
+ */
+export declare function changesetReducer(state: ChangesetState, action: ChangesetAction, log?: (msg: string) => void): ChangesetState;

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-changeset/reducer.js

@@ -0,0 +1,72 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { ChangesetOperationStatus, ChangesetStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import { softAssertNever } from '../common/reducer-helpers.js';
+
+function changesetReducer(state, action, log) {
+    switch (action.type) {
+        case ActionType.ChangesetStatusChanged: {
+            if (action.status === ChangesetStatus.Error) {
+                return { ...state, status: action.status, error: action.error };
+            }
+            const { error: _ignored, ...rest } = state;
+            return { ...rest, status: action.status };
+        }
+        case ActionType.ChangesetFileSet: {
+            const idx = state.files.findIndex(f => f.id === action.file.id);
+            if (idx < 0) {
+                return { ...state, files: [...state.files, action.file] };
+            }
+            const next = [...state.files];
+            next[idx] = action.file;
+            return { ...state, files: next };
+        }
+        case ActionType.ChangesetFileRemoved: {
+            const idx = state.files.findIndex(f => f.id === action.fileId);
+            if (idx < 0) {
+                return state;
+            }
+            const next = [...state.files];
+            next.splice(idx, 1);
+            return { ...state, files: next };
+        }
+        case ActionType.ChangesetOperationsChanged: {
+            if (action.operations === undefined) {
+                const { operations: _ignored, ...rest } = state;
+                return rest;
+            }
+            return { ...state, operations: action.operations };
+        }
+        case ActionType.ChangesetOperationStatusChanged: {
+            if (state.operations === undefined) {
+                return state;
+            }
+            const idx = state.operations.findIndex(o => o.id === action.operationId);
+            if (idx < 0) {
+                return state;
+            }
+            const current = state.operations[idx];
+            let nextOp;
+            if (action.status === ChangesetOperationStatus.Error) {
+                nextOp = { ...current, status: action.status, error: action.error };
+            }
+            else {
+                const { error: _ignored, ...rest } = current;
+                nextOp = { ...rest, status: action.status };
+            }
+            const next = [...state.operations];
+            next[idx] = nextOp;
+            return { ...state, operations: next };
+        }
+        case ActionType.ChangesetCleared:
+            if (state.files.length === 0) {
+                return state;
+            }
+            return { ...state, files: [] };
+        default:
+            softAssertNever(action, log);
+            return state;
+    }
+}
+
+export { changesetReducer };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-root/reducer.d.ts

@@ -0,0 +1,6 @@
+import type { RootState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state";
+import type { RootAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for root state. Handles all {@link RootAction} variants.
+ */
+export declare function rootReducer(state: RootState, action: RootAction, log?: (msg: string) => void): RootState;

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-root/reducer.js

@@ -0,0 +1,30 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { softAssertNever } from '../common/reducer-helpers.js';
+
+function rootReducer(state, action, log) {
+    switch (action.type) {
+        case ActionType.RootAgentsChanged:
+            return { ...state, agents: action.agents };
+        case ActionType.RootActiveSessionsChanged:
+            return { ...state, activeSessions: action.activeSessions };
+        case ActionType.RootTerminalsChanged:
+            return { ...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;
+    }
+}
+
+export { rootReducer };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-session/reducer.d.ts

@@ -0,0 +1,6 @@
+import { type SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state";
+import type { SessionAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for session state. Handles all {@link SessionAction} variants.
+ */
+export declare function sessionReducer(state: SessionState, action: SessionAction, log?: (msg: string) => void): SessionState;

package/vscode/src/vs/platform/agentHost/common/state/protocol/{reducers.js → channels-session/reducer.js}

@@ -1,17 +1,14 @@
 
-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';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { ResponsePartKind, ToolCallStatus, SessionStatus, ToolCallCancellationReason, PendingMessageKind, CustomizationType, TurnState, SessionLifecycle } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { softAssertNever } from '../common/reducer-helpers.js';
 
-function softAssertNever(value, log) {
-    const msg = `Unhandled action type: ${JSON.stringify(value)}`;
-    (log ?? console.warn)(msg);
-}
 function tcBase(tc) {
     return {
         toolCallId: tc.toolCallId,
         toolName: tc.toolName,
         displayName: tc.displayName,
-        toolClientId: tc.toolClientId,
+        contributor: tc.contributor,
         _meta: tc._meta
     };
 }
@@ -78,7 +75,7 @@ function endTurn(state, turnId, turnState, terminalStatus, error) {
     }));
     const turn = {
         id: active.id,
-        userMessage: active.userMessage,
+        message: active.message,
         responseParts,
         usage: active.usage,
         state: turnState,
@@ -146,54 +143,12 @@ function updateResponsePart(state, turnId, partId, updater) {
         return state;
     }
 }
-function rootReducer(state, action, log) {
-    switch (action.type) {
-    case ActionType.RootAgentsChanged:
-        return {
-            ...state,
-            agents: action.agents
-        };
-    case ActionType.RootActiveSessionsChanged:
-        return {
-            ...state,
-            activeSessions: action.activeSessions
-        };
-    case ActionType.RootTerminalsChanged:
-        return {
-            ...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;
-    }
-}
 function sessionReducer(state, action, log) {
     switch (action.type) {
     case ActionType.SessionReady:
         return {
             ...state,
-            lifecycle: SessionLifecycle.Ready,
-            summary: {
-                ...state.summary,
-                status: SessionStatus.Idle
-            }
+            lifecycle: SessionLifecycle.Ready
         };
     case ActionType.SessionCreationFailed:
         return {
@@ -207,7 +162,7 @@ function sessionReducer(state, action, log) {
                 ...state,
                 activeTurn: {
                     id: action.turnId,
-                    userMessage: action.userMessage,
+                    message: action.message,
                     responseParts: [],
                     usage: undefined
                 }
@@ -270,7 +225,7 @@ function sessionReducer(state, action, log) {
                         toolCallId: action.toolCallId,
                         toolName: action.toolName,
                         displayName: action.displayName,
-                        toolClientId: action.toolClientId,
+                        contributor: action.contributor,
                         _meta: action._meta,
                         status: ToolCallStatus.Streaming
                     }
@@ -320,38 +275,54 @@ function sessionReducer(state, action, log) {
                 modifiedAt: Date.now()
             }
         };
-    case ActionType.SessionIsReadChanged:
+    case ActionType.SessionAgentChanged:
         return {
             ...state,
             summary: {
                 ...state.summary,
-                status: withStatusFlag(state.summary.status, SessionStatus.IsRead, action.isRead)
+                agent: action.agent,
+                modifiedAt: Date.now()
             }
         };
-    case ActionType.SessionIsArchivedChanged:
+    case ActionType.SessionIsReadChanged:
         return {
             ...state,
             summary: {
                 ...state.summary,
-                status: withStatusFlag(state.summary.status, SessionStatus.IsArchived, action.isArchived)
+                status: withStatusFlag(state.summary.status, SessionStatus.IsRead, action.isRead)
             }
         };
-    case ActionType.SessionActivityChanged:
+    case ActionType.SessionIsArchivedChanged:
         return {
             ...state,
             summary: {
                 ...state.summary,
-                activity: action.activity
+                status: withStatusFlag(state.summary.status, SessionStatus.IsArchived, action.isArchived)
             }
         };
-    case ActionType.SessionDiffsChanged:
+    case ActionType.SessionActivityChanged:
         return {
             ...state,
             summary: {
                 ...state.summary,
-                diffs: action.diffs
+                activity: action.activity
             }
         };
+    case ActionType.SessionChangesetsChanged:
+        {
+            const {
+                changesets: _omit,
+                ...summaryWithoutChangesets
+            } = state.summary;
+            const newSummary = action.changesets ? {
+                ...summaryWithoutChangesets,
+                changesets: action.changesets
+            } : summaryWithoutChangesets;
+            return {
+                ...state,
+                summary: newSummary
+            };
+        }
     case ActionType.SessionConfigChanged:
         if (!state.config) {
             return state;
@@ -409,7 +380,7 @@ function sessionReducer(state, action, log) {
             if (!list) {
                 return state;
             }
-            const idx = list.findIndex(c => c.customization.uri === action.uri);
+            const idx = list.findIndex(c => c.id === action.id);
             if (idx < 0) {
                 return state;
             }
@@ -423,6 +394,70 @@ function sessionReducer(state, action, log) {
                 customizations: updated
             };
         }
+    case ActionType.SessionCustomizationUpdated:
+        {
+            const list = state.customizations ?? [];
+            const idx = list.findIndex(c => c.id === action.customization.id);
+            if (idx < 0) {
+                return {
+                    ...state,
+                    customizations: [...list, action.customization]
+                };
+            }
+            const updated = [...list];
+            updated[idx] = action.customization;
+            return {
+                ...state,
+                customizations: updated
+            };
+        }
+    case ActionType.SessionCustomizationRemoved:
+        {
+            const list = state.customizations;
+            if (!list) {
+                return state;
+            }
+            const topIdx = list.findIndex(c => c.id === action.id);
+            if (topIdx >= 0) {
+                const updated = list.slice();
+                updated.splice(topIdx, 1);
+                return {
+                    ...state,
+                    customizations: updated
+                };
+            }
+            {
+                return state;
+            }
+        }
+    case ActionType.SessionMcpServerStateChanged:
+        {
+            const list = state.customizations;
+            if (!list) {
+                return state;
+            }
+            const topIdx = list.findIndex(c => c.id === action.id);
+            if (topIdx >= 0) {
+                const entry = list[topIdx];
+                if (entry.type !== CustomizationType.McpServer) {
+                    return state;
+                }
+                const updatedEntry = {
+                    ...entry,
+                    state: action.state,
+                    channel: action.channel
+                };
+                const updated = list.slice();
+                updated[topIdx] = updatedEntry;
+                return {
+                    ...state,
+                    customizations: updated
+                };
+            }
+            {
+                return state;
+            }
+        }
     case ActionType.SessionTruncated:
         {
             let turns;
@@ -513,7 +548,7 @@ function sessionReducer(state, action, log) {
         {
             const entry = {
                 id: action.id,
-                userMessage: action.userMessage
+                message: action.message
             };
             if (action.kind === PendingMessageKind.Steering) {
                 return {
@@ -587,109 +622,5 @@ function sessionReducer(state, action, log) {
         return state;
     }
 }
-function terminalReducer(state, action, log) {
-    switch (action.type) {
-    case ActionType.TerminalData:
-        {
-            const content = [...state.content];
-            const tail = content.length > 0 ? content[content.length - 1] : undefined;
-            if (tail && tail.type === "command" && !tail.isComplete) {
-                content[content.length - 1] = {
-                    ...tail,
-                    output: tail.output + action.data
-                };
-            } else if (tail && tail.type === "unclassified") {
-                content[content.length - 1] = {
-                    ...tail,
-                    value: tail.value + action.data
-                };
-            } else {
-                content.push({
-                    type: "unclassified",
-                    value: action.data
-                });
-            }
-            return {
-                ...state,
-                content
-            };
-        }
-    case ActionType.TerminalInput:
-        return state;
-    case ActionType.TerminalResized:
-        return {
-            ...state,
-            cols: action.cols,
-            rows: action.rows
-        };
-    case ActionType.TerminalClaimed:
-        return {
-            ...state,
-            claim: action.claim
-        };
-    case ActionType.TerminalTitleChanged:
-        return {
-            ...state,
-            title: action.title
-        };
-    case ActionType.TerminalCwdChanged:
-        return {
-            ...state,
-            cwd: action.cwd
-        };
-    case ActionType.TerminalExited:
-        return {
-            ...state,
-            exitCode: action.exitCode
-        };
-    case ActionType.TerminalCleared:
-        return {
-            ...state,
-            content: []
-        };
-    case ActionType.TerminalCommandDetectionAvailable:
-        return {
-            ...state,
-            supportsCommandDetection: true
-        };
-    case ActionType.TerminalCommandExecuted:
-        {
-            const part = {
-                type: "command",
-                commandId: action.commandId,
-                commandLine: action.commandLine,
-                output: "",
-                timestamp: action.timestamp,
-                isComplete: false
-            };
-            return {
-                ...state,
-                content: [...state.content, part],
-                supportsCommandDetection: true
-            };
-        }
-    case ActionType.TerminalCommandFinished:
-        {
-            const content = ( state.content.map(p => {
-                if (p.type === "command" && p.commandId === action.commandId) {
-                    return {
-                        ...p,
-                        isComplete: true,
-                        exitCode: action.exitCode,
-                        durationMs: action.durationMs
-                    };
-                }
-                return p;
-            }));
-            return {
-                ...state,
-                content
-            };
-        }
-    default:
-        softAssertNever(action, log);
-        return state;
-    }
-}
 
-export { rootReducer, sessionReducer, softAssertNever, terminalReducer };
+export { sessionReducer };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-terminal/reducer.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state";
+import type { TerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for terminal state. Handles all {@link TerminalAction} variants.
+ */
+export declare function terminalReducer(state: TerminalState, action: TerminalAction, log?: (msg: string) => void): TerminalState;

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-terminal/reducer.js

@@ -0,0 +1,110 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { softAssertNever } from '../common/reducer-helpers.js';
+
+function terminalReducer(state, action, log) {
+    switch (action.type) {
+    case ActionType.TerminalData:
+        {
+            const content = [...state.content];
+            const tail = content.length > 0 ? content[content.length - 1] : undefined;
+            if (tail && tail.type === "command" && !tail.isComplete) {
+                content[content.length - 1] = {
+                    ...tail,
+                    output: tail.output + action.data
+                };
+            } else if (tail && tail.type === "unclassified") {
+                content[content.length - 1] = {
+                    ...tail,
+                    value: tail.value + action.data
+                };
+            } else {
+                content.push({
+                    type: "unclassified",
+                    value: action.data
+                });
+            }
+            return {
+                ...state,
+                content
+            };
+        }
+    case ActionType.TerminalInput:
+        return state;
+    case ActionType.TerminalResized:
+        return {
+            ...state,
+            cols: action.cols,
+            rows: action.rows
+        };
+    case ActionType.TerminalClaimed:
+        return {
+            ...state,
+            claim: action.claim
+        };
+    case ActionType.TerminalTitleChanged:
+        return {
+            ...state,
+            title: action.title
+        };
+    case ActionType.TerminalCwdChanged:
+        return {
+            ...state,
+            cwd: action.cwd
+        };
+    case ActionType.TerminalExited:
+        return {
+            ...state,
+            exitCode: action.exitCode
+        };
+    case ActionType.TerminalCleared:
+        return {
+            ...state,
+            content: []
+        };
+    case ActionType.TerminalCommandDetectionAvailable:
+        return {
+            ...state,
+            supportsCommandDetection: true
+        };
+    case ActionType.TerminalCommandExecuted:
+        {
+            const part = {
+                type: "command",
+                commandId: action.commandId,
+                commandLine: action.commandLine,
+                output: "",
+                timestamp: action.timestamp,
+                isComplete: false
+            };
+            return {
+                ...state,
+                content: [...state.content, part],
+                supportsCommandDetection: true
+            };
+        }
+    case ActionType.TerminalCommandFinished:
+        {
+            const content = ( state.content.map(p => {
+                if (p.type === "command" && p.commandId === action.commandId) {
+                    return {
+                        ...p,
+                        isComplete: true,
+                        exitCode: action.exitCode,
+                        durationMs: action.durationMs
+                    };
+                }
+                return p;
+            }));
+            return {
+                ...state,
+                content
+            };
+        }
+    default:
+        softAssertNever(action, log);
+        return state;
+    }
+}
+
+export { terminalReducer };

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

@@ -1,5 +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";
+import type { ProtectedResourceMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/state";
+import type { ResourceRequestParams } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/commands";
 /**
  * Standard JSON-RPC 2.0 error codes.
  *
@@ -69,6 +69,17 @@ export declare const AhpErrorCodes: {
      * overwriting (e.g. `resourceWrite` with `createOnly: true`).
      */
     readonly AlreadyExists: -32010;
+    /**
+     * An optimistic-concurrency precondition failed.
+     *
+     * Returned when a request carries a precondition token that no longer
+     * matches the receiver's current state — for example, `resourceWrite`
+     * with an `ifMatch` etag that has been superseded by a concurrent
+     * write. Callers SHOULD re-read the resource (e.g. via
+     * `resourceResolve`) and decide whether to retry the operation with the
+     * fresh token or surface the conflict to the user.
+     */
+    readonly Conflict: -32011;
 };
 /** Union type of all AHP application error codes. */
 export type AhpErrorCode = (typeof AhpErrorCodes)[keyof typeof AhpErrorCodes];

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

@@ -5,7 +5,6 @@ const JsonRpcErrorCodes = {
 const AhpErrorCodes = {
     NotFound: -32008,
     PermissionDenied: -32009,
-    AlreadyExists: -32010,
-};
+    AlreadyExists: -32010};
 
 export { AhpErrorCodes, JsonRpcErrorCodes };

package/vscode/src/vs/platform/agentHost/common/state/protocol/common/reducer-helpers.d.ts

@@ -0,0 +1,17 @@
+import { type RootAction, type ClientRootAction, type SessionAction, type ClientSessionAction, type TerminalAction, type ClientTerminalAction, type ChangesetAction, type ClientChangesetAction } 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
+ * is added but not handled.
+ *
+ * At runtime, logs a warning instead of throwing so that forward-compatible
+ * clients receiving unknown actions from a newer server degrade gracefully.
+ */
+export declare function softAssertNever(value: never, log?: (msg: string) => void): void;
+/**
+ * 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: RootAction | SessionAction | TerminalAction | ChangesetAction): action is ClientRootAction | ClientSessionAction | ClientTerminalAction | ClientChangesetAction;

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

@@ -0,0 +1,9 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+
+function softAssertNever(value, log) {
+    const msg = `Unhandled action type: ${JSON.stringify(value)}`;
+    (log ?? console.warn)(msg);
+}
+
+export { softAssertNever };