@zeniai/client-epic-state 4.19.24-betaRR9 → 4.19.24-betaSK01

package/lib/cjs/entity/aiCfo/aiCfoReducer.d.ts

@@ -0,0 +1,46 @@
+import { ID } from '../../commonStateTypes/common';
+import { ZeniDate } from '../../zeniDayJS';
+import { AiCfoAnswerPayload, AiCfoVisualizationPayload, ChatSessionPayload, MessagePayload } from './aiCfoPayload';
+import { AiCfoState, AiCfoVisualization, FileAttachmentMetadata } from './aiCfoState';
+export declare const initialAiCfoState: AiCfoState;
+export declare const toAiCfoVisualization: (visualization: AiCfoVisualizationPayload) => AiCfoVisualization | undefined;
+export declare const setNewSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    createdAt: ZeniDate;
+    userId: ID;
+}, "aiCfo/setNewSession">, clearSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "aiCfo/clearSession">, setSessions: import("@reduxjs/toolkit").ActionCreatorWithPayload<ChatSessionPayload[], "aiCfo/setSessions">, setChatHistory: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    history: MessagePayload[];
+    isPaginationComplete?: boolean;
+}, "aiCfo/setChatHistory">, upsertAnswerPayload: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    answerPayload: AiCfoAnswerPayload;
+    chatSessionId: ID;
+    userId: ID;
+    questionAnswerId?: ID;
+}, "aiCfo/upsertAnswerPayload">, upsertOrAddQuestionAnswerPayload: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    answerPayload: AiCfoAnswerPayload;
+    chatSessionId: ID;
+    question: {
+        createdAt: ZeniDate;
+        questionId: ID;
+        text: string;
+    };
+    questionAnswerId: ID;
+    userId: ID;
+    insertQuestionAnswer?: boolean;
+}, "aiCfo/upsertOrAddQuestionAnswerPayload">, addQuestionPayload: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    question: {
+        createdAt: ZeniDate;
+        questionId: ID;
+        text: string;
+    };
+    questionAnswerId: ID;
+    userId: ID;
+    attachments?: FileAttachmentMetadata[];
+}, "aiCfo/addQuestionPayload">, clearAiCfo: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfo/clearAiCfo">, deleteQuestion: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    questionAnswerId: ID;
+}, "aiCfo/deleteQuestion">;
+declare const _default: import("redux").Reducer<AiCfoState>;
+export default _default;

package/lib/cjs/entity/aiCfo/aiCfoReducer.js

