@zeniai/client-epic-state 5.0.96 → 5.0.97

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

@@ -1,9 +1,10 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { date as zeniDate } from '../../zeniDayJS';
-import { ALL_AI_CFO_ANSWER_RESPONSE_TYPES, toAiCfoAnswerResponseType, toAiCfoAnswerResponseTypeStrict, toAiCfoAnswerStateType, toAiCfoVisualizationTypeStrict, toMessageSender, toMessageType, toYFormatScaleStrict, toYFormatTypeStrict, toYFormatUnitStrict, } from './aiCfoState';
+import { ALL_AI_CFO_ANSWER_RESPONSE_TYPES, toAiCfoAnswerResponseType, toAiCfoAnswerResponseTypeStrict, toAiCfoAnswerStateType, toAiCfoVisualizationTypeStrict, toInteractiveFormTypeStrict, toMessageSender, toMessageType, toYFormatScaleStrict, toYFormatTypeStrict, toYFormatUnitStrict, } from './aiCfoState';
 export const initialAiCfoState = {
     aiCfoByChatSessionId: {},
     partialQuestionAnswers: {},
+    syntheticAnswersByChatSessionId: {},
 };
 // Utility: Merge two arrays of Q&A pairs, combining responses for the same question
 function mergeQuestionAnswerPairs(existing, newQAs) {
@@ -136,9 +137,171 @@ export 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 = toAiCfoVisualizationTypeStrict(visualization.type);
+    if (normalizedType == null) {
+        return undefined;
+    }
+    return {
+        type: normalizedType,
+        data: normalizedType === 'interactive_form'
+            ? toInteractiveFormVisualization(visualization.data)
+            : toAiCfoVisualizationData(visualization.data),
+    };
+};
+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 = 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 {
-        type: toAiCfoVisualizationTypeStrict(visualization.type) ?? 'table',
-        data: toAiCfoVisualizationData(visualization.data),
+        ...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) => {
@@ -375,10 +538,8 @@ const aiCfo = createSlice({
             // 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.
-         */
+        // 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];
@@ -455,10 +616,82 @@ const aiCfo = createSlice({
                 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];
-            // Clear partial Q&A if it belongs to the cleared session
+            delete draft.syntheticAnswersByChatSessionId[sessionId];
             if (draft.partialQuestionAnswers?.[sessionId] != null) {
                 draft.partialQuestionAnswers[sessionId] = undefined;
             }
@@ -466,6 +699,7 @@ const aiCfo = createSlice({
         clearAiCfo(draft) {
             draft.aiCfoByChatSessionId = {};
             draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
         },
         deleteQuestion(draft, action) {
             const { chatSessionId, questionAnswerId } = action.payload;
@@ -478,6 +712,12 @@ const aiCfo = createSlice({
             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);
+            }
         },
     },
 });
@@ -490,5 +730,5 @@ const toChatSession = (chatSessionPayload) => {
         createdAt: zeniDate(created_at),
     };
 };
-export const { setNewSession, clearSession, setSessions, setChatHistory, upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, addQuestionPayload, clearAiCfo, deleteQuestion, } = aiCfo.actions;
+export const { setNewSession, clearSession, setSessions, setChatHistory, upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, addQuestionPayload, clearAiCfo, deleteQuestion, updateAiCfoAnswerCardPolicyWizardPlan, appendSyntheticAiCfoAnswer, updateSyntheticAiCfoAnswer, removeSyntheticAiCfoAnswer, clearSyntheticAiCfoAnswers, } = aiCfo.actions;
 export default aiCfo.reducer;

package/lib/esm/entity/aiCfo/aiCfoSelector.js

@@ -32,5 +32,21 @@ export function getAiCfoSelectorView(state) {
             : [],
     }))
         .sort((a, b) => b.chatSession.createdAt.valueOf() - a.chatSession.createdAt.valueOf());
