@redacto.io/consent-sdk-react 3.6.0 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redacto.io/consent-sdk-react",
-  "version": "3.6.0",
+  "version": "5.0.0",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",

package/src/RedactoNoticeConsent/RedactoNoticeConsent.tsx

@@ -32,7 +32,7 @@ import logo from "./assets/redacto-logo.png";
 
 // Constants
 import { DPO_AUDIO_ELEMENT_MAP } from "./constants";
-import { toBcp47Code } from "./language-codes";
+import { toBcp47Code, toNativeLabel } from "./language-codes";
 
 // Utility imports
 import { injectCheckboxStyles } from "./injectStyles";
@@ -3780,9 +3780,9 @@ export const RedactoNoticeConsent = ({
                           aria-expanded={isLanguageDropdownOpen}
                           aria-haspopup="listbox"
                           aria-controls="language-listbox"
-                          aria-label={`Select language. Current language: ${selectedLanguage}`}
+                          aria-label={`Select language. Current language: ${toNativeLabel(selectedLanguage)}`}
                         >
-                          {selectedLanguage}
+                          {toNativeLabel(selectedLanguage)}
                           <svg
                             xmlns="http://www.w3.org/2000/svg"
                             width="16"
@@ -3829,9 +3829,9 @@ export const RedactoNoticeConsent = ({
                             role="option"
                             aria-selected={selectedLanguage === lang}
                             tabIndex={0}
-                            aria-label={`Select ${lang} language`}
+                            aria-label={`Select ${toNativeLabel(lang)} language`}
                           >
-                            {lang}
+                            {toNativeLabel(lang)}
                           </li>
                         ))}
                       </ul>

package/src/RedactoNoticeConsent/language-codes.ts

@@ -1,3 +1,38 @@
+/**
+ * Maps English language names to "Native script (English)" display labels.
+ * English itself is kept as-is; all others show the native script first.
+ */
+export const LANGUAGE_NATIVE_LABELS: Record<string, string> = {
+  English: "English",
+  Assamese: "অসমীয়া (Assamese)",
+  Bengali: "বাংলা (Bengali)",
+  Bhojpuri: "भोजपुरी (Bhojpuri)",
+  Bodo: "बड़ो (Bodo)",
+  Dogri: "डोगरी (Dogri)",
+  Gujarati: "ગુજરાતી (Gujarati)",
+  Hindi: "हिन्दी (Hindi)",
+  Kannada: "ಕನ್ನಡ (Kannada)",
+  Kashmiri: "كٲشُر (Kashmiri)",
+  "Goan Konkani": "कोंकणी (Goan Konkani)",
+  Maithili: "मैथिली (Maithili)",
+  Malayalam: "മലയാളം (Malayalam)",
+  Manipuri: "ꯃꯩꯇꯩꯂꯣꯟ (Manipuri)",
+  Marathi: "मराठी (Marathi)",
+  Nepali: "नेपाली (Nepali)",
+  Odia: "ଓଡ଼ିଆ (Odia)",
+  Punjabi: "ਪੰਜਾਬੀ (Punjabi)",
+  Sanskrit: "संस्कृतम् (Sanskrit)",
+  Santali: "ᱥᱟᱱᱛᱟᱲᱤ (Santali)",
+  Sindhi: "سنڌي (Sindhi)",
+  Tamil: "தமிழ் (Tamil)",
+  Telugu: "తెలుగు (Telugu)",
+  Urdu: "اردو (Urdu)",
+};
+
+/** Returns the "Native (English)" display label for a language name, falling back to the name itself. */
+export const toNativeLabel = (name: string): string =>
+  LANGUAGE_NATIVE_LABELS[name] ?? name;
+
 /**
  * Maps display language names (as used in supported_languages_and_translations
  * keys and the language dropdown) to BCP-47 codes for the submit-consent payload.
@@ -9,13 +44,14 @@ const LANGUAGE_NAME_TO_BCP47: Record<string, string> = {
   English: "en",
   Assamese: "as",
   Bengali: "bn",
+  Bhojpuri: "bho",
   Bodo: "brx",
   Dogri: "doi",
   Gujarati: "gu",
   Hindi: "hi",
   Kannada: "kn",
   Kashmiri: "ks",
-  Konkani: "gom",
+  "Goan Konkani": "gom",
   Maithili: "mai",
   Malayalam: "ml",
   Manipuri: "mni-Mtei",

package/src/RedactoNoticeConsentInline/RedactoNoticeConsentInline.tsx

@@ -87,9 +87,6 @@ const RedactoConsentInlineComponent = ({
     onValidationChange?.(areAllRequiredElementsChecked);
   }, [areAllRequiredElementsChecked, onValidationChange]);
 
-  const acceptDisabled =
-    isSubmitting || !areAllRequiredElementsChecked || !accessToken;
-
   useEffect(() => {
     if (hasAlreadyConsented) {
       onAccept?.();

package/src/RedactoNoticeConsentInline/api/index.ts

@@ -12,7 +12,6 @@ export const fetchConsentContent = async ({
   workspace_uuid,
   notice_uuid,
   baseUrl,
-  language = "en",
   specific_uuid,
 }: FetchConsentContentParams): Promise<ConsentContent> => {
   try {

package/src/RedactoPrivacyCenter/PrivacyCenterCaseDetailsPage.tsx

@@ -0,0 +1,154 @@
+import { useState, useEffect, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { IoArrowBack } from 'react-icons/io5';
+import { PCButton, PCBadge, PCLoader } from './ui';
+import { useInternalNavigation } from './context/NavigationContext';
+import { formatDate } from './components/utils';
+import type { CaseDetailsTab, TabId } from './lib/types';
+import { getCaseStatusVariant, formatCaseStatus } from './components/CaseDetails/utils';
+import { MessagesTab } from './components/CaseDetails/MessagesTab';
+import { RequestDetailsTab } from './components/CaseDetails/RequestDetailsTab';
+import { useCaseHistory } from './lib/queries';
+import { useOrganization } from './context/OrganizationContext';
+import { useAuth } from './context/AuthContext';
+
+// ─── Page shell ──────────────────────────────────────────────────────────────
+
+export const PrivacyCenterCaseDetailsPage = () => {
+  const { t } = useTranslation();
+  const { navigateTo, selectedCase, setSelectedCase, pendingCaseUuid } = useInternalNavigation();
+  const [activeTab, setActiveTab] = useState<TabId>('request-details');
+
+  const { organization } = useOrganization();
+  const { accessToken, refreshToken, onError, updateTokens } = useAuth();
+  const organizationId = organization?.uuid;
+  const workspaceId = organization?.workspaces[0]?.uuid;
+  const contact = typeof window !== 'undefined' ? sessionStorage.getItem('email') || '' : '';
+
+  const authContext = useMemo(() => ({
+    accessToken, refreshToken, onError, updateTokens,
+  }), [accessToken, refreshToken, onError, updateTokens]);
+
+  // The target UUID comes from the in-memory case (normal navigation) or the
+  // persisted UUID (page-refresh). Always fetch so language changes re-hydrate
+  // selectedCase with fresh server-translated data.
+  const targetUuid = selectedCase?.uuid ?? pendingCaseUuid;
+
+  const { data: cases, isLoading } = useCaseHistory(
+    organizationId,
+    workspaceId,
+    contact,
+    authContext,
+  );
+
+  // Update selectedCase from fetched list (covers language-change re-hydration and page-refresh).
+  useEffect(() => {
+    if (!cases) return;
+    if (cases.length === 0) {
+      navigateTo('form');
+      return;
+    }
+    if (!targetUuid) return;
+    const found = cases.find((c) => c.uuid === targetUuid);
+    if (found) {
+      setSelectedCase(found);
+    } else {
+      navigateTo('form');
+    }
+  }, [cases, targetUuid, setSelectedCase, navigateTo]);
+
+  // If the query is disabled (missing org/workspace/contact), cases stays undefined
+  // and isLoading stays false — navigate away so the component does not stay blank.
+  useEffect(() => {
+    if (!targetUuid || isLoading || cases !== undefined) return;
+    if (!organizationId || !workspaceId || !contact) {
+      navigateTo('form');
+    }
+  }, [targetUuid, organizationId, workspaceId, contact, cases, isLoading, navigateTo]);
+
+  // Navigate away when there is no case and nothing to load — kept in an effect
+  // to avoid calling navigateTo during render.
+  useEffect(() => {
+    if (!selectedCase && !targetUuid && !isLoading) {
+      navigateTo('form');
+    }
+  }, [selectedCase, targetUuid, isLoading, navigateTo]);
+
+  if (!selectedCase) {
+    return isLoading ? (
+      <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', minHeight: '200px' }}>
+        <PCLoader size="lg" />
+      </div>
+    ) : null;
+  }
+
+  const { request_details } = selectedCase;
+  const requestTypeLabel = selectedCase.request_type_display || selectedCase.request_type.replace('_', ' ');
+  const isDueDateOverdue = selectedCase.due_date && new Date(selectedCase.due_date) < new Date();
+
+  const tabs: CaseDetailsTab[] = [
+    { id: 'request-details', label: t('requestDetails') },
+    { id: 'messages', label: t('messages') },
+  ];
+
+  return (
+    <div className="pc-case-page">
+      {/* Back */}
+      <div className="pc-case-back">
+        <PCButton
+          variant="text"
+          size="sm"
+          onClick={() => navigateTo('form')}
+          className="pc-case-back-btn"
+        >
+          <IoArrowBack size={16} className="pc-case-back-icon" />
+          {t('backToHome')}
+        </PCButton>
+      </div>
+
+      {/* Case header */}
+      <div className="pc-case-header">
+        <span className="pc-case-header-id">
+          {selectedCase.case_id}
+        </span>
+        <span>·</span>
+        <span>{requestTypeLabel}</span>
+        <span>·</span>
+        <span>{t('submitted')} {formatDate(selectedCase.created_at)}</span>
+        {selectedCase.due_date && (
+          <>
+            <span>·</span>
+            <span className={isDueDateOverdue ? 'pc-case-header-overdue' : undefined}>
+              {t('responseDue')} {formatDate(selectedCase.due_date)}
+            </span>
+          </>
+        )}
+        <span>·</span>
+        <PCBadge variant={getCaseStatusVariant(selectedCase.status)} size="sm" className="pc-status-badge">
+          {selectedCase.status_display || formatCaseStatus(selectedCase.status)}
+        </PCBadge>
+      </div>
+
+      {/* Tabs */}
+      <div className="pc-case-tabs">
+        {tabs.map((tab) => (
+          <button
+            key={tab.id}
+            onClick={() => setActiveTab(tab.id)}
+            className={`pc-case-tab ${activeTab === tab.id ? 'pc-case-tab--active' : ''}`}
+          >
+            {tab.label}
+          </button>
+        ))}
+      </div>
+
+      {/* Tab content */}
+      <div className="pc-case-tab-content">
+        {activeTab === 'messages' && <MessagesTab caseUuid={selectedCase.uuid} />}
+        {activeTab === 'request-details' && (
+          <RequestDetailsTab selectedCase={selectedCase} request_details={request_details} requestTypeLabel={requestTypeLabel} />
+        )}
+      </div>
+    </div>
+  );
+};