@@ -0,0 +1,490 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteQuestion = exports.clearAiCfo = exports.addQuestionPayload = exports.upsertOrAddQuestionAnswerPayload = exports.upsertAnswerPayload = exports.setChatHistory = exports.setSessions = exports.clearSession = exports.setNewSession = exports.toAiCfoVisualization = exports.initialAiCfoState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const zeniDayJS_1 = require("../../zeniDayJS");
+const aiCfoState_1 = require("./aiCfoState");
+exports.initialAiCfoState = {
+    aiCfoByChatSessionId: {},
+    partialQuestionAnswers: {},
+};
+// Utility: Merge two arrays of Q&A pairs, combining responses for the same question
+function mergeQuestionAnswerPairs(existing, newQAs) {
+    const merged = new Map();
+    // Add existing Q&A pairs
+    for (const qa of existing) {
+        merged.set(qa.questionAnswerId, Object.assign({}, qa));
+    }
+    // Merge new Q&A pairs
+    for (const newQA of newQAs) {
+        const existingQA = merged.get(newQA.questionAnswerId);
+        if (existingQA) {
+            // Merge responses
+            const mergedResponses = Object.assign(Object.assign({}, existingQA.responses), newQA.responses);
+            merged.set(newQA.questionAnswerId, Object.assign(Object.assign({}, newQA), { responses: mergedResponses }));
+        }
+        else {
+            // Add new Q&A pair
+            merged.set(newQA.questionAnswerId, newQA);
+        }
+    }
+    // Convert back to array and sort by question creation time
+    return Array.from(merged.values()).sort((a, b) => a.question.createdAt.valueOf() - b.question.createdAt.valueOf());
+}
+// Utility: Convert chat history (array of MessagePayload) to AiCfoQuestionWithAnswer[]
+function chatHistoryToQA(history) {
+    var _a, _b, _c;
+    const questionGroups = new Map();
+    // First pass: collect all messages and group by message_id
+    for (const message of history) {
+        const messageId = message.message_id;
+        if (!questionGroups.has(messageId)) {
+            questionGroups.set(messageId, {
+                question: null,
+                responses: [],
+            });
+        }
+        const group = questionGroups.get(messageId);
+        if (!group) {
+            continue;
+        }
+        if (message.sender === 'user') {
+            // User message is the question
+            group.question = message;
+        }
+        else if (message.sender === 'agent') {
+            // Agent message is a response block
+            group.responses.push(message);
+        }
+    }
+    // Convert groups to AiCfoQuestionWithAnswer
+    const questionAnswerPairs = [];
+    for (const [messageId, group] of questionGroups.entries()) {
+        // Skip groups that don't have a question
+        if (!group.question) {
+            continue;
+        }
+        const question = {
+            messageId: group.question.message_id,
+            chatSessionId: group.question.chat_session_id,
+            userId: group.question.user_id,
+            sender: (0, aiCfoState_1.toMessageSender)(group.question.sender),
+            state: 'complete',
+            questionText: group.question.content,
+            createdAt: (0, zeniDayJS_1.date)(group.question.created_at),
+        };
+        const responses = {};
+        // Process each response for this question
+        for (const agentMessage of group.responses) {
+            try {
+                const parsedAgentMessage = (0, aiCfoState_1.toMessageType)(agentMessage.message_type) === 'json'
+                    ? JSON.parse(agentMessage.content)
+                    : {
+                        text: agentMessage.content,
+                        state: 'complete',
+                        type: 'answer',
+                        visualization: null,
+                        follow_up_questions: [],
+                    };
+                const responseType = (0, aiCfoState_1.toAiCfoAnswerResponseType)(parsedAgentMessage.type);
+                const responseState = (0, aiCfoState_1.toAiCfoAnswerStateType)(parsedAgentMessage.state);
+                if (typeof parsedAgentMessage.text === 'string' &&
+                    aiCfoState_1.ALL_AI_CFO_ANSWER_RESPONSE_TYPES.includes(responseType)) {
+                    responses[responseType] = {
+                        messageId: agentMessage.message_id,
+                        chatSessionId: agentMessage.chat_session_id,
+                        userId: agentMessage.user_id,
+                        sender: (0, aiCfoState_1.toMessageSender)(agentMessage.sender),
+                        type: responseType,
+                        state: responseState,
+                        content: {
+                            text: parsedAgentMessage.text,
+                            visualization: parsedAgentMessage.visualization
+                                ? (0, exports.toAiCfoVisualization)(parsedAgentMessage.visualization)
+                                : undefined,
+                            followUpQuestions: Array.isArray(parsedAgentMessage.follow_up_questions)
+                                ? parsedAgentMessage.follow_up_questions
+                                : [],
+                            assumptions: (_a = parsedAgentMessage.assumptions) !== null && _a !== void 0 ? _a : '',
+                            insights: (_b = parsedAgentMessage.insights) !== null && _b !== void 0 ? _b : '',
+                            summarizedTitle: (_c = parsedAgentMessage.summarized_title) !== null && _c !== void 0 ? _c : undefined,
+                            chainOfThoughtActionSteps: [],
+                        },
+                        createdAt: (0, zeniDayJS_1.date)(agentMessage.created_at),
+                    };
+                }
+            }
+            catch (error) {
+                console.error('Failed to parse agent message: ', error);
+            }
+        }
+        questionAnswerPairs.push({
+            questionAnswerId: `qa_${messageId}`,
+            question,
+            responses,
+        });
+    }
+    // Sort by question creation time (oldest first)
+    return questionAnswerPairs.sort((a, b) => a.question.createdAt.valueOf() - b.question.createdAt.valueOf());
+}
+const toAiCfoVisualization = (visualization) => {
+    var _a;
+    if (visualization.type == null || visualization.data == null) {
+        return undefined;
+    }
+    return {
+        type: (_a = (0, aiCfoState_1.toAiCfoVisualizationTypeStrict)(visualization.type)) !== null && _a !== void 0 ? _a : 'table',
+        data: toAiCfoVisualizationData(visualization.data),
+    };
+};
+exports.toAiCfoVisualization = toAiCfoVisualization;
+const toAiCfoVisualizationData = (data) => {
+    var _a, _b, _c, _d, _e;
+    if ('x' in data && 'y' in data) {
+        // Normalize y to always be an array
+        const yArray = Array.isArray(data.y) ? data.y : [data.y];
+        // Handle y_format (now required)
+        const yFormat = data.y_format != null
+            ? {
+                type: (_a = (0, aiCfoState_1.toYFormatTypeStrict)(data.y_format.type)) !== null && _a !== void 0 ? _a : 'number',
+                unit: (0, aiCfoState_1.toYFormatUnitStrict)(data.y_format.unit),
+                scale: (_b = (0, aiCfoState_1.toYFormatScaleStrict)(data.y_format.scale)) !== null && _b !== void 0 ? _b : 'raw',
+                symbol: (_c = data.y_format.symbol) !== null && _c !== void 0 ? _c : undefined,
+            }
+            : undefined;
+        return {
+            values: data.values,
+            x: data.x,
+            y: yArray,
+            lines: (_d = data.lines) !== null && _d !== void 0 ? _d : [],
+            yFormat,
+        };
+    }
+    // Table cleaning logic: only strip quotes from column names and cell values
+    const stripQuotes = (s) => {
+        if (typeof s === 'string') {
+            return s.replace(/^"+|"+$/g, '');
+        }
+        // If not a string, convert to string (e.g., number, null, undefined)
+        return String(s);
+    };
+    const columns = (Array.isArray(data.columns)
+        ? data.columns
+        : Object.keys((_e = data.values[0]) !== null && _e !== void 0 ? _e : [])).map(stripQuotes);
+    const rows = data.values.map((row) => columns.map((col) => {
+        const value = row[col];
+        return value == null ? '' : stripQuotes(value);
+    }));
+    return {
+        rows,
+        columns,
+    };
+};
+const toResponseBlockType = (answer, userId) => {
+    const { metadata, state, type, text, visualization, follow_up_questions, assumptions, insights, summarized_title, } = answer;
+    const { chat_session_id, message_id, timestamp, chain_of_thought_action_steps: chainOfThoughtActionSteps = [], } = metadata;
+    return {
+        messageId: message_id,
+        chatSessionId: chat_session_id,
+        userId,
+        sender: 'agent',
+        state: (0, aiCfoState_1.toAiCfoAnswerStateType)(state),
+        type: (0, aiCfoState_1.toAiCfoAnswerResponseType)(type),
+        content: {
+            text: text,
+            visualization: visualization != null ? (0, exports.toAiCfoVisualization)(visualization) : undefined,
+            followUpQuestions: follow_up_questions !== null && follow_up_questions !== void 0 ? follow_up_questions : [],
+            assumptions: assumptions !== null && assumptions !== void 0 ? assumptions : '',
+            insights: insights !== null && insights !== void 0 ? insights : '',
+            summarizedTitle: summarized_title !== null && summarized_title !== void 0 ? summarized_title : undefined,
+            chainOfThoughtActionSteps,
+        },
+        createdAt: (0, zeniDayJS_1.date)(timestamp),
+    };
+};
+const aiCfo = (0, toolkit_1.createSlice)({
+    name: 'aiCfo',
+    initialState: exports.initialAiCfoState,
+    reducers: {
+        setNewSession(draft, action) {
+            const { chatSessionId, userId, createdAt } = action.payload;
+            draft.aiCfoByChatSessionId[chatSessionId] = {
+                chatSession: {
+                    chatSessionId,
+                    userId,
+                    chatSessionSummary: '',
+                    createdAt,
+                },
+                questionAnswers: [],
+            };
+            // Clear any existing partial Q&A when creating a new session
+            draft.partialQuestionAnswers[chatSessionId] = undefined;
+        },
+        setSessions(draft, action) {
+            action.payload.forEach((chatSessionPayload) => {
+                const { chat_session_id } = chatSessionPayload;
+                // This is to prevent overwriting the session if it is already in state
+                if (draft.aiCfoByChatSessionId[chat_session_id] == null) {
+                    draft.aiCfoByChatSessionId[chat_session_id] = {
+                        chatSession: toChatSession(chatSessionPayload),
+                        questionAnswers: [],
+                    };
+                    // Clear any existing partial Q&A for this session
+                    draft.partialQuestionAnswers[chat_session_id] = undefined;
+                }
+            });
+        },
+        setChatHistory(draft, action) {
+            const { chatSessionId, history, isPaginationComplete = false, } = action.payload;
+            if (draft.aiCfoByChatSessionId[chatSessionId] == null) {
+                console.warn(`session with id ${chatSessionId} not found in setChatHistory`);
+                return;
+            }
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            // Check if we have an existing partial Q&A pair for this session
+            const existingPartialQA = draft.partialQuestionAnswers[chatSessionId];
+            // Process new messages into Q&A pairs
+            const newQAs = chatHistoryToQA(history);
+            // If we have an existing partial Q&A pair, merge with new Q&A pairs
+            let mergedQAs;
+            if (existingPartialQA && newQAs.length > 0) {
+                // Check if any new QAs have the same message_id as the existing partial QA
+                const hasMatchingMessageId = newQAs.some((newQA) => newQA.question.messageId === existingPartialQA.question.messageId);
+                if (hasMatchingMessageId) {
+                    // Merge the existing partial QA with new QAs that have matching message_id
+                    mergedQAs = mergeQuestionAnswerPairs([existingPartialQA], newQAs);
+                }
+                else {
+                    // No matching message_id - existing partial QA should be moved to complete
+                    // and new QAs should be processed separately
+                    mergedQAs = [existingPartialQA, ...newQAs];
+                }
+            }
+            else if (existingPartialQA && newQAs.length === 0) {
+                // Intermediate page scenario: existing partial QA but no new blocks to merge
+                // This means the partial QA is complete (no more blocks coming to complete it)
+                mergedQAs = [existingPartialQA];
+            }
+            else {
+                mergedQAs = newQAs;
+            }
+            // Separate complete and incomplete pairs
+            const completeQAs = [];
+            let incompleteQA;
+            for (const qa of mergedQAs) {
+                const questionText = qa.question.questionText;
+                const hasQuestion = questionText != null && questionText.trim().length > 0;
+                if (!hasQuestion) {
+                    // Skip if no question text
+                    continue;
+                }
+                // Check if this Q&A pair is complete
+                // A Q&A pair is considered complete if it has:
+                // 1. A question (already checked above)
+                // 2. At least one agent response (any type: thought, reasoning, analysis, answer, etc.)
+                // 3. AND EITHER:
+                //    - At least one response with state: 'complete' (not 'partial')
+                //    - OR multiple response blocks (thought, reasoning, analysis) even if they're all partial
+                const hasAnyResponse = Object.keys(qa.responses).length > 0;
+                const hasCompleteResponse = Object.values(qa.responses).some((response) => response.state === 'complete');
+                const hasMultipleResponseBlocks = Object.keys(qa.responses).length > 1;
+                // Check if this is an existing partial QA that should be moved to complete
+                // because no more blocks are coming to complete it
+                const isExistingPartialQA = existingPartialQA &&
+                    qa.question.messageId === existingPartialQA.question.messageId &&
+                    !hasCompleteResponse;
+                if (hasQuestion &&
+                    hasAnyResponse &&
+                    (hasCompleteResponse || hasMultipleResponseBlocks)) {
+                    // This Q&A pair is complete - has question and either:
+                    // - at least one complete response, OR
+                    // - multiple response blocks (thought, reasoning, analysis) even if all partial
+                    completeQAs.push(qa);
+                }
+                else if (hasQuestion &&
+                    hasAnyResponse &&
+                    isExistingPartialQA === true) {
+                    // This is an existing partial QA that should be moved to complete
+                    // because no more blocks are coming to complete it (intermediate page scenario)
+                    completeQAs.push(qa);
+                }
+                else if (hasQuestion && hasAnyResponse) {
+                    // This Q&A pair has a question and responses but they're all partial
+                    // Keep as incomplete for potential merging with future pages
+                    if (!incompleteQA) {
+                        incompleteQA = qa;
+                    }
+                }
+                else if (hasQuestion) {
+                    // This Q&A pair has only a question, no responses yet
+                    // Keep as incomplete for potential merging with future pages
+                    if (!incompleteQA) {
+                        incompleteQA = qa;
+                    }
+                }
+            }
+            // Update partialQuestionAnswers based on completion status
+            if (isPaginationComplete) {
+                // If pagination is complete, we should have processed all messages
+                // Any remaining incomplete Q&A pairs should be moved to complete
+                if (incompleteQA) {
+                    // When pagination is complete, move all incomplete Q&A pairs to complete
+                    // This handles cases where:
+                    // 1. Question with no responses (error in generation)
+                    // 2. Question with only partial responses (error in generation)
+                    // 3. Question with only answer blocks (no thought/reasoning blocks)
+                    completeQAs.push(incompleteQA);
+                    draft.partialQuestionAnswers[chatSessionId] = undefined;
+                }
+                else {
+                    // No incomplete Q&A pairs, clear partialQuestionAnswers
+                    draft.partialQuestionAnswers[chatSessionId] = undefined;
+                }
+            }
+            else if (incompleteQA) {
+                // Check if this is an intermediate page scenario
+                // If we had an existing partial QA but no new blocks were merged,
+                // then the partial QA should be considered complete
+                if (existingPartialQA && newQAs.length === 0) {
+                    // Intermediate page: existing partial QA but no new blocks to merge
+                    // Move the partial QA to complete since no more blocks are coming
+                    completeQAs.push(incompleteQA);
+                    draft.partialQuestionAnswers[chatSessionId] = undefined;
+                }
+                else {
+                    // Pagination is not complete, keep incomplete Q&A pairs for future merging
+                    draft.partialQuestionAnswers[chatSessionId] = incompleteQA;
+                }
+            }
+            else if (existingPartialQA && newQAs.length === 0) {
+                // Special case: existing partial QA but no new blocks and no incomplete QA in mergedQAs
+                // This means the existing partial QA should be moved to complete
+                completeQAs.push(existingPartialQA);
+                draft.partialQuestionAnswers[chatSessionId] = undefined;
+            }
+            else {
+                // No incomplete Q&A pairs, clear partialQuestionAnswers
+                draft.partialQuestionAnswers[chatSessionId] = undefined;
+            }
+            // Update state - append new complete Q&As to existing ones
+            session.questionAnswers = mergeQuestionAnswerPairs(session.questionAnswers, completeQAs);
+        },
+        /**
+         * Upsert a Q/A pair: if the questionAnswerId exists, upsert the response block; if not, add a new Q/A entry.
+         * Used for push notification payloads that may introduce a new question.
+         */
+        upsertOrAddQuestionAnswerPayload(draft, action) {
+            const { chatSessionId, questionAnswerId, question: { questionId, createdAt, text }, answerPayload, userId, insertQuestionAnswer, } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                console.warn(`session with id ${chatSessionId} not found `);
+                return;
+            }
+            let qa = session.questionAnswers.find((qa) => qa.questionAnswerId === questionAnswerId);
+            const responseType = (0, aiCfoState_1.toAiCfoAnswerResponseTypeStrict)(answerPayload.type);
+            if (insertQuestionAnswer === true && qa == null) {
+                // Add new Q/A
+                qa = {
+                    questionAnswerId,
+                    question: {
+                        messageId: questionId,
+                        questionText: text,
+                        sender: 'user',
+                        createdAt,
+                        chatSessionId,
+                        state: 'complete',
+                        userId,
+                    },
+                    responses: responseType != null
+                        ? { [responseType]: toResponseBlockType(answerPayload, userId) }
+                        : {},
+                };
+                session.questionAnswers.push(qa);
+            }
+            else if (qa != null && responseType != null) {
+                // Upsert response block
+                qa.responses[responseType] = toResponseBlockType(answerPayload, userId);
+            }
+        },
+        upsertAnswerPayload(draft, action) {
+            const { chatSessionId, answerPayload, questionAnswerId, userId } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                console.warn(`session with id ${chatSessionId} not found in upsertAnswerPayload`);
+                return;
+            }
+            const latestQA = questionAnswerId != null
+                ? session.questionAnswers.find((questionAnswer) => questionAnswer.questionAnswerId === questionAnswerId)
+                : session.questionAnswers.slice(-1)[0];
+            const responseType = (0, aiCfoState_1.toAiCfoAnswerResponseTypeStrict)(answerPayload.type);
+            if (latestQA != null && responseType != null) {
+                // Directly mutate the responses property
+                latestQA.responses[responseType] = toResponseBlockType(answerPayload, userId);
+            }
+        },
+        addQuestionPayload(draft, action) {
+            const { chatSessionId, questionAnswerId, question: { questionId, createdAt, text }, userId, attachments, } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                console.warn(`session with id ${chatSessionId} not found in addQuestionPayload`);
+                return;
+            }
+            let qa = session.questionAnswers.find((qa) => qa.questionAnswerId === questionAnswerId);
+            if (qa == null) {
+                // Add new Q/A
+                qa = {
+                    questionAnswerId,
+                    question: {
+                        messageId: questionId,
+                        questionText: text,
+                        sender: 'user',
+                        createdAt,
+                        chatSessionId,
+                        state: 'complete',
+                        userId,
+                        attachments,
+                    },
+                    responses: {},
+                };
+                session.questionAnswers.push(qa);
+            }
+        },
+        clearSession(draft, action) {
+            var _a;
+            const sessionId = action.payload;
+            delete draft.aiCfoByChatSessionId[sessionId];
+            // Clear partial Q&A if it belongs to the cleared session
+            if (((_a = draft.partialQuestionAnswers) === null || _a === void 0 ? void 0 : _a[sessionId]) != null) {
+                draft.partialQuestionAnswers[sessionId] = undefined;
+            }
+        },
+        clearAiCfo(draft) {
+            draft.aiCfoByChatSessionId = {};
+            draft.partialQuestionAnswers = {};
+        },
+        deleteQuestion(draft, action) {
+            const { chatSessionId, questionAnswerId } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                console.warn(`session with id ${chatSessionId} not found in deleteQuestion`);
+                return;
+            }
+            const idx = session.questionAnswers.findIndex((qa) => qa.questionAnswerId === questionAnswerId);
+            if (idx !== -1) {
+                session.questionAnswers.splice(idx, 1);
+            }
+        },
+    },
+});
+const toChatSession = (chatSessionPayload) => {
+    const { chat_session_id, user_id, created_at, chat_session_summary } = chatSessionPayload;
+    return {
+        chatSessionId: chat_session_id,
+        userId: user_id,
+        chatSessionSummary: chat_session_summary !== null && chat_session_summary !== void 0 ? chat_session_summary : undefined,
+        createdAt: (0, zeniDayJS_1.date)(created_at),
+    };
+};
+_a = aiCfo.actions, exports.setNewSession = _a.setNewSession, exports.clearSession = _a.clearSession, exports.setSessions = _a.setSessions, exports.setChatHistory = _a.setChatHistory, exports.upsertAnswerPayload = _a.upsertAnswerPayload, exports.upsertOrAddQuestionAnswerPayload = _a.upsertOrAddQuestionAnswerPayload, exports.addQuestionPayload = _a.addQuestionPayload, exports.clearAiCfo = _a.clearAiCfo, exports.deleteQuestion = _a.deleteQuestion;
+exports.default = aiCfo.reducer;

