@zeniai/client-epic-state 5.0.65-betaML2 → 5.0.65-betaRR1

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

@@ -1,6 +1,6 @@
 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: {},
@@ -135,11 +135,120 @@ export const toAiCfoVisualization = (visualization) => {
     if (visualization.type == null || visualization.data == null) {
         return undefined;
     }
+    const normalizedType = toAiCfoVisualizationTypeStrict(visualization.type) ?? 'table';
     return {
-        type: toAiCfoVisualizationTypeStrict(visualization.type) ?? 'table',
-        data: toAiCfoVisualizationData(visualization.data),
+        type: normalizedType,
+        data: normalizedType === 'interactive_form'
+            ? toInteractiveFormVisualization(visualization.data)
+            : toAiCfoVisualizationData(visualization.data),
     };
 };
+const toInteractiveFormVisualization = (data) => {
+    const formType = 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 === 'cards-only') {
+        return {
+            mode: 'cards-only',
+            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,
+            })),
+        };
+    }
+    return {
+        mode: 'team-then-cards',
+        cardOptions,
+        suggestedOwnerUserIdByTeamId: Object.fromEntries(Object.entries(payload.suggested_owner_user_id_by_team_id ?? {}).map(([teamId, userId]) => [teamId, userId ?? undefined])),
+        teamRows: (payload.team_rows ?? []).map((row) => ({
+            avgMonthlySpend: row.avg_monthly_spend,
+            id: row.id,
+            label: row.label,
+            recommendedLimit: row.recommended_limit,
+            recommendedLimitCadence: row.recommended_limit_cadence ?? undefined,
+        })),
+    };
+};
+const toCardPolicyInitialData = (payload) => {
+    const suggestedPolicies = (payload.suggested_policies ?? []).map((policy) => ({
+        id: policy.id,
+        isChecked: policy.is_checked,
+        name: policy.name,
+        chipGroups: (policy.chip_groups ?? []).map((group) => ({
+            id: group.id,
+            label: group.label,
+            chips: (group.chips ?? []).map((chip) => ({
+                id: chip.id,
+                label: chip.label,
+                chipKind: chip.chip_kind,
+            })),
+        })),
+    }));
+    if (payload.policy_kind === 'review-only') {
+        return {
+            policyKind: 'review-only',
+            suggestedPolicies,
+        };
+    }
+    const toCardRowSeed = (card) => ({
+        cardName: card.card_name,
+        id: card.id,
+        isChecked: card.is_checked,
+        last4: card.last4,
+        limitAmount: card.limit_amount,
+        limitCadence: card.limit_cadence ?? undefined,
+        owner: {
+            userId: card.owner.user_id,
+            displayName: card.owner.display_name,
+            roleLabel: card.owner.role_label ?? undefined,
+        },
+        utilizationAmount: card.utilization_amount,
+    });
+    if (payload.policy_kind === 'doc-upload') {
+        return {
+            policyKind: 'doc-upload',
+            suggestedPolicies,
+            cards: (payload.cards ?? []).map(toCardRowSeed),
+        };
+    }
+    return {
+        policyKind: 'full-builder',
+        suggestedPolicies,
+        vendors: (payload.vendors ?? []).map(toCardPolicyTagSeed),
+        categories: (payload.categories ?? []).map(toCardPolicyTagSeed),
+        cards: (payload.cards ?? []).map(toCardRowSeed),
+        defaultLimits: (payload.default_limits ?? []).map((row) => ({
+            id: row.id,
+            isEnabled: row.is_enabled,
+            amount: row.amount ?? undefined,
+        })),
+    };
+};
+const toCardPolicyTagSeed = (tag) => ({
+    id: tag.id,
+    isSelected: tag.is_selected,
+    label: tag.label,
+    optionalCode: tag.optional_code ?? undefined,
+});
 const toAiCfoVisualizationData = (data) => {
     if ('x' in data && 'y' in data) {
         // Normalize y to always be an array

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);

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

@@ -0,0 +1,101 @@
+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.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 camelCase create request into the snake_case wire body.
+ * Used by the epic at request time.
+ */
+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,
+    },
+});
+// Update body uses the exact same wire shape as create — the PUT
+// endpoint is a full replace.
+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,180 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toCardPolicyTemplate, toCardPolicyVendorSearchOption, toExtractedCardPolicyRules, toMccCategory, } from './cardPolicyPayload';
+const initialPolicyDocumentExtractionState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    extractedRules: undefined,
+    uploadedFileName: undefined,
+};
+const initialVendorSearchState = {
+    fetchState: 'Not-Started',
+    searchString: '',
+    vendors: [],
+    error: undefined,
+};
+export const initialState = {
+    cardPolicyTemplateById: {},
+    mccCategories: [],
+    mccCategoriesError: undefined,
+    mccCategoriesFetchState: 'Not-Started',
+    policyDocumentExtraction: initialPolicyDocumentExtractionState,
+    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);
+            // Persist BE-suggested allow / block seeds alongside the universe.
+            // Both flows (manual create page + AI CFO interactive form) read
+            // these to pre-populate the chip cloud body before the user edits.
+            draft.suggestedAllowMerchants =
+                action.payload.suggested_allow_merchants ?? [];
+            draft.suggestedBlockMerchants =
+                action.payload.suggested_block_merchants ?? [];
+            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;
+        },
+        /**
+         * Store a newly-created (or refreshed) card-policy template keyed by
+         * `templateId`. Dispatched by the create / list / get epics; consumed
+         * by both manual and AI-CFO policy flows via `getCardPolicyTemplateById`.
+         */
+        updateCreatedCardPolicyTemplate(draft, action) {
+            const template = toCardPolicyTemplate(action.payload);
+            draft.cardPolicyTemplateById[template.templateId] = template;
+        },
+        /**
+         * Replace the entity store's `cardPolicyTemplateById` map with the
+         * full list returned by the templates-list endpoint. Full replace is
+         * intentional — templates that no longer exist on the server should be
+         * dropped from local state too. The view slice keeps the server-order
+         * ID list separately for stable list rendering.
+         */
+        updateCardPolicyTemplates(draft, action) {
+            const byId = {};
+            for (const template of action.payload) {
+                byId[template.templateId] = template;
+            }
+            draft.cardPolicyTemplateById = byId;
+        },
+        /**
+         * Drop a single template from the entity map. Dispatched by the
+         * archive (DELETE) epic on success; also usable by any future flow
+         * that needs to evict a template (e.g. AI-CFO rejection).
+         */
+        removeCardPolicyTemplate(draft, action) {
+            delete draft.cardPolicyTemplateById[action.payload];
+        },
+        /**
+         * Replace the tenant-wide policy stats. Dispatched alongside
+         * `updateCardPolicyTemplates` from the list epic, but lives on the
+         * entity slice so any consumer can read it without re-fetching the
+         * list.
+         */
+        updateCardPolicyStats(draft, action) {
+            draft.cardPolicyStats = action.payload;
+        },
+        /**
+         * Kick off the `POST /cards/1.0/policy-documents/extract` request.
+         *
+         * Synchronously flips the sub-slice to `In-Progress` and captures the
+         * first uploaded file's name (used by the manual `CardPolicyCreatePage`
+         * to render the "Policy.pdf ×" pill once the request completes) so
+         * downstream callers don't have to keep their own file refs.
+         *
+         * The accompanying `extractPolicyDocumentEpic` listens for this action,
+         * POSTs multipart form-data to the cards micro-service, and dispatches
+         * either `updatePolicyDocumentExtractionSuccess` or
+         * `updatePolicyDocumentExtractionFailure`.
+         *
+         * Designed to be dispatched from both the manual create page and a
+         * future AI CFO composer/upload surface — selectors return a single
+         * source of truth.
+         */
+        extractPolicyDocument: {
+            reducer(draft, action) {
+                draft.policyDocumentExtraction.fetchState = 'In-Progress';
+                draft.policyDocumentExtraction.error = undefined;
+                draft.policyDocumentExtraction.extractedRules = undefined;
+                draft.policyDocumentExtraction.uploadedFileName =
+                    action.meta.uploadedFileName;
+            },
+            prepare(files) {
+                return {
+                    payload: { files },
+                    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,
+            };
+        },
+        /**
+         * Kick off `GET /accounting/1.0/vendors` (card-policy mode). When
+         * `searchString` is empty the BE returns the top vendors sorted by
+         * year-to-date spend; with a non-empty value it filters server-side.
+         *
+         * The accompanying `fetchCardPolicyVendorOptionsEpic` listens for
+         * this action, builds the `query` JSON (matching `fetchVendorsList`'s
+         * `view: "vendor_list"` shape) and dispatches success / failure.
+         *
+         * Designed to be dispatched from both the manual `CardPolicyCreate /
+         * EditScreen` (on mount + on every chip-picker keystroke, debounced)
+         * and the AI CFO interactive form's vendor step.
+         */
+        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) {
+            draft.vendorSearch.vendors = (action.payload.vendors ?? []).map(toCardPolicyVendorSearchOption);
+            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, clearCardPolicy, } = cardPolicy.actions;
+export default cardPolicy.reducer;

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

