@zeniai/client-epic-state 5.0.81-betaML3 → 5.0.81-betaRR0

package/lib/entity/aiCfo/aiCfoPayload.d.ts

@@ -20,8 +20,178 @@ export interface ChartVisualizationPayload {
     lines?: string[] | null;
     y_format?: YFormatPayload;
 }
+export interface CardsCardOptionPayload {
+    id: string;
+    label: string;
+    description?: string | null;
+}
+/**
+ * Single AI-suggested card on the wire. The controller ships an array of
+ * these mixing vendor and department entries; entries with
+ * `is_suggested: true` seed step 1 of the form pre-checked, while entries
+ * with `is_suggested: false` are available in the step-2 Card dropdown and
+ * step-1 search but don't appear as initial rows.
+ */
+export interface SuggestedCardPayload {
+    avg_spend: number;
+    card_name: string;
+    card_name_id: string;
+    card_type: 'vendor' | 'department';
+    credit_limit: number;
+    is_suggested: boolean;
+    owner_id: string;
+}
+/**
+ * Discriminated payload for the AI Card Creation interactive form. The wire
+ * format mirrors the FE-side `CardsCreationInitialData` field-for-field
+ * (with snake_case field names converted to camelCase by the reducer).
+ *
+ * - `review` (default): the AI suggests rows (vendors + departments);
+ *   user reviews them in step 1, then configures cards in step 2. The wire
+ *   format ships a flat `suggested_cards` array. Both suggested and
+ *   not-suggested entries are included; the reducer splits them into seed
+ *   rows vs. dropdown options. The legacy `team_rows` /
+ *   `suggested_owner_user_id_by_team_id` shape is also accepted for
+ *   backward compatibility with mocks and tests.
+ * - `create` (1-step): the AI has already chosen cards; user lands
+ *   directly on the editable card table for confirmation.
+ */
+export type CardsCreationInitialDataPayload = {
+    card_options: CardsCardOptionPayload[];
+    mode: 'review';
+    /**
+     * Preferred wire format: flat list of vendor/department cards with an
+     * `is_suggested` discriminator. The reducer derives `team_rows`,
+     * `suggested_owner_user_id_by_team_id`, and the full `cardNameOptions`
+     * universe from this single array.
+     */
+    suggested_cards?: SuggestedCardPayload[];
+    /**
+     * Legacy/test shape — pre-shaped seed rows. Mutually exclusive with
+     * `suggested_cards`; when both are present, `suggested_cards` wins.
+     */
+    suggested_owner_user_id_by_team_id?: Record<string, string | null>;
+    team_rows?: Array<{
+        avg_monthly_spend: string;
+        id: string;
+        label: string;
+        recommended_limit: string;
+        card_kind?: 'vendor' | 'class' | null;
+        recommended_limit_cadence?: string | null;
+    }>;
+} | {
+    card_options: CardsCardOptionPayload[];
+    card_rows: Array<{
+        card_option_id: string;
+        id: string;
+        /**
+         * Optional team-derived display label rendered in the card cell
+         * trigger (e.g. "Engineering"). Drives the row's first-letter avatar
+         * in step 2.
+         */
+        label?: string | null;
+        recommended_limit?: number | null;
+        suggested_owner_user_id?: string | null;
+    }>;
+    mode: 'create';
+};
+/**
+ * Per-policy allow / block bucket on the wire. The two arrays are
+ * independent (a draft policy may populate both, only one, or neither).
+ */
+export interface DraftPolicyEntityPayload {
+    category_codes: string[];
+    merchant_names: string[];
+}
+/**
+ * Spend-limit bucket per policy. `transaction` is the only cadence the
+ * BE ships today; left open-ended for future cadences (e.g.
+ * `monthly`, `quarterly`).
+ */
+export interface DraftPolicySpendLimitsPayload {
+    transaction: number;
+    [cadence: string]: number | undefined;
+}
+/**
+ * Single draft policy on the wire. The controller emits one of these
+ * per recommended policy in `step_5_review.draft_policies`. Identity is
+ * positional (no stable `id` from the BE); the FE synthesizes one on
+ * decode.
+ */
+export interface DraftPolicyPayload {
+    allowed_entity: DraftPolicyEntityPayload;
+    apply_to_cards: string[];
+    blocked_entity: DraftPolicyEntityPayload;
+    description: string;
+    /** Enforcement mode for the policy (e.g. `"strict"`). Carried into
+     * state for guided submit; ignored for `auto` / `upload`. */
+    mode: string;
+    name: string;
+    required_receipt_threshold: number;
+    spend_limits: DraftPolicySpendLimitsPayload;
+}
+/**
+ * `step_5_review` block — the only step in `wizard_plan` the FE reads.
+ * Steps 1–4 are intentionally not modeled.
+ */
+export interface CardPolicyStep5ReviewPayload {
+    draft_policies: DraftPolicyPayload[];
+    /** Header text shown above the review list / wizard. */
+    prompt: string;
+    /** How the BE grouped the suggested policies. `"none"` today; may
+     * surface as a header banner in a future iteration. */
+    grouping_source?: string;
+}
+export interface CardPolicyWizardPlanPayload {
+    step_5_review: CardPolicyStep5ReviewPayload;
+}
+/**
+ * Upload-mode metadata that the `policy-recommendation-from-upload` API
+ * returns alongside the wizard plan. Absent on the initial controller
+ * response; populated after the file upload + recommendation chain.
+ */
+export interface CardPolicyUploadSourcePayload {
+    confidence_score: number;
+    file_name: string;
+    low_confidence_fields: string[];
+}
+/**
+ * Discriminated payload for the AI Card Policy interactive form.
+ * All three modes share the same `wizard_plan.step_5_review.draft_policies`
+ * envelope; the FE renders different forms based on `mode`.
+ *
+ * - `auto` (1-step review): user reviews suggested policies and submits.
+ * - `guided` (5-step wizard): Steps 1–4 seeded from `draft_policies[0]`,
+ *   Step 5 lists every draft policy.
+ * - `upload` (3-step): upload doc → pick cards → review. Controller
+ *   responses for `mode === "upload"` arrive *before* the user uploads,
+ *   so `wizard_plan` is optional; populated after the upload-recommendation
+ *   API returns.
+ */
+export type CardPolicyInitialDataPayload = {
+    mode: 'auto';
+    wizard_plan: CardPolicyWizardPlanPayload;
+} | {
+    mode: 'guided';
+    wizard_plan: CardPolicyWizardPlanPayload;
+} | {
+    mode: 'upload';
+    source?: CardPolicyUploadSourcePayload;
+    wizard_plan?: CardPolicyWizardPlanPayload;
+};
+/**
+ * Discriminated visualization payload. The FE narrows on `form_type` and
+ * casts `payload` to the matching shape.
+ */
+export type InteractiveFormVisualizationPayload = {
+    form_type: 'cards_creation';
+    payload: CardsCreationInitialDataPayload;
+} | {
+    form_type: 'card_policy';
+    payload: CardPolicyInitialDataPayload;
+};
 export interface AiCfoVisualizationPayload {
-    data: TableVisualizationPayload | ChartVisualizationPayload | null;
+    data: TableVisualizationPayload | ChartVisualizationPayload | InteractiveFormVisualizationPayload | null;
     type: string | null;
 }
 export interface AiCfoAnswerPayload {

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

@@ -1,7 +1,8 @@
 import { ID } from '../../commonStateTypes/common';
 import { ZeniDate } from '../../zeniDayJS';
 import { AiCfoAnswerPayload, AiCfoVisualizationPayload, ChatSessionPayload, MessagePayload } from './aiCfoPayload';
-import { AiCfoState, AiCfoVisualization, FileAttachmentMetadata } from './aiCfoState';
+import { AiCfoState, AiCfoVisualization, FileAttachmentMetadata, SyntheticAiCfoAnswerKind } from './aiCfoState';
+import type { CardPolicyUploadSource, CardPolicyWizardPlan } from './aiCfoState';
 export declare const initialAiCfoState: AiCfoState;
 export declare const toAiCfoVisualization: (visualization: AiCfoVisualizationPayload) => AiCfoVisualization | undefined;
 export declare const setNewSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
@@ -41,6 +42,25 @@ export declare const setNewSession: import("@reduxjs/toolkit").ActionCreatorWith
 }, "aiCfo/addQuestionPayload">, clearAiCfo: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"aiCfo/clearAiCfo">, deleteQuestion: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     chatSessionId: ID;
     questionAnswerId: ID;
-}, "aiCfo/deleteQuestion">;
+}, "aiCfo/deleteQuestion">, updateAiCfoAnswerCardPolicyWizardPlan: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    answerId: ID;
+    chatSessionId: ID;
+    wizardPlan: CardPolicyWizardPlan;
+    source?: CardPolicyUploadSource;
+}, "aiCfo/updateAiCfoAnswerCardPolicyWizardPlan">, appendSyntheticAiCfoAnswer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    createdAt: ZeniDate;
+    id: ID;
+    kind: SyntheticAiCfoAnswerKind;
+    entityIds?: ID[];
+}, "aiCfo/appendSyntheticAiCfoAnswer">, updateSyntheticAiCfoAnswer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    id: ID;
+    kind: SyntheticAiCfoAnswerKind;
+    entityIds?: ID[];
+}, "aiCfo/updateSyntheticAiCfoAnswer">, removeSyntheticAiCfoAnswer: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    chatSessionId: ID;
+    id: ID;
+}, "aiCfo/removeSyntheticAiCfoAnswer">, clearSyntheticAiCfoAnswers: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "aiCfo/clearSyntheticAiCfoAnswers">;
 declare const _default: import("redux").Reducer<AiCfoState>;
 export default _default;

package/lib/entity/aiCfo/aiCfoReducer.js

