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

package/lib/esm/entity/account/accountSelector.js

@@ -51,17 +51,6 @@ export const getAccountBase = (accountState, accountId, reportId) => {
         reconciliationSource: account.reconciliationSource,
     };
 };
-/**
- * Transfer-account IDs from the API are resolved under `transfer_accounts`; if that
- * slice is not hydrated yet, fall back to `account_list` so dropdowns still populate.
- */
-export const getAccountBaseForTransferAccounts = (accountState, accountId) => getAccountBase(accountState, accountId, 'transfer_accounts') ??
-    getAccountBase(accountState, accountId, 'account_list');
-/**
- * Credit-card-only pool from the transfer-flow accounts API; falls back to `account_list`.
- */
-export const getAccountBaseForCreditCardTransferAccounts = (accountState, accountId) => getAccountBase(accountState, accountId, 'credit_card_transfer_accounts') ??
-    getAccountBase(accountState, accountId, 'account_list');
 export function getAccount(accountState, id, filter, additionalBalancesOptions) {
     const key = getAccountKey(id.reportId, id.accountId, id.classesViewParentId, id.accountsViewParentId, id.projectsViewParentId);
     const account = accountState.accountsByKey[key];

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) {
@@ -135,9 +136,185 @@ 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 === '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) => {
@@ -453,9 +630,118 @@ const aiCfo = 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;
@@ -464,6 +750,7 @@ const aiCfo = createSlice({
         clearAiCfo(draft) {
             draft.aiCfoByChatSessionId = {};
             draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
         },
         deleteQuestion(draft, action) {
             const { chatSessionId, questionAnswerId } = action.payload;
@@ -488,5 +775,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,14 @@ 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());
 }

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,16 @@ 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);
+/**
+ * Discriminator for client-synthesized AI CFO answer bubbles. These are not
+ * Q/A pairs streamed from the backend — they are pushed locally by the AI
+ * CFO flow when it kicks off a cards or policy create from an interactive
+ * form, so the drawer can render a "Creating…" placeholder and later a
+ * "Created" success bubble while the corresponding mutation epic runs.
+ */
+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,
+});