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

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, CARDS_CREATION_DEFAULT_CARD_OPTION_ID, 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,216 @@ export const toAiCfoVisualization = (visualization) => {
     if (visualization.type == null || visualization.data == null) {
         return undefined;
     }
+    // Reject unknown viz types instead of silently defaulting to `table`.
+    // The previous `?? 'table'` fallback funneled any non-strict-union
+    // payload into `toAiCfoVisualizationData`, which is the table/chart
+    // decoder and dereferences `data.values.map(...)`. Interactive-form
+    // payloads (e.g. when the BE ships `type: <new_form_kind>` we don't
+    // know about yet) carry no `values`, so that path threw during answer
+    // upsert and broke rendering for the whole Q/A. Returning `undefined`
+    // matches the existing "missing type / data" guard above — callers
+    // already handle a no-visualization answer.
+    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, fall back to a payload-shape
+    // heuristic instead of blindly defaulting to `cards_creation`. A
+    // `card_policy` payload always carries `mode: 'auto' | 'guided' |
+    // 'upload'` (see `CardPolicyInitialDataPayload`); a `cards_creation`
+    // payload carries `suggested_cards` and never that exact `mode` set.
+    // Without this, a card-policy answer with a malformed `form_type`
+    // would be decoded as cards_creation, surfacing the wrong interactive
+    // form (and wrong submit path) in the UI.
+    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';
+};
+/**
+ * Decode the unified `cards_creation` interactive-form payload into the FE
+ * state shape. Both `review` and `create` modes ship the same envelope
+ * (`{mode, suggested_cards[]}`); the only thing that varies is how the
+ * common derivations are exposed:
+ *
+ * - `review` (2-step): `is_suggested: true` rows -> `teamRows`; the full
+ *   universe -> `cardNameOptions` (step-2 swap + step-1 "Add something
+ *   else" search).
+ * - `create` (1-step): `is_suggested: true` rows -> `cardRows` pre-seeded
+ *   for the step-2 editable table (with `cardOptionId` defaulted to
+ *   `'virtual'`); the full universe -> `cardNameOptions` (step-2 swap).
+ *
+ * `cardOptions` (physical / virtual / subscription) is intentionally not
+ * derived here — the wire never carries it. The component prop is fed
+ * from `AI_CARD_CREATION_VIRTUAL_ONLY_CARD_OPTIONS` at render time. The
+ * state field is preserved as `[]` for backward compatibility with
+ * consumers that still narrow on it.
+ */
+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,
+        cardOptions: [],
+        suggestedOwnerUserIdByTeamId,
+    };
+    if (payload.mode === 'create') {
+        return {
+            ...common,
+            mode: 'create',
+            cardRows: suggestedOnly.map(({ card, uniqueId }) => ({
+                cardKind: toCardKind(card.card_type),
+                cardOptionId: CARDS_CREATION_DEFAULT_CARD_OPTION_ID,
+                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,
+});
+/**
+ * Normalize the controller's `owner_id` into `string | undefined`. The
+ * BE may emit either `null` or `""` to signal "no owner picked"; both
+ * collapse to `undefined` so downstream resolvers don't try to look up
+ * a user with an empty id.
+ */
+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';
+};
+/**
+ * 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,10 +661,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, sourceQuestionAnswerId, } = action.payload;
+            if (draft.syntheticAnswersByChatSessionId[chatSessionId] == null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] = [];
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId].push({
+                id,
+                kind,
+                entityIds: entityIds ?? [],
+                createdAt,
+                sourceQuestionAnswerId,
+            });
+        },
+        /**
+         * 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);
+        },
+        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;
             }
@@ -464,6 +780,7 @@ const aiCfo = createSlice({
         clearAiCfo(draft) {
             draft.aiCfoByChatSessionId = {};
             draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
         },
         deleteQuestion(draft, action) {
             const { chatSessionId, questionAnswerId } = action.payload;
@@ -476,6 +793,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);
+            }
         },
     },
 });
@@ -488,5 +811,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,30 @@ 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());
+}
+/**
+ * Look up the synthetic answer bubble (if any) whose source AI CFO Q/A
+ * is `questionAnswerId`. Used by the in-place renderer to swap a Q/A's
+ * answer bubble with the "Creating…" / "Created" tile.
+ *
+ * Returns `undefined` when no synthetic bubble has been dispatched for
+ * the answer yet (i.e. the user hasn't submitted the interactive form),
+ * or when the chat session has no synthetic entries at all.
+ */
+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);
@@ -52,9 +59,29 @@ export const toAiCfoAnswerStateType = (v) => stringToUnion(v, ALL_AI_CFO_ANSWER_
 export const toAiCfoAnswerResponseType = (v) => stringToUnion(v, ALL_AI_CFO_ANSWER_RESPONSE_TYPES);
 export const toAiCfoAnswerStateTypeStrict = (v) => stringToUnionStrict(v, ALL_AI_CFO_ANSWER_STATE_TYPES);
 export const toAiCfoAnswerResponseTypeStrict = (v) => stringToUnionStrict(v, ALL_AI_CFO_ANSWER_RESPONSE_TYPES);
+/**
+ * Default `cardOptionId` (physical / virtual / subscription) assigned to
+ * every seeded card row. The AI Card Creation flow currently issues virtual
+ * credit cards only — this constant is kept in sync with
+ * `AI_CARD_CREATION_VIRTUAL_ONLY_CARD_OPTIONS` in `zeni-web-app-ui`.
+ */
+export const CARDS_CREATION_DEFAULT_CARD_OPTION_ID = 'virtual';
 const ALL_MESSAGE_SENDERS = ['user', 'agent'];
 const ALL_MESSAGE_TYPES = ['plain_text', 'json'];
 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,
+});