@zeniai/client-epic-state 5.2.4 → 5.2.5

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

@@ -29,7 +29,56 @@ const EMPTY_SKILLS_STATE = {
     fetchState: 'Not-Started',
     error: undefined,
     skills: [],
+    // false, so the Skills entry stays hidden until the server confirms the feature
+    // is on. Defaulting true would flash a menu at tenants who never get one.
+    skillsEnabled: false,
+    // false, for the same reason as skillsEnabled: withhold the publish control until the
+    // server says this user may use it.
+    canPublish: false,
+    deletedMacroIds: [],
+};
+const EMPTY_SKILL_DETAIL_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    detail: undefined,
+    macroId: undefined,
+};
+// Same stable-fallback reason as the two above: a selector that built a fresh object
+// each call would re-render every subscriber on every unrelated state change.
+const EMPTY_SKILL_VERSIONS_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    versions: [],
+    macroId: undefined,
+};
+const EMPTY_SKILL_VERSION_BODY_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    instructions: undefined,
+    macroId: undefined,
+    version: undefined,
+};
+const EMPTY_SKILL_MUTATION_STATE = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    savedMacroId: undefined,
 };
 export function getSkills(state) {
     return state.aiCfoViewState?.skills ?? EMPTY_SKILLS_STATE;
 }
+export function getSkillDetail(state) {
+    return state.aiCfoViewState?.skillDetail ?? EMPTY_SKILL_DETAIL_STATE;
+}
+export function getSkillVersions(state) {
+    return state.aiCfoViewState?.skillVersions ?? EMPTY_SKILL_VERSIONS_STATE;
+}
+export function getSkillVersionBody(state) {
+    return (state.aiCfoViewState?.skillVersionBody ?? EMPTY_SKILL_VERSION_BODY_STATE);
+}
+export function getSkillMutation(state) {
+    return state.aiCfoViewState?.skillMutation ?? EMPTY_SKILL_MUTATION_STATE;
+}
+/** True only when the server says the feature is on for this tenant. */
+export function getSkillsEnabled(state) {
+    return getSkills(state).skillsEnabled;
+}

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

@@ -0,0 +1,23 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessStatus } from '../../../responsePayload';
+import { deleteSkill, deleteSkillFailure, deleteSkillSuccess, } from '../aiCfoViewReducer';
+/** DELETE /1.0/skills/{macroId} — soft-deletes every version, frees the name. */
+export const deleteSkillEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteSkill.match), 
+// mergeMap for the same reason as the save: cancelling a delete does not un-delete
+// it, and two deletes are for different skills anyway.
+mergeMap((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}`;
+    return zeniAPI.deleteAndGetJSON(url).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. Using it reported
+        // every completed delete as a failure — the row stayed on screen and a retry
+        // 404'd on a skill that was already gone. deleteChatSessionEpic uses the status
+        // check for the same reason.
+        if (isSuccessStatus(response)) {
+            return of(deleteSkillSuccess({ macroId }));
+        }
+        return of(deleteSkillFailure(response.status));
+    }), catchError((error) => of(deleteSkillFailure(createZeniAPIStatus('Unexpected Error', 'Delete skill REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

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

@@ -0,0 +1,35 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillDetail, fetchSkillDetailFailure, fetchSkillDetailSuccess, } from '../aiCfoViewReducer';
+import { isSkillDetailPayload, toSkillDetail } from './toSkillDetail';
+// Deliberately minimal: the browser already holds the full Skill from the list, and
+// this response's `skill` block exists so a deep link can open a detail view without
+// the list ever having been fetched.
+/** GET {aiCfoMicroServiceBaseUrl}/1.0/skills/{macroId} — one skill's prompt + card. */
+export const fetchSkillDetailEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSkillDetail.match), 
+// switchMap: clicking through the list fires one of these per skill, and only the
+// one the user is currently looking at matters. The reducer also drops responses
+// whose macroId no longer matches, so a cancelled-but-in-flight request cannot
+// render the wrong prompt under the right title.
+switchMap((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        // Shared mapper and shared guard. This epic used to keep its own `toSkill`
+        // and default a missing prompt to '', so the same malformed body showed an
+        // empty prompt here and failed the read elsewhere — and `isMine` was nearly
+        // added to only two of the three copies.
+        if (isSuccessResponse(response) &&
+            isSkillDetailPayload(response.data)) {
+            return of(fetchSkillDetailSuccess({
+                detail: toSkillDetail(response.data),
+                macroId,
+            }));
+        }
+        return of(fetchSkillDetailFailure({ error: response.status, macroId }));
+    }), catchError((error) => of(fetchSkillDetailFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch skill detail REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+        macroId,
+    }))));
+}));

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

@@ -0,0 +1,45 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillVersionBody, fetchSkillVersionBodyFailure, fetchSkillVersionBodySuccess, } from '../aiCfoViewReducer';
+import { hasPromptBody } from './toSkillDetail';
+/**
+ * GET /1.0/skills/{macroId}?version=N — one historical version's prompt.
+ *
+ * Only used to seed a restore. The history list carries metadata only, deliberately: a
+ * 20-version history would otherwise be a 240kB response for a panel that shows dates.
+ */
+export const fetchSkillVersionBodyEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSkillVersionBody.match), 
+// switchMap: a read, and only the version the user last clicked matters. The reducer
+// also drops a response whose (macroId, version) no longer matches, so a
+// cancelled-but-in-flight request cannot seed the form with the wrong body.
+switchMap((action) => {
+    const { macroId, version } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}?version=${encodeURIComponent(String(version))}`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        // `instructions` checked, not just `data`: the payload TYPE says the field is
+        // required, and the network is under no obligation to agree. Without this the
+        // epic reported success with `instructions: undefined`, and the browser — which
+        // holds the editor closed until a body arrives — showed "Loading this version…"
+        // for ever, with no error and no way forward.
+        if (isSuccessResponse(response) && hasPromptBody(response.data)) {
+            return of(fetchSkillVersionBodySuccess({
+                macroId,
+                version,
+                instructions: response.data.instructions,
+            }));
+        }
+        // A malformed 2xx is a failure. An empty STRING is not malformed and is allowed
+        // through: the editor's own minimum-length rule refuses to save it, so the user
+        // sees a validation message on a form they can fix rather than a dead end.
+        return of(fetchSkillVersionBodyFailure({
+            macroId,
+            version,
+            error: response.status,
+        }));
+    }), catchError((error) => of(fetchSkillVersionBodyFailure({
+        macroId,
+        version,
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch skill version body REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }))));
+}));

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

