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

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

@@ -0,0 +1,400 @@
+
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+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';
+
+function tcBase(tc) {
+    return {
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        displayName: tc.displayName,
+        intention: tc.intention,
+        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.status & -32 | activity;
+}
+function refreshSummaryStatus(state) {
+    const status = summaryStatus(state);
+    if (status === state.status) {
+        return state;
+    }
+    return {
+        ...state,
+        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,
+        modifiedAt: ( new Date(Date.now())).toISOString()
+    };
+    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] = {
+            ...request,
+            answers
+        };
+    } else {
+        inputRequests.push(request);
+    }
+    const next = {
+        ...state,
+        inputRequests
+    };
+    return {
+        ...next,
+        status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
+        modifiedAt: ( new Date(Date.now())).toISOString()
+    };
+}
+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 chatReducer(state, action, log) {
+    switch (action.type) {
+    case ActionType.ChatTurnStarted:
+        {
+            let next = {
+                ...state,
+                activeTurn: {
+                    id: action.turnId,
+                    message: action.message,
+                    responseParts: [],
+                    usage: undefined
+                }
+            };
+            next = {
+                ...next,
+                status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
+                modifiedAt: ( new Date(Date.now())).toISOString()
+            };
+            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
+                    };
+                }
+            }
+            return next;
+        }
+    case ActionType.ChatDelta:
+        return updateResponsePart(state, action.turnId);
+    case ActionType.ChatResponsePart:
+        if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
+            return state;
+        }
+        return {
+            ...state,
+            activeTurn: {
+                ...state.activeTurn,
+                responseParts: [...state.activeTurn.responseParts, action.part]
+            }
+        };
+    case ActionType.ChatTurnComplete:
+        return endTurn(state, action.turnId, TurnState.Complete);
+    case ActionType.ChatTurnCancelled:
+        return endTurn(state, action.turnId, TurnState.Cancelled);
+    case ActionType.ChatError:
+        return endTurn(state, action.turnId, TurnState.Error, SessionStatus.Error, action.error);
+    case ActionType.ChatActivityChanged:
+        return {
+            ...state,
+            activity: action.activity
+        };
+    case ActionType.ChatToolCallStart:
+        if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
+            return state;
+        }
+        return {
+            ...state,
+            activeTurn: {
+                ...state.activeTurn,
+                responseParts: [...state.activeTurn.responseParts, {
+                    kind: ResponsePartKind.ToolCall,
+                    toolCall: {
+                        toolCallId: action.toolCallId,
+                        toolName: action.toolName,
+                        displayName: action.displayName,
+                        intention: action.intention,
+                        contributor: action.contributor,
+                        _meta: action._meta,
+                        status: ToolCallStatus.Streaming
+                    }
+                }]
+            }
+        };
+    case ActionType.ChatToolCallDelta:
+        return updateToolCallInParts(state, action.turnId);
+    case ActionType.ChatToolCallReady:
+        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
+    case ActionType.ChatToolCallConfirmed:
+        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
+    case ActionType.ChatToolCallComplete:
+        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
+    case ActionType.ChatToolCallResultConfirmed:
+        return refreshSummaryStatus(updateToolCallInParts(state, action.turnId));
+    case ActionType.ChatToolCallContentChanged:
+        return updateToolCallInParts(state, action.turnId);
+    case ActionType.ChatUsage:
+        if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
+            return state;
+        }
+        return {
+            ...state,
+            activeTurn: {
+                ...state.activeTurn,
+                usage: action.usage
+            }
+        };
+    case ActionType.ChatReasoning:
+        return updateResponsePart(state, action.turnId);
+    case ActionType.ChatTruncated:
+        {
+            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,
+                modifiedAt: ( new Date(Date.now())).toISOString()
+            };
+            delete next.inputRequests;
+            return {
+                ...next,
+                status: summaryStatus(next)
+            };
+        }
+    case ActionType.ChatInputRequested:
+        return upsertInputRequest(state, action.request);
+    case ActionType.ChatInputAnswerChanged:
+        {
+            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,
+                modifiedAt: ( new Date(Date.now())).toISOString()
+            };
+        }
+    case ActionType.ChatInputCompleted:
+        {
+            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,
+                status: summaryStatus(next),
+                modifiedAt: ( new Date(Date.now())).toISOString()
+            };
+        }
+    case ActionType.ChatPendingMessageSet:
+        {
+            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.ChatPendingMessageRemoved:
+        {
+            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.ChatQueuedMessagesReordered:
+        {
+            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
+            };
+        }
+    case ActionType.ChatDraftChanged:
+        return {
+            ...state,
+            draft: action.draft
+        };
+    default:
+        softAssertNever(action, log);
+        return state;
+    }
+}
+
+export { chatReducer };