@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

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

@@ -1,147 +1,16 @@
 
 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 { SessionStatus, CustomizationType, SessionLifecycle } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import { softAssertNever } from '../common/reducer-helpers.js';
 
-function tcBase(tc) {
-    return {
-        toolCallId: tc.toolCallId,
-        toolName: tc.toolName,
-        displayName: tc.displayName,
-        contributor: tc.contributor,
-        _meta: tc._meta
-    };
-}
-function hasPendingToolCallConfirmation(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)
-    ));
-}
 function withStatusFlag(status, flag, set) {
     return set ? status | flag : status & ~flag;
 }
-function summaryStatus(state, terminalStatus) {
-    let activity;
-    if (terminalStatus) {
-        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 state.summary.status & -32 | activity;
-}
-function refreshSummaryStatus(state) {
-    const status = summaryStatus(state);
-    if (status === state.summary.status) {
-        return state;
-    }
-    return {
-        ...state,
-        summary: {
-            ...state.summary,
-            status
-        }
-    };
-}
-function endTurn(state, turnId, turnState, terminalStatus, error) {
-    if (!state.activeTurn || state.activeTurn.id !== turnId) {
-        return state;
-    }
-    const active = state.activeTurn;
-    const responseParts = ( active.responseParts.map(part => {
-        if (part.kind !== ResponsePartKind.ToolCall) {
-            return part;
-        }
-        const tc = part.toolCall;
-        if (tc.status === ToolCallStatus.Completed || tc.status === ToolCallStatus.Cancelled) {
-            return part;
-        }
-        return {
-            kind: ResponsePartKind.ToolCall,
-            toolCall: {
-                status: ToolCallStatus.Cancelled,
-                ...tcBase(tc),
-                invocationMessage: tc.status === ToolCallStatus.Streaming ? (tc.invocationMessage ?? "") : tc.invocationMessage,
-                toolInput: tc.status === ToolCallStatus.Streaming ? undefined : tc.toolInput,
-                reason: ToolCallCancellationReason.Skipped
-            }
-        };
-    }));
-    const turn = {
-        id: active.id,
-        message: active.message,
-        responseParts,
-        usage: active.usage,
-        state: turnState,
-        error
-    };
-    const next = {
-        ...state,
-        turns: [...state.turns, turn],
-        activeTurn: undefined,
-        summary: {
-            ...state.summary,
-            modifiedAt: Date.now()
-        }
-    };
-    delete next.inputRequests;
-    return {
-        ...next,
-        summary: {
-            ...next.summary,
-            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] = {
-            ...request,
-            answers
-        };
-    } else {
-        inputRequests.push(request);
-    }
-    const next = {
-        ...state,
-        inputRequests
-    };
-    return {
-        ...next,
-        summary: {
-            ...next.summary,
-            status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
-            modifiedAt: Date.now()
-        }
-    };
-}
-function updateToolCallInParts(state, turnId, toolCallId, updater) {
-    const activeTurn = state.activeTurn;
-    if (!activeTurn || activeTurn.id !== turnId) {
-        return state;
-    }
-    {
-        return state;
-    }
-}
-function updateResponsePart(state, turnId, partId, updater) {
-    const activeTurn = state.activeTurn;
-    if (!activeTurn || activeTurn.id !== turnId) {
-        return state;
-    }
-    {
-        return state;
+function withInputNeededStatus(status, inputNeeded) {
+    if (inputNeeded.length > 0) {
+        return (status & -32) | SessionStatus.InputNeeded;
     }
+    return status & ~(SessionStatus.InputNeeded & ~SessionStatus.InProgress);
 }
 function sessionReducer(state, action, log) {
     switch (action.type) {
@@ -156,172 +25,97 @@ function sessionReducer(state, action, log) {
             lifecycle: SessionLifecycle.CreationFailed,
             creationError: action.error
         };
-    case ActionType.SessionTurnStarted:
+    case ActionType.SessionChatAdded:
         {
-            let next = {
+            const list = state.chats;
+            const idx = list.findIndex(c => c.resource === action.summary.resource);
+            if (idx < 0) {
+                return {
+                    ...state,
+                    chats: [...list, action.summary]
+                };
+            }
+            const updated = list.slice();
+            updated[idx] = action.summary;
+            return {
                 ...state,
-                activeTurn: {
-                    id: action.turnId,
-                    message: action.message,
-                    responseParts: [],
-                    usage: undefined
-                }
+                chats: updated
             };
-            next = {
-                ...next,
-                summary: {
-                    ...next.summary,
-                    status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
-                    modifiedAt: Date.now()
-                }
+        }
+    case ActionType.SessionChatRemoved:
+        {
+            const list = state.chats;
+            const idx = list.findIndex(c => c.resource === action.chat);
+            if (idx < 0) {
+                return state;
+            }
+            const updated = list.slice();
+            updated.splice(idx, 1);
+            const next = {
+                ...state,
+                chats: updated
             };
-            if (action.queuedMessageId) {
-                if (next.steeringMessage?.id === action.queuedMessageId) {
-                    next = {
-                        ...next,
-                        steeringMessage: undefined
-                    };
-                }
-                if (next.queuedMessages) {
-                    const filtered = next.queuedMessages.filter(m => m.id !== action.queuedMessageId);
-                    next = {
-                        ...next,
-                        queuedMessages: filtered.length > 0 ? filtered : undefined
-                    };
-                }
+            if (state.defaultChat === action.chat) {
+                delete next.defaultChat;
             }
             return next;
         }
-    case ActionType.SessionDelta:
-        return updateResponsePart(state, action.turnId);
-    case ActionType.SessionResponsePart:
-        if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
-            return state;
-        }
-        return {
-            ...state,
-            activeTurn: {
-                ...state.activeTurn,
-                responseParts: [...state.activeTurn.responseParts, action.part]
+    case ActionType.SessionChatUpdated:
+        {
+            const list = state.chats;
+            const idx = list.findIndex(c => c.resource === action.chat);
+            if (idx < 0) {
+                return state;
             }
-        };
-    case ActionType.SessionTurnComplete:
-        return endTurn(state, action.turnId, TurnState.Complete);
-    case ActionType.SessionTurnCancelled:
-        return endTurn(state, action.turnId, TurnState.Cancelled);
-    case ActionType.SessionError:
-        return endTurn(state, action.turnId, TurnState.Error, SessionStatus.Error, action.error);
-    case ActionType.SessionToolCallStart:
-        if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
-            return state;
+            const {
+                resource: _ignored,
+                ...changes
+            } = action.changes;
+            const updated = list.slice();
+            updated[idx] = {
+                ...list[idx],
+                ...changes
+            };
+            return {
+                ...state,
+                chats: updated
+            };
         }
+    case ActionType.SessionDefaultChatChanged:
         return {
             ...state,
-            activeTurn: {
-                ...state.activeTurn,
-                responseParts: [...state.activeTurn.responseParts, {
-                    kind: ResponsePartKind.ToolCall,
-                    toolCall: {
-                        toolCallId: action.toolCallId,
-                        toolName: action.toolName,
-                        displayName: action.displayName,
-                        contributor: action.contributor,
-                        _meta: action._meta,
-                        status: ToolCallStatus.Streaming
-                    }
-                }]
-            }
+            defaultChat: action.defaultChat
         };
-    case ActionType.SessionToolCallDelta:
-        return updateToolCallInParts(state, action.turnId);
-    case ActionType.SessionToolCallReady:
-        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
-    case ActionType.SessionToolCallConfirmed:
-        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
-    case ActionType.SessionToolCallComplete:
-        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
-    case ActionType.SessionToolCallResultConfirmed:
-        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
-    case ActionType.SessionToolCallContentChanged:
-        return updateToolCallInParts(state, action.turnId);
     case ActionType.SessionTitleChanged:
         return {
             ...state,
-            summary: {
-                ...state.summary,
-                title: action.title,
-                modifiedAt: Date.now()
-            }
-        };
-    case ActionType.SessionUsage:
-        if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
-            return state;
-        }
-        return {
-            ...state,
-            activeTurn: {
-                ...state.activeTurn,
-                usage: action.usage
-            }
-        };
-    case ActionType.SessionReasoning:
-        return updateResponsePart(state, action.turnId);
-    case ActionType.SessionModelChanged:
-        return {
-            ...state,
-            summary: {
-                ...state.summary,
-                model: action.model,
-                modifiedAt: Date.now()
-            }
-        };
-    case ActionType.SessionAgentChanged:
-        return {
-            ...state,
-            summary: {
-                ...state.summary,
-                agent: action.agent,
-                modifiedAt: Date.now()
-            }
+            title: action.title
         };
     case ActionType.SessionIsReadChanged:
         return {
             ...state,
-            summary: {
-                ...state.summary,
-                status: withStatusFlag(state.summary.status, SessionStatus.IsRead, action.isRead)
-            }
+            status: withStatusFlag(state.status, SessionStatus.IsRead, action.isRead)
         };
     case ActionType.SessionIsArchivedChanged:
         return {
             ...state,
-            summary: {
-                ...state.summary,
-                status: withStatusFlag(state.summary.status, SessionStatus.IsArchived, action.isArchived)
-            }
+            status: withStatusFlag(state.status, SessionStatus.IsArchived, action.isArchived)
         };
     case ActionType.SessionActivityChanged:
         return {
             ...state,
-            summary: {
-                ...state.summary,
-                activity: action.activity
-            }
+            activity: action.activity
         };
     case ActionType.SessionChangesetsChanged:
         {
             const {
                 changesets: _omit,
-                ...summaryWithoutChangesets
-            } = state.summary;
-            const newSummary = action.changesets ? {
-                ...summaryWithoutChangesets,
+                ...stateWithoutChangesets
+            } = state;
+            return action.changesets ? {
+                ...stateWithoutChangesets,
                 changesets: action.changesets
-            } : summaryWithoutChangesets;
-            return {
-                ...state,
-                summary: newSummary
-            };
+            } : stateWithoutChangesets;
         }
     case ActionType.SessionConfigChanged:
         if (!state.config) {
@@ -337,10 +131,6 @@ function sessionReducer(state, action, log) {
                     ...state.config.values,
                     ...action.config
                 }
-            },
-            summary: {
-                ...state.summary,
-                modifiedAt: Date.now()
             }
         };
     case ActionType.SessionMetaChanged:
@@ -353,22 +143,74 @@ function sessionReducer(state, action, log) {
             ...state,
             serverTools: action.tools
         };
-    case ActionType.SessionActiveClientChanged:
-        return {
-            ...state,
-            activeClient: action.activeClient ?? undefined
-        };
-    case ActionType.SessionActiveClientToolsChanged:
-        if (!state.activeClient) {
-            return state;
+    case ActionType.SessionActiveClientSet:
+        {
+            const list = state.activeClients;
+            const idx = list.findIndex(c => c.clientId === action.activeClient.clientId);
+            if (idx < 0) {
+                return {
+                    ...state,
+                    activeClients: [...list, action.activeClient]
+                };
+            }
+            const updated = list.slice();
+            updated[idx] = action.activeClient;
+            return {
+                ...state,
+                activeClients: updated
+            };
         }
-        return {
-            ...state,
-            activeClient: {
-                ...state.activeClient,
-                tools: action.tools
+    case ActionType.SessionActiveClientRemoved:
+        {
+            const list = state.activeClients;
+            const idx = list.findIndex(c => c.clientId === action.clientId);
+            if (idx < 0) {
+                return state;
             }
-        };
+            const updated = list.slice();
+            updated.splice(idx, 1);
+            return {
+                ...state,
+                activeClients: updated
+            };
+        }
+    case ActionType.SessionInputNeededSet:
+        {
+            const list = state.inputNeeded ?? [];
+            const idx = list.findIndex(r => r.id === action.request.id);
+            const inputNeeded = idx < 0 ? [...list, action.request] : list.slice();
+            if (idx >= 0) {
+                inputNeeded[idx] = action.request;
+            }
+            return {
+                ...state,
+                inputNeeded,
+                status: withInputNeededStatus(state.status, inputNeeded)
+            };
+        }
+    case ActionType.SessionInputNeededRemoved:
+        {
+            const list = state.inputNeeded;
+            if (!list) {
+                return state;
+            }
+            const idx = list.findIndex(r => r.id === action.id);
+            if (idx < 0) {
+                return state;
+            }
+            const remaining = list.slice();
+            remaining.splice(idx, 1);
+            const next = {
+                ...state,
+                status: withInputNeededStatus(state.status, remaining)
+            };
+            if (remaining.length > 0) {
+                next.inputNeeded = remaining;
+            } else {
+                delete next.inputNeeded;
+            }
+            return next;
+        }
     case ActionType.SessionCustomizationsChanged:
         return {
             ...state,
@@ -458,165 +300,6 @@ function sessionReducer(state, action, log) {
                 return state;
             }
         }
-    case ActionType.SessionTruncated:
-        {
-            let turns;
-            if (action.turnId === undefined) {
-                turns = [];
-            } else {
-                const idx = state.turns.findIndex(t => t.id === action.turnId);
-                if (idx < 0) {
-                    return state;
-                }
-                turns = state.turns.slice(0, idx + 1);
-            }
-            const next = {
-                ...state,
-                turns,
-                activeTurn: undefined,
-                summary: {
-                    ...state.summary,
-                    modifiedAt: Date.now()
-                }
-            };
-            delete next.inputRequests;
-            return {
-                ...next,
-                summary: {
-                    ...next.summary,
-                    status: summaryStatus(next)
-                }
-            };
-        }
-    case ActionType.SessionInputRequested:
-        return upsertInputRequest(state, action.request);
-    case ActionType.SessionInputAnswerChanged:
-        {
-            const existing = state.inputRequests;
-            const idx = existing?.findIndex(request => request.id === action.requestId) ?? -1;
-            if (!existing || idx < 0) {
-                return state;
-            }
-            const request = existing[idx];
-            const answers = {
-                ...(request.answers ?? {})
-            };
-            if (action.answer === undefined) {
-                delete answers[action.questionId];
-            } else {
-                answers[action.questionId] = action.answer;
-            }
-            const updated = [...existing];
-            updated[idx] = {
-                ...request,
-                answers: ( Object.keys(answers)).length > 0 ? answers : undefined
-            };
-            return {
-                ...state,
-                inputRequests: updated,
-                summary: {
-                    ...state.summary,
-                    modifiedAt: Date.now()
-                }
-            };
-        }
-    case ActionType.SessionInputCompleted:
-        {
-            const existing = state.inputRequests;
-            if (!existing?.some(request => request.id === action.requestId)) {
-                return state;
-            }
-            const inputRequests = existing.filter(request => request.id !== action.requestId);
-            const next = {
-                ...state
-            };
-            if (inputRequests.length > 0) {
-                next.inputRequests = inputRequests;
-            } else {
-                delete next.inputRequests;
-            }
-            return {
-                ...next,
-                summary: {
-                    ...next.summary,
-                    status: summaryStatus(next),
-                    modifiedAt: Date.now()
-                }
-            };
-        }
-    case ActionType.SessionPendingMessageSet:
-        {
-            const entry = {
-                id: action.id,
-                message: action.message
-            };
-            if (action.kind === PendingMessageKind.Steering) {
-                return {
-                    ...state,
-                    steeringMessage: entry
-                };
-            }
-            const existing = state.queuedMessages ?? [];
-            const idx = existing.findIndex(m => m.id === action.id);
-            if (idx >= 0) {
-                const updated = [...existing];
-                updated[idx] = entry;
-                return {
-                    ...state,
-                    queuedMessages: updated
-                };
-            }
-            return {
-                ...state,
-                queuedMessages: [...existing, entry]
-            };
-        }
-    case ActionType.SessionPendingMessageRemoved:
-        {
-            if (action.kind === PendingMessageKind.Steering) {
-                if (!state.steeringMessage || state.steeringMessage.id !== action.id) {
-                    return state;
-                }
-                return {
-                    ...state,
-                    steeringMessage: undefined
-                };
-            }
-            const existing = state.queuedMessages;
-            if (!existing) {
-                return state;
-            }
-            const filtered = existing.filter(m => m.id !== action.id);
-            return filtered.length === existing.length ? state : {
-                ...state,
-                queuedMessages: filtered.length > 0 ? filtered : undefined
-            };
-        }
-    case ActionType.SessionQueuedMessagesReordered:
-        {
-            const existing = state.queuedMessages;
-            if (!existing) {
-                return state;
-            }
-            const byId = ( new Map(( existing.map(m => [m.id, m]))));
-            const ordered = ( new Set());
-            const reordered = ( action.order.filter(id => {
-                if (( byId.has(id)) && !( ordered.has(id))) {
-                    ordered.add(id);
-                    return true;
-                }
-                return false;
-            }).map(id => byId.get(id)));
-            for (const m of existing) {
-                if (!( ordered.has(m.id))) {
-                    reordered.push(m);
-                }
-            }
-            return {
-                ...state,
-                queuedMessages: reordered
-            };
-        }
     default:
         softAssertNever(action, log);
         return state;

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

@@ -1,4 +1,4 @@
-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";
+import { type RootAction, type ClientRootAction, type SessionAction, type ClientSessionAction, type TerminalAction, type ClientTerminalAction, type ChangesetAction, type ClientChangesetAction, type AnnotationsAction, type ClientAnnotationsAction } 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
@@ -14,4 +14,4 @@ export declare function softAssertNever(value: never, log?: (msg: string) => voi
  * 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;
+export declare function isClientDispatchable(action: RootAction | SessionAction | TerminalAction | ChangesetAction | AnnotationsAction): action is ClientRootAction | ClientSessionAction | ClientTerminalAction | ClientChangesetAction | ClientAnnotationsAction;

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

@@ -5,7 +5,7 @@ import type { ServerNotificationMap } from "@codingame/monaco-vscode-api/vscode/
  *
  * Formatted as a [SemVer](https://semver.org) `MAJOR.MINOR.PATCH` string.
  */
-export declare const PROTOCOL_VERSION = "0.3.0";
+export declare const PROTOCOL_VERSION = "0.5.1";
 /**
  * Every protocol version a client built from this source tree is willing
  * to negotiate via the `initialize` handshake. Ordered **most preferred

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

@@ -1,6 +1,6 @@
 
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
 
-const PROTOCOL_VERSION = "0.3.0";
+const PROTOCOL_VERSION = "0.5.1";
 
 export { PROTOCOL_VERSION };