@@ -0,0 +1,37 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillVersions, fetchSkillVersionsFailure, fetchSkillVersionsSuccess, } from '../aiCfoViewReducer';
+const toVersion = (payload) => ({
+    version: payload.version,
+    semver: payload.semver ?? null,
+    displayName: payload.display_name ?? null,
+    updatedAt: payload.updated_at ?? null,
+    // Defaulted defensively: these are booleans the server always sends, but a malformed
+    // 2xx should render a row as inactive-and-not-latest rather than as the live one.
+    isActive: payload.is_active === true,
+    isLatest: payload.is_latest === true,
+    instructionsCharCount: payload.instructions_char_count ?? 0,
+});
+/** GET /1.0/skills/{macroId}/versions — the history panel. */
+export const fetchSkillVersionsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchSkillVersions.match), 
+// switchMap: a read, and only the skill currently open matters. The reducer also
+// drops responses whose macroId no longer matches, so a cancelled-but-in-flight
+// request cannot render one skill's history under another's title.
+switchMap((action) => {
+    const { macroId } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}/versions`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(fetchSkillVersionsSuccess({
+                macroId,
+                // Guard the array: a malformed 2xx without `versions` must not crash .map.
+                versions: (response.data.versions ?? []).map(toVersion),
+            }));
+        }
+        return of(fetchSkillVersionsFailure({ macroId, error: response.status }));
+    }), catchError((error) => of(fetchSkillVersionsFailure({
+        macroId,
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch skill versions REST API call failed', error instanceof Error ? { message: error.message } : undefined),
+    }))));
+}));

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

@@ -2,6 +2,7 @@ import { of } from 'rxjs';
 import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
 import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
 import { fetchSkills, fetchSkillsFailure, fetchSkillsSuccess, } from '../aiCfoViewReducer';
+import { toBaseSkill } from './toSkillDetail';
 const isNonBlankString = (value) => typeof value === 'string' && value.trim() !== '';
 // parameter_hints is a free-form {param: exampleValue(s)} map; flatten its non-blank
 // string values (a single string or an array of them) into display-ready "try: …"
@@ -27,14 +28,12 @@ const toExampleHints = (parameterHints) => {
     // a broken duplicate to the user — dedupe across parameter keys and array entries.
     return Array.from(new Set(hints));
 };
+// Only the LIST route returns parameter_hints, so this is the one call site that has
+// hints to spread in. Everything else about a summary comes from the shared base mapper,
+// so a new `Skill` field cannot land here and be missed on the detail path.
 const toSkill = (skillSummaryPayload) => ({
-    macroId: skillSummaryPayload.macro_id,
-    name: skillSummaryPayload.name,
-    displayName: skillSummaryPayload.display_name,
-    description: skillSummaryPayload.description,
-    semver: skillSummaryPayload.semver,
+    ...toBaseSkill(skillSummaryPayload),
     exampleHints: toExampleHints(skillSummaryPayload.parameter_hints),
-    hasScripts: skillSummaryPayload.has_scripts,
 });
 /** GET {aiCfoMicroServiceBaseUrl}/1.0/skills — chat-visible skills for the `/` menu. */
 export const fetchSkillsEpic = (actions$, 
@@ -52,6 +51,12 @@ switchMap(() => {
             // Guard the array: a malformed 2xx body without `skills` must not crash .map.
             return of(fetchSkillsSuccess({
                 skills: (response.data.skills ?? []).map(toSkill),
+                // === true, not a truthy check: a body missing the field entirely
+                // must read as "off" so the Skills entry stays hidden by default.
+                skillsEnabled: response.data.skills_enabled === true,
+                // Same discipline: a body without the field must withhold the publish
+                // control, not grant it.
+                canPublish: response.data.can_publish === true,
             }));
         }
         return of(fetchSkillsFailure(response.status));

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

@@ -0,0 +1,72 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkillVersions, fetchSkills, saveSkill, saveSkillFailure, saveSkillSuccess, } from '../aiCfoViewReducer';
+import { getSkillDetail } from '../aiCfoViewSelector';
+import { isSkillDetailPayload, toSkillDetail } from './toSkillDetail';
+/**
+ * POST /1.0/skills (create) or PUT /1.0/skills/{macroId} (new version).
+ *
+ * One epic for both because they are the same action to a user — "save what I wrote" —
+ * and the server answers both with the detail payload. Splitting them would duplicate
+ * the payload mapping and the error handling for a difference the form does not have.
+ */
+export const saveSkillEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(saveSkill.match), 
+// mergeMap, NOT switchMap: a save is a write. Cancelling an in-flight one because
+// another started does not un-send it, it just hides the outcome — and for a
+// create that means a skill exists that the user was never told about.
+mergeMap((action) => {
+    const { draft, macroId } = action.payload;
+    const base = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills`;
+    const body = {
+        name: draft.name,
+        instructions: draft.instructions,
+        description: draft.description,
+        // Sent as the menu name too. The server derives the unique `/` slug from it, so
+        // letting the two drift would make the command stop matching the row's title.
+        display_name: draft.name,
+        // Spread, not `visibility: draft.visibility`: the server distinguishes an ABSENT
+        // visibility ("leave it alone") from an explicit null or 'private' ("make it
+        // private"). Sending the key with a null value would unpublish a tenant-wide
+        // skill on any edit by someone who cannot publish.
+        //
+        // `!= null`, not `!== null`: the type says this is always present, but the value
+        // arrives from a component, and an untyped caller omitting it would spread
+        // `{visibility: undefined}` — a key present with no value, which is the one shape
+        // the rule above is about. The looser check costs nothing and closes it.
+        ...(draft.visibility != null && { visibility: draft.visibility }),
+    };
+    const request$ = macroId != null && macroId !== ''
+        ? zeniAPI.putAndGetJSON(`${base}/${encodeURIComponent(macroId)}`, body)
+        : zeniAPI.postAndGetJSON(base, body);
+    return request$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            isSkillDetailPayload(response.data)) {
+            const saved = response.data;
+            const savedMacroId = saved.skill.macro_id;
+            const emitted = [
+                saveSkillSuccess({
+                    macroId: savedMacroId,
+                    // The response is a full detail read — carried through so an editor left
+                    // on this skill shows what it just saved rather than the previous prompt.
+                    detail: toSkillDetail(saved),
+                }),
+                // Refetch rather than splice the response in: a create changes the list's
+                // ordering and an update can change the name it is sorted by, so a local
+                // insert would put the row somewhere the next load moves it away from.
+                fetchSkills(),
+            ];
+            // A save adds a version, so the history panel is one behind — but only
+            // refetch when this skill is still the one on screen. `fetchSkillVersions`
+            // takes ownership of the versions slice, so firing it for a skill the user
+            // has already left would cancel the history of whatever they opened next.
+            if (getSkillDetail(state$.value).macroId === savedMacroId) {
+                emitted.push(fetchSkillVersions({ macroId: savedMacroId }));
+            }
+            return of(...emitted);
+        }
+        // A malformed 2xx is a failure, not a silent success: reporting "saved" when
+        // no skill came back leaves the user believing work was persisted.
+        return of(saveSkillFailure(response.status));
+    }), catchError((error) => of(saveSkillFailure(createZeniAPIStatus('Unexpected Error', 'Save skill REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

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

@@ -0,0 +1,32 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchSkills, setSkillVisibility, setSkillVisibilityFailure, setSkillVisibilitySuccess, } from '../aiCfoViewReducer';
+import { isSkillDetailPayload, toSkillDetail } from './toSkillDetail';
+/**
+ * PUT /1.0/skills/{macroId}/visibility — publish or unpublish, without a new version.
+ *
+ * Its own route rather than the prompt PUT: that one requires name and instructions, so a
+ * visibility-only change cannot be expressed through it, and sending the whole prompt back
+ * to flip one field would create a version whose prompt is identical to its parent's.
+ */
+export const setSkillVisibilityEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(setSkillVisibility.match), 
+// mergeMap, like the other writes: cancelling a write in flight does not un-send it,
+// it only hides the outcome — and for a publish that means a skill sitting in every
+// colleague's menu with nobody told it got there.
+mergeMap((action) => {
+    const { macroId, visibility } = action.payload;
+    const url = `${zeniAPI.apiEndPoints.aiCfoMicroServiceBaseUrl}/1.0/skills/${encodeURIComponent(macroId)}/visibility`;
+    return zeniAPI.putAndGetJSON(url, { visibility }).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) &&
+            isSkillDetailPayload(response.data)) {
+            return of(setSkillVisibilitySuccess({
+                macroId,
+                detail: toSkillDetail(response.data),
+            }), 
+            // The list carries the badge that shows the audience, so it is now stale.
+            fetchSkills());
+        }
+        return of(setSkillVisibilityFailure(response.status));
+    }), catchError((error) => of(setSkillVisibilityFailure(createZeniAPIStatus('Unexpected Error', 'Set skill visibility REST API call failed', error instanceof Error ? { message: error.message } : undefined)))));
+}));

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

