@zeniai/client-epic-state 5.0.82 → 5.0.83-betaRR0

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;

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

@@ -0,0 +1,75 @@
+export function getCardPolicyMccCategories(state) {
+    return state.mccCategories;
+}
+export function getCardPolicyMccCategoriesFetchState(state) {
+    return state.mccCategoriesFetchState;
+}
+export function getCardPolicyMccCategoriesError(state) {
+    return state.mccCategoriesError;
+}
+export function getCardPolicyTemplateById(state, templateId) {
+    return state.cardPolicyTemplateById[templateId];
+}
+export function getAllCardPolicyTemplates(state) {
+    return Object.values(state.cardPolicyTemplateById);
+}
+/**
+ * Resolve an ordered list of `templateId`s against the entity store and
+ * return the corresponding `CardPolicyTemplate[]` in the same order.
+ * Missing IDs (e.g. stale local state during a refetch) are silently
+ * dropped. Pair with `getCardPolicyTemplateIds` from the view slice to
+ * render the Policy List page in server order.
+ */
+export function getCardPolicyTemplatesByIds(state, templateIds) {
+    return templateIds
+        .map((id) => state.cardPolicyTemplateById[id])
+        .filter((template) => template != null);
+}
+export function getCardPolicyStats(state) {
+    return state.cardPolicyStats;
+}
+export function getPolicyDocumentExtractionFetchState(state) {
+    return state.policyDocumentExtraction.fetchState;
+}
+export function getPolicyDocumentExtractionError(state) {
+    return state.policyDocumentExtraction.error;
+}
+export function getExtractedCardPolicyRules(state) {
+    return state.policyDocumentExtraction.extractedRules;
+}
+export function getUploadedPolicyDocumentFileName(state) {
+    return state.policyDocumentExtraction.uploadedFileName;
+}
+export function getPolicyRecommendationFromUploadFetchState(state) {
+    return state.policyRecommendationFromUpload.fetchState;
+}
+export function getPolicyRecommendationFromUploadError(state) {
+    return state.policyRecommendationFromUpload.error;
+}
+export function getPolicyRecommendationFromUploadAnswerId(state) {
+    return state.policyRecommendationFromUpload.answerId;
+}
+export function getPolicyRecommendationFromUploadChatSessionId(state) {
+    return state.policyRecommendationFromUpload.chatSessionId;
+}
+export function getCardPolicySuggestedAllowMerchants(state) {
+    return state.suggestedAllowMerchants;
+}
+export function getCardPolicySuggestedBlockMerchants(state) {
+    return state.suggestedBlockMerchants;
+}
+export function getCardPolicySuggestedAllowCategories(state) {
+    return state.suggestedAllowCategories;
+}
+export function getCardPolicySuggestedBlockCategories(state) {
+    return state.suggestedBlockCategories;
+}
+export function getCardPolicyVendorSearchOptions(state) {
+    return state.vendorSearch.vendors;
+}
+export function getCardPolicyVendorSearchFetchState(state) {
+    return state.vendorSearch.fetchState;
+}
+export function getCardPolicyVendorSearchString(state) {
+    return state.vendorSearch.searchString;
+}

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

@@ -0,0 +1,9 @@
+import { stringToUnion } from '../../commonStateTypes/stringToUnion';
+export const ALL_CARD_POLICY_TEMPLATE_MODES = ['strict', 'flexible'];
+export const toCardPolicyTemplateMode = (v) => stringToUnion(v, ALL_CARD_POLICY_TEMPLATE_MODES);
+export const ALL_CARD_POLICY_TEMPLATE_STATUSES = [
+    'active',
+    'inactive',
+    'archived',
+];
+export const toCardPolicyTemplateStatus = (v) => stringToUnion(v, ALL_CARD_POLICY_TEMPLATE_STATUSES);

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