-    return { allSessionsWithOrderedQuestionAnswers };
+    return {
+        allSessionsWithOrderedQuestionAnswers,
+        syntheticAnswersByChatSessionId: state.syntheticAnswersByChatSessionId ?? {},
+    };
+}
+export function getSyntheticAiCfoAnswersForChatSession(state, chatSessionId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId] ?? [];
+    return arr
+        .slice()
+        .sort((a, b) => a.createdAt.valueOf() - b.createdAt.valueOf());
+}
+export function getSyntheticAiCfoAnswerByQuestionAnswerId(state, chatSessionId, questionAnswerId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId];
+    if (arr == null) {
+        return undefined;
+    }
+    return arr.find((answer) => answer.sourceQuestionAnswerId === questionAnswerId);
 }

package/lib/esm/entity/aiCfo/aiCfoState.js

@@ -7,7 +7,14 @@ export const ALL_AI_CFO_CHARTS_TYPES = [
 export const ALL_AI_CFO_VISUALIZATION_TYPES = [
     ...ALL_AI_CFO_CHARTS_TYPES,
     'table',
+    'interactive_form',
 ];
+export const ALL_INTERACTIVE_FORM_TYPES = [
+    'cards_creation',
+    'card_policy',
+];
+export const toInteractiveFormType = (v) => stringToUnion(v, ALL_INTERACTIVE_FORM_TYPES);
+export const toInteractiveFormTypeStrict = (v) => stringToUnionStrict(v, ALL_INTERACTIVE_FORM_TYPES);
 export const toAiCfoVisualizationType = (v) => stringToUnion(v, ALL_AI_CFO_VISUALIZATION_TYPES);
 export const toAiCfoVisualizationTypeStrict = (v) => stringToUnionStrict(v, ALL_AI_CFO_VISUALIZATION_TYPES);
 export const toAiCfoChartType = (v) => stringToUnion(v, ALL_AI_CFO_CHARTS_TYPES);
@@ -58,3 +65,11 @@ export const toMessageSender = (v) => stringToUnion(v, ALL_MESSAGE_SENDERS);
 export const toMessageType = (v) => stringToUnion(v, ALL_MESSAGE_TYPES);
 export const toMessageSenderStrict = (v) => stringToUnionStrict(v, ALL_MESSAGE_SENDERS);
 export const toMessageTypeStrict = (v) => stringToUnionStrict(v, ALL_MESSAGE_TYPES);
+// Client-synthesized AI CFO answer bubbles (Creating…/Created) pushed when the user
+// submits an interactive form; not streamed from the backend.
+export const ALL_SYNTHETIC_AI_CFO_ANSWER_KINDS = [
+    'creating_cards',
+    'creating_policy',
+    'created_cards',
+    'created_policy',
+];

package/lib/esm/entity/cardPolicy/cardPolicyPayload.js

@@ -0,0 +1,130 @@
+import { date } from '../../zeniDayJS';
+import { toCardPolicyTemplateMode, toCardPolicyTemplateStatus, } from './cardPolicyState';
+export const toMccCategory = (payload) => ({
+    count: payload.count,
+    mccCodes: payload.mcc_codes ?? [],
+    name: payload.name,
+});
+export const toCardPolicyVendorSearchOption = (payload) => ({
+    vendorId: payload.vendor_id,
+    name: payload.vendor_name,
+});
+export const toCardPolicyStats = (payload) => ({
+    activePolicies: payload.active_policies,
+    totalCards: payload.total_cards,
+    totalTemplates: payload.total_templates,
+});
+export const toCardPolicyTemplateList = (data) => (data.templates ?? []).map((row) => toCardPolicyTemplate(row.data.template));
+const toCardPolicyTemplateEntityList = (payload) => ({
+    categoryCodes: payload.category_codes ?? [],
+    merchantNames: payload.merchant_names ?? [],
+});
+export const toCardPolicyTemplate = (payload) => ({
+    allowedEntity: toCardPolicyTemplateEntityList(payload.allowed_entity),
+    appliedCards: payload.applied_cards ?? [],
+    blockedEntity: toCardPolicyTemplateEntityList(payload.blocked_entity),
+    cardsCount: payload.cards_count,
+    categoryRestrictions: payload.category_restrictions ?? [],
+    createdAt: date(payload.created_at),
+    createdBy: payload.created_by,
+    description: payload.description,
+    mode: toCardPolicyTemplateMode(payload.mode),
+    name: payload.name,
+    requiredReceiptThreshold: payload.required_receipt_threshold,
+    spendLimits: {
+        transaction: payload.spend_limits.transaction,
+    },
+    status: toCardPolicyTemplateStatus(payload.status),
+    templateId: payload.template_id,
+    tenantId: payload.tenant_id,
+    updatedAt: date(payload.updated_at),
+});
+/**
+ * Re-shape a single camelCase create request into the snake_case wire
+ * body. Used by the bulk-create mapper to build each entry of the
+ * `templates` array, and directly by the update epic (PUT) since the
+ * update endpoint still consumes a single object.
+ */
+export const toCreateCardPolicyTemplateRequestBody = (request) => ({
+    allowed_entity: {
+        category_codes: request.allowedEntity.categoryCodes,
+        merchant_names: request.allowedEntity.merchantNames,
+    },
+    apply_to_cards: request.applyToCards,
+    blocked_entity: {
+        category_codes: request.blockedEntity.categoryCodes,
+        merchant_names: request.blockedEntity.merchantNames,
+    },
+    description: request.description,
+    mode: request.mode ?? 'strict',
+    name: request.name,
+    required_receipt_threshold: request.requiredReceiptThreshold,
+    spend_limits: {
+        transaction: request.spendLimits.transaction,
+    },
+});
+/**
+ * Re-shape a bulk create request into the snake_case wire body for
+ * `POST /cards/1.0/policy-templates`. Maps each entry through
+ * `toCreateCardPolicyTemplateRequestBody` and only emits
+ * `source_chat_session_id` when the camelCase counterpart is defined,
+ * so manual-create callers don't ship a stray `undefined` over the wire.
+ */
+export const toCreateCardPolicyTemplatesRequestBody = (request) => {
+    const body = {
+        templates: request.templates.map(toCreateCardPolicyTemplateRequestBody),
+    };
+    if (request.sourceChatSessionId != null) {
+        body.source_chat_session_id = request.sourceChatSessionId;
+    }
+    return body;
+};
+/**
+ * Map a single bulk-response error payload to its camelCased view shape.
+ * Defensive against missing optional fields (see `BulkCreateCardPolicyTemplateErrorPayload`
+ * docstring — the BE contract isn't fully locked yet).
+ */
+export const toBulkCreateCardPolicyTemplateError = (payload) => ({
+    message: payload.message,
+    code: payload.code,
+    index: payload.index,
+    name: payload.name,
+});
+// Update body uses the exact same wire shape as create — the PUT
+// endpoint is a full replace and was not affected by the bulk migration.
+export const toUpdateCardPolicyTemplateRequestBody = toCreateCardPolicyTemplateRequestBody;
+/**
+ * Seed an edit-form draft (`CreateCardPolicyTemplateRequest`) from an
+ * existing camelCased `CardPolicyTemplate`. Used by the detail-fetch
+ * epic so the edit page can render with the saved values pre-populated.
+ */
+export const toCardPolicyEditFormDraft = (template) => ({
+    allowedEntity: {
+        categoryCodes: [...template.allowedEntity.categoryCodes],
+        merchantNames: [...template.allowedEntity.merchantNames],
+    },
+    applyToCards: [...template.appliedCards],
+    blockedEntity: {
+        categoryCodes: [...template.blockedEntity.categoryCodes],
+        merchantNames: [...template.blockedEntity.merchantNames],
+    },
+    description: template.description,
+    mode: template.mode,
+    name: template.name,
+    requiredReceiptThreshold: template.requiredReceiptThreshold,
+    spendLimits: { transaction: template.spendLimits.transaction },
+});
+export const toExtractedCardPolicyRules = (payload) => ({
+    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 ?? [],
+    },
+    confidenceScore: payload.confidence_score,
+    policyName: payload.policy_name,
+    requiredReceiptThreshold: payload.required_receipt_threshold,
+    transactionLimit: payload.transaction_limit,
+});

