@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -0,0 +1,662 @@
+
+import { ActionType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import { ResponsePartKind, ToolCallStatus, SessionStatus, ToolCallCancellationReason, PendingMessageKind, TurnState, SessionLifecycle } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state';
+
+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,
+        _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 summaryStatus(state, terminalStatus) {
+    if (terminalStatus) {
+        return terminalStatus;
+    }
+    if ((state.inputRequests?.length ?? 0) > 0 || hasPendingToolCallConfirmation(state)) {
+        return SessionStatus.InputNeeded;
+    }
+    if (state.activeTurn) {
+        return SessionStatus.InProgress;
+    }
+    return SessionStatus.Idle;
+}
+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,
+        userMessage: active.userMessage,
+        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: summaryStatus(next),
+            modifiedAt: Date.now(),
+            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 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
+        };
+    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
+            }
+        };
+    case ActionType.SessionCreationFailed:
+        return {
+            ...state,
+            lifecycle: SessionLifecycle.CreationFailed,
+            creationError: action.error
+        };
+    case ActionType.SessionTurnStarted:
+        {
+            let next = {
+                ...state,
+                activeTurn: {
+                    id: action.turnId,
+                    userMessage: action.userMessage,
+                    responseParts: [],
+                    usage: undefined
+                }
+            };
+            next = {
+                ...next,
+                summary: {
+                    ...next.summary,
+                    status: summaryStatus(next),
+                    modifiedAt: Date.now(),
+                    isRead: false
+                }
+            };
+            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.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.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;
+        }
+        return {
+            ...state,
+            activeTurn: {
+                ...state.activeTurn,
+                responseParts: [...state.activeTurn.responseParts, {
+                    kind: ResponsePartKind.ToolCall,
+                    toolCall: {
+                        toolCallId: action.toolCallId,
+                        toolName: action.toolName,
+                        displayName: action.displayName,
+                        toolClientId: action.toolClientId,
+                        _meta: action._meta,
+                        status: ToolCallStatus.Streaming
+                    }
+                }]
+            }
+        };
+    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.SessionIsReadChanged:
+        return {
+            ...state,
+            summary: {
+                ...state.summary,
+                isRead: action.isRead
+            }
+        };
+    case ActionType.SessionIsDoneChanged:
+        return {
+            ...state,
+            summary: {
+                ...state.summary,
+                isDone: action.isDone
+            }
+        };
+    case ActionType.SessionDiffsChanged:
+        return {
+            ...state,
+            summary: {
+                ...state.summary,
+                diffs: action.diffs
+            }
+        };
+    case ActionType.SessionConfigChanged:
+        if (!state.config) {
+            return state;
+        }
+        return {
+            ...state,
+            config: {
+                ...state.config,
+                values: {
+                    ...state.config.values,
+                    ...action.config
+                }
+            },
+            summary: {
+                ...state.summary,
+                modifiedAt: Date.now()
+            }
+        };
+    case ActionType.SessionServerToolsChanged:
+        return {
+            ...state,
+            serverTools: action.tools
+        };
+    case ActionType.SessionActiveClientChanged:
+        return {
+            ...state,
+            activeClient: action.activeClient ?? undefined
+        };
+    case ActionType.SessionActiveClientToolsChanged:
+        if (!state.activeClient) {
+            return state;
+        }
+        return {
+            ...state,
+            activeClient: {
+                ...state.activeClient,
+                tools: action.tools
+            }
+        };
+    case ActionType.SessionCustomizationsChanged:
+        return {
+            ...state,
+            customizations: action.customizations
+        };
+    case ActionType.SessionCustomizationToggled:
+        {
+            const list = state.customizations;
+            if (!list) {
+                return state;
+            }
+            const idx = list.findIndex(c => c.customization.uri === action.uri);
+            if (idx < 0) {
+                return state;
+            }
+            const updated = [...list];
+            updated[idx] = {
+                ...list[idx],
+                enabled: action.enabled
+            };
+            return {
+                ...state,
+                customizations: updated
+            };
+        }
+    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,
+                userMessage: action.userMessage
+            };
+            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;
+    }
+}
+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 };

package/vscode/src/vs/platform/agentHost/common/state/sessionActions.d.ts