@@ -0,0 +1,64 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap, takeUntil } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus } from '../../responsePayload';
+import { clearPolicyDocumentExtraction, extractPolicyDocument, updatePolicyDocumentExtractionFailure, updatePolicyDocumentExtractionSuccess, } from './cardPolicyReducer';
+/**
+ * Build a multipart `FormData` body for `POST /cards/1.0/policy-documents/extract`.
+ *
+ * Uses the same `attachment_file_<i>` / `attachment_json_<i>` field-naming
+ * convention as the charge-card receipt upload (`uploadReceipts.ts` in
+ * `web-components`) so backends that already support that wire shape
+ * accept this endpoint without bespoke parsing.
+ */
+const buildPolicyDocumentFormData = (files) => {
+    const data = new FormData();
+    files.forEach((file, index) => {
+        data.append(`attachment_file_${index}`, file);
+        const attachmentJson = JSON.stringify({
+            file_name: file.name,
+            content_type: file.type,
+            size: file.size,
+        });
+        data.append(`attachment_json_${index}`, attachmentJson);
+    });
+    return data;
+};
+/**
+ * Listens for `extractPolicyDocument`, POSTs the file(s) as multipart
+ * form-data to the cards micro-service's policy-document extract endpoint,
+ * and dispatches success / failure into the entity slice.
+ *
+ * Consumed by:
+ *  - Manual `CardPolicyCreatePage` (read result via
+ *    `getExtractedCardPolicyRules` then pre-fill the RHF form via
+ *    `applyExtractedPolicyRulesToFormValues` from `@zeniai/web-components`).
+ *  - (Future) AI CFO upload surface — same action + selector contract.
+ */
+export const extractPolicyDocumentEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(extractPolicyDocument.match), 
+// `switchMap` (vs `mergeMap`) cancels any in-flight extract whenever a
+// new upload is dispatched. With `mergeMap` an older, slower response
+// could win the race: `updatePolicyDocumentExtractionSuccess` would
+// fire with stale `extractedRules` and the chained bridge epic would
+// pair them with whatever `aiCfoAnswerId` / `aiCfoChatSessionId` are
+// currently in state — recommending the old file's rules against the
+// wrong AI CFO answer.
+switchMap((action) => {
+    const formData = buildPolicyDocumentFormData(action.payload.files);
+    return zeniAPI
+        .postFormData(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-documents/extract`, formData)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) &&
+            response.data != null &&
+            response.data.extracted_rules != null) {
+            return of(updatePolicyDocumentExtractionSuccess(response.data.extracted_rules));
+        }
+        return of(updatePolicyDocumentExtractionFailure(response.status));
+    }), catchError((error) => of(updatePolicyDocumentExtractionFailure(createZeniAPIStatus('Unexpected Error', 'Extract card-policy document REST API call errored out' +
+        JSON.stringify(error))))), 
+    // `clearPolicyDocumentExtraction` (e.g. user clicks the "× Policy.pdf"
+    // pill) tears down the in-flight extract subscription, so a late
+    // response can't re-flip `policyDocumentExtraction.fetchState` back
+    // to `Completed` or repopulate `extractedRules` after the user
+    // already dismissed the upload.
+    takeUntil(actions$.pipe(filter(clearPolicyDocumentExtraction.match))));
+}));

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

@@ -0,0 +1,43 @@
+import { of } from 'rxjs';
+import { catchError, filter, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus } from '../../responsePayload';
+import { fetchCardPolicyVendorOptions, updateCardPolicyVendorOptions, updateCardPolicyVendorOptionsFailure, } from './cardPolicyReducer';
+const buildQuery = (searchString) => ({
+    view: 'vendor_list',
+    page_token: null,
+    sort_by: 'year_to_date_spend',
+    sort_order: 'desc',
+    search_text: searchString,
+    vendor_name: searchString,
+});
+/**
+ * Card-policy vendor search.
+ *
+ * Listens for `fetchCardPolicyVendorOptions` and hits the same
+ * `/accounting/1.0/vendors` endpoint the Vendors-tab uses, but writes
+ * results onto the dedicated `cardPolicyState.vendorSearch` slice — no
+ * fan-out to the global `vendor` / `account` / `class` / `vendorList`
+ * entities. That isolation is important: the user may be configuring a
+ * card policy in parallel with browsing the Vendors tab, and we don't
+ * want either flow to clobber the other's list state.
+ *
+ * Uses `switchMap` so the latest typed search wins — earlier in-flight
+ * requests are abandoned, which is the right semantics for a
+ * search-as-you-type UX.
+ *
+ * Consumers:
+ *  - Manual `CardPolicyCreate / EditScreen`
+ *  - AI CFO `CardPolicyInteractiveForm` (vendor step)
+ */
+export const fetchCardPolicyVendorOptionsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyVendorOptions.match), switchMap((action) => {
+    const query = buildQuery(action.payload.searchString);
+    const apiUrl = `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/vendors` +
+        `?query=${encodeURIComponent(JSON.stringify(query))}`;
+    return zeniAPI.getJSON(apiUrl).pipe(switchMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            return of(updateCardPolicyVendorOptions(response.data));
+        }
+        return of(updateCardPolicyVendorOptionsFailure(response.status));
+    }), catchError((error) => of(updateCardPolicyVendorOptionsFailure(createZeniAPIStatus('Unexpected Error', 'Fetch card policy vendor options REST API call errored out' +
+        JSON.stringify(error))))));
+}));

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

@@ -0,0 +1,35 @@
+import { EMPTY, of } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { fetchCardPolicyRecommendationFromUpload, updatePolicyDocumentExtractionSuccess, } from './cardPolicyReducer';
+/**
+ * Bridge epic — chains the AI CFO `upload`-mode flow's two API hops.
+ *
+ * The first hop (`extractPolicyDocument` → multipart POST to
+ * `policy-documents/extract`) lives on the cardPolicy slice and is
+ * shared with the manual `CardPolicyCreatePage`. The second hop
+ * (`fetchCardPolicyRecommendationFromUpload` → JSON POST to
+ * `ai-cfo/policy-recommendation-from-upload`) is AI-CFO only.
+ *
+ * The chain is gated on `policyDocumentExtraction.aiCfoAnswerId` being
+ * populated — manual callers leave it undefined, so the bridge is a
+ * silent no-op there.
+ *
+ * Splitting this off from `policyRecommendationFromUploadEpic` keeps
+ * the wizard component a pure renderer: it dispatches
+ * `extractPolicyDocument(files, answerId, chatSessionId)` once, then
+ * subscribes to `cardPolicyState` lifecycle flags to drive its
+ * "Extracting…" / "Recommending…" pill.
+ */
+export const policyDocumentExtractionToRecommendationBridgeEpic = (actions$, state$) => actions$.pipe(filter(updatePolicyDocumentExtractionSuccess.match), mergeMap((action) => {
+    const extraction = state$.value.cardPolicyState.policyDocumentExtraction;
+    const aiCfoAnswerId = extraction.aiCfoAnswerId;
+    const aiCfoChatSessionId = extraction.aiCfoChatSessionId;
+    const extractedRules = extraction.extractedRules;
+    if (aiCfoAnswerId == null ||
+        aiCfoChatSessionId == null ||
+        extractedRules == null) {
+        return EMPTY;
+    }
+    void action;
+    return of(fetchCardPolicyRecommendationFromUpload(aiCfoAnswerId, aiCfoChatSessionId, extractedRules));
+}));

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

@@ -0,0 +1,100 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap, takeUntil } from 'rxjs/operators';
+import { updateAiCfoAnswerCardPolicyWizardPlan } from '../aiCfo/aiCfoReducer';
+import { createZeniAPIStatus, isSuccessStatus } from '../../responsePayload';
+import { clearPolicyDocumentExtraction, fetchCardPolicyRecommendationFromUpload, updatePolicyRecommendationFromUploadFailure, updatePolicyRecommendationFromUploadSuccess, } from './cardPolicyReducer';
+/**
+ * Listens for `fetchCardPolicyRecommendationFromUpload` and POSTs the
+ * just-extracted policy rules to the AI-CFO recommendation endpoint.
+ *
+ * On success — dispatches BOTH:
+ *  - `updatePolicyRecommendationFromUploadSuccess` (flips the
+ *    cardPolicy slice's recommendation lifecycle to `Completed`), and
+ *  - `updateAiCfoAnswerCardPolicyWizardPlan` (patches the in-flight AI
+ *    CFO answer's `CardPolicyInitialData` so the wizard can advance from
+ *    Step 1 → Step 2 in the upload variant).
+ *
+ * The reducer payload originally captured at kickoff (`answerId` +
+ * `chatSessionId`) re-enters via the action so the patch can find the
+ * right answer to merge into.
+ */
+export const policyRecommendationFromUploadEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyRecommendationFromUpload.match), 
+// `switchMap` (vs `mergeMap`) cancels any in-flight recommendation
+// whenever a new upload kicks off another one. Without this an older,
+// slower recommendation response could still resolve after a fresh
+// extract has started — that late response would dispatch
+// `updateAiCfoAnswerCardPolicyWizardPlan` against the *current*
+// `answerId`/`chatSessionId` (the ones captured at its kickoff) and
+// overwrite the wizard plan with stale draft policies from the prior
+// document. Pairs with the matching `switchMap` in
+// `extractPolicyDocumentEpic`.
+switchMap((action) => {
+    const { answerId, chatSessionId, extractedRules } = action.payload;
+    const body = {
+        extracted_rules: {
+            allowed_entity: {
+                category_codes: extractedRules.allowedEntity.categoryCodes,
+                merchant_names: extractedRules.allowedEntity.merchantNames,
+            },
+            blocked_entity: {
+                category_codes: extractedRules.blockedEntity.categoryCodes,
+                merchant_names: extractedRules.blockedEntity.merchantNames,
+            },
+            confidence_score: extractedRules.confidenceScore,
+            policy_name: extractedRules.policyName,
+            required_receipt_threshold: extractedRules.requiredReceiptThreshold,
+            transaction_limit: extractedRules.transactionLimit,
+        },
+    };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/ai-cfo/policy-recommendation-from-upload`, body)
+        .pipe(mergeMap((response) => {
+        if (!isSuccessStatus(response) ||
+            response.data?.wizard_plan?.step_5_review == null) {
+            return of(updatePolicyRecommendationFromUploadFailure(response.status));
+        }
+        const data = response.data;
+        const review = data.wizard_plan.step_5_review;
+        const wizardPlan = {
+            step5Review: {
+                draftPolicies: (review.draft_policies ?? []).map((draft, index) => ({
+                    id: `draft-${index}`,
+                    name: draft.name,
+                    description: draft.description ?? '',
+                    mode: draft.mode,
+                    allowedEntity: {
+                        categoryCodes: draft.allowed_entity?.category_codes ?? [],
+                        merchantNames: draft.allowed_entity?.merchant_names ?? [],
+                    },
+                    blockedEntity: {
+                        categoryCodes: draft.blocked_entity?.category_codes ?? [],
+                        merchantNames: draft.blocked_entity?.merchant_names ?? [],
+                    },
+                    applyToCards: draft.apply_to_cards ?? [],
+                    requiredReceiptThreshold: draft.required_receipt_threshold ?? 0,
+                    spendLimits: {
+                        transaction: draft.spend_limits?.transaction ?? 0,
+                    },
+                })),
+                groupingSource: review.grouping_source ?? 'none',
+                prompt: review.prompt ?? '',
+            },
+        };
+        const source = data.source != null
+            ? {
+                confidenceScore: data.source.confidence_score,
+                fileName: data.source.file_name,
+                lowConfidenceFields: data.source.low_confidence_fields ?? [],
+            }
+            : undefined;
+        return of(updatePolicyRecommendationFromUploadSuccess(), updateAiCfoAnswerCardPolicyWizardPlan({
+            answerId,
+            chatSessionId,
+            wizardPlan,
+            source,
+        }));
+    }), catchError((error) => of(updatePolicyRecommendationFromUploadFailure(createZeniAPIStatus('Unexpected Error', 'Policy recommendation from upload REST API call errored out' +
+        JSON.stringify(error))))), 
+    // Guards the user-dismissed case that switchMap doesn't cover: a late response would patch a wizard plan the user already cleared.
+    takeUntil(actions$.pipe(filter(clearPolicyDocumentExtraction.match))));
+}));

