@zeniai/client-epic-state 5.1.18-betaDI1 → 5.1.18-betaDI3

package/lib/entity/aiCfo/aiCfoReducer.js

@@ -0,0 +1,739 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearSyntheticAiCfoAnswers = exports.removeSyntheticAiCfoAnswer = exports.updateSyntheticAiCfoAnswer = exports.appendSyntheticAiCfoAnswer = exports.updateAiCfoAnswerCardPolicyWizardPlan = 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: {},
+    syntheticAnswersByChatSessionId: {},
+};
+// 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, { ...qa });
+    }
+    // Merge new Q&A pairs
+    for (const newQA of newQAs) {
+        const existingQA = merged.get(newQA.questionAnswerId);
+        if (existingQA) {
+            // Merge responses
+            const mergedResponses = { ...existingQA.responses, ...newQA.responses };
+            merged.set(newQA.questionAnswerId, {
+                ...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) {
+    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,
+                            table: parsedAgentMessage.table != null
+                                ? (0, exports.toAiCfoVisualization)(parsedAgentMessage.table)
+                                : undefined,
+                            followUpQuestions: Array.isArray(parsedAgentMessage.follow_up_questions)
+                                ? parsedAgentMessage.follow_up_questions
+                                : [],
+                            assumptions: parsedAgentMessage.assumptions ?? '',
+                            insights: parsedAgentMessage.insights ?? '',
+                            summarizedTitle: parsedAgentMessage.summarized_title ?? undefined,
+                            chainOfThoughtActionSteps: [],
+                            artifact: parsedAgentMessage.artifact ?? undefined,
+                            artifactTitle: parsedAgentMessage.artifact_title ?? undefined,
+                            artifactHostUrl: parsedAgentMessage.artifact_host_url ?? undefined,
+                        },
+                        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) => {
+    if (visualization.type == null || visualization.data == null) {
+        return undefined;
+    }
+    // Reject unknown viz types; `?? 'table'` used to throw in the chart/table decoder
+    // when interactive-form payloads (no `values`) hit it.
+    const normalizedType = (0, aiCfoState_1.toAiCfoVisualizationTypeStrict)(visualization.type);
+    if (normalizedType == null) {
+        return undefined;
+    }
+    return {
+        type: normalizedType,
+        data: normalizedType === 'interactive_form'
+            ? toInteractiveFormVisualization(visualization.data)
+            : toAiCfoVisualizationData(visualization.data),
+    };
+};
+exports.toAiCfoVisualization = toAiCfoVisualization;
+const toInteractiveFormVisualization = (data) => {
+    // When `form_type` is missing / mistyped, infer from payload shape so a malformed
+    // card-policy answer doesn't get decoded as cards_creation (wrong form + submit path).
+    const formType = (0, aiCfoState_1.toInteractiveFormTypeStrict)(data.form_type) ??
+        inferInteractiveFormTypeFromPayload(data.payload);
+    if (formType === 'card_policy') {
+        return {
+            formType: 'card_policy',
+            payload: toCardPolicyInitialData(data.payload),
+        };
+    }
+    return {
+        formType: 'cards_creation',
+        payload: toCardsCreationInitialData(data.payload),
+    };
+};
+const inferInteractiveFormTypeFromPayload = (payload) => {
+    if (payload != null && typeof payload === 'object' && 'mode' in payload) {
+        const mode = payload.mode;
+        if (mode === 'auto' || mode === 'guided' || mode === 'upload') {
+            return 'card_policy';
+        }
+    }
+    return 'cards_creation';
+};
+const toCardsCreationInitialData = (payload) => {
+    const suggestedCards = payload.suggested_cards ?? [];
+    const ordered = [...suggestedCards].sort((a, b) => KIND_RANK[a.card_type] - KIND_RANK[b.card_type]);
+    const withUniqueIds = withSynthesizedIds(ordered);
+    const suggestedOnly = withUniqueIds.filter(({ card }) => card.is_suggested);
+    const cardNameOptions = withUniqueIds.map(({ card, uniqueId }) => ({
+        id: uniqueId,
+        kind: toCardKind(card.card_type),
+        label: card.card_name,
+    }));
+    const suggestedOwnerUserIdByTeamId = Object.fromEntries(suggestedOnly.map(({ card, uniqueId }) => [
+        uniqueId,
+        normalizeOwnerId(card.owner_id),
+    ]));
+    const common = {
+        cardNameOptions,
+        suggestedOwnerUserIdByTeamId,
+    };
+    if (payload.mode === 'create') {
+        return {
+            ...common,
+            mode: 'create',
+            cardRows: suggestedOnly.map(({ card, uniqueId }) => ({
+                cardKind: toCardKind(card.card_type),
+                id: uniqueId,
+                label: card.card_name,
+                recommendedLimit: card.credit_limit > 0 ? card.credit_limit : undefined,
+                suggestedOwnerUserId: normalizeOwnerId(card.owner_id),
+            })),
+        };
+    }
+    return {
+        ...common,
+        mode: 'review',
+        teamRows: suggestedOnly.map(({ card, uniqueId }) => ({
+            avgMonthlySpend: CURRENCY_FORMATTER.format(card.avg_spend),
+            cardKind: toCardKind(card.card_type),
+            id: uniqueId,
+            label: card.card_name,
+            recommendedLimit: CURRENCY_FORMATTER.format(card.credit_limit),
+            recommendedLimitCadence: 'Monthly',
+        })),
+    };
+};
+const CURRENCY_FORMATTER = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    maximumFractionDigits: 0,
+});
+// BE emits `null` or `""` for "no owner picked"; collapse both to `undefined`.
+const normalizeOwnerId = (ownerId) => (ownerId != null && ownerId !== '' ? ownerId : undefined);
+const KIND_RANK = {
+    vendor: 0,
+    category: 1,
+    department: 2,
+};
+const toCardKind = (cardType) => {
+    if (cardType === 'department') {
+        return 'class';
+    }
+    if (cardType === 'category') {
+        return 'category';
+    }
+    return 'vendor';
+};
+// Falls back to `${kind}__${card_name_id}__${index}` when `card_name_id` collides
+// (sample payloads ship the literal `"vendor_uuid"`), to keep RHF row keys unique.
+const withSynthesizedIds = (cards) => {
+    const seen = new Set();
+    return cards.map((card, index) => {
+        const preferred = card.card_name_id;
+        if (preferred != null && preferred !== '' && !seen.has(preferred)) {
+            seen.add(preferred);
+            return { card, uniqueId: preferred };
+        }
+        const synthesized = `${card.card_type}__${preferred ?? 'unknown'}__${index}`;
+        seen.add(synthesized);
+        return { card, uniqueId: synthesized };
+    });
+};
+const toCardPolicyDraftPolicy = (payload, index) => ({
+    id: `draft-${index}`,
+    name: payload.name,
+    description: payload.description ?? '',
+    mode: payload.mode,
+    allowedEntity: {
+        categoryCodes: payload.allowed_entity?.category_codes ?? [],
+        merchantNames: payload.allowed_entity?.merchant_names ?? [],
+    },
+    blockedEntity: {
+        categoryCodes: payload.blocked_entity?.category_codes ?? [],
+        merchantNames: payload.blocked_entity?.merchant_names ?? [],
+    },
+    applyToCards: payload.apply_to_cards ?? [],
+    requiredReceiptThreshold: payload.required_receipt_threshold ?? 0,
+    spendLimits: {
+        transaction: payload.spend_limits?.transaction ?? 0,
+    },
+});
+const toCardPolicyStep5Review = (payload) => ({
+    draftPolicies: (payload.draft_policies ?? []).map(toCardPolicyDraftPolicy),
+    groupingSource: payload.grouping_source ?? 'none',
+    prompt: payload.prompt ?? '',
+});
+const toCardPolicyWizardPlan = (payload) => ({
+    step5Review: toCardPolicyStep5Review(payload.step_5_review),
+});
+const toCardPolicyUploadSource = (payload) => ({
+    confidenceScore: payload.confidence_score,
+    fileName: payload.file_name,
+    lowConfidenceFields: payload.low_confidence_fields ?? [],
+});
+const toCardPolicyInitialData = (payload) => {
+    if (payload.mode === 'upload') {
+        return {
+            policyKind: 'upload',
+            wizardPlan: payload.wizard_plan != null
+                ? toCardPolicyWizardPlan(payload.wizard_plan)
+                : undefined,
+            source: payload.source != null
+                ? toCardPolicyUploadSource(payload.source)
+                : undefined,
+        };
+    }
+    return {
+        policyKind: payload.mode,
+        wizardPlan: toCardPolicyWizardPlan(payload.wizard_plan),
+    };
+};
+const toAiCfoVisualizationData = (data) => {
+    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: (0, aiCfoState_1.toYFormatTypeStrict)(data.y_format.type) ?? 'number',
+                unit: (0, aiCfoState_1.toYFormatUnitStrict)(data.y_format.unit),
+                scale: (0, aiCfoState_1.toYFormatScaleStrict)(data.y_format.scale) ?? 'raw',
+                symbol: data.y_format.symbol ?? undefined,
+            }
+            : undefined;
+        return {
+            values: data.values,
+            x: data.x,
+            y: yArray,
+            lines: data.lines ?? [],
+            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(data.values[0] ?? [])).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, table, follow_up_questions, assumptions, insights, summarized_title, artifact, artifact_title, artifact_host_url, } = 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,
+            table: table != null ? (0, exports.toAiCfoVisualization)(table) : undefined,
+            followUpQuestions: follow_up_questions ?? [],
+            assumptions: assumptions ?? '',
+            insights: insights ?? '',
+            summarizedTitle: summarized_title ?? undefined,
+            chainOfThoughtActionSteps,
+            artifact: artifact ?? undefined,
+            artifactTitle: artifact_title ?? undefined,
+            artifactHostUrl: artifact_host_url ?? undefined,
+        },
+        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);
+        },
+        // Upserts the response block when `questionAnswerId` exists; otherwise adds the 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);
+            }
+        },
+        // Patches an upload-mode card-policy answer with the wizard plan + source returned
+        // by `policy-recommendation-from-upload`. No-op for non-upload / missing targets.
+        updateAiCfoAnswerCardPolicyWizardPlan(draft, action) {
+            const { answerId, chatSessionId, source, wizardPlan } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                return;
+            }
+            const qa = session.questionAnswers.find((entry) => entry.questionAnswerId === answerId);
+            if (qa == null) {
+                return;
+            }
+            for (const response of Object.values(qa.responses)) {
+                const visualization = response?.content.visualization;
+                if (visualization == null ||
+                    visualization.type !== 'interactive_form') {
+                    continue;
+                }
+                const data = visualization.data;
+                if (data.formType !== 'card_policy' ||
+                    data.payload.policyKind !== 'upload') {
+                    continue;
+                }
+                data.payload = {
+                    ...data.payload,
+                    wizardPlan,
+                    source: source ?? data.payload.source,
+                };
+            }
+        },
+        // Renders a "Creating…" placeholder while the cards/policy create mutation runs.
+        // Caller supplies a stable `id` (updated in place by `updateSyntheticAiCfoAnswer`).
+        appendSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, createdAt, entityIds, sourceQuestionAnswerId, } = action.payload;
+            if (draft.syntheticAnswersByChatSessionId[chatSessionId] == null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] = [];
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId].push({
+                id,
+                kind,
+                entityIds: entityIds ?? [],
+                createdAt,
+                sourceQuestionAnswerId,
+            });
+        },
+        // Transitions a bubble from `creating_*` to `created_*` once the mutation completes.
+        updateSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, entityIds } = action.payload;
+            const list = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (list == null) {
+                return;
+            }
+            const entry = list.find((item) => item.id === id);
+            if (entry == null) {
+                return;
+            }
+            entry.kind = kind;
+            if (entityIds != null) {
+                entry.entityIds = entityIds;
+            }
+        },
+        removeSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id } = action.payload;
+            const list = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (list == null) {
+                return;
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId] = list.filter((item) => item.id !== id);
+        },
+        clearSyntheticAiCfoAnswers(draft, action) {
+            delete draft.syntheticAnswersByChatSessionId[action.payload];
+        },
+        clearSession(draft, action) {
+            const sessionId = action.payload;
+            delete draft.aiCfoByChatSessionId[sessionId];
+            delete draft.syntheticAnswersByChatSessionId[sessionId];
+            if (draft.partialQuestionAnswers?.[sessionId] != null) {
+                draft.partialQuestionAnswers[sessionId] = undefined;
+            }
+        },
+        clearAiCfo(draft) {
+            draft.aiCfoByChatSessionId = {};
+            draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
+        },
+        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);
+            }
+            // Drop synthetic bubbles whose sourceQuestionAnswerId is the deleted Q/A; otherwise "Creating…" / "Created" tiles outlive their Q/A.
+            const syntheticAnswers = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (syntheticAnswers != null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] =
+                    syntheticAnswers.filter((answer) => answer.sourceQuestionAnswerId !== questionAnswerId);
+            }
+        },
+    },
+});
+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 ?? 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.updateAiCfoAnswerCardPolicyWizardPlan = _a.updateAiCfoAnswerCardPolicyWizardPlan, exports.appendSyntheticAiCfoAnswer = _a.appendSyntheticAiCfoAnswer, exports.updateSyntheticAiCfoAnswer = _a.updateSyntheticAiCfoAnswer, exports.removeSyntheticAiCfoAnswer = _a.removeSyntheticAiCfoAnswer, exports.clearSyntheticAiCfoAnswers = _a.clearSyntheticAiCfoAnswers;
+exports.default = aiCfo.reducer;