@@ -0,0 +1,66 @@
+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;
+}
+// ── Policy document extraction ───────────────────────────────────────
+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;
+}
+// ── Suggested allow / block seeds (shipped alongside MCC categories) ─
+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;
+}
+// ── Vendor search dropdown ───────────────────────────────────────────
+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,50 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus } from '../../responsePayload';
+import { 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), mergeMap((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))))));
+}));

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/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';
@@ -167,6 +170,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';
@@ -243,6 +247,8 @@ export const clearAllEpic = (actions$) => actions$.pipe(filter(clearAll.match),
         clearBillPaySetupView(),
         clearCardBalance(),
         clearCardPaymentView(),
+        clearCardPolicyDetail(),
+        clearCardPolicyList(),
         clearCardUserOnboarding(),
         clearCashbackDetail(),
         clearCashBalance(),
@@ -262,6 +268,7 @@ export const clearAllEpic = (actions$) => actions$.pipe(filter(clearAll.match),
         clearCompanyMonthEndReportView(),
         clearCompanyTaskManagerView(),
         clearCompanyView(),
+        clearCreateCardPolicy(),
         clearAllCreditAgent(),
         clearCreditAgentView(),
         clearDashboard(),
@@ -422,6 +429,7 @@ export const clearAllEpic = (actions$) => actions$.pipe(filter(clearAll.match),
         clearAllVendorExpenseTrends(),
         clearAllVendors(),
         clearCannedResponses(),
+        clearCardPolicy(),
         clearClassList(),
         clearContacts(),
         clearCountryList(),