@iblai/web-utils 1.6.1 → 1.6.2

package/dist/index.js

@@ -1016,6 +1016,15 @@ function clearCookies() {
         document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/;Domain=${getParentDomain(window.location.hostname)}`;
     }
 }
+/**
+ * Get the value of a cookie by name
+ * @param name - Cookie name
+ * @returns The cookie value or null if not found
+ */
+function getCookieValue(name) {
+    const match = document.cookie.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`));
+    return match ? decodeURIComponent(match[1]) : null;
+}
 /**
  * Check if user is currently logged in
  * @param tokenKey - The localStorage key for the auth token (default: 'axd_token')
@@ -1080,8 +1089,48 @@ async function redirectToAuthSpa(options) {
         userData: "ibl_user_data",
         tenant: "ibl_tenant",
         logoutTimestamp: "ibl_logout_timestamp",
-    }, } = options;
-    // Clear localStorage
+        loginTimestamp: "ibl_login_timestamp",
+        tenantSwitching: "ibl_tenant_switching",
+    }, hasNonExpiredAuthToken, isOffline, preserveTokenKey, authRedirectProxy, isNativeApp, } = options;
+    console.log("[redirectToAuthSpa] starting redirect to auth spa", redirectTo, platformKey, logout, saveRedirect);
+    // Skip if a tenant switch is already in progress
+    if (cookieNames.tenantSwitching &&
+        document.cookie.includes(cookieNames.tenantSwitching)) {
+        console.log("[redirectToAuthSpa] Tenant switch in progress, skipping redirect");
+        return;
+    }
+    // Skip if a login occurred after the last logout (login takes precedence)
+    // but only if this app actually has a valid auth token
+    if (hasNonExpiredAuthToken &&
+        cookieNames.loginTimestamp &&
+        cookieNames.logoutTimestamp) {
+        const loginTs = getCookieValue(cookieNames.loginTimestamp);
+        const logoutTs = getCookieValue(cookieNames.logoutTimestamp);
+        const hasValidToken = hasNonExpiredAuthToken();
+        console.log("[redirectToAuthSpa] Login/logout timestamp check", {
+            loginTs,
+            logoutTs,
+            hasValidToken,
+            loginAhead: loginTs && logoutTs ? Number(loginTs) > Number(logoutTs) : false,
+        });
+        if (hasValidToken &&
+            loginTs &&
+            logoutTs &&
+            Number(loginTs) > Number(logoutTs)) {
+            console.log("[redirectToAuthSpa] Login timestamp is ahead of logout timestamp, skipping redirect", { loginTs, logoutTs });
+            return;
+        }
+    }
+    // Skip redirect in offline mode
+    if (isOffline === null || isOffline === void 0 ? void 0 : isOffline()) {
+        console.log("[redirectToAuthSpa] Skipping redirect - offline mode");
+        return;
+    }
+    // Preserve a token before clearing localStorage if requested
+    const preservedToken = preserveTokenKey
+        ? window.localStorage.getItem(preserveTokenKey)
+        : null;
+    console.log("[redirectToAuthSpa] clearing local storage");
     localStorage.clear();
     if (logout || isInIframe()) {
         // Delete authentication cookies for cross-SPA synchronization
@@ -1096,7 +1145,7 @@ async function redirectToAuthSpa(options) {
             deleteCookieOnAllDomains(cookieNames.tenant, currentDomain);
         }
         // Set logout timestamp cookie to trigger logout on other SPAs
-        if (cookieNames.logoutTimestamp) {
+        if (cookieNames.logoutTimestamp && !isInIframe()) {
             setCookieForAuth(cookieNames.logoutTimestamp, Date.now().toString());
         }
     }
@@ -1125,8 +1174,22 @@ async function redirectToAuthSpa(options) {
     }
     // Small delay for any pending operations
     await new Promise((resolve) => setTimeout(resolve, 100));
-    // Redirect to auth SPA
-    window.location.href = authRedirectUrl;
+    if (isNativeApp === null || isNativeApp === void 0 ? void 0 : isNativeApp()) {
+        // On native apps (e.g., Tauri), pass preserved token and navigate directly
+        if (preservedToken && preserveTokenKey) {
+            authRedirectUrl += `&token=${encodeURIComponent(preservedToken)}`;
+            console.log("[redirectToAuthSpa] Added preserved token to auth URL");
+        }
+        console.log("[redirectToAuthSpa] Native app, navigating to auth URL:", authRedirectUrl);
+        window.location.href = authRedirectUrl;
+    }
+    else if (authRedirectProxy) {
+        // Use auth redirect proxy endpoint
+        window.location.href = `${authRedirectProxy}?to=${encodeURIComponent(authRedirectUrl)}`;
+    }
+    else {
+        window.location.href = authRedirectUrl;
+    }
 }
 /**
  * Get the URL for joining a tenant (sign up flow)
@@ -17655,6 +17718,570 @@ createApi({
     }),
 });
 
+const CLAW_REDUCER_PATH = 'clawApiSlice';
+const CLAW_TAG_TYPES = [
+    'ClawMentorConfig',
+    'ClawInstances',
+    'AgentConfig',
+    'AgentSkills',
+    'AgentSkillResources',
+    'MentorSkillAssignments',
+];
+const CLAW_ENDPOINTS = {
+    // ── Claw Mentor Config (singular, nested under mentor) ─────────────────────
+    GET_MENTOR_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/claw-config/`,
+        service: SERVICES.DM,
+    },
+    CREATE_MENTOR_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/claw-config/`,
+        service: SERVICES.DM,
+    },
+    UPDATE_MENTOR_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/claw-config/`,
+        service: SERVICES.DM,
+    },
+    DELETE_MENTOR_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/claw-config/`,
+        service: SERVICES.DM,
+    },
+    PUSH_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/claw-config/push-config/`,
+        service: SERVICES.DM,
+    },
+    // ── Claw Instances (unchanged) ─────────────────────────────────────────────
+    GET_INSTANCES: {
+        path: (org) => `/api/ai-mentor/orgs/${org}/claw/instances/`,
+        service: SERVICES.DM,
+    },
+    GET_INSTANCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/claw/instances/${id}/`,
+        service: SERVICES.DM,
+    },
+    CREATE_INSTANCE: {
+        path: (org) => `/api/ai-mentor/orgs/${org}/claw/instances/`,
+        service: SERVICES.DM,
+    },
+    UPDATE_INSTANCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/claw/instances/${id}/`,
+        service: SERVICES.DM,
+    },
+    DELETE_INSTANCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/claw/instances/${id}/`,
+        service: SERVICES.DM,
+    },
+    HEALTH_CHECK_INSTANCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/claw/instances/${id}/health-check/`,
+        service: SERVICES.DM,
+    },
+    TEST_CONNECTIVITY_INSTANCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/claw/instances/${id}/test-connectivity/`,
+        service: SERVICES.DM,
+    },
+    REFRESH_VERSION_INSTANCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/claw/instances/${id}/refresh-version/`,
+        service: SERVICES.DM,
+    },
+    // ── Agent Config (singular, nested under mentor) ───────────────────────────
+    GET_AGENT_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/agent-config/`,
+        service: SERVICES.DM,
+    },
+    /** PATCH is upsert — first write bootstraps the row, no separate POST. */
+    UPDATE_AGENT_CONFIG: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/agent-config/`,
+        service: SERVICES.DM,
+    },
+    // ── Agent Skills (platform-level, unchanged) ───────────────────────────────
+    GET_AGENT_SKILLS: {
+        path: (org) => `/api/ai-mentor/orgs/${org}/agent-skills/`,
+        service: SERVICES.DM,
+    },
+    GET_AGENT_SKILL: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/agent-skills/${id}/`,
+        service: SERVICES.DM,
+    },
+    CREATE_AGENT_SKILL: {
+        path: (org) => `/api/ai-mentor/orgs/${org}/agent-skills/`,
+        service: SERVICES.DM,
+    },
+    UPDATE_AGENT_SKILL: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/agent-skills/${id}/`,
+        service: SERVICES.DM,
+    },
+    DELETE_AGENT_SKILL: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/agent-skills/${id}/`,
+        service: SERVICES.DM,
+    },
+    // ── Agent Skill Resources (file resources attached to skills) ──────────────
+    GET_AGENT_SKILL_RESOURCES: {
+        path: (org) => `/api/ai-mentor/orgs/${org}/agent-skill-resources/`,
+        service: SERVICES.DM,
+    },
+    GET_AGENT_SKILL_RESOURCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/agent-skill-resources/${id}/`,
+        service: SERVICES.DM,
+    },
+    CREATE_AGENT_SKILL_RESOURCE: {
+        path: (org) => `/api/ai-mentor/orgs/${org}/agent-skill-resources/`,
+        service: SERVICES.DM,
+    },
+    UPDATE_AGENT_SKILL_RESOURCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/agent-skill-resources/${id}/`,
+        service: SERVICES.DM,
+    },
+    DELETE_AGENT_SKILL_RESOURCE: {
+        path: (org, id) => `/api/ai-mentor/orgs/${org}/agent-skill-resources/${id}/`,
+        service: SERVICES.DM,
+    },
+    // ── Mentor Skill Assignments (nested under mentor) ─────────────────────────
+    GET_MENTOR_SKILL_ASSIGNMENTS: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/skills/`,
+        service: SERVICES.DM,
+    },
+    CREATE_MENTOR_SKILL_ASSIGNMENT: {
+        path: (org, mentorUniqueId) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/skills/`,
+        service: SERVICES.DM,
+    },
+    GET_MENTOR_SKILL_ASSIGNMENT: {
+        path: (org, mentorUniqueId, assignmentPk) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/skills/${assignmentPk}/`,
+        service: SERVICES.DM,
+    },
+    UPDATE_MENTOR_SKILL_ASSIGNMENT: {
+        path: (org, mentorUniqueId, assignmentPk) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/skills/${assignmentPk}/`,
+        service: SERVICES.DM,
+    },
+    DELETE_MENTOR_SKILL_ASSIGNMENT: {
+        path: (org, mentorUniqueId, assignmentPk) => `/api/ai-mentor/orgs/${org}/mentors/${mentorUniqueId}/skills/${assignmentPk}/`,
+        service: SERVICES.DM,
+    },
+};
+
+/**
+ * Normalize API responses that may return either a plain array or a
+ * paginated envelope `{ results: T[] }`.
+ */
+function normalizeList(response) {
+    return Array.isArray(response) ? response : response.results;
+}
+const clawApiSlice = createApi({
+    reducerPath: CLAW_REDUCER_PATH,
+    baseQuery: iblFetchBaseQuery,
+    tagTypes: [...CLAW_TAG_TYPES],
+    endpoints: (builder) => ({
+        // ── Claw Mentor Config (singular) ─────────────────────────────────────
+        getClawMentorConfig: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_MENTOR_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.GET_MENTOR_CONFIG.service,
+            }),
+            providesTags: (_result, _error, args) => [
+                { type: 'ClawMentorConfig', id: args.mentorUniqueId },
+            ],
+        }),
+        createClawMentorConfig: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.CREATE_MENTOR_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.CREATE_MENTOR_CONFIG.service,
+                method: 'POST',
+                body: {
+                    server: args.server,
+                    ...(args.enabled !== undefined && { enabled: args.enabled }),
+                    ...(args.agent_id !== undefined && { agent_id: args.agent_id }),
+                },
+            }),
+            // Seed the GET cache with the create response and then invalidate so the
+            // subscribed query refetches the joined fields (server_name, status, etc.)
+            // that the POST body doesn't include. The refetch is a 200 — no retry storm.
+            async onQueryStarted({ org, mentorUniqueId }, { dispatch, queryFulfilled }) {
+                try {
+                    const { data } = await queryFulfilled;
+                    dispatch(clawApiSlice.util.upsertQueryData('getClawMentorConfig', { org, mentorUniqueId }, data));
+                }
+                catch (_a) {
+                    // Surface error via the mutation's own error state.
+                }
+            },
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawMentorConfig', id: args.mentorUniqueId },
+            ],
+        }),
+        updateClawMentorConfig: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.UPDATE_MENTOR_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.UPDATE_MENTOR_CONFIG.service,
+                method: 'PATCH',
+                body: {
+                    ...(args.server !== undefined && { server: args.server }),
+                    ...(args.enabled !== undefined && { enabled: args.enabled }),
+                    ...(args.auto_push !== undefined && { auto_push: args.auto_push }),
+                    ...(args.agent_config !== undefined && { agent_config: args.agent_config }),
+                    ...(args.agent_id !== undefined && { agent_id: args.agent_id }),
+                },
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawMentorConfig', id: args.mentorUniqueId },
+            ],
+        }),
+        deleteClawMentorConfig: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.DELETE_MENTOR_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.DELETE_MENTOR_CONFIG.service,
+                method: 'DELETE',
+            }),
+            // Optimistically clear the GET cache before the request resolves so the
+            // UI flips to "not connected" instantly. On failure, invalidate to refetch
+            // the real state. We don't invalidate on success — the GET would 404 and
+            // the base query retries 3× on error, which is the lag the user sees.
+            async onQueryStarted({ org, mentorUniqueId }, { dispatch, queryFulfilled }) {
+                dispatch(clawApiSlice.util.upsertQueryData('getClawMentorConfig', { org, mentorUniqueId }, null));
+                try {
+                    await queryFulfilled;
+                }
+                catch (_a) {
+                    dispatch(clawApiSlice.util.invalidateTags([{ type: 'ClawMentorConfig', id: mentorUniqueId }]));
+                }
+            },
+        }),
+        pushClawConfig: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.PUSH_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.PUSH_CONFIG.service,
+                method: 'POST',
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawMentorConfig', id: args.mentorUniqueId },
+            ],
+        }),
+        // ── Claw Instances ────────────────────────────────────────────────────
+        getClawInstances: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_INSTANCES.path(args.org),
+                service: CLAW_ENDPOINTS.GET_INSTANCES.service,
+            }),
+            transformResponse: (response) => normalizeList(response),
+            providesTags: ['ClawInstances'],
+        }),
+        getClawInstance: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_INSTANCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.GET_INSTANCE.service,
+            }),
+            providesTags: (_result, _error, args) => [{ type: 'ClawInstances', id: args.id }],
+        }),
+        createClawInstance: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.CREATE_INSTANCE.path(args.org),
+                service: CLAW_ENDPOINTS.CREATE_INSTANCE.service,
+                method: 'POST',
+                body: {
+                    name: args.name,
+                    claw_type: args.claw_type,
+                    server_url: args.server_url,
+                    ...(args.gateway_token && { gateway_token: args.gateway_token }),
+                    ...(args.auth_headers && { auth_headers: args.auth_headers }),
+                    ...(args.connection_params && { connection_params: args.connection_params }),
+                    ...(args.deployment_backend !== undefined && {
+                        deployment_backend: args.deployment_backend,
+                    }),
+                },
+            }),
+            invalidatesTags: ['ClawInstances'],
+        }),
+        updateClawInstance: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.UPDATE_INSTANCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.UPDATE_INSTANCE.service,
+                method: 'PATCH',
+                body: {
+                    ...(args.name !== undefined && { name: args.name }),
+                    ...(args.claw_type !== undefined && { claw_type: args.claw_type }),
+                    ...(args.server_url !== undefined && { server_url: args.server_url }),
+                    ...(args.gateway_token && { gateway_token: args.gateway_token }),
+                    ...(args.auth_headers && { auth_headers: args.auth_headers }),
+                    ...(args.connection_params && { connection_params: args.connection_params }),
+                    ...(args.deployment_backend !== undefined && {
+                        deployment_backend: args.deployment_backend,
+                    }),
+                },
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawInstances', id: args.id },
+                'ClawInstances',
+            ],
+        }),
+        deleteClawInstance: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.DELETE_INSTANCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.DELETE_INSTANCE.service,
+                method: 'DELETE',
+            }),
+            invalidatesTags: ['ClawInstances'],
+        }),
+        healthCheckClawInstance: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.HEALTH_CHECK_INSTANCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.HEALTH_CHECK_INSTANCE.service,
+                method: 'POST',
+            }),
+            // Health check updates last_health_check / last_health_status / claw_version
+            // on the instance — invalidate so the list refetches with fresh values.
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawInstances', id: args.id },
+                'ClawInstances',
+            ],
+        }),
+        testConnectivityClawInstance: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.TEST_CONNECTIVITY_INSTANCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.TEST_CONNECTIVITY_INSTANCE.service,
+                method: 'POST',
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawInstances', id: args.id },
+                'ClawInstances',
+            ],
+        }),
+        refreshVersionClawInstance: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.REFRESH_VERSION_INSTANCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.REFRESH_VERSION_INSTANCE.service,
+                method: 'POST',
+            }),
+            // Refresh-version updates the instance's `claw_version` (and may touch
+            // health fields too) — invalidate so the table picks up the new value.
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'ClawInstances', id: args.id },
+                'ClawInstances',
+            ],
+        }),
+        // ── Agent Config (singular, PATCH is upsert) ──────────────────────────
+        getAgentConfig: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_AGENT_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.GET_AGENT_CONFIG.service,
+            }),
+            providesTags: (_result, _error, args) => [{ type: 'AgentConfig', id: args.mentorUniqueId }],
+        }),
+        updateAgentConfig: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.UPDATE_AGENT_CONFIG.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.UPDATE_AGENT_CONFIG.service,
+                method: 'PATCH',
+                body: {
+                    ...(args.identity !== undefined && { identity: args.identity }),
+                    ...(args.soul !== undefined && { soul: args.soul }),
+                    ...(args.user_context !== undefined && { user_context: args.user_context }),
+                    ...(args.tools !== undefined && { tools: args.tools }),
+                    ...(args.agents !== undefined && { agents: args.agents }),
+                    ...(args.bootstrap !== undefined && { bootstrap: args.bootstrap }),
+                    ...(args.heartbeat !== undefined && { heartbeat: args.heartbeat }),
+                    ...(args.memory !== undefined && { memory: args.memory }),
+                    ...(args.model !== undefined && { model: args.model }),
+                    ...(args.config !== undefined && { config: args.config }),
+                },
+            }),
+            // PATCH is upsert and returns the full AgentConfig. Write it straight into
+            // the GET cache so UI subscribers see the new value immediately — relying
+            // on tag invalidation alone leaves a stale window when the prior GET was a
+            // 404 (the entry sits in error state until the refetch completes).
+            async onQueryStarted({ org, mentorUniqueId }, { dispatch, queryFulfilled }) {
+                try {
+                    const { data } = await queryFulfilled;
+                    dispatch(clawApiSlice.util.upsertQueryData('getAgentConfig', { org, mentorUniqueId }, data));
+                }
+                catch (_a) {
+                    // Mutation error surfaces via the hook's own state.
+                }
+            },
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'AgentConfig', id: args.mentorUniqueId },
+            ],
+        }),
+        // ── Agent Skills (platform-level) ─────────────────────────────────────
+        getAgentSkills: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_AGENT_SKILLS.path(args.org),
+                service: CLAW_ENDPOINTS.GET_AGENT_SKILLS.service,
+            }),
+            transformResponse: (response) => normalizeList(response),
+            providesTags: ['AgentSkills'],
+        }),
+        getAgentSkill: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_AGENT_SKILL.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.GET_AGENT_SKILL.service,
+            }),
+            providesTags: (_result, _error, args) => [{ type: 'AgentSkills', id: args.id }],
+        }),
+        createAgentSkill: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.CREATE_AGENT_SKILL.path(args.org),
+                service: CLAW_ENDPOINTS.CREATE_AGENT_SKILL.service,
+                method: 'POST',
+                body: {
+                    name: args.name,
+                    slug: args.slug,
+                    ...(args.description !== undefined && { description: args.description }),
+                    ...(args.version !== undefined && { version: args.version }),
+                    ...(args.instruction !== undefined && { instruction: args.instruction }),
+                    ...(args.metadata !== undefined && { metadata: args.metadata }),
+                    ...(args.enabled !== undefined && { enabled: args.enabled }),
+                },
+            }),
+            invalidatesTags: ['AgentSkills'],
+        }),
+        updateAgentSkill: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.UPDATE_AGENT_SKILL.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.UPDATE_AGENT_SKILL.service,
+                method: 'PATCH',
+                body: {
+                    ...(args.name !== undefined && { name: args.name }),
+                    ...(args.slug !== undefined && { slug: args.slug }),
+                    ...(args.description !== undefined && { description: args.description }),
+                    ...(args.version !== undefined && { version: args.version }),
+                    ...(args.instruction !== undefined && { instruction: args.instruction }),
+                    ...(args.metadata !== undefined && { metadata: args.metadata }),
+                    ...(args.enabled !== undefined && { enabled: args.enabled }),
+                },
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'AgentSkills', id: args.id },
+                'AgentSkills',
+            ],
+        }),
+        deleteAgentSkill: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.DELETE_AGENT_SKILL.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.DELETE_AGENT_SKILL.service,
+                method: 'DELETE',
+            }),
+            invalidatesTags: ['AgentSkills'],
+        }),
+        // ── Agent Skill Resources ─────────────────────────────────────────────
+        getAgentSkillResources: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_AGENT_SKILL_RESOURCES.path(args.org),
+                service: CLAW_ENDPOINTS.GET_AGENT_SKILL_RESOURCES.service,
+                params: {
+                    ...(args.skill !== undefined && { skill: args.skill }),
+                    ...(args.file_type !== undefined && { file_type: args.file_type }),
+                },
+            }),
+            transformResponse: (response) => normalizeList(response),
+            providesTags: ['AgentSkillResources'],
+        }),
+        getAgentSkillResource: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_AGENT_SKILL_RESOURCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.GET_AGENT_SKILL_RESOURCE.service,
+            }),
+            providesTags: (_result, _error, args) => [{ type: 'AgentSkillResources', id: args.id }],
+        }),
+        createAgentSkillResource: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.CREATE_AGENT_SKILL_RESOURCE.path(args.org),
+                service: CLAW_ENDPOINTS.CREATE_AGENT_SKILL_RESOURCE.service,
+                method: 'POST',
+                body: {
+                    skill: args.skill,
+                    file_type: args.file_type,
+                    name: args.name,
+                    ...(args.url !== undefined && { url: args.url }),
+                    ...(args.content !== undefined && { content: args.content }),
+                    ...(args.metadata !== undefined && { metadata: args.metadata }),
+                },
+            }),
+            invalidatesTags: ['AgentSkillResources'],
+        }),
+        updateAgentSkillResource: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.UPDATE_AGENT_SKILL_RESOURCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.UPDATE_AGENT_SKILL_RESOURCE.service,
+                method: 'PATCH',
+                body: {
+                    ...(args.skill !== undefined && { skill: args.skill }),
+                    ...(args.file_type !== undefined && { file_type: args.file_type }),
+                    ...(args.name !== undefined && { name: args.name }),
+                    ...(args.url !== undefined && { url: args.url }),
+                    ...(args.content !== undefined && { content: args.content }),
+                    ...(args.metadata !== undefined && { metadata: args.metadata }),
+                },
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'AgentSkillResources', id: args.id },
+                'AgentSkillResources',
+            ],
+        }),
+        deleteAgentSkillResource: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.DELETE_AGENT_SKILL_RESOURCE.path(args.org, args.id),
+                service: CLAW_ENDPOINTS.DELETE_AGENT_SKILL_RESOURCE.service,
+                method: 'DELETE',
+            }),
+            invalidatesTags: ['AgentSkillResources'],
+        }),
+        // ── Mentor Skill Assignments (nested under mentor) ────────────────────
+        getMentorSkillAssignments: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_MENTOR_SKILL_ASSIGNMENTS.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.GET_MENTOR_SKILL_ASSIGNMENTS.service,
+            }),
+            transformResponse: (response) => normalizeList(response),
+            providesTags: (_result, _error, args) => [
+                { type: 'MentorSkillAssignments', id: args.mentorUniqueId },
+            ],
+        }),
+        getMentorSkillAssignment: builder.query({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.GET_MENTOR_SKILL_ASSIGNMENT.path(args.org, args.mentorUniqueId, args.assignmentPk),
+                service: CLAW_ENDPOINTS.GET_MENTOR_SKILL_ASSIGNMENT.service,
+            }),
+            providesTags: (_result, _error, args) => [
+                { type: 'MentorSkillAssignments', id: args.assignmentPk },
+            ],
+        }),
+        createMentorSkillAssignment: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.CREATE_MENTOR_SKILL_ASSIGNMENT.path(args.org, args.mentorUniqueId),
+                service: CLAW_ENDPOINTS.CREATE_MENTOR_SKILL_ASSIGNMENT.service,
+                method: 'POST',
+                body: {
+                    skill: args.skill,
+                    ...(args.enabled !== undefined && { enabled: args.enabled }),
+                },
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'MentorSkillAssignments', id: args.mentorUniqueId },
+            ],
+        }),
+        updateMentorSkillAssignment: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.UPDATE_MENTOR_SKILL_ASSIGNMENT.path(args.org, args.mentorUniqueId, args.assignmentPk),
+                service: CLAW_ENDPOINTS.UPDATE_MENTOR_SKILL_ASSIGNMENT.service,
+                method: 'PATCH',
+                body: {
+                    ...(args.enabled !== undefined && { enabled: args.enabled }),
+                },
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'MentorSkillAssignments', id: args.mentorUniqueId },
+            ],
+        }),
+        deleteMentorSkillAssignment: builder.mutation({
+            query: (args) => ({
+                url: CLAW_ENDPOINTS.DELETE_MENTOR_SKILL_ASSIGNMENT.path(args.org, args.mentorUniqueId, args.assignmentPk),
+                service: CLAW_ENDPOINTS.DELETE_MENTOR_SKILL_ASSIGNMENT.service,
+                method: 'DELETE',
+            }),
+            invalidatesTags: (_result, _error, args) => [
+                { type: 'MentorSkillAssignments', id: args.mentorUniqueId },
+            ],
+        }),
+    }),
+});
+
 const CUSTOM_DOMAIN_REDUCER_PATH = 'customDomainApiSlice';
 const CUSTOM_DOMAIN_ENDPOINTS = {
     GET_CUSTOM_DOMAINS: {
@@ -24064,6 +24691,7 @@ exports.filesReducer = filesReducer;
 exports.filesSlice = filesSlice;
 exports.formatRelativeTime = formatRelativeTime;
 exports.getAuthSpaJoinUrl = getAuthSpaJoinUrl;
+exports.getCookieValue = getCookieValue;
 exports.getDomainParts = getDomainParts;
 exports.getFileInfo = getFileInfo;
 exports.getInitials = getInitials;