package/src/RedactoPrivacyCenter/PrivacyCenterHomePage.tsx

@@ -4,6 +4,7 @@ import { useInternalNavigation } from './context/NavigationContext';
 import { PrivacyCenterConsentManagerPage } from './PrivacyCenterConsentManagerPage';
 import { PrivacyCenterFormPage } from './PrivacyCenterFormPage';
 import { PrivacyCenterActivityPage } from './PrivacyCenterActivityPage';
+import { PrivacyCenterCaseDetailsPage } from './PrivacyCenterCaseDetailsPage';
 
 export function PrivacyCenterHomePage() {
   const { currentPage } = useInternalNavigation();
@@ -21,6 +22,8 @@ export function PrivacyCenterHomePage() {
       return <PrivacyCenterFormPage />;
     case 'activity':
       return <PrivacyCenterActivityPage />;
+    case 'case-details':
+      return <PrivacyCenterCaseDetailsPage />;
     default:
       return <PrivacyCenterConsentManagerPage />;
   }

package/src/RedactoPrivacyCenter/PrivacyCenterLayout.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState, useRef, ReactNode } from 'react';
+import { useEffect, useState, useRef, type ReactNode } from 'react';
 import { OrganizationProvider } from './context/OrganizationContext';
 import { ThemeProvider } from './context/theme';
 import type { OrganizationDetail } from './lib/types';