@@ -0,0 +1,102 @@
+/**
+ * Every value `SkillVisibility` admits, as data so the converter below cannot drift from
+ * the type. Adding a tier to the union without adding it here is a compile error.
+ */
+const SKILL_VISIBILITIES = ['private', 'tenant'];
+/**
+ * A wire string narrowed to {@link SkillVisibility}, or null.
+ *
+ * A converter rather than passing the raw string through, because `Skill.visibility` is a
+ * union on the state type and this is the boundary where an unvalidated payload becomes
+ * it — the repo's rule about explicit converters at scalar boundaries instead of a bare
+ * cast.
+ *
+ * Unrecognised maps to NULL, not to `'private'`. Null already means "does not apply" for a
+ * Zeni default, and consumers show no audience badge for it — so an unknown tier renders
+ * as no badge. Defaulting to `'private'` would instead label a skill the whole tenant can
+ * run as author-only, which is a confident lie rather than a visible gap.
+ */
+export const toSkillVisibility = (raw) => SKILL_VISIBILITIES.find((known) => known === raw) ?? null;
+/**
+ * Everything about a skill summary EXCEPT `exampleHints`, which no shared mapper can
+ * honestly supply.
+ *
+ * Only the LIST route returns `parameter_hints`; the detail and write routes do not. A
+ * shared mapper hardcoding `exampleHints: []` would put a "try: …" line under a skill
+ * that has hints, or drop them from the menu — so the field is `Omit`ted and each caller
+ * spreads in what its own route actually knows.
+ *
+ * Returning `Omit<Skill, 'exampleHints'>` rather than duplicating the mapper is what
+ * makes a new `Skill` field land in one place: this function stops compiling until the
+ * field is mapped, and both callers inherit it. The previous shape — two full copies —
+ * is how `isMine` was nearly added to only one of them, which would have silently
+ * withheld the edit and delete controls on whichever surface was missed.
+ */
+export const toBaseSkill = (payload) => ({
+    macroId: payload.macro_id,
+    name: payload.name,
+    displayName: payload.display_name,
+    description: payload.description,
+    semver: payload.semver,
+    hasScripts: payload.has_scripts === true,
+    // === true, so an absent field withholds the write controls rather than offering ones
+    // the API refuses.
+    isMine: payload.is_mine === true,
+    isOwnedByTenant: payload.is_owned_by_tenant === true,
+    updatedAt: payload.updated_at ?? null,
+    visibility: toSkillVisibility(payload.visibility),
+});
+/**
+ * Whether a 2xx body carries a prompt.
+ *
+ * Narrows to {@link PromptBody} and NOT to the whole payload, because the only consumer —
+ * the version-body read — dereferences `instructions` and nothing else. Asserting the
+ * whole shape here would claim `skill` was checked when it was not, and tying the read to
+ * it would fail a response whose prompt was fine and whose `skill` block was malformed,
+ * which is exactly what happened when this was one predicate instead of two.
+ *
+ * Takes `unknown`: the input is an unvalidated network body, and typing the parameter as
+ * the payload interface would assume the very thing being checked.
+ */
+export const hasPromptBody = (data) => typeof data?.instructions ===
+    'string';
+/**
+ * Whether a 2xx body can build a whole {@link SkillDetail}.
+ *
+ * Narrows to the payload type itself, which is now truthful: the two fields this checks
+ * are the two the interface still declares required, and the other three are optional
+ * there. Stricter than {@link hasPromptBody} by exactly one field. Four epics read this shape
+ * and each used to guard it differently — `data != null`, `data?.skill != null`, and a
+ * real `instructions` check — so one malformed response became a failure in one place, an
+ * empty prompt in another, and `undefined` in a third.
+ */
+export const isSkillDetailPayload = (data) => hasPromptBody(data) && data.skill != null;
+/**
+ * The detail payload every write route answers with.
+ *
+ * Shared because three epics need it — save, visibility, and the detail read — and a
+ * fourth copy is how one of them quietly stops carrying a field the others do.
+ *
+ * The coercions are not defensive habit; the payload type makes them mandatory — the
+ * three optional fields cannot be assigned to a non-optional `SkillDetail` without one.
+ * Which fields get coerced and which do not is the deliberate part:
+ *
+ * - `instructions` is load-bearing and already proven, so it passes through. Defaulting a
+ *   missing prompt to `''` is the one thing this module exists to prevent: the user
+ *   cannot tell an empty prompt from a skill that has one, and may save over the real
+ *   thing.
+ * - `instructionsCharCount` falls back to the prompt's own length, NOT to 0. A 12,000
+ *   character prompt displayed as "0 characters" is a lie the user can see, and the
+ *   prompt is right here to measure. Approximate only for astral-plane characters, where
+ *   UTF-16 units and the server's count differ — a rounding error, against a guaranteed
+ *   wrong answer.
+ * - `artifact` and `artifactTitle` degrade to empty. They render a preview card, so
+ *   losing them costs a card; failing the whole read would cost the user the skill.
+ */
+export const toSkillDetail = (payload) => ({
+    skill: { ...toBaseSkill(payload.skill), exampleHints: [] },
+    instructions: payload.instructions,
+    instructionsCharCount: payload.instructions_char_count ?? payload.instructions.length,
+    artifact: payload.artifact ?? '',
+    artifactTitle: payload.artifact_title ?? '',
+});

