@zeniai/client-epic-state 5.2.32 → 5.2.34

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

@@ -81,6 +81,29 @@ export const initialAiCfoViewState = {
         skillsEnabled: false,
         canPublish: false,
     },
+    routines: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        deletedScheduleIds: [],
+        routines: [],
+        routinesEnabled: false,
+        // 0 until the server says otherwise. The form reads this to decide whether
+        // "New routine" is available, and a guessed cap would either block a user
+        // who is under it or invite one who is over it to fill in a doomed form.
+        maxRoutines: 0,
+    },
+    routineMutation: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        kind: undefined,
+    },
+    routineRuns: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        runs: [],
+        scheduleId: null,
+        sessionId: null,
+    },
 };
 /**
  * Forget the skill that was open — prompt AND history together.
@@ -263,6 +286,15 @@ const aiCfoView = createSlice({
                 fetchState: 'Error',
                 error,
             };
+            // A page that failed is not a promise of another one. Leaving `hasMore`
+            // at its default meant the screen kept asking: the fetch condition is
+            // "not in flight and there is more", and Error satisfies the first half,
+            // so a session whose history 404s was requested in a tight loop forever
+            // while the view sat on its loading skeletons.
+            draft.uiState.chatHistoryNextPageToken[chatSessionId] = {
+                nextPageToken: null,
+                hasMore: false,
+            };
         },
         setSession(draft, action) {
             draft.uiState.currentChatSessionId = action.payload.sessionId;
@@ -601,6 +633,229 @@ const aiCfoView = createSlice({
                 error,
             };
         },
+        fetchRoutines(draft) {
+            draft.routines = {
+                fetchState: 'In-Progress',
+                error: undefined,
+                routines: draft.routines.routines,
+                maxRoutines: draft.routines.maxRoutines,
+                // Carried for the same reason as maxRoutines: a refetch in flight is not
+                // a reason to hide the entry the user is currently looking at.
+                routinesEnabled: draft.routines.routinesEnabled,
+                // Carried, not cleared: the response about to arrive may still contain a
+                // routine deleted moments ago, which is the whole reason the list exists.
+                deletedScheduleIds: draft.routines.deletedScheduleIds,
+            };
+        },
+        fetchRoutinesSuccess(draft, action) {
+            draft.routines = {
+                fetchState: 'Completed',
+                error: undefined,
+                // A list response can predate a delete — a save refetches, and a delete
+                // can land while that is outstanding — so replacing wholesale would put
+                // the deleted row back and read as the delete having failed.
+                routines: action.payload.routines.filter((routine) => !draft.routines.deletedScheduleIds.includes(routine.scheduleId)),
+                maxRoutines: action.payload.maxRoutines,
+                routinesEnabled: action.payload.routinesEnabled,
+                // Carried, NOT cleared here.
+                //
+                // The skills slice clears its tombstone on a list response, which fixed
+                // one bug and introduced the mirror of it: two list responses can both
+                // land before the DELETE is processed, and the second one — arriving
+                // with an empty tombstone — puts the deleted row back. The window is
+                // small and entirely real, since a save refetches.
+                //
+                // The tombstone's true lifetime is the delete request, so it is dropped
+                // in deleteRoutineSuccess / deleteRoutineFailure instead. That bounds it
+                // just as tightly (a delete always resolves) without this race.
+                deletedScheduleIds: draft.routines.deletedScheduleIds,
+            };
+        },
+        fetchRoutinesFailure(draft, action) {
+            draft.routines = {
+                fetchState: 'Error',
+                error: action.payload,
+                routines: draft.routines.routines,
+                // Kept: a failed refresh is not evidence the cap changed, and zeroing it
+                // would disable "New routine" on any transient error.
+                maxRoutines: draft.routines.maxRoutines,
+                // Same again: a transient error must not make the entry vanish.
+                routinesEnabled: draft.routines.routinesEnabled,
+                deletedScheduleIds: draft.routines.deletedScheduleIds,
+            };
+        },
+        setRoutineEnabled: {
+            prepare: (payload) => ({
+                payload,
+            }),
+            reducer(draft, action) {
+                // Pause and resume without a full draft. A routine whose cadence this
+                // client does not recognise has `recurrence: null`, so it cannot build
+                // a RoutineDraft at all — and that is exactly the routine a user most
+                // needs to be able to stop. Flipped locally too, so the switch responds
+                // immediately; the refetch confirms it.
+                const routine = draft.routines.routines.find((candidate) => candidate.scheduleId === action.payload.scheduleId);
+                if (routine) {
+                    routine.enabled = action.payload.enabled;
+                }
+                draft.routineMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    kind: 'save',
+                };
+            },
+        },
+        fetchRoutineRuns: {
+            prepare: (payload) => ({ payload }),
+            reducer(draft, action) {
+                // Only a different routine's rows are wrong to show. This list polls
+                // itself while a run is in flight, and clearing on every fetch blanked
+                // the history and its summary a few times a minute — the rows were
+                // being replaced by "Loading runs…" and then re-rendered, which reads
+                // as the page breaking rather than refreshing.
+                const sameRoutine = draft.routineRuns.scheduleId === action.payload.scheduleId;
+                draft.routineRuns = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    // Showing one routine's runs under another's name is the one thing a
+                    // history must never do, so a change of routine still clears.
+                    runs: sameRoutine ? draft.routineRuns.runs : [],
+                    scheduleId: action.payload.scheduleId,
+                    sessionId: sameRoutine ? draft.routineRuns.sessionId : null,
+                };
+            },
+        },
+        fetchRoutineRunsSuccess: {
+            prepare: (payload) => ({ payload }),
+            reducer(draft, action) {
+                // A response for a routine the user has since collapsed or swapped away
+                // from is dropped. switchMap makes this rare, not impossible.
+                if (draft.routineRuns.scheduleId !== action.payload.scheduleId) {
+                    return;
+                }
+                draft.routineRuns = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                    runs: action.payload.runs,
+                    scheduleId: action.payload.scheduleId,
+                    sessionId: action.payload.sessionId,
+                };
+            },
+        },
+        fetchRoutineRunsFailure(draft, action) {
+            draft.routineRuns.fetchState = 'Error';
+            draft.routineRuns.error = action.payload;
+        },
+        closeRoutineRuns(draft) {
+            draft.routineRuns = {
+                fetchState: 'Not-Started',
+                error: undefined,
+                runs: [],
+                scheduleId: null,
+                sessionId: null,
+            };
+        },
+        runRoutine: {
+            prepare: (payload) => ({ payload }),
+            reducer(draft, action) {
+                draft.routineMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    kind: 'run',
+                    runningScheduleId: action.payload.scheduleId,
+                };
+            },
+        },
+        runRoutineSuccess(draft) {
+            draft.routineMutation = {
+                fetchState: 'Completed',
+                error: undefined,
+                kind: 'run',
+                // Cleared: the request is done. The RUN is not — the answer arrives by
+                // email a minute or two later, and the row reports that through
+                // last_run_at on the next fetch, not through this flag.
+                runningScheduleId: undefined,
+            };
+        },
+        runRoutineFailure(draft, action) {
+            draft.routineMutation = {
+                fetchState: 'Error',
+                error: action.payload,
+                kind: 'run',
+                runningScheduleId: undefined,
+            };
+        },
+        saveRoutine: {
+            prepare: (payload) => ({
+                payload,
+            }),
+            reducer(draft) {
+                draft.routineMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    kind: 'save',
+                };
+            },
+        },
+        saveRoutineSuccess(draft) {
+            draft.routineMutation = {
+                fetchState: 'Completed',
+                error: undefined,
+                kind: 'save',
+            };
+        },
+        saveRoutineFailure(draft, action) {
+            // On its OWN slice, so the `fetchRoutines` this write triggers cannot
+            // clear the error in the same tick and report a failed save as nothing.
+            draft.routineMutation = {
+                fetchState: 'Error',
+                error: action.payload,
+                kind: 'save',
+            };
+        },
+        deleteRoutine: {
+            prepare: (payload) => ({ payload }),
+            reducer(draft, action) {
+                draft.routineMutation = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                    kind: 'delete',
+                };
+                // Removed immediately AND tombstoned. The row must leave the list now —
+                // waiting for the refetch makes the click feel ignored — and the
+                // tombstone is what stops an in-flight list response restoring it.
+                draft.routines.routines = draft.routines.routines.filter((routine) => routine.scheduleId !== action.payload.scheduleId);
+                draft.routines.deletedScheduleIds = [
+                    ...draft.routines.deletedScheduleIds,
+                    action.payload.scheduleId,
+                ];
+            },
+        },
+        deleteRoutineSuccess(draft, action) {
+            // The server has it. Nothing it sends from here on will contain this row,
+            // so the tombstone has done its job and holding it any longer is what
+            // makes a routine recreated under the same id invisible forever.
+            draft.routines.deletedScheduleIds = draft.routines.deletedScheduleIds.filter((id) => id !== action.payload.scheduleId);
+            draft.routineMutation = {
+                fetchState: 'Completed',
+                error: undefined,
+                kind: 'delete',
+            };
+        },
+        deleteRoutineFailure(draft, action) {
+            // The routine still exists and is still emailing. Dropping the tombstone
+            // is what lets the refetch put the row back — leaving it hidden would
+            // tell the user they had stopped something they had not, which is the
+            // worst outcome this list can produce.
+            draft.routines.deletedScheduleIds = draft.routines.deletedScheduleIds.filter((id) => id !== action.payload.scheduleId);
+            // Its own slice: the refetch that puts the row back would otherwise wipe
+            // this error, leaving the row silently reappearing with no explanation.
+            draft.routineMutation = {
+                fetchState: 'Error',
+                error: action.payload.status,
+                kind: 'delete',
+            };
+        },
         fetchSkills(draft) {
             // Read straight off `draft.skills` — no optional chain. This store is never
             // persisted or rehydrated (no redux-persist anywhere in the repo, and no
@@ -898,8 +1153,18 @@ const aiCfoView = createSlice({
                 kind: undefined,
             };
         },
+        openRoutinesBrowser(draft) {
+            draft.uiState.isRoutinesBrowserOpen = true;
+            // The two browsers share the page body, so opening one closes the other.
+            // Leaving both true renders whichever the screen happens to check first.
+            draft.uiState.isSkillsBrowserOpen = false;
+        },
+        closeRoutinesBrowser(draft) {
+            draft.uiState.isRoutinesBrowserOpen = false;
+        },
         openSkillsBrowser(draft) {
             draft.uiState.isSkillsBrowserOpen = true;
+            draft.uiState.isRoutinesBrowserOpen = false;
         },
         closeSkillsBrowser(draft) {
             // Unguarded, unlike the implicit closes: an explicit close should clear a lingering
@@ -918,5 +1183,5 @@ const aiCfoView = createSlice({
         });
     },
 });
-export const { submitQuestion, submitQuestionSuccess, submitQuestionFailure, updateResponseState, updateAiCfoViewScrollPosition, updateCurrentInput, submitFeedback, submitFeedbackSuccess, submitFeedbackFailure, setSession, createSession, createSessionSuccess, createSessionFailure, createSessionAndSubmit, initializeNewSessionState, createSessionAndSubmitSuccess, createSessionAndSubmitFailure, fetchChatSessionsForUser, fetchChatSessionsForUserSuccess, fetchChatSessionsForUserFailure, fetchChatHistory, fetchChatHistorySuccess, fetchChatHistoryFailure, clearCurrentSessionId, clearLastContextMessage, stopSubmit, stopSubmitSuccess, stopSubmitFailure, stopSubmitQuestion, stopSubmitQuestionSuccess, stopSubmitQuestionFailure, acceptMasterTOS, acceptMasterTOSSuccess, acceptMasterTOSFailure, deleteChatSession, deleteChatSessionSuccess, deleteChatSessionFailure, clearDeleteChatSessionStatus, updateCotCollapsedState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, fetchSkillDetail, fetchSkillDetailSuccess, fetchSkillDetailFailure, clearSkillDetail, clearSkillMutation, deleteSkill, deleteSkillSuccess, deleteSkillFailure, fetchSkillVersionBody, fetchSkillVersionBodySuccess, fetchSkillVersionBodyFailure, fetchSkillVersions, fetchSkillVersionsSuccess, fetchSkillVersionsFailure, saveSkill, saveSkillSuccess, saveSkillFailure, setSkillVisibility, setSkillVisibilitySuccess, setSkillVisibilityFailure, openSkillsBrowser, closeSkillsBrowser, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } = aiCfoView.actions;
+export const { acceptMasterTOS, acceptMasterTOSFailure, acceptMasterTOSSuccess, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, clearCurrentSessionId, clearDeleteChatSessionStatus, clearLastContextMessage, clearSkillDetail, clearSkillMutation, closeRoutineRuns, closeRoutinesBrowser, closeSkillsBrowser, createSession, createSessionAndSubmit, createSessionAndSubmitFailure, createSessionAndSubmitSuccess, createSessionFailure, createSessionSuccess, deleteChatSession, deleteChatSessionFailure, deleteChatSessionSuccess, deleteRoutine, deleteRoutineFailure, deleteRoutineSuccess, deleteSkill, deleteSkillFailure, deleteSkillSuccess, fetchChatHistory, fetchChatHistoryFailure, fetchChatHistorySuccess, fetchChatSessionsForUser, fetchChatSessionsForUserFailure, fetchChatSessionsForUserSuccess, fetchRoutineRuns, fetchRoutineRunsFailure, fetchRoutineRunsSuccess, fetchRoutines, fetchRoutinesFailure, fetchRoutinesSuccess, fetchSkillDetail, fetchSkillDetailFailure, fetchSkillDetailSuccess, fetchSkills, fetchSkillsFailure, fetchSkillsSuccess, fetchSkillVersionBody, fetchSkillVersionBodyFailure, fetchSkillVersionBodySuccess, fetchSkillVersions, fetchSkillVersionsFailure, fetchSkillVersionsSuccess, fetchSuggestedQuestions, fetchSuggestedQuestionsFailure, fetchSuggestedQuestionsSuccess, initializeNewSessionState, openRoutinesBrowser, openSkillsBrowser, runRoutine, runRoutineFailure, runRoutineSuccess, saveRoutine, saveRoutineFailure, saveRoutineSuccess, saveSkill, saveSkillFailure, saveSkillSuccess, setRoutineEnabled, setSession, setSkillVisibility, setSkillVisibilityFailure, setSkillVisibilitySuccess, stopSubmit, stopSubmitFailure, stopSubmitQuestion, stopSubmitQuestionFailure, stopSubmitQuestionSuccess, stopSubmitSuccess, submitFeedback, submitFeedbackFailure, submitFeedbackSuccess, submitQuestion, submitQuestionFailure, submitQuestionSuccess, updateAiCfoViewScrollPosition, updateCotCollapsedState, updateCurrentInput, updateResponseState, } = aiCfoView.actions;
 export default aiCfoView.reducer;

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

@@ -64,6 +64,56 @@ const EMPTY_SKILL_MUTATION_STATE = {
     savedMacroId: undefined,
     kind: undefined,
 };
+// Stable fallback, same reasoning as EMPTY_SKILLS_STATE: a fresh literal each
+// call defeats useSelector identity checks and re-renders the list for nothing.
+const EMPTY_ROUTINES_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    routines: [],
+    // 0 withholds "New routine" until the server states the cap. Guessing a number
+    // either blocks a user who is under it or invites one who is over it into a
+    // form that cannot save.
+    maxRoutines: 0,
+    // false, so the Routines entry stays hidden until the server confirms the
+    // feature is on. Defaulting true would flash an entry at tenants without it.
+    routinesEnabled: false,
+    deletedScheduleIds: [],
+};
+const EMPTY_ROUTINE_MUTATION_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    kind: undefined,
+};
+export function getRoutineMutation(state) {
+    return state.aiCfoViewState?.routineMutation ?? EMPTY_ROUTINE_MUTATION_STATE;
+}
+const EMPTY_ROUTINE_RUNS_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    runs: [],
+    scheduleId: null,
+    sessionId: null,
+};
+export function getRoutineRuns(state) {
+    return state.aiCfoViewState?.routineRuns ?? EMPTY_ROUTINE_RUNS_STATE;
+}
+export function getRoutines(state) {
+    return state.aiCfoViewState?.routines ?? EMPTY_ROUTINES_STATE;
+}
+/**
+ * Whether another routine may be created.
+ *
+ * False while the cap is still unknown: offering the control and failing on
+ * save is worse than withholding it for the moment the list takes to load.
+ */
+export function canCreateRoutine(state) {
+    const { maxRoutines, routines } = getRoutines(state);
+    return maxRoutines > 0 && routines.length < maxRoutines;
+}
+/** True only when the server says Routines is on for this tenant. */
+export function getRoutinesEnabled(state) {
+    return getRoutines(state).routinesEnabled;
+}
 export function getSkills(state) {
     return state.aiCfoViewState?.skills ?? EMPTY_SKILLS_STATE;
 }

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

@@ -0,0 +1,35 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../responsePayload';
+import { deleteRoutine, deleteRoutineFailure, deleteRoutineSuccess, fetchRoutines, } from '../aiCfoViewReducer';
+/**
+ * DELETE /1.0/routines/{scheduleId}.
+ *
+ * The row has already left the list by the time this runs — the reducer removes
+ * it optimistically so the click does not feel ignored.
+ *
+ * A failure therefore has to put it BACK, not merely report. The routine still
+ * exists and is still emailing the user their financials on a schedule; leaving
+ * it hidden would tell them they had stopped something they had not. So a
+ * failure drops the tombstone and refetches, and the error explains why the row
+ * returned.
+ */
+export const deleteRoutineEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteRoutine.match), 
+// mergeMap: deleting one routine must not cancel the delete of another.
+mergeMap((action) => {
+    const { scheduleId } = action.payload;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/routines/${encodeURIComponent(scheduleId)}`)
+        .pipe(mergeMap((response) => 
+    // isSuccessStatus, NOT isSuccessResponse: the latter also requires a
+    // non-null `data`, and a successful DELETE here is a 204 with no body.
+    // deleteSkillEpic carries the same note for the same reason — using
+    // the wrong one reported every completed delete as a failure, which
+    // here would also drop the tombstone and refetch the row back.
+    isSuccessStatus(response)
+        ? of(deleteRoutineSuccess({ scheduleId }))
+        : of(deleteRoutineFailure({ scheduleId, status: response.status }), fetchRoutines())), catchError((error) => of(deleteRoutineFailure({
+        scheduleId,
+        status: createZeniAPIStatus('Unexpected Error', 'Delete routine REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }), fetchRoutines())));
+}));

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

@@ -0,0 +1,35 @@
+import { of } from 'rxjs';
+import { catchError, filter, map, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchRoutineRuns, fetchRoutineRunsFailure, fetchRoutineRunsSuccess, } from '../aiCfoViewReducer';
+import { isRoutineRunPayload, toRoutineRun } from './toRoutineRun';
+/**
+ * GET /1.0/routines/{scheduleId}/runs — one routine's run history.
+ *
+ * switchMap: only the history the user has open matters, so expanding a second
+ * routine while the first is still loading should abandon the first rather than
+ * race it into the single slot the state keeps.
+ */
+export const fetchRoutineRunsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchRoutineRuns.match), switchMap((action) => {
+    const { scheduleId } = action.payload;
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/routines/${encodeURIComponent(scheduleId)}/runs`)
+        .pipe(map((response) => {
+        // The explicit `data == null` is what narrows the type — the helper
+        // returns a plain boolean, not a type guard — and it means a
+        // malformed 2xx becomes a failure rather than an empty history,
+        // which would read as "this has never run" when it has.
+        if (!isSuccessResponse(response) || response.data == null) {
+            return fetchRoutineRunsFailure(response.status);
+        }
+        const { data } = response;
+        return fetchRoutineRunsSuccess({
+            // Filtered, not trusted: one malformed row must not take the
+            // whole history down, and a run without an id is not addressable
+            // by anything the UI does with it.
+            runs: (data.runs ?? []).filter(isRoutineRunPayload).map(toRoutineRun),
+            scheduleId,
+            sessionId: data.session_id ?? null,
+        });
+    }), catchError((error) => of(fetchRoutineRunsFailure(createZeniAPIStatus('Unexpected Error', 'Fetch routine runs REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

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

@@ -0,0 +1,37 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchRoutines, fetchRoutinesFailure, fetchRoutinesSuccess, } from '../aiCfoViewReducer';
+import { isRoutinePayload, toRoutine } from './toRoutine';
+/** GET /1.0/routines — the caller's own scheduled runs. */
+export const fetchRoutinesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchRoutines.match), 
+// switchMap: a read. A newer list request makes an older one's answer
+// irrelevant, and letting both land means the older can arrive second and
+// overwrite the newer — which matters here because every write refetches,
+// so two GETs in flight is the normal case rather than the exotic one. It
+// also widens the delete tombstone's race window.
+switchMap(() => zeniAPI
+    .getJSON(`${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/routines`)
+    .pipe(mergeMap((response) => {
+    // The explicit `data == null` is what narrows the type — the
+    // helper returns a plain boolean, not a type guard — and it means a
+    // malformed 2xx becomes a failure rather than a silent empty list,
+    // which would read as "you have no routines" when you do.
+    if (!isSuccessResponse(response) || response.data == null) {
+        return of(fetchRoutinesFailure(response.status));
+    }
+    const { data } = response;
+    return of(fetchRoutinesSuccess({
+        // Malformed rows are dropped, not defaulted into existence: a
+        // routine with no id cannot be opened, paused or deleted, so
+        // rendering one offers controls that cannot work.
+        routines: (data.routines ?? [])
+            .filter(isRoutinePayload)
+            .map(toRoutine),
+        maxRoutines: data.max_routines ?? 0,
+        // Absent reads as OFF, matching the server's fail-closed gate:
+        // an older backend that does not send it should hide the entry,
+        // not show one whose endpoints 404.
+        routinesEnabled: data.routines_enabled === true,
+    }));
+}), catchError((error) => of(fetchRoutinesFailure(createZeniAPIStatus('Unexpected Error', 'Fetch routines REST API call failed', error instanceof Error ? { message: error.message } : undefined)))))));

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

@@ -0,0 +1,34 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus } from '../../../responsePayload';
+import { fetchRoutineRuns, fetchRoutines, runRoutine, runRoutineFailure, runRoutineSuccess, } from '../aiCfoViewReducer';
+/**
+ * POST /1.0/routines/{scheduleId}/run — run a routine now.
+ *
+ * The response says the run was QUEUED, not that it finished: the answer is
+ * emailed a minute or two later. So nothing is spliced in — both refetches are
+ * what show the new run, and the outcome arrives on a later fetch rather than
+ * being polled for.
+ */
+export const runRoutineEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(runRoutine.match), 
+// mergeMap, not exhaustMap: these target different rows, so running one
+// routine must not swallow a request to run another. A double-click on the
+// SAME row is already harmless — the server keys a manual run by the
+// minute, so the second press finds the first run and reports it.
+mergeMap((action) => {
+    const { scheduleId } = action.payload;
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/routines/${encodeURIComponent(scheduleId)}/run`, {})
+        .pipe(mergeMap((response) => 
+    // isSuccessStatus, not isSuccessResponse: "already_running" is a
+    // legitimate 200 whose body carries no routine, and treating a
+    // second press as a failure would be a lie about what happened.
+    isSuccessStatus(response)
+        ? of(runRoutineSuccess(), fetchRoutines(), 
+        // The run history too, or the panel the user is looking at
+        // keeps showing the runs from before they pressed Run. The
+        // new row comes back as claimed/running — the run has been
+        // queued, not finished — which is the honest thing to show.
+        fetchRoutineRuns({ scheduleId }))
+        : of(runRoutineFailure(response.status))), catchError((error) => of(runRoutineFailure(createZeniAPIStatus('Unexpected Error', 'Run routine REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

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

@@ -0,0 +1,65 @@
+import { of } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchRoutines, saveRoutine, saveRoutineFailure, saveRoutineSuccess, } from '../aiCfoViewReducer';
+/**
+ * POST /1.0/routines (create) or PUT /1.0/routines/{scheduleId} (update).
+ *
+ * One epic for both: to a user they are the same act, and the server answers
+ * both with the routine. Splitting them would duplicate the body mapping and
+ * the error handling for a difference the form does not have.
+ */
+export const saveRoutineEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(saveRoutine.match), 
+// exhaustMap, and neither of the obvious two.
+//
+// switchMap is wrong: it cancels the client's subscription, not the request
+// that already left the browser. The routine is still created; the client
+// just stops listening and never tells the user.
+//
+// mergeMap is wrong for the same reason in reverse: a double-clicked Save
+// sends two POSTs, and the user gets two routines that both email them the
+// company's financials on the same schedule.
+//
+// exhaustMap ignores further saves while one is in flight, which is exactly
+// what a submit button should do.
+exhaustMap((action) => {
+    const { draft, scheduleId } = action.payload;
+    const base = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/routines`;
+    const isUpdate = scheduleId != null && scheduleId !== '';
+    const body = {
+        name: draft.name,
+        recurrence: draft.recurrence,
+        hour: draft.hour,
+        minute: draft.minute ?? 0,
+        tz_name: draft.tzName,
+        // Spread rather than sent as null. `weekday` and `day_of_month` are
+        // meaningful only for their own recurrence, and the server validates
+        // that pairing — sending a stale weekday alongside a monthly cadence is
+        // a 400 rather than a field politely ignored.
+        ...(draft.recurrence === 'weekly' &&
+            draft.weekday != null && { weekday: draft.weekday }),
+        ...(draft.recurrence === 'monthly' &&
+            draft.dayOfMonth != null && { day_of_month: draft.dayOfMonth }),
+        ...(draft.enabled != null && { enabled: draft.enabled }),
+        // `macro_id` is create-only: re-sending it on an update would let an
+        // edit silently repoint a schedule at a different skill.
+        ...(!isUpdate && draft.macroId != null && { macro_id: draft.macroId }),
+        // `prompt` is allowed on both. On update the server accepts it only for
+        // a one-off, where it saves a new version of the routine's own
+        // instructions — that is editing what this routine says, not repointing
+        // it at someone else's skill.
+        ...(draft.prompt != null && { prompt: draft.prompt }),
+    };
+    const request$ = isUpdate
+        ? zeniAPI.putAndGetJSON(`${base}/${encodeURIComponent(scheduleId)}`, body)
+        : zeniAPI.postAndGetJSON(base, body);
+    return request$.pipe(mergeMap((response) => {
+        if (!isSuccessResponse(response)) {
+            return of(saveRoutineFailure(response.status));
+        }
+        // Refetch rather than splice the response in: a create changes the
+        // list's ordering, and the server recomputes `next_run_at` on every
+        // write, so a local insert would show a time the next load moves.
+        return of(saveRoutineSuccess(), fetchRoutines());
+    }), catchError((error) => of(saveRoutineFailure(createZeniAPIStatus('Unexpected Error', 'Save routine REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

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

@@ -0,0 +1,28 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchRoutines, saveRoutineFailure, saveRoutineSuccess, setRoutineEnabled, } from '../aiCfoViewReducer';
+/**
+ * PUT /1.0/routines/{scheduleId} with nothing but `enabled`.
+ *
+ * Separate from `saveRoutineEpic` because pausing is not editing. A routine
+ * whose cadence this client version does not recognise has `recurrence: null`
+ * and cannot produce a `RoutineDraft` — and that is precisely the routine
+ * someone most needs to be able to stop. Sending only `enabled` also means a
+ * pause can never rewrite a schedule as a side effect.
+ */
+export const setRoutineEnabledEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(setRoutineEnabled.match), 
+// mergeMap: pausing one routine must not cancel pausing another, and these
+// target different rows so they cannot collide the way two saves of one
+// form would.
+mergeMap((action) => {
+    const { enabled, scheduleId } = action.payload;
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/routines/${encodeURIComponent(scheduleId)}`, { enabled })
+        .pipe(mergeMap((response) => isSuccessResponse(response)
+        ? of(saveRoutineSuccess(), fetchRoutines())
+        : // Refetch on failure too: the switch was flipped optimistically,
+            // and leaving it showing "paused" for a routine that is still
+            // running would be the one lie this list must not tell.
+            of(saveRoutineFailure(response.status), fetchRoutines())), catchError((error) => of(saveRoutineFailure(createZeniAPIStatus('Unexpected Error', 'Set routine enabled REST API call failed', error instanceof Error ? { message: error.message } : undefined)), fetchRoutines())));
+}));