@zeniai/client-epic-state 5.1.34 → 5.1.35

package/lib/esm/view/aiCfoView/aiCfoViewSelector.js

@@ -22,3 +22,14 @@ export const getAiCfoView = (state) => {
 export function getSuggestedQuestionsForPageContext(state, pageContext) {
     return state.aiCfoViewState?.suggestedQuestionsByPageContext?.[pageContext];
 }
+// Stable fallback so getSkills returns a referentially-stable object when skills
+// state is absent — a fresh literal each call would defeat useSelector identity
+// checks and cause needless re-renders.
+const EMPTY_SKILLS_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    skills: [],
+};
+export function getSkills(state) {
+    return state.aiCfoViewState?.skills ?? EMPTY_SKILLS_STATE;
+}

package/lib/esm/view/aiCfoView/epics/createSessionAndSubmitEpic.js

@@ -66,7 +66,7 @@ function waitForChannelSubscription(pusherInstance, channelName, timeoutMs = 500
     }));
 }
 export const createSessionAndSubmitEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(createSessionAndSubmit.match), switchMap((action) => {
-    const { agentId, userId, questionAnswerId, questionId, createdAt, question, files, pageContext, } = action.payload;
+    const { agentId, userId, questionAnswerId, questionId, createdAt, question, files, pageContext, macroId, } = action.payload;
     const payload = {
         agent_id: agentId,
         ...(pageContext != null && { page_context: pageContext }),
@@ -113,7 +113,7 @@ export const createSessionAndSubmitEpic = (actions$, _state$, zeniAPI) => action
                 // This allows fetchChatHistory to run after the question is submitted
                 of(createSessionAndSubmitSuccess(), 
                 // Submit the question after handlers are bound
-                submitQuestion(sessionId, questionAnswerId, userId, questionId, createdAt, question, files), 
+                submitQuestion(sessionId, questionAnswerId, userId, questionId, createdAt, question, files, macroId), 
                 // Add question payload optimistically after submitQuestion (matches original order)
                 // This is idempotent - won't create duplicates if called multiple times
                 // submitQuestionEpic will find the question already exists and only update the response

package/lib/esm/view/aiCfoView/epics/fetchSkillsEpic.js

@@ -0,0 +1,34 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkills, fetchSkillsFailure, fetchSkillsSuccess, } from '../aiCfoViewReducer';
+const toSkill = (s) => ({
+    macroId: s.macro_id,
+    name: s.name,
+    displayName: s.display_name,
+    description: s.description,
+    semver: s.semver,
+    parameterHints: s.parameter_hints,
+    hasScripts: s.has_scripts,
+});
+/** GET {aiCfoMicroServiceBaseUrl}/1.0/skills — chat-visible skills for the `/` menu. */
+export const fetchSkillsEpic = (actions$, 
+// state$ intentionally unused: the `/` menu dispatches this once per slash-entry
+// (the composer dedupes), so we always re-fetch the (small, singleton) list.
+_state$, zeniAPI) => actions$.pipe(filter(fetchSkills.match), 
+// switchMap: a singleton list endpoint with no key — cancel any in-flight
+// fetch so the latest dispatch wins (no racing writes to `skills`).
+switchMap(() => {
+    // aiCfoMicroServiceBaseUrl already targets the chat service (it serves the
+    // /1.0/agents/{id} submit route too); /1.0/skills lives on the same service.
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            // Guard the array: a malformed 2xx body without `skills` must not crash .map.
+            return of(fetchSkillsSuccess({
+                skills: (response.data.skills ?? []).map(toSkill),
+            }));
+        }
+        return of(fetchSkillsFailure(response.status));
+    }), catchError((error) => of(fetchSkillsFailure(createZeniAPIStatus('Unexpected Error', 'Fetch skills REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

package/lib/esm/view/aiCfoView/epics/submitQuestionEpic.js

@@ -4,7 +4,7 @@ import { upsertOrAddQuestionAnswerPayload } from '../../../entity/aiCfo/aiCfoRed
 import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
 import { submitQuestion, submitQuestionFailure, submitQuestionSuccess, } from '../aiCfoViewReducer';
 export const submitQuestionEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(submitQuestion.match), mergeMap((action) => {
-    const { questionAnswerId, userId, sessionId, questionId, createdAt, question, files, } = action.payload;
+    const { questionAnswerId, userId, sessionId, questionId, createdAt, question, files, macroId, } = action.payload;
     const { aiCfoViewState } = state$.value;
     const { uiState } = aiCfoViewState;
     const agentId = uiState.agentId;
@@ -17,15 +17,21 @@ export const submitQuestionEpic = (actions$, state$, zeniAPI) => actions$.pipe(f
         const formData = new FormData();
         formData.append('chat_session_id', sessionId);
         formData.append('message', question);
+        if (macroId != null) {
+            formData.append('macro_id', macroId);
+        }
         for (const file of files) {
             formData.append('files', file, file.name);
         }
         apiCall = zeniAPI.postFormData(endpoint, formData);
     }
     else {
+        // `message` is the display token (e.g. "/flux"); `macro_id` tells the chat
+        // service to expand the skill's instructions as the actual agent prompt.
         apiCall = zeniAPI.postAndGetJSON(endpoint, {
             chat_session_id: sessionId,
             message: question,
+            ...(macroId != null && { macro_id: macroId }),
         });
     }
     return apiCall.pipe(mergeMap((response) => {

package/lib/esm/view/expenseAutomationView/epics/accountRecon/parseStatementEpic.js

@@ -0,0 +1,34 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { transformParseStatementPayloadToState, } from '../../payload/reconciliationPayload';
+import { parseStatement, parseStatementFailure, parseStatementSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
+export const parseStatementEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(parseStatement.match), switchMap((action) => {
+    const { accountId, selectedPeriod, statementUploadId } = action.payload;
+    const parseStatementApi$ = zeniAPI.getJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`);
+    return parseStatementApi$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            const actions = [];
+            const transformedData = transformParseStatementPayloadToState(response.data);
+            actions.push(updateParsedStatementData({
+                accountId,
+                selectedPeriod,
+                parsedStatementData: transformedData,
+            }));
+            actions.push(parseStatementSuccess({ accountId, selectedPeriod }));
+            return from(actions);
+        }
+        else {
+            return of(parseStatementFailure({
+                accountId,
+                selectedPeriod,
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(parseStatementFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Parse Statement REST API call errored out ' +
+            (error instanceof Error ? error.message : String(error))),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/accountRecon/reparseStatementEpic.js

@@ -0,0 +1,31 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateAccountReconReparseStatement } from '../../../../entity/accountRecon/accountReconReducer';
+import { toAccountReconKey } from '../../../../entity/accountRecon/accountReconState';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { reparseStatement, reparseStatementFailure, reparseStatementSuccess, } from '../../reducers/reconciliationViewReducer';
+export const reparseStatementEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(reparseStatement.match), switchMap((action) => {
+    const { accountId, selectedPeriod, statementUploadId } = action.payload;
+    const reparseStatementApi$ = zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/1.0/reconciliation/statements/${statementUploadId}/reparse`);
+    return reparseStatementApi$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            const accountReconKey = toAccountReconKey(accountId, selectedPeriod);
+            return from([
+                updateAccountReconReparseStatement(accountReconKey, response.data),
+                reparseStatementSuccess({ accountId, selectedPeriod }),
+            ]);
+        }
+        else {
+            return of(reparseStatementFailure({
+                accountId,
+                selectedPeriod,
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(reparseStatementFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Reparse Statement REST API call errored out ' +
+            (error instanceof Error ? error.message : String(error))),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/accountRecon/updateStatementInfoEpic.js

@@ -0,0 +1,57 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { toMonthYearPeriodId } from '../../../../commonStateTypes/timePeriod';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { isStatementDateConflictResponse, toStatementUpdateRequestBody, transformStatementDateConflictToState, transformUpdateStatementInfoPayloadToState, } from '../../payload/reconciliationPayload';
+import { submitStatementUpdate, submitStatementUpdateFailure, submitStatementUpdateSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
+export const updateStatementInfoEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(submitStatementUpdate.match), switchMap((action) => {
+    const { accountId, selectedPeriod, statementUploadId } = action.payload;
+    const state = state$.value;
+    const reconciliationView = state.expenseAutomationReconciliationViewState;
+    const accountRecon = reconciliationView.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+    const localData = accountRecon?.localData?.statementUpdateLocalData;
+    if (!localData) {
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: createZeniAPIStatus('Missing Data', 'No statement update data found'),
+        }));
+    }
+    const hasInvalidUpdates = localData.statementTransactions.updated.some((txn) => txn.statementTransactionId == null);
+    if (hasInvalidUpdates) {
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: createZeniAPIStatus('Invalid Data', 'One or more edited transactions are missing statement transaction ids'),
+        }));
+    }
+    const body = toStatementUpdateRequestBody(localData);
+    const updateStatementApi$ = zeniAPI.putAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`, body);
+    return updateStatementApi$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            const parsedStatementData = transformUpdateStatementInfoPayloadToState(response.data);
+            return of(updateParsedStatementData({
+                accountId,
+                selectedPeriod,
+                parsedStatementData,
+            }), submitStatementUpdateSuccess({
+                accountId,
+                selectedPeriod,
+            }));
+        }
+        const dateConflict = isStatementDateConflictResponse(response)
+            ? transformStatementDateConflictToState(response)
+            : null;
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: response.status,
+            dateConflict,
+        }));
+    }), catchError((error) => of(submitStatementUpdateFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Update Statement REST API call errored out ' +
+            (error instanceof Error ? error.message : String(error))),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/payload/reconciliationPayload.js

@@ -67,3 +67,156 @@ function createReviewTransactionPayload(accountReconciliationEntity) {
     });
     return reviewTransactionsPayload;
 }
+export function isStatementDateConflictResponse(response) {
+    return response.status.code === 409 && response.error_code != null;
+}
+function transformStatementUploadPayloadToState(statementUploadPayload) {
+    return {
+        account: {
+            accountId: statementUploadPayload.account.account_id,
+            accountName: statementUploadPayload.account.account_name,
+            accountType: statementUploadPayload.account.account_type,
+            currencyCode: statementUploadPayload.account.currency_code,
+            last4Digits: statementUploadPayload.account.last_4_digits,
+        },
+        file: statementUploadPayload.file != null
+            ? {
+                fileId: statementUploadPayload.file.file_id,
+                fileName: statementUploadPayload.file.file_name,
+                signedUrl: statementUploadPayload.file.signed_url,
+            }
+            : null,
+        statementMeta: {
+            closingBalance: statementUploadPayload.statement_meta.closing_balance,
+            openingBalance: statementUploadPayload.statement_meta.opening_balance,
+            statementDataStatus: statementUploadPayload.statement_meta.statement_data_status,
+            statementEndDate: statementUploadPayload.statement_meta.statement_end_date,
+            statementStartDate: statementUploadPayload.statement_meta.statement_start_date,
+            statementStatus: statementUploadPayload.statement_meta.statement_status,
+            statementUploadId: statementUploadPayload.statement_meta.statement_upload_id,
+            totalDeposits: statementUploadPayload.statement_meta.total_deposits,
+            totalPayments: statementUploadPayload.statement_meta.total_payments,
+        },
+        statementTransactions: (statementUploadPayload.statement_transactions ?? []).map((txn) => ({
+            amount: txn.amount,
+            citations: (txn.citation ?? []).map((c) => ({
+                page: c.page,
+                pageHeight: c.page_height,
+                pageWidth: c.page_width,
+                polygon: (c.polygon ?? []).map((point) => ({
+                    x: point.x,
+                    y: point.y,
+                })),
+                referenceText: c.reference_text,
+            })),
+            isUserAdded: txn.is_user_added,
+            isUserEdited: txn.is_user_edited,
+            statementTransactionId: txn.statement_transaction_id,
+            transactionDate: txn.transaction_date,
+            transactionDirection: txn.transaction_direction,
+            transactionMemo: txn.transaction_memo,
+        })),
+        aiSummary: transformAiSummaryPayloadToState(statementUploadPayload.ai_summary),
+    };
+}
+function transformPreviousReconciliationInfoToState(payload) {
+    if (payload == null) {
+        return null;
+    }
+    return {
+        endDate: payload.end_date,
+        reconciledAt: payload.reconciled_at,
+        reconciledByUserId: payload.reconciled_by_user_id,
+        reconciliationId: payload.reconciliation_id,
+        startDate: payload.start_date,
+    };
+}
+function transformAiSummaryPayloadToState(aiSummaryPayload) {
+    if (aiSummaryPayload == null) {
+        return null;
+    }
+    const { chain_status: chainStatus } = aiSummaryPayload;
+    return {
+        accountIdentified: aiSummaryPayload.account_identified,
+        transactionsExtracted: aiSummaryPayload.transactions_extracted,
+        exceptionsDetected: aiSummaryPayload.exceptions_detected,
+        fieldsCaptured: (aiSummaryPayload.fields_captured ?? []).map((field) => ({
+            code: field.code,
+            label: field.label,
+        })),
+        chainStatus: {
+            code: chainStatus?.code ?? '',
+            label: chainStatus?.label ?? '',
+            expectedStartDate: chainStatus?.expected_start_date ?? null,
+            previousReconciliationInfo: transformPreviousReconciliationInfoToState(chainStatus?.previous_reconciliation_info),
+        },
+    };
+}
+/**
+ * Builds date-conflict state from a 409 Confirm & Save response.
+ * Returns null for non-409 responses or 409s without a recognized error code.
+ */
+export function transformStatementDateConflictToState(response) {
+    if (isStatementDateConflictResponse(response) === false) {
+        return null;
+    }
+    const previousReconciliationInfo = transformPreviousReconciliationInfoToState(response.previous_reconciliation_info);
+    if (response.error_code === 'STATEMENT_RANGE_ALREADY_RECONCILED' &&
+        previousReconciliationInfo == null) {
+        return null;
+    }
+    if (response.error_code === 'STATEMENT_RANGE_HAS_GAP' &&
+        response.expected_start_date == null &&
+        previousReconciliationInfo == null) {
+        return null;
+    }
+    return {
+        errorCode: response.error_code,
+        expectedStartDate: response.expected_start_date ?? null,
+        ...(previousReconciliationInfo != null ? { previousReconciliationInfo } : {}),
+    };
+}
+export function transformParseStatementPayloadToState(payload) {
+    return {
+        statementUpload: transformStatementUploadPayloadToState(payload.statement_upload),
+    };
+}
+export function transformUpdateStatementInfoPayloadToState(payload) {
+    return {
+        statementUpload: transformStatementUploadPayloadToState(payload.statement_upload),
+    };
+}
+export function transformStatementUpdateStateToPayload(localData) {
+    const { statementMeta, statementTransactions } = localData;
+    return {
+        statement_meta: {
+            opening_balance: statementMeta.openingBalance,
+            statement_end_date: statementMeta.statementEndDate,
+            statement_start_date: statementMeta.statementStartDate,
+            total_deposits: statementMeta.totalDeposits,
+            total_payments: statementMeta.totalPayments,
+        },
+        statement_transactions: {
+            added: statementTransactions.added.map((txn) => ({
+                amount: txn.amount,
+                transaction_date: txn.transactionDate,
+                transaction_direction: txn.transactionDirection,
+                transaction_memo: txn.transactionMemo,
+            })),
+            deleted_ids: statementTransactions.deletedIds,
+            updated: statementTransactions.updated
+                .filter((txn) => txn.statementTransactionId != null)
+                .map((txn) => ({
+                amount: txn.amount,
+                statement_transaction_id: txn.statementTransactionId,
+                transaction_date: txn.transactionDate,
+                transaction_direction: txn.transactionDirection,
+                transaction_memo: txn.transactionMemo,
+            })),
+        },
+    };
+}
+/** API request body for PUT statement-uploads; cast lives here for putAndGetJSON. */
+export function toStatementUpdateRequestBody(localData) {
+    return transformStatementUpdateStateToPayload(localData);
+}