@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

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

@@ -1,544 +0,0 @@
-
-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';
-import { addMillisecondsToTimestamp } from '../common/timestamps.js';
-
-function tcBase(tc) {
-    return {
-        toolCallId: tc.toolCallId,
-        toolName: tc.toolName,
-        displayName: tc.displayName,
-        intention: tc.intention,
-        contributor: tc.contributor,
-        _meta: tc._meta
-    };
-}
-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.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;
-}
-function summaryStatus(state, terminalStatus) {
-    let activity;
-    if (terminalStatus) {
-        activity = terminalStatus;
-    } else if (hasOpenInputRequest(state) || hasBlockingToolCall(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, duration, terminalStatus, errorPart) {
-    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
-            }
-        };
-    }));
-    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
-    };
-    const next = {
-        ...state,
-        turns: [...state.turns, turn],
-        activeTurn: undefined,
-        modifiedAt: addMillisecondsToTimestamp(active.startedAt, turn.duration ?? 0)
-    };
-    return {
-        ...next,
-        status: summaryStatus(next, terminalStatus)
-    };
-}
-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: request.answers ?? existing.part.request.answers
-        };
-        responseParts[existing.index] = part;
-    } else {
-        responseParts.push(part);
-    }
-    const next = {
-        ...state,
-        activeTurn: {
-            ...activeTurn,
-            responseParts
-        }
-    };
-    return {
-        ...next,
-        status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false)
-    };
-}
-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,
-                    startedAt: action.startedAt,
-                    message: action.message,
-                    responseParts: [],
-                    usage: undefined
-                }
-            };
-            next = {
-                ...next,
-                status: withStatusFlag(summaryStatus(next), SessionStatus.IsRead, false),
-                modifiedAt: action.startedAt
-            };
-            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;
-        }
-        if (isErrorResponsePart(action.part)) {
-            return state;
-        }
-        return {
-            ...state,
-            activeTurn: {
-                ...state.activeTurn,
-                responseParts: [...state.activeTurn.responseParts, action.part]
-            }
-        };
-    case ActionType.ChatTurnComplete:
-        return endTurn(state, action.turnId, TurnState.Complete, action.duration);
-    case ActionType.ChatTurnCancelled:
-        return endTurn(state, action.turnId, TurnState.Cancelled, action.duration);
-    case ActionType.ChatError:
-        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;
-        }
-        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.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;
-        }
-        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
-            };
-            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 upsertInputRequestPart(state, action.request);
-    case ActionType.ChatInputAnswerChanged:
-        {
-            const activeTurn = state.activeTurn;
-            const existing = activeTurn ? findOpenInputRequestPart(activeTurn.responseParts, action.requestId) : undefined;
-            if (!activeTurn || !existing) {
-                return state;
-            }
-            const {
-                index,
-                part
-            } = existing;
-            const request = part.request;
-            const answers = {
-                ...(request.answers ?? {})
-            };
-            if (action.answer === undefined) {
-                delete answers[action.questionId];
-            } else {
-                answers[action.questionId] = action.answer;
-            }
-            const responseParts = [...activeTurn.responseParts];
-            responseParts[index] = {
-                ...part,
-                request: {
-                    ...request,
-                    answers: ( Object.keys(answers)).length > 0 ? answers : undefined
-                }
-            };
-            return {
-                ...state,
-                activeTurn: {
-                    ...activeTurn,
-                    responseParts
-                }
-            };
-        }
-    case ActionType.ChatInputCompleted:
-        {
-            const activeTurn = state.activeTurn;
-            const existing = activeTurn ? findOpenInputRequestPart(activeTurn.responseParts, action.requestId) : undefined;
-            if (!activeTurn || !existing) {
-                return state;
-            }
-            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,
-                activeTurn: {
-                    ...activeTurn,
-                    responseParts
-                }
-            };
-            return {
-                ...next,
-                status: summaryStatus(next)
-            };
-        }
-    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 };

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

@@ -1,6 +0,0 @@
-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

@@ -1,30 +0,0 @@
-
-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

@@ -1,6 +0,0 @@
-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;