@@ -1,12 +1,14 @@
-export { ActionType, type IActionEnvelope, type IActionOrigin, type IRootAgentsChangedAction, type IRootActiveSessionsChangedAction, type ISessionCreationFailedAction, type ISessionDeltaAction, type ISessionErrorAction, type ISessionModelChangedAction, type ISessionReadyAction, type ISessionReasoningAction, type ISessionResponsePartAction, type ISessionToolCallCompleteAction, type ISessionToolCallConfirmedAction, type ISessionToolCallApprovedAction, type ISessionToolCallDeniedAction, type ISessionToolCallDeltaAction, type ISessionToolCallReadyAction, type ISessionToolCallResultConfirmedAction, type ISessionToolCallStartAction, type ISessionTitleChangedAction, type ISessionTurnCancelledAction, type ISessionTurnCompleteAction, type ISessionTurnStartedAction, type ISessionUsageAction, type ISessionServerToolsChangedAction, type ISessionActiveClientChangedAction, type ISessionActiveClientToolsChangedAction, type ISessionPendingMessageSetAction, type ISessionPendingMessageRemovedAction, type ISessionQueuedMessagesReorderedAction, type IStateAction, } from "./protocol/actions.js";
-export { NotificationType, AuthRequiredReason, type ISessionAddedNotification, type ISessionRemovedNotification, type IAuthRequiredNotification, } from "./protocol/notifications.js";
-import type { IRootAgentsChangedAction, IRootActiveSessionsChangedAction, ISessionDeltaAction, ISessionModelChangedAction, ISessionReasoningAction, ISessionResponsePartAction, ISessionToolCallApprovedAction, ISessionToolCallCompleteAction, ISessionToolCallConfirmedAction, ISessionToolCallDeniedAction, ISessionToolCallDeltaAction, ISessionToolCallReadyAction, ISessionToolCallResultConfirmedAction, ISessionToolCallStartAction, ISessionTitleChangedAction, ISessionTurnCancelledAction, ISessionTurnCompleteAction, ISessionTurnStartedAction, ISessionUsageAction, IStateAction, ISessionPendingMessageSetAction, ISessionPendingMessageRemovedAction, ISessionQueuedMessagesReorderedAction } from "./protocol/actions.js";
-import type { IProtocolNotification } from "./protocol/notifications.js";
-import type { IRootAction as IRootAction_, ISessionAction as ISessionAction_, IClientSessionAction as IClientSessionAction_, IServerSessionAction as IServerSessionAction_ } from "./protocol/action-origin.generated.js";
+export { ActionType, type IActionEnvelope, type IActionOrigin, type IRootAgentsChangedAction, type IRootActiveSessionsChangedAction, type ISessionCreationFailedAction, type ISessionDeltaAction, type ISessionDiffsChangedAction, type ISessionErrorAction, type ISessionModelChangedAction, type ISessionReadyAction, type ISessionReasoningAction, type ISessionResponsePartAction, type ISessionToolCallCompleteAction, type ISessionToolCallConfirmedAction, type ISessionToolCallApprovedAction, type ISessionToolCallDeniedAction, type ISessionToolCallDeltaAction, type ISessionToolCallReadyAction, type ISessionToolCallResultConfirmedAction, type ISessionToolCallStartAction, type ISessionTitleChangedAction, type ISessionTurnCancelledAction, type ISessionTurnCompleteAction, type ISessionTurnStartedAction, type ISessionUsageAction, type ISessionServerToolsChangedAction, type ISessionActiveClientChangedAction, type ISessionActiveClientToolsChangedAction, type ISessionCustomizationsChangedAction, type ISessionCustomizationToggledAction, type ISessionPendingMessageSetAction, type ISessionPendingMessageRemovedAction, type ISessionQueuedMessagesReorderedAction, type ISessionInputRequestedAction, type ISessionInputCompletedAction, type ISessionIsReadChangedAction, type ISessionIsDoneChangedAction, type ISessionToolCallContentChangedAction, type IStateAction, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+export { NotificationType, AuthRequiredReason, type ISessionAddedNotification, type ISessionRemovedNotification, type IAuthRequiredNotification, } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
+import type { IRootAgentsChangedAction, IRootActiveSessionsChangedAction, ISessionDeltaAction, ISessionModelChangedAction, ISessionReasoningAction, ISessionResponsePartAction, ISessionToolCallApprovedAction, ISessionToolCallCompleteAction, ISessionToolCallConfirmedAction, ISessionToolCallDeniedAction, ISessionToolCallDeltaAction, ISessionToolCallReadyAction, ISessionToolCallResultConfirmedAction, ISessionToolCallStartAction, ISessionTitleChangedAction, ISessionTurnCancelledAction, ISessionTurnCompleteAction, ISessionTurnStartedAction, ISessionUsageAction, IStateAction, ISessionPendingMessageSetAction, ISessionPendingMessageRemovedAction, ISessionQueuedMessagesReorderedAction, ISessionIsReadChangedAction, ISessionIsDoneChangedAction } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions";
+import type { IProtocolNotification } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications";
+import type { IRootAction as IRootAction_, ISessionAction as ISessionAction_, IClientSessionAction as IClientSessionAction_, IServerSessionAction as IServerSessionAction_, ITerminalAction as ITerminalAction_, IClientTerminalAction as IClientTerminalAction_ } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
 export type IRootAction = IRootAction_;
 export type ISessionAction = ISessionAction_;
 export type IClientSessionAction = IClientSessionAction_;
 export type IServerSessionAction = IServerSessionAction_;
+export type ITerminalAction = ITerminalAction_;
+export type IClientTerminalAction = IClientTerminalAction_;
 export type IAgentsChangedAction = IRootAgentsChangedAction;
 export type IActiveSessionsChangedAction = IRootActiveSessionsChangedAction;
 export type ITurnStartedAction = ISessionTurnStartedAction;
@@ -26,9 +28,14 @@ export type ITitleChangedAction = ISessionTitleChangedAction;
 export type IUsageAction = ISessionUsageAction;
 export type IReasoningAction = ISessionReasoningAction;
 export type IModelChangedAction = ISessionModelChangedAction;
+export type ICustomizationsChangedAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").ISessionCustomizationsChangedAction;
+export type ICustomizationToggledAction = import("@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions").ISessionCustomizationToggledAction;
 export type IPendingMessageSetAction = ISessionPendingMessageSetAction;
 export type IPendingMessageRemovedAction = ISessionPendingMessageRemovedAction;
 export type IQueuedMessagesReorderedAction = ISessionQueuedMessagesReorderedAction;
+export type IIsReadChangedAction = ISessionIsReadChangedAction;
+export type IIsDoneChangedAction = ISessionIsDoneChangedAction;
 export type INotification = IProtocolNotification;
 export declare function isRootAction(action: IStateAction): action is IRootAction;
 export declare function isSessionAction(action: IStateAction): action is ISessionAction;
+export declare function isTerminalAction(action: IStateAction): action is ITerminalAction;