@@ -7,6 +7,7 @@ import {
   decodeJwtToken,
 } from './lib/utils';
 import { useBaseUrl } from './context/BaseUrlContext';
+import { useAuth } from './context/AuthContext';
 import { PCLoader } from './ui';
 import { pcStyles } from './styles/pcStyles';
 import PrivacyCenterLayoutComponent from './components/PrivacyCenterLayout';
@@ -20,6 +21,10 @@ interface PrivacyCenterLayoutProps {
 
 export function PrivacyCenterLayout({ children, defaultTheme, slug, onBack }: PrivacyCenterLayoutProps) {
   const { consentClient } = useBaseUrl();
+  // Read accessToken from AuthContext so this effect re-runs after AuthProvider
+  // syncs JWT data to sessionStorage (fixes race condition where child effects
+  // run before parent effects in React)
+  const { accessToken: authAccessToken } = useAuth();
   const [organization, setOrganization] = useState<OrganizationDetail | null>(null);
   const [isCheckingAuth, setIsCheckingAuth] = useState(true);
   const [isLoadingOrg, setIsLoadingOrg] = useState(true);
@@ -27,58 +32,84 @@ export function PrivacyCenterLayout({ children, defaultTheme, slug, onBack }: Pr
   const authCheckInProgressRef = useRef(false);
 
   useEffect(() => {
-    // Load organization info from sessionStorage
-    if (typeof window !== 'undefined' && slug) {
-      const accessToken = sessionStorage.getItem('access_token');
-      const orgId = sessionStorage.getItem('pc_org_id');
-      const workspaceId = sessionStorage.getItem('pc_workspace_id');
-      const orgSlug = sessionStorage.getItem('pc_org_slug');
-
-      // Create organization object from sessionStorage
-      if (accessToken && orgId && workspaceId && orgSlug === slug) {
-        // Prefer organisation_name from JWT; fall back to slug-derived name
-        const decoded = decodeJwtToken(accessToken);
-        const orgNameFromJwt = decoded?.organisation_name;
-        const orgName =
-          typeof orgNameFromJwt === 'string' && orgNameFromJwt.trim() !== ''
-            ? orgNameFromJwt
-            : slug
-              .split('-')
-              .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-              .join(' ');
-
-        setOrganization({
-          uuid: orgId,
+    if (typeof window === 'undefined') return;
+
+    // Try sessionStorage first
+    let accessToken = sessionStorage.getItem('access_token');
+    let orgId = sessionStorage.getItem('pc_org_id');
+    let workspaceId = sessionStorage.getItem('pc_workspace_id');
+    let orgSlug = sessionStorage.getItem('pc_org_slug');
+
+    // If sessionStorage is not yet populated (race condition: AuthProvider's
+    // effect hasn't run yet), fall back to decoding the JWT from AuthContext
+    if (authAccessToken && (!accessToken || !orgId || !workspaceId || !orgSlug)) {
+      const decoded = decodeJwtToken(authAccessToken);
+      if (decoded) {
+        accessToken = accessToken || authAccessToken;
+        orgId = orgId || (typeof decoded.organisation_uuid === 'string' ? decoded.organisation_uuid : null);
+        workspaceId = workspaceId || (typeof decoded.workspace_uuid === 'string' ? decoded.workspace_uuid : null);
+        orgSlug = orgSlug || (typeof decoded.organisation_slug === 'string' ? decoded.organisation_slug : null);
+
+        // Write to sessionStorage so child components (SideBarPC, ConsentManager)
+        // can read these values when they mount
+        if (accessToken) sessionStorage.setItem('access_token', accessToken);
+        if (orgId) sessionStorage.setItem('pc_org_id', orgId);
+        if (workspaceId) sessionStorage.setItem('pc_workspace_id', workspaceId);
+        if (orgSlug) sessionStorage.setItem('pc_org_slug', orgSlug);
+
+        // Extract and set email from JWT for sidebar and consent manager
+        const email = decoded.contact || decoded.primary_email;
+        if (email && typeof email === 'string') {
+          sessionStorage.setItem('email', email);
+        }
+      }
+    }
+
+    // Use slug prop if provided, otherwise fall back to JWT-derived slug
+    const effectiveSlug = slug || orgSlug || '';
+
+    if (accessToken && orgId && workspaceId && effectiveSlug) {
+      // Prefer organisation_name from JWT; fall back to slug-derived name
+      const decoded = decodeJwtToken(accessToken);
+      const orgNameFromJwt = decoded?.organisation_name;
+      const orgName =
+        typeof orgNameFromJwt === 'string' && orgNameFromJwt.trim() !== ''
+          ? orgNameFromJwt
+          : effectiveSlug
+            .split('-')
+            .map((word: string) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+
+      setOrganization({
+        uuid: orgId,
+        suid: '',
+        name: orgName,
+        slug: effectiveSlug,
+        description: '',
+        domain: '',
+        workspaces: [{
+          uuid: workspaceId,
           suid: '',
-          name: orgName,
-          slug: slug,
+          name: '',
           description: '',
-          domain: '',
-          workspaces: [{
-            uuid: workspaceId,
-            suid: '',
-            name: '',
-            description: '',
-            workspace_type: '',
-            status: '',
-          }],
-          ai_summary: {},
-          icon_url: null,
-          activated: true,
-          allowed_domains: [],
-        });
-        setIsLoadingOrg(false);
-      } else {
-        // If organization info is not available, set loading to false
-        // User will need to authenticate first
-        setIsLoadingOrg(false);
-      }
+          workspace_type: '',
+          status: '',
+        }],
+        ai_summary: {},
+        icon_url: null,
+        activated: true,
+        allowed_domains: [],
+      });
+      setIsLoadingOrg(false);
+    } else {
+      // If organization info is not available, set loading to false
+      setIsLoadingOrg(false);
     }
-  }, [slug]);
+  }, [slug, authAccessToken]);
 
   useEffect(() => {
     // Don't check auth while still loading organization
-    if (isLoadingOrg || !slug || !organization) {
+    if (isLoadingOrg || !organization) {
       return;
     }
 
@@ -93,8 +124,8 @@ export function PrivacyCenterLayout({ children, defaultTheme, slug, onBack }: Pr
 
       try {
         // Check if user is authenticated, attempt refresh if needed
-        const isAuthenticated = await checkAndRefreshAuth(
-          slug,
+        await checkAndRefreshAuth(
+          organization.slug || slug,
           organization?.uuid,
           organization?.workspaces[0]?.uuid,
           consentClient
@@ -113,7 +144,7 @@ export function PrivacyCenterLayout({ children, defaultTheme, slug, onBack }: Pr
 
     // Check auth after organization is loaded
     checkAuth();
-  }, [slug, organization, isLoadingOrg, consentClient]);
+  }, [slug, organization, isLoadingOrg, consentClient, authAccessToken]);
 
   // Show loading state while checking authentication or loading organization
   if (isLoadingOrg || !organization || isCheckingAuth) {

package/src/RedactoPrivacyCenter/RedactoPrivacyCenter.tsx

@@ -7,6 +7,10 @@ import { AuthProvider } from './context/AuthContext';
 import { NavigationProvider } from './context/NavigationContext';
 import type { InternalPage } from './context/NavigationContext';
 import { PageChromeProvider } from './context/PageChromeContext';
+import { injectPCStyles } from './styles/injectStyles';
+
+// Inject Privacy Center CSS styles on module load
+injectPCStyles();
 
 interface RedactoPrivacyCenterProps {
   baseUrl: string; // Consent server base URL

package/src/RedactoPrivacyCenter/api/actions.ts

@@ -1,5 +1,4 @@
 import type { BaseRequest } from './client';
-import { useBaseUrl } from '../context/BaseUrlContext';
 
 export type ConsentApiErrorCode = 'NOMINATOR_NOT_FOUND' | 'NOMINEE_MUST_SPECIFY_NOMINATOR';
 
@@ -14,17 +13,30 @@ export class ConsentApiError extends Error {
 
 import type {
   ActivityDetail,
+  CaseActionBaseParams,
   CaseHistoryDetail,
+  CaseMessage,
   ConsentAction,
   CreateCaseResponse,
   FormData,
+  GetCaseDocumentParams,
+  GetCaseMessagesParams,
+  MessageDocument,
   OtpResponse,
   OtpVerificationResponse,
   Pagination,
+  SendCaseMessageParams,
+  SubmitDocumentForRequestParams,
   TokenExchangeResponse,
+  UploadCaseDocumentParams,
+  UploadDocumentResponse,
   UserConsentDetail,
 } from '../lib/types';
 
+function buildBaseRequest(organizationId: string, workspaceId: string, authToken?: string): BaseRequest {
+  return { organisationUuid: organizationId, workspaceUuid: workspaceId, authToken: authToken || '' };
+}
+
 /**
  * Check if an error is an authentication/JWT related error
  */
@@ -70,11 +82,7 @@ export async function getFormDataServer(
     if (!consentClient) {
       throw new Error('Consent client is required');
     }
-    const baseRequest: BaseRequest = {
-      organisationUuid: organizationId,
-      workspaceUuid: workspaceId,
-      authToken: authToken || '',
-    };
+    const baseRequest = buildBaseRequest(organizationId, workspaceId, authToken);
 
     // If useSessionAuth is true (case management), use X-Auth-Token
     // Otherwise (privacy center), use JWT Bearer token
@@ -99,11 +107,7 @@ export async function createCaseRequestServer(
     if (!consentClient) {
       throw new Error('Consent client is required');
     }
-    const baseRequest: BaseRequest = {
-      organisationUuid: organizationId,
-      workspaceUuid: workspaceId,
-      authToken: authToken || '',
-    };
+    const baseRequest = buildBaseRequest(organizationId, workspaceId, authToken);
 
     // If useSessionAuth is true (case management), use X-Auth-Token
     // Otherwise (privacy center), use JWT Bearer token
@@ -238,11 +242,7 @@ export async function fetchProductsServer(params: {
       throw new Error('Consent client is required');
     }
     // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest: BaseRequest = {
-      organisationUuid: params.organizationId,
-      workspaceUuid: params.workspaceId,
-      authToken: params.authToken || '',
-    };
+    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
 
     const result = await params.consentClient.getProducts(
       baseRequest,
@@ -273,11 +273,7 @@ export async function fetchUserConsentsServer(params: {
       throw new Error('Consent client is required');
     }
     // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest: BaseRequest = {
-      organisationUuid: params.organizationId,
-      workspaceUuid: params.workspaceId,
-      authToken: params.authToken || '',
-    };
+    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
 
     const result = await params.consentClient.getUserConsents(
       baseRequest,
@@ -313,11 +309,7 @@ export async function manageConsentServer(params: {
       throw new Error('Consent client is required');
     }
     // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest: BaseRequest = {
-      organisationUuid: params.organizationId,
-      workspaceUuid: params.workspaceId,
-      authToken: params.authToken || '',
-    };
+    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
 
     const result = await params.consentClient.manageConsent(
       baseRequest,
@@ -358,11 +350,7 @@ export async function fetchActivitiesServer(params: {
     }
 
     // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest: BaseRequest = {
-      organisationUuid: params.organizationId,
-      workspaceUuid: params.workspaceId,
-      authToken: params.authToken || '',
-    };
+    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
 
     const result = await params.consentClient.getActivities(
       baseRequest,
@@ -392,11 +380,7 @@ export async function fetchCaseHistoryServer(params: {
       throw new Error('Consent client is required');
     }
     // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest: BaseRequest = {
-      organisationUuid: params.organizationId,
-      workspaceUuid: params.workspaceId,
-      authToken: params.authToken || '',
-    };
+    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
 
     const result = await params.consentClient.getCaseHistory(
       baseRequest,
@@ -442,3 +426,51 @@ export async function fetchCaseHistoryServer(params: {
     return handleServerActionError(error, 'fetching case history');
   }
 }
+
+// ─── Case Communication ──────────────────────────────────────────────────────
+
+type ConsentClient = NonNullable<CaseActionBaseParams['consentClient']>;
+
+async function runCaseAction<T>(
+  params: CaseActionBaseParams,
+  label: string,
+  fn: (client: ConsentClient, baseRequest: BaseRequest) => Promise<T>
+): Promise<T | null> {
+  try {
+    if (!params.consentClient) throw new Error('Consent client is required');
+    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
+    return await fn(params.consentClient, baseRequest);
+  } catch (error: any) {
+    return handleServerActionError(error, label);
+  }
+}
+
+export async function getCaseMessagesServer(params: GetCaseMessagesParams): Promise<CaseMessage[] | null> {
+  return runCaseAction(params, 'fetching case messages', (client, base) =>
+    client.getCaseMessages(base, params.caseUuid, params.authToken)
+  );
+}
+
+export async function sendCaseMessageServer(params: SendCaseMessageParams): Promise<CaseMessage | null> {
+  return runCaseAction(params, 'sending case message', (client, base) =>
+    client.sendCaseMessage(base, params.caseUuid, params.body, params.documentUuids, params.authToken)
+  );
+}
+
+export async function uploadCaseDocumentServer(params: UploadCaseDocumentParams): Promise<UploadDocumentResponse | null> {
+  return runCaseAction(params, 'uploading case document', (client, base) =>
+    client.uploadCaseDocument(base, params.caseUuid, params.file, params.authToken)
+  );
+}
+
+export async function submitDocumentForRequestServer(params: SubmitDocumentForRequestParams): Promise<CaseMessage | null> {
+  return runCaseAction(params, 'submitting document for request', (client, base) =>
+    client.submitDocumentForRequest(base, params.caseUuid, params.requestEventUuid, params.documentUuid, params.body, params.authToken)
+  );
+}
+
+export async function getCaseDocumentServer(params: GetCaseDocumentParams): Promise<MessageDocument | null> {
+  return runCaseAction(params, 'fetching case document', (client, base) =>
+    client.getCaseDocument(base, params.caseUuid, params.documentUuid, params.authToken)
+  );
+}