@@ -1,13 +1,14 @@
 "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;
+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) {
@@ -139,12 +140,188 @@ const toAiCfoVisualization = (visualization) => {
     if (visualization.type == null || visualization.data == null) {
         return undefined;
     }
+    const normalizedType = (0, aiCfoState_1.toAiCfoVisualizationTypeStrict)(visualization.type) ?? 'table';
     return {
-        type: (0, aiCfoState_1.toAiCfoVisualizationTypeStrict)(visualization.type) ?? 'table',
-        data: toAiCfoVisualizationData(visualization.data),
+        type: normalizedType,
+        data: normalizedType === 'interactive_form'
+            ? toInteractiveFormVisualization(visualization.data)
+            : toAiCfoVisualizationData(visualization.data),
     };
 };
 exports.toAiCfoVisualization = toAiCfoVisualization;
+const toInteractiveFormVisualization = (data) => {
+    const formType = (0, aiCfoState_1.toInteractiveFormTypeStrict)(data.form_type) ?? 'cards_creation';
+    if (formType === 'card_policy') {
+        return {
+            formType: 'card_policy',
+            payload: toCardPolicyInitialData(data.payload),
+        };
+    }
+    return {
+        formType: 'cards_creation',
+        payload: toCardsCreationInitialData(data.payload),
+    };
+};
+const toCardsCreationInitialData = (payload) => {
+    const cardOptions = (payload.card_options ?? []).map((option) => ({
+        id: option.id,
+        label: option.label,
+        description: option.description ?? undefined,
+    }));
+    if (payload.mode === 'create') {
+        return {
+            mode: 'create',
+            cardOptions,
+            cardRows: (payload.card_rows ?? []).map((row) => ({
+                cardOptionId: row.card_option_id,
+                id: row.id,
+                label: row.label ?? undefined,
+                recommendedLimit: row.recommended_limit ?? undefined,
+                suggestedOwnerUserId: row.suggested_owner_user_id ?? undefined,
+            })),
+        };
+    }
+    // Preferred wire format: a flat `suggested_cards` array with an
+    // `is_suggested` discriminator. The adapter splits it into seed rows,
+    // owner map, and the full dropdown universe.
+    if (payload.suggested_cards != null) {
+        return fromSuggestedCards(payload.suggested_cards, cardOptions);
+    }
+    // Legacy / test shape: backend already pre-shapes seeds. Synthesize an
+    // empty `cardNameOptions` (step 2 dropdown still works via row-self ids).
+    const teamRows = (payload.team_rows ?? []).map((row) => ({
+        avgMonthlySpend: row.avg_monthly_spend,
+        cardKind: (row.card_kind ?? 'vendor'),
+        id: row.id,
+        label: row.label,
+        recommendedLimit: row.recommended_limit,
+        recommendedLimitCadence: row.recommended_limit_cadence ?? undefined,
+    }));
+    return {
+        mode: 'review',
+        cardOptions,
+        cardNameOptions: teamRows.map((row) => ({
+            id: row.id,
+            kind: row.cardKind,
+            label: row.label,
+        })),
+        suggestedOwnerUserIdByTeamId: Object.fromEntries(Object.entries(payload.suggested_owner_user_id_by_team_id ?? {}).map(([teamId, userId]) => [teamId, userId ?? undefined])),
+        teamRows,
+    };
+};
+const CURRENCY_FORMATTER = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    maximumFractionDigits: 0,
+});
+const fromSuggestedCards = (suggestedCards, cardOptions) => {
+    const ordered = [...suggestedCards].sort((a, b) => {
+        if (a.card_type === b.card_type) {
+            return 0;
+        }
+        return a.card_type === 'vendor' ? -1 : 1;
+    });
+    const withUniqueIds = withSynthesizedIds(ordered);
+    const teamRows = withUniqueIds
+        .filter(({ card }) => card.is_suggested)
+        .map(({ card, uniqueId }) => ({
+        avgMonthlySpend: CURRENCY_FORMATTER.format(card.avg_spend),
+        cardKind: card.card_type === 'department'
+            ? 'class'
+            : 'vendor',
+        id: uniqueId,
+        label: card.card_name,
+        recommendedLimit: CURRENCY_FORMATTER.format(card.credit_limit),
+        recommendedLimitCadence: 'Monthly',
+    }));
+    const suggestedOwnerUserIdByTeamId = Object.fromEntries(withUniqueIds
+        .filter(({ card }) => card.is_suggested)
+        .map(({ card, uniqueId }) => [uniqueId, card.owner_id]));
+    const cardNameOptions = withUniqueIds.map(({ card, uniqueId }) => ({
+        id: uniqueId,
+        kind: card.card_type === 'department'
+            ? 'class'
+            : 'vendor',
+        label: card.card_name,
+    }));
+    return {
+        mode: 'review',
+        cardOptions,
+        cardNameOptions,
+        suggestedOwnerUserIdByTeamId,
+        teamRows,
+    };
+};
+/**
+ * Stamp each suggested card with a stable unique id derived from its
+ * `card_name_id`. If two cards in the same payload share the same
+ * `card_name_id` (which happens in the current sample payload where
+ * `card_name_id` is the literal `"vendor_uuid"`), fall back to a
+ * synthesized id `${kind}__${card_name_id}__${index}` so RHF row keying
+ * stays 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
@@ -458,9 +635,118 @@ const aiCfo = (0, toolkit_1.createSlice)({
                 session.questionAnswers.push(qa);
             }
         },
+        /**
+         * Patch the `card_policy` interactive-form payload for a specific
+         * answer in a chat session to merge in the wizard plan + upload
+         * source metadata returned by
+         * `POST /cards/1.0/ai-cfo/policy-recommendation-from-upload`.
+         *
+         * Dispatched by the recommendation epic after a successful response;
+         * the wizard re-renders Steps 2 + 3 of the upload variant once the
+         * payload becomes a populated `CardPolicyInitialData` with
+         * `policyKind: "upload"` + `wizardPlan` + `source`.
+         *
+         * No-op when the target answer / chat session / form payload is
+         * missing or isn't an upload-mode card-policy interactive form —
+         * the bridge epic is best-effort and silently drops in edge cases
+         * (e.g. the user closed the chat before recommendation returned).
+         */
+        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,
+                };
+            }
+        },
+        /**
+         * Append a client-synthesized answer bubble to a chat session. Used by
+         * the AI CFO cards/policy create flow to render a "Creating…" placeholder
+         * in the drawer while the underlying mutation runs.
+         *
+         * The caller is responsible for generating a stable `id` (so the same
+         * bubble can later be updated in place via `updateSyntheticAiCfoAnswer`
+         * once the mutation completes) and a `createdAt` timestamp so the
+         * renderer can interleave synthetic bubbles with streamed Q&A pairs in
+         * chronological order.
+         */
+        appendSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, createdAt, entityIds } = action.payload;
+            if (draft.syntheticAnswersByChatSessionId[chatSessionId] == null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] = [];
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId].push({
+                id,
+                kind,
+                entityIds: entityIds ?? [],
+                createdAt,
+            });
+        },
+        /**
+         * Update an existing synthetic answer bubble in place. Typically called
+         * when the create mutation completes: the screen transitions the bubble
+         * from `creating_*` to `created_*` and populates `entityIds` with the
+         * newly created cards / policy templates.
+         *
+         * No-op when the target bubble is missing (e.g. the session was cleared
+         * before the mutation returned).
+         */
+        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;
+            }
+        },
+        /**
+         * Remove a single synthetic answer bubble (e.g. when the user manually
+         * dismisses it or the mutation errors out and we want to fall back to
+         * an inline error snackbar).
+         */
+        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);
+        },
+        /** Clear every synthetic bubble for a session. */
+        clearSyntheticAiCfoAnswers(draft, action) {
+            delete draft.syntheticAnswersByChatSessionId[action.payload];
+        },
         clearSession(draft, action) {
             const sessionId = action.payload;
             delete draft.aiCfoByChatSessionId[sessionId];
+            delete draft.syntheticAnswersByChatSessionId[sessionId];
             // Clear partial Q&A if it belongs to the cleared session
             if (draft.partialQuestionAnswers?.[sessionId] != null) {
                 draft.partialQuestionAnswers[sessionId] = undefined;
@@ -469,6 +755,7 @@ const aiCfo = (0, toolkit_1.createSlice)({
         clearAiCfo(draft) {
             draft.aiCfoByChatSessionId = {};
             draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
         },
         deleteQuestion(draft, action) {
             const { chatSessionId, questionAnswerId } = action.payload;
@@ -493,5 +780,5 @@ const toChatSession = (chatSessionPayload) => {
         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;
+_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;

package/lib/entity/aiCfo/aiCfoSelector.d.ts

@@ -1,13 +1,15 @@
 import { ID } from '../../commonStateTypes/common';
-import { AiCfoQuestionWithAnswer, AiCfoState, ChatSession } from './aiCfoState';
+import { AiCfoQuestionWithAnswer, AiCfoState, ChatSession, SyntheticAiCfoAnswer } from './aiCfoState';
 export declare function getAllQuestionAnswersForChatSession(state: AiCfoState, chatSessionId: ID): AiCfoQuestionWithAnswer[];
 export declare function getQuestionAnswerByIdForChatSession(state: AiCfoState, chatSessionId: ID, questionAnswerId: ID): AiCfoQuestionWithAnswer | undefined;
 export declare function getAllQuestionsForChatSession(state: AiCfoState, chatSessionId: ID): string[];
 export interface AiCfoSelectorView {
     allSessionsWithOrderedQuestionAnswers: ChatSessionWithOrderedQuestionAnswers[];
+    syntheticAnswersByChatSessionId: Record<ID, SyntheticAiCfoAnswer[]>;
 }
 export interface ChatSessionWithOrderedQuestionAnswers {
     chatSession: ChatSession;
     questionAnswers: AiCfoQuestionWithAnswer[];
 }
 export declare function getAiCfoSelectorView(state: AiCfoState): AiCfoSelectorView;
+export declare function getSyntheticAiCfoAnswersForChatSession(state: AiCfoState, chatSessionId: ID): SyntheticAiCfoAnswer[];

package/lib/entity/aiCfo/aiCfoSelector.js

@@ -4,6 +4,7 @@ exports.getAllQuestionAnswersForChatSession = getAllQuestionAnswersForChatSessio
 exports.getQuestionAnswerByIdForChatSession = getQuestionAnswerByIdForChatSession;
 exports.getAllQuestionsForChatSession = getAllQuestionsForChatSession;
 exports.getAiCfoSelectorView = getAiCfoSelectorView;
+exports.getSyntheticAiCfoAnswersForChatSession = getSyntheticAiCfoAnswersForChatSession;
 function getAllQuestionAnswersForChatSession(state, chatSessionId) {
     const arr = state.aiCfoByChatSessionId[chatSessionId]?.questionAnswers ?? [];
     return arr
@@ -38,5 +39,14 @@ function getAiCfoSelectorView(state) {
             : [],
     }))
         .sort((a, b) => b.chatSession.createdAt.valueOf() - a.chatSession.createdAt.valueOf());
-    return { allSessionsWithOrderedQuestionAnswers };
+    return {
+        allSessionsWithOrderedQuestionAnswers,
+        syntheticAnswersByChatSessionId: state.syntheticAnswersByChatSessionId ?? {},
+    };
+}
+function getSyntheticAiCfoAnswersForChatSession(state, chatSessionId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId] ?? [];
+    return arr
+        .slice()
+        .sort((a, b) => a.createdAt.valueOf() - b.createdAt.valueOf());
 }