package/lib/index.d.ts

@@ -968,12 +968,12 @@ export { AiAccountantCustomerViewState, AiAccountantSortKey, AiAccountantUIState
 export { AiAccountantFilterCategoryField } from './view/companyView/types/cockpitTypes';
 export { cancelAiAccountantOnboarding, fetchAiAccountantCustomers, fetchAiAccountantJobs, setSelectedTenantIdsForJobTrigger, triggerAiAccountantJob, updateAiAccountantUIState, } from './view/aiAccountantView/aiAccountantViewReducer';
 export { AiAccountantCockpitView, getAiAccountantCockpitView, } from './view/aiAccountantView/aiAccountantViewSelector';
-export { fetchChatSessionsForUser, createSession, submitQuestion, updateAiCfoViewScrollPosition, updateCurrentInput, updateCotCollapsedState, setSession, clearCurrentSessionId, clearDeleteChatSessionStatus, clearLastContextMessage, createSessionAndSubmit, stopSubmit, stopSubmitQuestion, fetchChatHistory, acceptMasterTOS, deleteChatSession, submitFeedback, updateResponseState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } from './view/aiCfoView/aiCfoViewReducer';
-export { AiCfoViewState, AiCfoViewUIState, Skill, SkillsState, SuggestedQuestionsForPageContext, } from './view/aiCfoView/aiCfoViewState';
+export { fetchChatSessionsForUser, createSession, submitQuestion, updateAiCfoViewScrollPosition, updateCurrentInput, updateCotCollapsedState, setSession, clearCurrentSessionId, clearDeleteChatSessionStatus, clearLastContextMessage, createSessionAndSubmit, stopSubmit, stopSubmitQuestion, fetchChatHistory, acceptMasterTOS, deleteChatSession, submitFeedback, updateResponseState, fetchSuggestedQuestions, fetchSuggestedQuestionsSuccess, fetchSuggestedQuestionsFailure, fetchSkills, fetchSkillsSuccess, fetchSkillsFailure, fetchSkillDetail, clearSkillDetail, clearSkillMutation, deleteSkill, fetchSkillVersionBody, fetchSkillVersions, saveSkill, setSkillVisibility, openSkillsBrowser, closeSkillsBrowser, applyAiCfoSidePanelHostPageTransition, clearAiCfoSidePanelHostPageContext, } from './view/aiCfoView/aiCfoViewReducer';
+export { AiCfoViewState, AiCfoViewUIState, Skill, SkillDetail, SkillDetailState, SkillDraft, SkillMutationState, SkillVersion, SkillVersionBodyState, SkillVersionsState, SkillVisibility, SkillsState, SuggestedQuestionsForPageContext, } from './view/aiCfoView/aiCfoViewState';
 export { FetchSuggestedQuestionsResponse, SuggestedQuestionsDataPayload, FetchSkillsResponse, SkillSummaryPayload, SkillListDataPayload, } from './view/aiCfoView/aiCfoViewPayload';
 export type { FeedbackType, SubmitFeedbackPayload, } from './view/aiCfoView/aiCfoViewPayload';
 export type { AiCfoSuggestedQuestionsPageContext } from './common/aiCfo/aiCfoSuggestedQuestionsPageContext';
-export { AiCfoViewSelector, getAiCfoView, getSuggestedQuestionsForPageContext, getSkills, } from './view/aiCfoView/aiCfoViewSelector';
+export { AiCfoViewSelector, getAiCfoView, getSuggestedQuestionsForPageContext, getSkills, getSkillDetail, getSkillMutation, getSkillVersionBody, getSkillVersions, getSkillsEnabled, } from './view/aiCfoView/aiCfoViewSelector';
 export { MessagePayload, ChatSessionPayload, AiCfoAnswerPayload, } from './entity/aiCfo/aiCfoPayload';
 export { setNewSession, setSessions, updateAiCfoAnswerCardPolicyWizardPlan, upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, addQuestionPayload, clearSession, toAiCfoExports, toAiCfoVisualization, appendSyntheticAiCfoAnswer, updateSyntheticAiCfoAnswer, removeSyntheticAiCfoAnswer, } from './entity/aiCfo/aiCfoReducer';
 export { AiCfoSelectorView, getAllQuestionAnswersForChatSession, getQuestionAnswerByIdForChatSession, getAllQuestionsForChatSession, getAiCfoSelectorView, getSyntheticAiCfoAnswersForChatSession, getSyntheticAiCfoAnswerByQuestionAnswerId, ChatSessionWithOrderedQuestionAnswers, } from './entity/aiCfo/aiCfoSelector';