@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -0,0 +1,37 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { softAssertNever } from '../common/reducer-helpers.js';
+
+function automationReducer(state, action, log) {
+    switch (action.type) {
+        case ActionType.AutomationCreateRequested:
+        case ActionType.AutomationUpdateRequested:
+            return state;
+        case ActionType.AutomationSet: {
+            const idx = state.entries.findIndex(automation => automation.resource === action.automation.resource);
+            if (idx < 0) {
+                return {
+                    ...state,
+                    entries: [...state.entries, action.automation],
+                };
+            }
+            const entries = state.entries.slice();
+            entries[idx] = action.automation;
+            return { ...state, entries };
+        }
+        case ActionType.AutomationRemoved: {
+            const idx = state.entries.findIndex(automation => automation.resource === action.resource);
+            if (idx < 0) {
+                return state;
+            }
+            const entries = state.entries.slice();
+            entries.splice(idx, 1);
+            return { ...state, entries };
+        }
+        default:
+            softAssertNever(action, log);
+            return state;
+    }
+}
+
+export { automationReducer };

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

@@ -0,0 +1,4 @@
+import type { AutomationRunAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+import type { AutomationRunState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state";
+/** Pure reducer for automation-run state. */
+export declare function automationRunReducer(state: AutomationRunState, action: AutomationRunAction, log?: (msg: string) => void): AutomationRunState;

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

@@ -0,0 +1,45 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { softAssertNever } from '../common/reducer-helpers.js';
+
+function automationRunReducer(state, action, log) {
+    switch (action.type) {
+        case ActionType.AutomationRunLifecycleChanged:
+            return { ...state, lifecycle: action.lifecycle };
+        case ActionType.AutomationRunSessionSet:
+            if (state.sessions.includes(action.session)) {
+                return state;
+            }
+            return { ...state, sessions: [...state.sessions, action.session] };
+        case ActionType.AutomationRunSessionRemoved: {
+            const index = state.sessions.indexOf(action.session);
+            if (index < 0) {
+                return state;
+            }
+            const sessions = state.sessions.slice();
+            sessions.splice(index, 1);
+            const next = { ...state, sessions };
+            if (state.primarySession === action.session) {
+                delete next.primarySession;
+            }
+            return next;
+        }
+        case ActionType.AutomationRunPrimarySessionChanged: {
+            const next = { ...state };
+            if (action.primarySession === undefined) {
+                delete next.primarySession;
+            }
+            else {
+                next.primarySession = action.primarySession;
+            }
+            return next;
+        }
+        case ActionType.AutomationRunCancelRequested:
+            return state;
+        default:
+            softAssertNever(action, log);
+            return state;
+    }
+}
+
+export { automationRunReducer };

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

@@ -4,9 +4,10 @@ import type { ChangesetAction } from "@codingame/monaco-vscode-api/vscode/vs/pla
  * 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.
+ * 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. Per-file review lives on
+ * {@link ChangesetFile.reviewed} and is toggled (per file, in batches) by the
+ * client-dispatchable {@link ActionType.ChangesetFilesReviewChanged}.
  */
 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

@@ -5,49 +5,99 @@ import { softAssertNever } from '../common/reducer-helpers.js';
 
 function changesetReducer(state, action, log) {
     switch (action.type) {
-        case ActionType.ChangesetStatusChanged: {
+    case ActionType.ChangesetStatusChanged:
+        {
             if (action.status === ChangesetStatus.Error) {
-                return { ...state, status: action.status, error: action.error };
+                return {
+                    ...state,
+                    status: action.status,
+                    error: action.error
+                };
             }
-            const { error: _ignored, ...rest } = state;
-            return { ...rest, status: action.status };
+            const {
+                error: _ignored,
+                ...rest
+            } = state;
+            return {
+                ...rest,
+                status: action.status
+            };
         }
-        case ActionType.ChangesetFileSet: {
+    case ActionType.ChangesetFileSet:
+        {
             const idx = state.files.findIndex(f => f.id === action.file.id);
             if (idx < 0) {
-                return { ...state, files: [...state.files, action.file] };
+                return {
+                    ...state,
+                    files: [...state.files, action.file]
+                };
             }
             const next = [...state.files];
             next[idx] = action.file;
-            return { ...state, files: next };
+            return {
+                ...state,
+                files: next
+            };
         }
-        case ActionType.ChangesetFileRemoved: {
+    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 };
+            return {
+                ...state,
+                files: next
+            };
         }
-        case ActionType.ChangesetContentChanged: {
-            const next = action.operations === undefined
-                ? { ...state, files: action.files }
-                : { ...state, files: action.files, operations: action.operations };
-            if (action.error === undefined) {
-                const { error: _ignored, ...rest } = next;
-                return rest;
-            }
-            return { ...next, error: action.error };
+    case ActionType.ChangesetFilesReviewChanged:
+        {
+            let changed = false;
+            const ids = ( new Set(action.files));
+            const next = ( state.files.map(f => {
+                if (!( ids.has(f.id)) || f.reviewed === action.reviewed) {
+                    return f;
+                }
+                changed = true;
+                return {
+                    ...f,
+                    reviewed: action.reviewed
+                };
+            }));
+            return changed ? {
+                ...state,
+                files: next
+            } : state;
         }
-        case ActionType.ChangesetOperationsChanged: {
+    case ActionType.ChangesetContentChanged:
+        {
+            return action.operations === undefined ? {
+                ...state,
+                files: action.files
+            } : {
+                ...state,
+                files: action.files,
+                operations: action.operations
+            };
+        }
+    case ActionType.ChangesetOperationsChanged:
+        {
             if (action.operations === undefined) {
-                const { operations: _ignored, ...rest } = state;
+                const {
+                    operations: _ignored,
+                    ...rest
+                } = state;
                 return rest;
             }
-            return { ...state, operations: action.operations };
+            return {
+                ...state,
+                operations: action.operations
+            };
         }
-        case ActionType.ChangesetOperationStatusChanged: {
+    case ActionType.ChangesetOperationStatusChanged:
+        {
             if (state.operations === undefined) {
                 return state;
             }
@@ -58,24 +108,39 @@ function changesetReducer(state, action, log) {
             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 };
+                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 };
+            return {
+                ...state,
+                operations: next
+            };
         }
-        case ActionType.ChangesetCleared:
-            if (state.files.length === 0) {
-                return state;
-            }
-            return { ...state, files: [] };
-        default:
-            softAssertNever(action, log);
+    case ActionType.ChangesetCleared:
+        if (state.files.length === 0) {
             return state;
+        }
+        return {
+            ...state,
+            files: []
+        };
+    default:
+        softAssertNever(action, log);
+        return state;
     }
 }
 

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

@@ -3,6 +3,7 @@ import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agen
 import { ResponsePartKind, ToolCallStatus, ToolCallCancellationReason, PendingMessageKind, TurnState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import { softAssertNever } from '../common/reducer-helpers.js';
+import { addMillisecondsToTimestamp } from '../common/timestamps.js';
 
 function tcBase(tc) {
     return {
@@ -14,14 +15,39 @@ function tcBase(tc) {
         _meta: tc._meta
     };
 }
-function hasPendingToolCallConfirmation(state) {
+function hasBlockingToolCall(state) {
     if (!state.activeTurn) {
         return false;
     }
     return ( state.activeTurn.responseParts.some(
-        part => part.kind === ResponsePartKind.ToolCall && (part.toolCall.status === ToolCallStatus.PendingConfirmation || part.toolCall.status === ToolCallStatus.PendingResultConfirmation)
+        part => part.kind === ResponsePartKind.ToolCall && (part.toolCall.status === ToolCallStatus.PendingConfirmation || part.toolCall.status === ToolCallStatus.PendingResultConfirmation || part.toolCall.status === ToolCallStatus.AuthRequired)
     ));
 }
+function hasOpenInputRequest(state) {
+    return state.activeTurn?.responseParts.some(
+        part => part.kind === ResponsePartKind.InputRequest && part.response === undefined
+    ) ?? false;
+}
+function findOpenInputRequestPart(responseParts, requestId) {
+    const index = responseParts.findIndex(
+        part => part.kind === ResponsePartKind.InputRequest && part.response === undefined && part.request.id === requestId
+    );
+    if (index < 0) {
+        return undefined;
+    }
+    const part = responseParts[index];
+    return part.kind === ResponsePartKind.InputRequest ? {
+        index,
+        part
+    } : undefined;
+}
+function hasResumableError(turn) {
+    const part = turn.responseParts[turn.responseParts.length - 1];
+    return part?.kind === ResponsePartKind.Error && part.resumable === true;
+}
+function isErrorResponsePart(part) {
+    return part.kind === ResponsePartKind.Error;
+}
 function withStatusFlag(status, flag, set) {
     return set ? status | flag : status & ~flag;
 }
@@ -29,7 +55,7 @@ function summaryStatus(state, terminalStatus) {
     let activity;
     if (terminalStatus) {
         activity = terminalStatus;
-    } else if ((state.inputRequests?.length ?? 0) > 0 || hasPendingToolCallConfirmation(state)) {
+    } else if (hasOpenInputRequest(state) || hasBlockingToolCall(state)) {
         activity = SessionStatus.InputNeeded;
     } else if (state.activeTurn) {
         activity = SessionStatus.InProgress;
@@ -48,7 +74,7 @@ function refreshSummaryStatus(state) {
         status
     };
 }
-function endTurn(state, turnId, turnState, terminalStatus, error) {
+function endTurn(state, turnId, turnState, duration, terminalStatus, errorPart) {
     if (!state.activeTurn || state.activeTurn.id !== turnId) {
         return state;
     }
@@ -72,47 +98,59 @@ function endTurn(state, turnId, turnState, terminalStatus, error) {
             }
         };
     }));
+    if (errorPart) {
+        responseParts.push(errorPart);
+    }
     const turn = {
         id: active.id,
+        startedAt: active.startedAt,
+        duration: Math.max(0, duration),
         message: active.message,
         responseParts,
         usage: active.usage,
-        state: turnState,
-        error
+        state: turnState
     };
     const next = {
         ...state,
         turns: [...state.turns, turn],
         activeTurn: undefined,
-        modifiedAt: ( new Date(Date.now())).toISOString()
+        modifiedAt: addMillisecondsToTimestamp(active.startedAt, turn.duration ?? 0)
     };
-    delete next.inputRequests;
     return {
         ...next,
         status: summaryStatus(next, terminalStatus)
     };
 }
-function upsertInputRequest(state, request) {
-    const existing = state.inputRequests ?? [];
-    const idx = existing.findIndex(r => r.id === request.id);
-    const inputRequests = [...existing];
-    if (idx >= 0) {
-        const answers = request.answers ?? inputRequests[idx].answers;
-        inputRequests[idx] = {
+function upsertInputRequestPart(state, request) {
+    const activeTurn = state.activeTurn;
+    if (!activeTurn) {
+        return state;
+    }
+    const existing = findOpenInputRequestPart(activeTurn.responseParts, request.id);
+    const responseParts = [...activeTurn.responseParts];
+    const part = {
+        kind: ResponsePartKind.InputRequest,
+        request
+    };
+    if (existing) {
+        part.request = {
             ...request,
-            answers
+            answers: request.answers ?? existing.part.request.answers
         };
+        responseParts[existing.index] = part;
     } else {
-        inputRequests.push(request);
+        responseParts.push(part);
     }
     const next = {
         ...state,
-        inputRequests
+        activeTurn: {
+            ...activeTurn,
+            responseParts
+        }
     };
     return {
         ...next,
-        status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
-        modifiedAt: ( new Date(Date.now())).toISOString()
+        status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false)
     };
 }
 function updateToolCallInParts(state, turnId, toolCallId, updater) {
@@ -141,6 +179,7 @@ function chatReducer(state, action, log) {
                 ...state,
                 activeTurn: {
                     id: action.turnId,
+                    startedAt: action.startedAt,
                     message: action.message,
                     responseParts: [],
                     usage: undefined
@@ -149,7 +188,7 @@ function chatReducer(state, action, log) {
             next = {
                 ...next,
                 status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
-                modifiedAt: ( new Date(Date.now())).toISOString()
+                modifiedAt: action.startedAt
             };
             if (action.queuedMessageId) {
                 if (next.steeringMessage?.id === action.queuedMessageId) {
@@ -174,6 +213,9 @@ function chatReducer(state, action, log) {
         if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
             return state;
         }
+        if (isErrorResponsePart(action.part)) {
+            return state;
+        }
         return {
             ...state,
             activeTurn: {
@@ -182,16 +224,79 @@ function chatReducer(state, action, log) {
             }
         };
     case ActionType.ChatTurnComplete:
-        return endTurn(state, action.turnId, TurnState.Complete);
+        return endTurn(state, action.turnId, TurnState.Complete, action.duration);
     case ActionType.ChatTurnCancelled:
-        return endTurn(state, action.turnId, TurnState.Cancelled);
+        return endTurn(state, action.turnId, TurnState.Cancelled, action.duration);
     case ActionType.ChatError:
-        return endTurn(state, action.turnId, TurnState.Error, SessionStatus.Error, action.error);
+        return endTurn(
+            state,
+            action.turnId,
+            TurnState.Error,
+            action.duration,
+            SessionStatus.Error,
+            action.part
+        );
+    case ActionType.ChatTurnResume:
+        {
+            if (state.activeTurn) {
+                return state;
+            }
+            const turnIndex = state.turns.length - 1;
+            const turn = state.turns[turnIndex];
+            if (!turn || turn.id !== action.turnId || turn.state !== TurnState.Error || !hasResumableError(turn)) {
+                return state;
+            }
+            const turns = state.turns.slice();
+            turns.splice(turnIndex, 1);
+            const next = {
+                ...state,
+                turns,
+                activeTurn: {
+                    id: turn.id,
+                    startedAt: turn.startedAt ?? state.modifiedAt,
+                    message: turn.message,
+                    responseParts: turn.responseParts,
+                    usage: turn.usage
+                }
+            };
+            return {
+                ...next,
+                status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false)
+            };
+        }
     case ActionType.ChatActivityChanged:
         return {
             ...state,
             activity: action.activity
         };
+    case ActionType.ChatWorkingDirectorySet:
+        {
+            const list = state.workingDirectories ?? [];
+            if (list.includes(action.directory)) {
+                return state;
+            }
+            return {
+                ...state,
+                workingDirectories: [...list, action.directory]
+            };
+        }
+    case ActionType.ChatWorkingDirectoryRemoved:
+        {
+            const list = state.workingDirectories;
+            if (!list) {
+                return state;
+            }
+            const idx = list.indexOf(action.directory);
+            if (idx < 0) {
+                return state;
+            }
+            const updated = list.slice();
+            updated.splice(idx, 1);
+            return {
+                ...state,
+                workingDirectories: updated
+            };
+        }
     case ActionType.ChatToolCallStart:
         if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
             return state;
@@ -226,6 +331,10 @@ function chatReducer(state, action, log) {
         return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
     case ActionType.ChatToolCallContentChanged:
         return updateToolCallInParts(state, action.turnId);
+    case ActionType.ChatToolCallAuthRequired:
+        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
+    case ActionType.ChatToolCallAuthResolved:
+        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
     case ActionType.ChatUsage:
         if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
             return state;
@@ -254,25 +363,40 @@ function chatReducer(state, action, log) {
             const next = {
                 ...state,
                 turns,
-                activeTurn: undefined,
-                modifiedAt: ( new Date(Date.now())).toISOString()
+                activeTurn: undefined
             };
-            delete next.inputRequests;
+            if (action.turnId === undefined) {
+                delete next.turnsNextCursor;
+            }
             return {
                 ...next,
                 status: summaryStatus(next)
             };
         }
+    case ActionType.ChatTurnsLoaded:
+        {
+            const existingIds = ( new Set(( state.turns.map(turn => turn.id))));
+            const olderTurns = action.turns.filter(turn => !( existingIds.has(turn.id)));
+            return {
+                ...state,
+                turns: [...olderTurns, ...state.turns],
+                turnsNextCursor: action.turnsNextCursor
+            };
+        }
     case ActionType.ChatInputRequested:
-        return upsertInputRequest(state, action.request);
+        return upsertInputRequestPart(state, action.request);
     case ActionType.ChatInputAnswerChanged:
         {
-            const existing = state.inputRequests;
-            const idx = existing?.findIndex(request => request.id === action.requestId) ?? -1;
-            if (!existing || idx < 0) {
+            const activeTurn = state.activeTurn;
+            const existing = activeTurn ? findOpenInputRequestPart(activeTurn.responseParts, action.requestId) : undefined;
+            if (!activeTurn || !existing) {
                 return state;
             }
-            const request = existing[idx];
+            const {
+                index,
+                part
+            } = existing;
+            const request = part.request;
             const answers = {
                 ...(request.answers ?? {})
             };
@@ -281,36 +405,56 @@ function chatReducer(state, action, log) {
             } else {
                 answers[action.questionId] = action.answer;
             }
-            const updated = [...existing];
-            updated[idx] = {
-                ...request,
-                answers: ( Object.keys(answers)).length > 0 ? answers : undefined
+            const responseParts = [...activeTurn.responseParts];
+            responseParts[index] = {
+                ...part,
+                request: {
+                    ...request,
+                    answers: ( Object.keys(answers)).length > 0 ? answers : undefined
+                }
             };
             return {
                 ...state,
-                inputRequests: updated,
-                modifiedAt: ( new Date(Date.now())).toISOString()
+                activeTurn: {
+                    ...activeTurn,
+                    responseParts
+                }
             };
         }
     case ActionType.ChatInputCompleted:
         {
-            const existing = state.inputRequests;
-            if (!existing?.some(request => request.id === action.requestId)) {
+            const activeTurn = state.activeTurn;
+            const existing = activeTurn ? findOpenInputRequestPart(activeTurn.responseParts, action.requestId) : undefined;
+            if (!activeTurn || !existing) {
                 return state;
             }
-            const inputRequests = existing.filter(request => request.id !== action.requestId);
+            const {
+                index,
+                part
+            } = existing;
+            const finalAnswers = {
+                ...(part.request.answers ?? {}),
+                ...(action.answers ?? {})
+            };
+            const responseParts = [...activeTurn.responseParts];
+            responseParts[index] = {
+                ...part,
+                request: {
+                    ...part.request,
+                    answers: ( Object.keys(finalAnswers)).length > 0 ? finalAnswers : undefined
+                },
+                response: action.response
+            };
             const next = {
-                ...state
+                ...state,
+                activeTurn: {
+                    ...activeTurn,
+                    responseParts
+                }
             };
-            if (inputRequests.length > 0) {
-                next.inputRequests = inputRequests;
-            } else {
-                delete next.inputRequests;
-            }
             return {
                 ...next,
-                status: summaryStatus(next),
-                modifiedAt: ( new Date(Date.now())).toISOString()
+                status: summaryStatus(next)
             };
         }
     case ActionType.ChatPendingMessageSet: