@zeniai/client-epic-state 5.1.20-betaDI1 → 5.1.20-betaDI2

package/lib/view/aiCfoView/aiCfoViewReducer.d.ts

@@ -0,0 +1,117 @@
+import type { AiCfoSuggestedQuestionsPageContext } from '../../common/aiCfo/aiCfoSuggestedQuestionsPageContext';
+import { FetchStateAndError, ID } from '../../commonStateTypes/common';
+import { PageToken } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { ChatSessionPayload } from '../../entity/aiCfo/aiCfoPayload';
+import { AiCfoAnswerResponseType } from '../../entity/aiCfo/aiCfoState';
+import { ZeniAPIStatus } from '../../responsePayload';
+import { ContextStatus } from './aiCfoViewPayload';
+import { AiCfoViewState } from './aiCfoViewState';
+export declare const initialAiCfoViewState: AiCfoViewState;
+export declare const submitQuestion: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[sessionId: string, questionAnswerId: string, userId: string, questionId: string, createdAt: import("dayjs").Dayjs, question: string, files?: File[] | undefined], {
+    sessionId: string;
+    questionAnswerId: string;
+    userId: string;
+    questionId: string;
+    createdAt: import("dayjs").Dayjs;
+    question: string;
+    files: File[] | undefined;
+}, "aiCfoView/submitQuestion", never, never>, submitQuestionSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "aiCfoView/submitQuestionSuccess">, submitQuestionFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error: ZeniAPIStatus;
+    sessionId: ID;
+}, "aiCfoView/submitQuestionFailure">, updateResponseState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    fetchState: FetchStateAndError;
+    responseType: AiCfoAnswerResponseType;
+}, "aiCfoView/updateResponseState">, updateAiCfoViewScrollPosition: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, "aiCfoView/updateAiCfoViewScrollPosition">, updateCurrentInput: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "aiCfoView/updateCurrentInput">, clearInput: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/clearInput">, setSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    agentId: string;
+    sessionId: string;
+}, "aiCfoView/setSession">, createSession: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[agentId: string, userId: string, contextRefId?: string | undefined, contextType?: string | undefined, pageContext?: string | undefined], {
+    agentId: string;
+    contextRefId: string | undefined;
+    contextType: string | undefined;
+    pageContext: string | undefined;
+    userId: string;
+}, "aiCfoView/createSession", never, never>, createSessionSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    agentId: string;
+    sessionId: ID;
+    contextMessage?: string;
+    contextStatus?: ContextStatus;
+}, "aiCfoView/createSessionSuccess">, createSessionFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "aiCfoView/createSessionFailure">, createSessionAndSubmit: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[agentId: string, userId: string, questionAnswerId: string, questionId: string, createdAt: import("dayjs").Dayjs, question: string, files?: File[] | undefined, pageContext?: string | undefined], {
+    agentId: string;
+    userId: string;
+    questionAnswerId: string;
+    questionId: string;
+    createdAt: import("dayjs").Dayjs;
+    question: string;
+    files: File[] | undefined;
+    pageContext: string | undefined;
+}, "aiCfoView/createSessionAndSubmit", never, never>, initializeNewSessionState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    agentId: string;
+    sessionId: ID;
+}, "aiCfoView/initializeNewSessionState">, createSessionAndSubmitSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/createSessionAndSubmitSuccess">, createSessionAndSubmitFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "aiCfoView/createSessionAndSubmitFailure">, fetchChatSessionsForUser: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/fetchChatSessionsForUser">, fetchChatSessionsForUserSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    nextPageToken: PageToken;
+    sessions: ChatSessionPayload[];
+}, "aiCfoView/fetchChatSessionsForUserSuccess">, fetchChatSessionsForUserFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "aiCfoView/fetchChatSessionsForUserFailure">, fetchChatHistory: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[chatSessionId: string, userId: string], {
+    chatSessionId: string;
+    userId: string;
+}, "aiCfoView/fetchChatHistory", never, never>, fetchChatHistorySuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    nextPageToken: PageToken;
+}, "aiCfoView/fetchChatHistorySuccess">, fetchChatHistoryFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    error: ZeniAPIStatus;
+}, "aiCfoView/fetchChatHistoryFailure">, clearCurrentSessionId: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/clearCurrentSessionId">, clearLastContextMessage: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/clearLastContextMessage">, stopSubmit: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[chatSessionId: string], {
+    chatSessionId: string;
+}, "aiCfoView/stopSubmit", never, never>, stopSubmitSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    isOnlyQuestionInSession: boolean;
+    question: string;
+}, "aiCfoView/stopSubmitSuccess">, stopSubmitFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    error: ZeniAPIStatus;
+}, "aiCfoView/stopSubmitFailure">, stopSubmitQuestion: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[chatSessionId: string], {
+    chatSessionId: string;
+}, "aiCfoView/stopSubmitQuestion", never, never>, stopSubmitQuestionSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    isOnlyQuestionInSession: boolean;
+    question: string;
+}, "aiCfoView/stopSubmitQuestionSuccess">, stopSubmitQuestionFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    error: ZeniAPIStatus;
+}, "aiCfoView/stopSubmitQuestionFailure">, acceptMasterTOS: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[userRoleId: string], {
+    userRoleId: string;
+}, "aiCfoView/acceptMasterTOS", never, never>, acceptMasterTOSSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/acceptMasterTOSSuccess">, acceptMasterTOSFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "aiCfoView/acceptMasterTOSFailure">, deleteChatSession: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[chatSessionId: string], {
+    chatSessionId: string;
+}, "aiCfoView/deleteChatSession", never, never>, deleteChatSessionSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+}, "aiCfoView/deleteChatSessionSuccess">, deleteChatSessionFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    error: ZeniAPIStatus;
+}, "aiCfoView/deleteChatSessionFailure">, clearDeleteChatSessionStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+}, "aiCfoView/clearDeleteChatSessionStatus">, clearAiCfoView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/clearAiCfoView">, updateCotCollapsedState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    isCollapsed: boolean;
+    questionAnswerId: ID;
+}, "aiCfoView/updateCotCollapsedState">, fetchSuggestedQuestions: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    pageContext: AiCfoSuggestedQuestionsPageContext;
+    /**
+     * AI Card Creation flow: when true, the epic appends `&no_card_created=true`
+     * so the backend tailors prompts for a tenant that has not yet created a
+     * card. The bucket key is unchanged (`pageContext`); see
+     * `useFetchSuggestedQuestionsWhenReady` for the refetch-on-flag-flip rule.
+     */
+    noCardCreated?: boolean;
+}, "aiCfoView/fetchSuggestedQuestions">, fetchSuggestedQuestionsSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    generatedAt: string;
+    pageContext: AiCfoSuggestedQuestionsPageContext;
+    suggestedQuestions: string[];
+}, "aiCfoView/fetchSuggestedQuestionsSuccess">, fetchSuggestedQuestionsFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error: ZeniAPIStatus;
+    pageContext: AiCfoSuggestedQuestionsPageContext;
+}, "aiCfoView/fetchSuggestedQuestionsFailure">, applyAiCfoSidePanelHostPageTransition: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    newAiCfoSidePanelHostPageKey: string;
+    /** When omitted or null, clears the active session (empty / suggested questions). */
+    nextCurrentChatSessionId?: ID | null;
+}, "aiCfoView/applyAiCfoSidePanelHostPageTransition">, clearAiCfoSidePanelHostPageContext: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfoView/clearAiCfoSidePanelHostPageContext">;
+declare const _default: import("redux").Reducer<AiCfoViewState>;
+export default _default;

package/lib/view/aiCfoView/aiCfoViewReducer.js

@@ -0,0 +1,463 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAiCfoSidePanelHostPageContext = exports.applyAiCfoSidePanelHostPageTransition = exports.fetchSuggestedQuestionsFailure = exports.fetchSuggestedQuestionsSuccess = exports.fetchSuggestedQuestions = exports.updateCotCollapsedState = exports.clearAiCfoView = exports.clearDeleteChatSessionStatus = exports.deleteChatSessionFailure = exports.deleteChatSessionSuccess = exports.deleteChatSession = exports.acceptMasterTOSFailure = exports.acceptMasterTOSSuccess = exports.acceptMasterTOS = exports.stopSubmitQuestionFailure = exports.stopSubmitQuestionSuccess = exports.stopSubmitQuestion = exports.stopSubmitFailure = exports.stopSubmitSuccess = exports.stopSubmit = exports.clearLastContextMessage = exports.clearCurrentSessionId = exports.fetchChatHistoryFailure = exports.fetchChatHistorySuccess = exports.fetchChatHistory = exports.fetchChatSessionsForUserFailure = exports.fetchChatSessionsForUserSuccess = exports.fetchChatSessionsForUser = exports.createSessionAndSubmitFailure = exports.createSessionAndSubmitSuccess = exports.initializeNewSessionState = exports.createSessionAndSubmit = exports.createSessionFailure = exports.createSessionSuccess = exports.createSession = exports.setSession = exports.clearInput = exports.updateCurrentInput = exports.updateAiCfoViewScrollPosition = exports.updateResponseState = exports.submitQuestionFailure = exports.submitQuestionSuccess = exports.submitQuestion = exports.initialAiCfoViewState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+function removeSessionIdFromPageKeyMap(draft, sessionId) {
+    const map = draft.uiState.chatSessionIdByPageKey;
+    for (const key of Object.keys(map)) {
+        if (map[key] === sessionId) {
+            delete map[key];
+        }
+    }
+}
+function mirrorCurrentSessionToPageKeyMapIfActive(draft) {
+    const key = draft.uiState.aiCfoSidePanelHostPageKey;
+    const sessionId = draft.uiState.currentChatSessionId;
+    if (key != null && sessionId != null) {
+        draft.uiState.chatSessionIdByPageKey[key] = sessionId;
+    }
+}
+exports.initialAiCfoViewState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    uiState: {
+        currentInput: '',
+        scrollPositionByChatSessionId: {},
+        currentChatSessionId: undefined,
+        aiCfoSidePanelHostPageKey: undefined,
+        chatSessionIdByPageKey: {},
+        agentId: undefined,
+        chatHistoryNextPageToken: {},
+        chatSessionsNextPageToken: { nextPageToken: null, hasMore: false },
+        chatSessionsFirstPageFetched: false,
+        cotCollapsedByQuestionAnswerId: {},
+    },
+    masterTOSAcceptanceState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    allChatSessionIds: [],
+    createSessionState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    createSessionAndSubmitState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    deleteChatSessionStateByChatSessionId: {},
+    fetchChatSessionHistoryByChatSessionId: {},
+    responseStateByChatSessionId: {},
+    stopSubmitStateByChatSessionId: {},
+    suggestedQuestionsByPageContext: {},
+};
+const aiCfoView = (0, toolkit_1.createSlice)({
+    name: 'aiCfoView',
+    initialState: exports.initialAiCfoViewState,
+    reducers: {
+        submitQuestion: {
+            reducer(draft, action) {
+                const { sessionId } = action.payload;
+                draft.responseStateByChatSessionId[sessionId] = {
+                    thought: { fetchState: 'In-Progress', error: undefined },
+                    analysis: { fetchState: 'In-Progress', error: undefined },
+                    reasoning: { fetchState: 'In-Progress', error: undefined },
+                    answer: { fetchState: 'In-Progress', error: undefined },
+                };
+            },
+            prepare(sessionId, questionAnswerId, userId, questionId, createdAt, question, files) {
+                return {
+                    payload: {
+                        sessionId,
+                        questionAnswerId,
+                        userId,
+                        questionId,
+                        createdAt,
+                        question,
+                        files,
+                    },
+                };
+            },
+        },
+        submitQuestionSuccess(draft, action) {
+            const sessionId = action.payload;
+            if (draft.responseStateByChatSessionId[sessionId] != null) {
+                draft.responseStateByChatSessionId[sessionId] = {
+                    thought: { fetchState: 'Completed', error: undefined },
+                    analysis: { fetchState: 'Completed', error: undefined },
+                    reasoning: { fetchState: 'Completed', error: undefined },
+                    answer: { fetchState: 'Completed', error: undefined },
+                };
+            }
+        },
+        submitQuestionFailure(draft, action) {
+            const { sessionId, error } = action.payload;
+            if (draft.responseStateByChatSessionId[sessionId] != null) {
+                draft.responseStateByChatSessionId[sessionId]['answer'] = {
+                    fetchState: 'Error',
+                    error,
+                };
+            }
+        },
+        updateResponseState(draft, action) {
+            const { chatSessionId, responseType, fetchState } = action.payload;
+            if (draft.responseStateByChatSessionId[chatSessionId] == null) {
+                draft.responseStateByChatSessionId[chatSessionId] = {
+                    thought: { fetchState: 'Not-Started', error: undefined },
+                    analysis: { fetchState: 'Not-Started', error: undefined },
+                    reasoning: { fetchState: 'Not-Started', error: undefined },
+                    answer: { fetchState: 'Not-Started', error: undefined },
+                };
+            }
+            draft.responseStateByChatSessionId[chatSessionId][responseType] =
+                fetchState;
+        },
+        updateAiCfoViewScrollPosition(draft, action) {
+            if (draft.uiState.currentChatSessionId != null) {
+                draft.uiState.scrollPositionByChatSessionId[draft.uiState.currentChatSessionId] = {
+                    scrollTop: action.payload,
+                };
+            }
+        },
+        fetchChatSessionsForUser(draft) {
+            draft.fetchState = 'In-Progress';
+            draft.error = undefined;
+        },
+        fetchChatSessionsForUserSuccess(draft, action) {
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+            draft.uiState.chatSessionsNextPageToken.nextPageToken =
+                action.payload.nextPageToken;
+            draft.uiState.chatSessionsNextPageToken.hasMore =
+                action.payload.nextPageToken != null;
+            if (draft.uiState.chatSessionsFirstPageFetched == false) {
+                draft.uiState.chatSessionsFirstPageFetched = true;
+            }
+            draft.allChatSessionIds = Array.from(new Set([
+                ...draft.allChatSessionIds,
+                ...action.payload.sessions.map((session) => session.chat_session_id),
+            ]));
+        },
+        fetchChatSessionsForUserFailure(draft, action) {
+            draft.fetchState = 'Error';
+            draft.error = action.payload;
+        },
+        fetchChatHistory: {
+            reducer(draft, action) {
+                const { chatSessionId } = action.payload;
+                draft.fetchChatSessionHistoryByChatSessionId[chatSessionId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(chatSessionId, userId) {
+                return { payload: { chatSessionId, userId } };
+            },
+        },
+        fetchChatHistorySuccess(draft, action) {
+            const { chatSessionId, nextPageToken } = action.payload;
+            draft.fetchChatSessionHistoryByChatSessionId[chatSessionId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.uiState.chatHistoryNextPageToken[chatSessionId] = {
+                nextPageToken,
+                hasMore: nextPageToken != null,
+            };
+            if (draft.responseStateByChatSessionId[chatSessionId] == null) {
+                draft.responseStateByChatSessionId[chatSessionId] = {
+                    thought: { fetchState: 'Completed', error: undefined },
+                    analysis: { fetchState: 'Completed', error: undefined },
+                    reasoning: { fetchState: 'Completed', error: undefined },
+                    answer: { fetchState: 'Completed', error: undefined },
+                };
+            }
+        },
+        fetchChatHistoryFailure(draft, action) {
+            const { chatSessionId, error } = action.payload;
+            draft.fetchChatSessionHistoryByChatSessionId[chatSessionId] = {
+                fetchState: 'Error',
+                error,
+            };
+        },
+        setSession(draft, action) {
+            draft.uiState.currentChatSessionId = action.payload.sessionId;
+            draft.uiState.agentId = action.payload.agentId;
+            mirrorCurrentSessionToPageKeyMapIfActive(draft);
+        },
+        createSession: {
+            reducer(draft, action) {
+                draft.uiState.agentId = action.payload.agentId;
+                draft.createSessionState.fetchState = 'In-Progress';
+                draft.createSessionState.error = undefined;
+            },
+            prepare(agentId, userId, contextRefId, contextType, pageContext) {
+                return {
+                    payload: { agentId, contextRefId, contextType, pageContext, userId },
+                };
+            },
+        },
+        createSessionSuccess(draft, action) {
+            const { agentId, contextMessage, contextStatus, sessionId } = action.payload;
+            draft.uiState.agentId = agentId;
+            draft.createSessionState.fetchState = 'Completed';
+            draft.createSessionState.error = undefined;
+            draft.uiState.currentChatSessionId = sessionId;
+            draft.uiState.lastContextMessage = contextMessage;
+            draft.uiState.lastContextStatus = contextStatus;
+            draft.uiState.chatHistoryNextPageToken[sessionId] = {
+                nextPageToken: null,
+                hasMore: false,
+            };
+            mirrorCurrentSessionToPageKeyMapIfActive(draft);
+        },
+        createSessionFailure(draft, action) {
+            draft.createSessionState.fetchState = 'Error';
+            draft.createSessionState.error = action.payload;
+        },
+        clearLastContextMessage(draft) {
+            draft.uiState.lastContextMessage = undefined;
+            draft.uiState.lastContextStatus = undefined;
+        },
+        createSessionAndSubmit: {
+            reducer(draft, action) {
+                draft.uiState.agentId = action.payload.agentId;
+                draft.createSessionAndSubmitState.fetchState = 'In-Progress';
+                draft.createSessionAndSubmitState.error = undefined;
+            },
+            prepare(agentId, userId, questionAnswerId, questionId, createdAt, question, files, pageContext) {
+                return {
+                    payload: {
+                        agentId,
+                        userId,
+                        questionAnswerId,
+                        questionId,
+                        createdAt,
+                        question,
+                        files,
+                        pageContext,
+                    },
+                };
+            },
+        },
+        initializeNewSessionState(draft, action) {
+            const { agentId, sessionId } = action.payload;
+            draft.uiState.currentChatSessionId = sessionId;
+            draft.uiState.agentId = agentId;
+            draft.uiState.chatHistoryNextPageToken[sessionId] = {
+                nextPageToken: null,
+                hasMore: false,
+            };
+            mirrorCurrentSessionToPageKeyMapIfActive(draft);
+        },
+        createSessionAndSubmitSuccess(draft) {
+            // Note: currentChatSessionId, agentId, and chatHistoryNextPageToken are set by initializeNewSessionState
+            // This action only marks the createSessionAndSubmit operation as completed
+            draft.createSessionAndSubmitState.fetchState = 'Completed';
+            draft.createSessionAndSubmitState.error = undefined;
+        },
+        createSessionAndSubmitFailure(draft, action) {
+            draft.createSessionAndSubmitState.fetchState = 'Error';
+            draft.createSessionAndSubmitState.error = action.payload;
+        },
+        updateCurrentInput(draft, action) {
+            draft.uiState.currentInput = action.payload;
+        },
+        stopSubmit: {
+            reducer(draft, action) {
+                const { chatSessionId } = action.payload;
+                draft.stopSubmitStateByChatSessionId[chatSessionId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(chatSessionId) {
+                return { payload: { chatSessionId } };
+            },
+        },
+        stopSubmitSuccess(draft, action) {
+            const { chatSessionId, isOnlyQuestionInSession } = action.payload;
+            draft.uiState.currentInput = action.payload.question;
+            draft.stopSubmitStateByChatSessionId[chatSessionId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            if (isOnlyQuestionInSession &&
+                draft.responseStateByChatSessionId[chatSessionId] != null) {
+                delete draft.responseStateByChatSessionId[chatSessionId];
+            }
+        },
+        stopSubmitFailure(draft, action) {
+            const { chatSessionId, error } = action.payload;
+            draft.stopSubmitStateByChatSessionId[chatSessionId] = {
+                fetchState: 'Error',
+                error,
+            };
+        },
+        stopSubmitQuestion: {
+            reducer(draft, action) {
+                const { chatSessionId } = action.payload;
+                draft.stopSubmitStateByChatSessionId[chatSessionId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(chatSessionId) {
+                return { payload: { chatSessionId } };
+            },
+        },
+        stopSubmitQuestionSuccess(draft, action) {
+            const { chatSessionId, isOnlyQuestionInSession } = action.payload;
+            draft.uiState.currentInput = action.payload.question;
+            draft.stopSubmitStateByChatSessionId[chatSessionId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            if (isOnlyQuestionInSession &&
+                draft.responseStateByChatSessionId[chatSessionId] != null) {
+                delete draft.responseStateByChatSessionId[chatSessionId];
+            }
+        },
+        stopSubmitQuestionFailure(draft, action) {
+            const { chatSessionId, error } = action.payload;
+            draft.stopSubmitStateByChatSessionId[chatSessionId] = {
+                fetchState: 'Error',
+                error,
+            };
+        },
+        acceptMasterTOS: {
+            reducer(draft) {
+                draft.masterTOSAcceptanceState.fetchState = 'In-Progress';
+                draft.masterTOSAcceptanceState.error = undefined;
+            },
+            prepare(userRoleId) {
+                return { payload: { userRoleId } };
+            },
+        },
+        acceptMasterTOSSuccess(draft) {
+            draft.masterTOSAcceptanceState.fetchState = 'Completed';
+            draft.masterTOSAcceptanceState.error = undefined;
+        },
+        acceptMasterTOSFailure(draft, action) {
+            draft.masterTOSAcceptanceState.fetchState = 'Error';
+            draft.masterTOSAcceptanceState.error = action.payload;
+        },
+        deleteChatSession: {
+            reducer(draft, action) {
+                const { chatSessionId } = action.payload;
+                draft.deleteChatSessionStateByChatSessionId[chatSessionId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(chatSessionId) {
+                return { payload: { chatSessionId } };
+            },
+        },
+        deleteChatSessionSuccess(draft, action) {
+            const { chatSessionId } = action.payload;
+            draft.deleteChatSessionStateByChatSessionId[chatSessionId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.allChatSessionIds = draft.allChatSessionIds.filter((id) => id !== chatSessionId);
+            if (draft.uiState.currentChatSessionId === chatSessionId) {
+                draft.uiState.currentChatSessionId = undefined;
+                draft.uiState.agentId = undefined;
+            }
+            removeSessionIdFromPageKeyMap(draft, chatSessionId);
+            delete draft.uiState.chatHistoryNextPageToken[chatSessionId];
+            delete draft.uiState.scrollPositionByChatSessionId[chatSessionId];
+            delete draft.fetchChatSessionHistoryByChatSessionId[chatSessionId];
+            delete draft.responseStateByChatSessionId[chatSessionId];
+            delete draft.stopSubmitStateByChatSessionId[chatSessionId];
+        },
+        deleteChatSessionFailure(draft, action) {
+            const { chatSessionId, error } = action.payload;
+            draft.deleteChatSessionStateByChatSessionId[chatSessionId] = {
+                fetchState: 'Error',
+                error,
+            };
+        },
+        clearDeleteChatSessionStatus(draft, action) {
+            const { chatSessionId } = action.payload;
+            delete draft.deleteChatSessionStateByChatSessionId[chatSessionId];
+        },
+        clearInput(draft) {
+            draft.uiState.currentInput = '';
+        },
+        clearCurrentSessionId(draft) {
+            draft.uiState.currentChatSessionId = undefined;
+            const key = draft.uiState.aiCfoSidePanelHostPageKey;
+            if (key != null) {
+                delete draft.uiState.chatSessionIdByPageKey[key];
+            }
+        },
+        applyAiCfoSidePanelHostPageTransition(draft, action) {
+            const { newAiCfoSidePanelHostPageKey, nextCurrentChatSessionId } = action.payload;
+            const prevKey = draft.uiState.aiCfoSidePanelHostPageKey;
+            const curId = draft.uiState.currentChatSessionId;
+            if (prevKey != null &&
+                prevKey !== newAiCfoSidePanelHostPageKey &&
+                curId != null) {
+                draft.uiState.chatSessionIdByPageKey[prevKey] = curId;
+            }
+            draft.uiState.aiCfoSidePanelHostPageKey = newAiCfoSidePanelHostPageKey;
+            draft.uiState.currentChatSessionId =
+                nextCurrentChatSessionId != null ? nextCurrentChatSessionId : undefined;
+            draft.uiState.currentInput = '';
+            mirrorCurrentSessionToPageKeyMapIfActive(draft);
+        },
+        clearAiCfoSidePanelHostPageContext(draft) {
+            const key = draft.uiState.aiCfoSidePanelHostPageKey;
+            const curId = draft.uiState.currentChatSessionId;
+            if (key != null && curId != null) {
+                draft.uiState.chatSessionIdByPageKey[key] = curId;
+            }
+            draft.uiState.aiCfoSidePanelHostPageKey = undefined;
+        },
+        fetchSuggestedQuestions(draft, action) {
+            const { pageContext } = action.payload;
+            const prev = draft.suggestedQuestionsByPageContext[pageContext];
+            draft.suggestedQuestionsByPageContext[pageContext] = {
+                fetchState: 'In-Progress',
+                pageContext,
+                suggestedQuestions: prev?.suggestedQuestions ?? [],
+                generatedAt: prev?.generatedAt,
+                error: undefined,
+            };
+        },
+        fetchSuggestedQuestionsSuccess(draft, action) {
+            const { pageContext, generatedAt, suggestedQuestions } = action.payload;
+            draft.suggestedQuestionsByPageContext[pageContext] = {
+                fetchState: 'Completed',
+                pageContext,
+                generatedAt,
+                suggestedQuestions,
+                error: undefined,
+            };
+        },
+        fetchSuggestedQuestionsFailure(draft, action) {
+            const { pageContext, error } = action.payload;
+            const prev = draft.suggestedQuestionsByPageContext[pageContext];
+            draft.suggestedQuestionsByPageContext[pageContext] = {
+                fetchState: 'Error',
+                pageContext,
+                suggestedQuestions: prev?.suggestedQuestions ?? [],
+                generatedAt: prev?.generatedAt,
+                error,
+            };
+        },
+        clearAiCfoView(draft) {
+            Object.assign(draft, exports.initialAiCfoViewState);
+        },
+        updateCotCollapsedState(draft, action) {
+            const { isCollapsed, questionAnswerId } = action.payload;
+            draft.uiState.cotCollapsedByQuestionAnswerId[questionAnswerId] =
+                isCollapsed;
+        },
+    },
+});
+_a = aiCfoView.actions, exports.submitQuestion = _a.submitQuestion, exports.submitQuestionSuccess = _a.submitQuestionSuccess, exports.submitQuestionFailure = _a.submitQuestionFailure, exports.updateResponseState = _a.updateResponseState, exports.updateAiCfoViewScrollPosition = _a.updateAiCfoViewScrollPosition, exports.updateCurrentInput = _a.updateCurrentInput, exports.clearInput = _a.clearInput, exports.setSession = _a.setSession, exports.createSession = _a.createSession, exports.createSessionSuccess = _a.createSessionSuccess, exports.createSessionFailure = _a.createSessionFailure, exports.createSessionAndSubmit = _a.createSessionAndSubmit, exports.initializeNewSessionState = _a.initializeNewSessionState, exports.createSessionAndSubmitSuccess = _a.createSessionAndSubmitSuccess, exports.createSessionAndSubmitFailure = _a.createSessionAndSubmitFailure, exports.fetchChatSessionsForUser = _a.fetchChatSessionsForUser, exports.fetchChatSessionsForUserSuccess = _a.fetchChatSessionsForUserSuccess, exports.fetchChatSessionsForUserFailure = _a.fetchChatSessionsForUserFailure, exports.fetchChatHistory = _a.fetchChatHistory, exports.fetchChatHistorySuccess = _a.fetchChatHistorySuccess, exports.fetchChatHistoryFailure = _a.fetchChatHistoryFailure, exports.clearCurrentSessionId = _a.clearCurrentSessionId, exports.clearLastContextMessage = _a.clearLastContextMessage, exports.stopSubmit = _a.stopSubmit, exports.stopSubmitSuccess = _a.stopSubmitSuccess, exports.stopSubmitFailure = _a.stopSubmitFailure, exports.stopSubmitQuestion = _a.stopSubmitQuestion, exports.stopSubmitQuestionSuccess = _a.stopSubmitQuestionSuccess, exports.stopSubmitQuestionFailure = _a.stopSubmitQuestionFailure, exports.acceptMasterTOS = _a.acceptMasterTOS, exports.acceptMasterTOSSuccess = _a.acceptMasterTOSSuccess, exports.acceptMasterTOSFailure = _a.acceptMasterTOSFailure, exports.deleteChatSession = _a.deleteChatSession, exports.deleteChatSessionSuccess = _a.deleteChatSessionSuccess, exports.deleteChatSessionFailure = _a.deleteChatSessionFailure, exports.clearDeleteChatSessionStatus = _a.clearDeleteChatSessionStatus, exports.clearAiCfoView = _a.clearAiCfoView, exports.updateCotCollapsedState = _a.updateCotCollapsedState, exports.fetchSuggestedQuestions = _a.fetchSuggestedQuestions, exports.fetchSuggestedQuestionsSuccess = _a.fetchSuggestedQuestionsSuccess, exports.fetchSuggestedQuestionsFailure = _a.fetchSuggestedQuestionsFailure, exports.applyAiCfoSidePanelHostPageTransition = _a.applyAiCfoSidePanelHostPageTransition, exports.clearAiCfoSidePanelHostPageContext = _a.clearAiCfoSidePanelHostPageContext;
+exports.default = aiCfoView.reducer;

package/lib/view/aiCfoView/aiCfoViewSelector.d.ts

@@ -0,0 +1,25 @@
+import type { AiCfoSuggestedQuestionsPageContext } from '../../common/aiCfo/aiCfoSuggestedQuestionsPageContext';
+import { ID } from '../../commonStateTypes/common';
+import { FetchStateAndError } from '../../commonStateTypes/common';
+import { SelectorView } from '../../commonStateTypes/viewAndReport/viewAndReport';
+import { AiCfoSelectorView } from '../../entity/aiCfo/aiCfoSelector';
+import { RootState } from '../../reducer';
+import { AiCfoViewUIState, SuggestedQuestionsForPageContext } from './aiCfoViewState';
+export interface AiCfoViewSelector extends SelectorView, AiCfoSelectorView {
+    createSessionAndSubmitState: FetchStateAndError;
+    createSessionState: FetchStateAndError;
+    deleteChatSessionStateByChatSessionId: Record<ID, FetchStateAndError>;
+    fetchChatSessionHistoryByChatSessionId: Record<ID, FetchStateAndError>;
+    masterTOSAcceptanceState: FetchStateAndError;
+    responseStateByChatSessionId: Record<ID, {
+        analysis: FetchStateAndError;
+        answer: FetchStateAndError;
+        reasoning: FetchStateAndError;
+        thought: FetchStateAndError;
+    }>;
+    stopSubmitStateByChatSessionId: Record<ID, FetchStateAndError>;
+    suggestedQuestionsByPageContext: Partial<Record<AiCfoSuggestedQuestionsPageContext, SuggestedQuestionsForPageContext>>;
+    uiState: AiCfoViewUIState;
+}
+export declare const getAiCfoView: (state: RootState) => AiCfoViewSelector;
+export declare function getSuggestedQuestionsForPageContext(state: RootState, pageContext: AiCfoSuggestedQuestionsPageContext): SuggestedQuestionsForPageContext | undefined;

package/lib/view/aiCfoView/aiCfoViewSelector.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiCfoView = void 0;
+exports.getSuggestedQuestionsForPageContext = getSuggestedQuestionsForPageContext;
+const aiCfoReducer_1 = require("../../entity/aiCfo/aiCfoReducer");
+const aiCfoSelector_1 = require("../../entity/aiCfo/aiCfoSelector");
+const aiCfoViewReducer_1 = require("./aiCfoViewReducer");
+const getAiCfoView = (state) => {
+    const { fetchState, error, uiState, createSessionState, createSessionAndSubmitState, deleteChatSessionStateByChatSessionId, stopSubmitStateByChatSessionId, responseStateByChatSessionId, fetchChatSessionHistoryByChatSessionId, masterTOSAcceptanceState, suggestedQuestionsByPageContext, } = state.aiCfoViewState ?? aiCfoViewReducer_1.initialAiCfoViewState;
+    return {
+        fetchState,
+        error,
+        createSessionState,
+        createSessionAndSubmitState,
+        deleteChatSessionStateByChatSessionId,
+        stopSubmitStateByChatSessionId,
+        responseStateByChatSessionId,
+        uiState,
+        fetchChatSessionHistoryByChatSessionId,
+        masterTOSAcceptanceState,
+        suggestedQuestionsByPageContext,
+        ...(0, aiCfoSelector_1.getAiCfoSelectorView)(state.aiCfoState ?? aiCfoReducer_1.initialAiCfoState),
+        version: 1,
+    };
+};
+exports.getAiCfoView = getAiCfoView;
+function getSuggestedQuestionsForPageContext(state, pageContext) {
+    return state.aiCfoViewState?.suggestedQuestionsByPageContext?.[pageContext];
+}