package/lib/cjs/entity/aiCfo/aiCfoState.d.ts

@@ -0,0 +1,115 @@
+import { ID } from '../../commonStateTypes/common';
+import { ZeniDate } from '../../zeniDayJS';
+export interface AiCfoAnswerParagraph {
+    text: string;
+    orderedList?: Array<{
+        text: string;
+        subText?: string;
+        unorderedList?: string[];
+    }>;
+}
+export declare const ALL_AI_CFO_CHARTS_TYPES: readonly ["bar_chart", "pie_chart", "line_chart"];
+export declare const ALL_AI_CFO_VISUALIZATION_TYPES: readonly ["bar_chart", "pie_chart", "line_chart", "table"];
+export declare const toAiCfoVisualizationType: (v: string) => "bar_chart" | "pie_chart" | "line_chart" | "table";
+export declare const toAiCfoVisualizationTypeStrict: (v: string) => "bar_chart" | "pie_chart" | "line_chart" | "table" | undefined;
+export type AiCfoVisualizationType = ReturnType<typeof toAiCfoVisualizationType>;
+export declare const toAiCfoChartType: (v: string) => "bar_chart" | "pie_chart" | "line_chart";
+export declare const toAiCfoChartTypeStrict: (v: string) => "bar_chart" | "pie_chart" | "line_chart" | undefined;
+export type AiCfoChartType = ReturnType<typeof toAiCfoChartType>;
+export declare const ALL_AI_CFO_ANSWER_STATE_TYPES: readonly ["complete", "partial"];
+export declare const ALL_AI_CFO_ANSWER_RESPONSE_TYPES: readonly ["analysis", "answer", "reasoning", "thought"];
+export declare const ALL_Y_FORMAT_TYPES: readonly ["currency", "number"];
+export declare const ALL_Y_FORMAT_NON_CURRENCY_UNITS: readonly ["percentage", "unit", "ratio"];
+export declare const ALL_Y_FORMAT_SCALES: readonly ["raw", "K", "M", "B", "T"];
+export declare const toYFormatType: (v: string) => "number" | "currency";
+export declare const toYFormatUnit: (v: string) => string;
+export declare const toYFormatScale: (v: string) => "M" | "raw" | "K" | "B" | "T";
+export declare const toYFormatTypeStrict: (v: string) => "number" | "currency" | undefined;
+export declare const toYFormatUnitStrict: (v: string) => string;
+export declare const toYFormatScaleStrict: (v: string) => "M" | "raw" | "K" | "B" | "T" | undefined;
+export type YFormatType = ReturnType<typeof toYFormatType>;
+export type YFormatUnit = ReturnType<typeof toYFormatUnit>;
+export type YFormatScale = ReturnType<typeof toYFormatScale>;
+export interface YFormat {
+    scale: YFormatScale;
+    type: YFormatType;
+    unit: YFormatUnit;
+    symbol?: string;
+}
+export declare const toAiCfoAnswerStateType: (v: string) => "complete" | "partial";
+export declare const toAiCfoAnswerResponseType: (v: string) => "reasoning" | "analysis" | "answer" | "thought";
+export declare const toAiCfoAnswerStateTypeStrict: (v: string) => "complete" | "partial" | undefined;
+export declare const toAiCfoAnswerResponseTypeStrict: (v: string) => "reasoning" | "analysis" | "answer" | "thought" | undefined;
+export type AiCfoAnswerStateType = ReturnType<typeof toAiCfoAnswerStateType>;
+export type AiCfoAnswerResponseType = ReturnType<typeof toAiCfoAnswerResponseType>;
+export interface TableVisualization {
+    columns: string[];
+    rows: string[][];
+}
+export interface ChartVisualization {
+    values: Array<Record<string, string | number>>;
+    x: string;
+    y: string[];
+    lines?: string[];
+    yFormat?: YFormat;
+}
+export interface AiCfoVisualization {
+    data: TableVisualization | ChartVisualization;
+    type: AiCfoVisualizationType;
+}
+export declare const toMessageSender: (v: string) => "user" | "agent";
+export declare const toMessageType: (v: string) => "plain_text" | "json";
+export declare const toMessageSenderStrict: (v: string) => "user" | "agent" | undefined;
+export declare const toMessageTypeStrict: (v: string) => "plain_text" | "json" | undefined;
+export type MessageSender = ReturnType<typeof toMessageSender>;
+export type MessageType = ReturnType<typeof toMessageType>;
+export interface ResponseBlockBase {
+    chatSessionId: ID;
+    createdAt: ZeniDate;
+    messageId: ID;
+    sender: MessageSender;
+    state: AiCfoAnswerStateType;
+    userId: ID;
+}
+export interface AnswerContentBlockBase {
+    assumptions: string;
+    chainOfThoughtActionSteps: string[];
+    followUpQuestions: string[];
+    insights: string;
+    text: string;
+    summarizedTitle?: string;
+    visualization?: AiCfoVisualization;
+}
+export interface FileAttachmentMetadata {
+    file_size: number;
+    filename: string;
+    mime_type: string;
+    file_id?: string;
+}
+export interface QuestionContentBlockBase extends ResponseBlockBase {
+    questionText: string;
+    attachments?: FileAttachmentMetadata[];
+}
+export interface ResponseBlockType extends ResponseBlockBase {
+    content: AnswerContentBlockBase;
+    type: AiCfoAnswerResponseType;
+}
+export interface AiCfoQuestionWithAnswer {
+    question: QuestionContentBlockBase;
+    questionAnswerId: ID;
+    responses: Partial<Record<AiCfoAnswerResponseType, ResponseBlockType>>;
+}
+export interface ChatSession {
+    chatSessionId: ID;
+    createdAt: ZeniDate;
+    userId: ID;
+    chatSessionSummary?: string;
+}
+export interface ChatSessionWithMessages {
+    chatSession: ChatSession;
+    questionAnswers: AiCfoQuestionWithAnswer[];
+}
+export interface AiCfoState {
+    aiCfoByChatSessionId: Record<ID, ChatSessionWithMessages>;
+    partialQuestionAnswers: Record<ID, AiCfoQuestionWithAnswer | undefined>;
+}