package/lib/esm/entity/snackbar/snackbarTypes.js

@@ -95,6 +95,9 @@ const ALL_SNACKBAR_MESSAGE_SECTIONS = [
     'charge_card_receipt_upload',
     'charge_card_resend_invite',
     'charge_card_revoke_invite',
+    'card_policy_created',
+    'card_policy_updated',
+    'card_policy_deleted',
     'charge_card_update_limit',
     'charge_cards_update_limit',
     'close_charge_card',

package/lib/esm/entity/tenant/clearAllEpic.js

@@ -97,6 +97,9 @@ import { clearInternationalWire } from '../../view/spendManagement/billPay/inter
 import { clearInternationalVerificationView } from '../../view/spendManagement/billPay/internationalWireVerification/internationalWireVerificationReducer';
 import { clearPreviousBills } from '../../view/spendManagement/billPay/previousBills/previousBillsReducer';
 import { clearWiseRedirectStatus } from '../../view/spendManagement/billPay/wiseRedirectView/wiseRedirectReducer';
+import { clearCardPolicyDetail } from '../../view/spendManagement/chargeCards/cardPolicy/cardPolicyDetail/cardPolicyDetailReducer';
+import { clearCardPolicyList } from '../../view/spendManagement/chargeCards/cardPolicy/cardPolicyList/cardPolicyListReducer';
+import { clearCreateCardPolicy } from '../../view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyReducer';
 import { clearCardUserOnboarding } from '../../view/spendManagement/chargeCards/cardUserOnboarding/cardUserOnboardingReducer';
 import { clearCashbackDetail } from '../../view/spendManagement/chargeCards/cashbackDetail/cashbackDetailReducer';
 import { clearChargeCardConfig } from '../../view/spendManagement/chargeCards/chargeCardConfig/chargeCardConfigReducer';
@@ -168,6 +171,7 @@ import { clearAllBillTransactions } from '../billPay/billTransaction/billTransac
 import { clearContacts } from '../billPay/contact/contactReducer';
 import { clearAllRecurringBills } from '../billPay/recurringBills/recurringBillsReducer';
 import { clearAllCardPayments } from '../cardPayment/cardPaymentReducer';
+import { clearCardPolicy } from '../cardPolicy/cardPolicyReducer';
 import { clearAllChargeCards } from '../chargeCard/chargeCardReducer';
 import { clearAllChargeCardRepayments } from '../chargeCardRepayment/chargeCardRepaymentReducer';
 import { clearAllChargeCardTransactions } from '../chargeCardTransaction/chargeCardTransactionReducer';
@@ -244,6 +248,8 @@ export const clearAllEpic = (actions$) => actions$.pipe(filter(clearAll.match),
         clearBillPaySetupView(),
         clearCardBalance(),
         clearCardPaymentView(),
+        clearCardPolicyDetail(),
+        clearCardPolicyList(),
         clearCardUserOnboarding(),
         clearCashbackDetail(),
         clearCashBalance(),
@@ -263,6 +269,7 @@ export const clearAllEpic = (actions$) => actions$.pipe(filter(clearAll.match),
         clearCompanyMonthEndReportView(),
         clearCompanyTaskManagerView(),
         clearCompanyView(),
+        clearCreateCardPolicy(),
         clearCreateTransferEntry(),
         clearAllCreditAgent(),
         clearCreditAgentView(),
@@ -424,6 +431,7 @@ export const clearAllEpic = (actions$) => actions$.pipe(filter(clearAll.match),
         clearAllVendorExpenseTrends(),
         clearAllVendors(),
         clearCannedResponses(),
+        clearCardPolicy(),
         clearClassList(),
         clearContacts(),
         clearCountryList(),