package/lib/esm/entity/cardPolicy/cardPolicyReducer.js

@@ -0,0 +1,171 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toCardPolicyTemplate, toCardPolicyVendorSearchOption, toExtractedCardPolicyRules, toMccCategory, } from './cardPolicyPayload';
+// `buildVendorChipId(name)` calls `name.trim().toLowerCase()`; empty/whitespace names would crash or collapse into one colliding chip-id.
+const isUsableMerchantName = (name) => typeof name === 'string' && name.trim() !== '';
+const initialPolicyDocumentExtractionState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    extractedRules: undefined,
+    uploadedFileName: undefined,
+};
+const initialPolicyRecommendationFromUploadState = {
+    fetchState: 'Not-Started',
+    answerId: undefined,
+    chatSessionId: undefined,
+    error: undefined,
+};
+const initialVendorSearchState = {
+    fetchState: 'Not-Started',
+    searchString: '',
+    vendors: [],
+    error: undefined,
+};
+export const initialState = {
+    cardPolicyTemplateById: {},
+    mccCategories: [],
+    mccCategoriesError: undefined,
+    mccCategoriesFetchState: 'Not-Started',
+    policyDocumentExtraction: initialPolicyDocumentExtractionState,
+    policyRecommendationFromUpload: initialPolicyRecommendationFromUploadState,
+    suggestedAllowCategories: [],
+    suggestedAllowMerchants: [],
+    suggestedBlockCategories: [],
+    suggestedBlockMerchants: [],
+    vendorSearch: initialVendorSearchState,
+    cardPolicyStats: undefined,
+};
+const cardPolicy = createSlice({
+    name: 'cardPolicy',
+    initialState,
+    reducers: {
+        fetchCardPolicyMccCategories(draft) {
+            draft.mccCategoriesFetchState = 'In-Progress';
+            draft.mccCategoriesError = undefined;
+        },
+        updateCardPolicyMccCategories(draft, action) {
+            draft.mccCategories = (action.payload.categories ?? []).map(toMccCategory);
+            // BE-suggested seeds pre-populate the chip cloud; `isUsableMerchantName` drops names that would break `buildVendorChipId`.
+            draft.suggestedAllowMerchants = (action.payload.suggested_allow_merchants ?? []).filter(isUsableMerchantName);
+            draft.suggestedBlockMerchants = (action.payload.suggested_block_merchants ?? []).filter(isUsableMerchantName);
+            draft.suggestedAllowCategories = (action.payload.suggested_allow_catagories ?? []).map(toMccCategory);
+            draft.suggestedBlockCategories = (action.payload.suggested_block_catagories ?? []).map(toMccCategory);
+            draft.mccCategoriesFetchState = 'Completed';
+            draft.mccCategoriesError = undefined;
+        },
+        updateCardPolicyMccCategoriesFailure(draft, action) {
+            draft.mccCategoriesFetchState = 'Error';
+            draft.mccCategoriesError = action.payload;
+        },
+        updateCreatedCardPolicyTemplate(draft, action) {
+            const template = toCardPolicyTemplate(action.payload);
+            draft.cardPolicyTemplateById[template.templateId] = template;
+        },
+        // Full replace so server-side deletes evict locally too; the view slice owns the ordered ID list.
+        updateCardPolicyTemplates(draft, action) {
+            const byId = {};
+            for (const template of action.payload) {
+                byId[template.templateId] = template;
+            }
+            draft.cardPolicyTemplateById = byId;
+        },
+        removeCardPolicyTemplate(draft, action) {
+            delete draft.cardPolicyTemplateById[action.payload];
+        },
+        updateCardPolicyStats(draft, action) {
+            draft.cardPolicyStats = action.payload;
+        },
+        // Captures the first file name so the upload pill can render without callers retaining a File ref.
+        extractPolicyDocument: {
+            reducer(draft, action) {
+                draft.policyDocumentExtraction.fetchState = 'In-Progress';
+                draft.policyDocumentExtraction.error = undefined;
+                draft.policyDocumentExtraction.extractedRules = undefined;
+                draft.policyDocumentExtraction.uploadedFileName =
+                    action.meta.uploadedFileName;
+                draft.policyDocumentExtraction.aiCfoAnswerId =
+                    action.payload.aiCfoAnswerId;
+                draft.policyDocumentExtraction.aiCfoChatSessionId =
+                    action.payload.aiCfoChatSessionId;
+                // Extraction + recommendation model one upload lifecycle; reset together so a re-upload doesn't read stale lifecycle from the prior chain.
+                draft.policyRecommendationFromUpload = {
+                    ...initialPolicyRecommendationFromUploadState,
+                };
+            },
+            prepare(files, aiCfoAnswerId, aiCfoChatSessionId) {
+                return {
+                    payload: { files, aiCfoAnswerId, aiCfoChatSessionId },
+                    meta: { uploadedFileName: files[0]?.name },
+                };
+            },
+        },
+        updatePolicyDocumentExtractionSuccess(draft, action) {
+            draft.policyDocumentExtraction.fetchState = 'Completed';
+            draft.policyDocumentExtraction.error = undefined;
+            draft.policyDocumentExtraction.extractedRules =
+                toExtractedCardPolicyRules(action.payload);
+        },
+        updatePolicyDocumentExtractionFailure(draft, action) {
+            draft.policyDocumentExtraction.fetchState = 'Error';
+            draft.policyDocumentExtraction.error = action.payload;
+            draft.policyDocumentExtraction.extractedRules = undefined;
+        },
+        clearPolicyDocumentExtraction(draft) {
+            draft.policyDocumentExtraction = {
+                ...initialPolicyDocumentExtractionState,
+            };
+            // Pair with extractPolicyDocument: the two sub-slices reset and advance together.
+            draft.policyRecommendationFromUpload = {
+                ...initialPolicyRecommendationFromUploadState,
+            };
+        },
+        // Chained after extractPolicyDocument; epic merges the returned wizard plan into the AI CFO answer identified by answerId + chatSessionId.
+        fetchCardPolicyRecommendationFromUpload: {
+            reducer(draft, action) {
+                draft.policyRecommendationFromUpload.fetchState = 'In-Progress';
+                draft.policyRecommendationFromUpload.answerId = action.payload.answerId;
+                draft.policyRecommendationFromUpload.chatSessionId =
+                    action.payload.chatSessionId;
+                draft.policyRecommendationFromUpload.error = undefined;
+            },
+            prepare(answerId, chatSessionId, extractedRules) {
+                return { payload: { answerId, chatSessionId, extractedRules } };
+            },
+        },
+        updatePolicyRecommendationFromUploadSuccess(draft) {
+            draft.policyRecommendationFromUpload.fetchState = 'Completed';
+            draft.policyRecommendationFromUpload.error = undefined;
+        },
+        updatePolicyRecommendationFromUploadFailure(draft, action) {
+            draft.policyRecommendationFromUpload.fetchState = 'Error';
+            draft.policyRecommendationFromUpload.error = action.payload;
+        },
+        // Empty searchString = top vendors by YTD spend; non-empty filters server-side.
+        fetchCardPolicyVendorOptions: {
+            reducer(draft, action) {
+                draft.vendorSearch.fetchState = 'In-Progress';
+                draft.vendorSearch.searchString = action.payload.searchString;
+                draft.vendorSearch.error = undefined;
+            },
+            prepare(searchString) {
+                return { payload: { searchString: searchString ?? '' } };
+            },
+        },
+        updateCardPolicyVendorOptions(draft, action) {
+            // Same `buildVendorChipId` guard as the suggested-merchants seeds above.
+            draft.vendorSearch.vendors = (action.payload.vendors ?? [])
+                .map(toCardPolicyVendorSearchOption)
+                .filter((vendor) => isUsableMerchantName(vendor.name));
+            draft.vendorSearch.fetchState = 'Completed';
+            draft.vendorSearch.error = undefined;
+        },
+        updateCardPolicyVendorOptionsFailure(draft, action) {
+            draft.vendorSearch.fetchState = 'Error';
+            draft.vendorSearch.error = action.payload;
+        },
+        clearCardPolicy(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchCardPolicyMccCategories, fetchCardPolicyVendorOptions, updateCardPolicyMccCategories, updateCardPolicyMccCategoriesFailure, updateCardPolicyVendorOptions, updateCardPolicyVendorOptionsFailure, updateCreatedCardPolicyTemplate, updateCardPolicyTemplates, removeCardPolicyTemplate, updateCardPolicyStats, extractPolicyDocument, updatePolicyDocumentExtractionSuccess, updatePolicyDocumentExtractionFailure, clearPolicyDocumentExtraction, fetchCardPolicyRecommendationFromUpload, updatePolicyRecommendationFromUploadSuccess, updatePolicyRecommendationFromUploadFailure, clearCardPolicy, } = cardPolicy.actions;
+export default cardPolicy.reducer;