@nexalink/carecompass-sdk 0.4.0-beta.15 → 0.5.0

package/dist/component.d.ts

@@ -1,13 +1,35 @@
 import React from "react";
-import { type CareCompassContext, type CareCompassCoreEvent, type CareCompassMessage } from "./core.js";
+import { type CareCompassContext, type CareCompassCore, type CareCompassCoreEvent, type CareCompassCoreOptions, type CareCompassCoreSnapshot, type CareCompassMessage, type CareCompassSendMessageOptions } from "./core.js";
+import type { CareCompassRuntimeTokenProvider } from "./client.js";
 import type { CareCompassConfig } from "./schema.js";
+import type { CareCompassAuditListener, CareCompassSafetyListener } from "./compliance.js";
 export type CareCompassChatProps = {
     config: CareCompassConfig;
     initialContext?: CareCompassContext;
+    onAuditEvent?: CareCompassAuditListener;
     onEvent?: (event: CareCompassCoreEvent) => void;
+    onSafetyEvent?: CareCompassSafetyListener;
     pollIntervalMs?: number;
     renderMessage?: (message: CareCompassMessage) => React.ReactNode;
     retryLabel?: string;
+    runtimeTokenProvider?: CareCompassRuntimeTokenProvider;
 };
-export declare function CareCompassChat({ config, initialContext, onEvent, pollIntervalMs, renderMessage, retryLabel, }: CareCompassChatProps): import("react/jsx-runtime").JSX.Element;
+/** Options for the headless React hook. Keep object-valued options stable with
+ * `useMemo` when the calling component rerenders. */
+export type UseCareCompassOptions = CareCompassCoreOptions;
+export type CareCompassReactController = {
+    core: CareCompassCore;
+    snapshot: CareCompassCoreSnapshot;
+    sendMessage: (prompt: string, options?: CareCompassSendMessageOptions) => Promise<CareCompassCoreSnapshot>;
+    streamMessage: CareCompassCore["streamMessage"];
+    retryLast: CareCompassCore["retryLast"];
+    reset: CareCompassCore["reset"];
+    setContext: CareCompassCore["setContext"];
+};
+/**
+ * React adapter for the headless CareCompass core. It owns the core lifecycle
+ * and subscribes React to its snapshots, leaving hosts free to render any UI.
+ */
+export declare function useCareCompass(config: CareCompassConfig, options?: UseCareCompassOptions): CareCompassReactController;
+export declare function CareCompassChat({ config, initialContext, onAuditEvent, onEvent, onSafetyEvent, pollIntervalMs, renderMessage, retryLabel, runtimeTokenProvider, }: CareCompassChatProps): React.JSX.Element;
 export declare const CareCompassEmbed: typeof CareCompassChat;

package/dist/component.js

@@ -26,11 +26,68 @@ class CareCompassErrorBoundary extends React.Component {
         return this.props.children;
     }
 }
-function CareCompassChatContent({ config, initialContext, onEvent, telemetry, pollIntervalMs = 1500, renderMessage, retryLabel = "Retry", }) {
+/**
+ * React adapter for the headless CareCompass core. It owns the core lifecycle
+ * and subscribes React to its snapshots, leaving hosts free to render any UI.
+ */
+export function useCareCompass(config, options = {}) {
+    const { compliance, fetcher, initialContext, now, onAuditEvent, onSafetyEvent, pollIntervalMs, runtimeTokenProvider, timeoutMs, } = options;
     const core = React.useMemo(() => createCareCompassCore(config, {
+        compliance,
+        fetcher,
         initialContext,
+        now,
+        onAuditEvent,
+        onSafetyEvent,
         pollIntervalMs,
-    }), [config, initialContext, pollIntervalMs]);
+        runtimeTokenProvider,
+        timeoutMs,
+    }), [
+        compliance,
+        config,
+        fetcher,
+        initialContext,
+        now,
+        onAuditEvent,
+        onSafetyEvent,
+        pollIntervalMs,
+        runtimeTokenProvider,
+        timeoutMs,
+    ]);
+    const [snapshot, setSnapshot] = React.useState(() => core.getSnapshot());
+    React.useEffect(() => {
+        const unsubscribe = core.subscribe(setSnapshot);
+        setSnapshot(core.getSnapshot());
+        return () => {
+            unsubscribe();
+            core.dispose();
+        };
+    }, [core]);
+    return React.useMemo(() => ({
+        core,
+        snapshot,
+        sendMessage: core.sendMessage,
+        streamMessage: core.streamMessage,
+        retryLast: core.retryLast,
+        reset: core.reset,
+        setContext: core.setContext,
+    }), [core, snapshot]);
+}
+function CareCompassChatContent({ config, initialContext, onAuditEvent, onEvent, onSafetyEvent, telemetry, pollIntervalMs = 1500, renderMessage, retryLabel = "Retry", runtimeTokenProvider, }) {
+    const core = React.useMemo(() => createCareCompassCore(config, {
+        initialContext,
+        onAuditEvent,
+        onSafetyEvent,
+        pollIntervalMs,
+        runtimeTokenProvider,
+    }), [
+        config,
+        initialContext,
+        onAuditEvent,
+        onSafetyEvent,
+        pollIntervalMs,
+        runtimeTokenProvider,
+    ]);
     const [snapshot, setSnapshot] = React.useState(() => core.getSnapshot());
     const [input, setInput] = React.useState("");
     React.useEffect(() => {
@@ -51,6 +108,7 @@ function CareCompassChatContent({ config, initialContext, onEvent, telemetry, po
             return;
         setInput("");
         try {
+            core.recordWidgetAction();
             for await (const coreEvent of core.streamMessage(prompt)) {
                 onEvent?.(coreEvent);
             }
@@ -62,6 +120,7 @@ function CareCompassChatContent({ config, initialContext, onEvent, telemetry, po
     }
     async function retryMessage() {
         try {
+            core.recordWidgetAction();
             await core.retryLast();
         }
         catch {
@@ -154,10 +213,10 @@ function CareCompassChatContent({ config, initialContext, onEvent, telemetry, po
                                     padding: "4px 8px",
                                 }, type: "button", children: retryLabel })) : null] })) : null, _jsx("div", { style: { fontSize: 11, opacity: 0.7 }, children: config.labels.disclaimer })] })] }));
 }
-export function CareCompassChat({ config, initialContext, onEvent, pollIntervalMs = 1500, renderMessage, retryLabel, }) {
+export function CareCompassChat({ config, initialContext, onAuditEvent, onEvent, onSafetyEvent, pollIntervalMs = 1500, renderMessage, retryLabel, runtimeTokenProvider, }) {
     // Telemetry is scoped to the validated public config; no per-message content
     // is passed through this component-level telemetry object.
     const telemetry = React.useMemo(() => createCareCompassTelemetry(config), [config]);
-    return (_jsx(CareCompassErrorBoundary, { config: config, telemetry: telemetry, children: _jsx(CareCompassChatContent, { config: config, initialContext: initialContext, onEvent: onEvent, pollIntervalMs: pollIntervalMs, renderMessage: renderMessage, retryLabel: retryLabel, telemetry: telemetry }) }));
+    return (_jsx(CareCompassErrorBoundary, { config: config, telemetry: telemetry, children: _jsx(CareCompassChatContent, { config: config, initialContext: initialContext, onAuditEvent: onAuditEvent, onEvent: onEvent, onSafetyEvent: onSafetyEvent, pollIntervalMs: pollIntervalMs, renderMessage: renderMessage, retryLabel: retryLabel, runtimeTokenProvider: runtimeTokenProvider, telemetry: telemetry }) }));
 }
 export const CareCompassEmbed = CareCompassChat;

package/dist/core.d.ts

@@ -1,4 +1,5 @@
-import { type CareCompassStatusResponse } from "./client.js";
+import { type CareCompassRuntimeTokenProvider, type CareCompassStatusResponse, type CareCompassWorkflowId } from "./client.js";
+import { type CareCompassAuditEvent, type CareCompassAuditListener, type CareCompassComplianceRuntimeOptions, type CareCompassSafetyDecision, type CareCompassSafetyListener } from "./compliance.js";
 import type { CareCompassConfig } from "./schema.js";
 type Fetcher = typeof fetch;
 export type CareCompassContext = Record<string, unknown>;
@@ -8,15 +9,18 @@ export type CareCompassMessage = {
     text: string;
     createdAt: number;
     status: "complete" | "failed" | "pending";
+    retrieval?: CareCompassStatusResponse["retrieval"];
 };
 export type CareCompassLifecyclePhase = "idle" | "submitting" | "streaming" | "complete" | "error" | "disposed";
-export type CareCompassCoreErrorCode = "request_failed" | "timeout" | "disposed";
+export type CareCompassCoreErrorCode = "request_failed" | "safety_blocked" | "timeout" | "disposed";
 export type CareCompassCoreError = {
     code: CareCompassCoreErrorCode;
     message: string;
 };
 export type CareCompassRetryMetadata = {
     prompt: string;
+    requestId?: string;
+    workflow?: CareCompassWorkflowId;
     context: CareCompassContext;
     attempts: number;
 };
@@ -55,18 +59,31 @@ export type CareCompassCoreEvent = {
     snapshot: CareCompassCoreSnapshot;
 };
 export type CareCompassCoreOptions = {
+    compliance?: CareCompassComplianceRuntimeOptions;
     fetcher?: Fetcher;
     initialContext?: CareCompassContext;
     now?: () => number;
+    onAuditEvent?: CareCompassAuditListener;
+    onSafetyEvent?: CareCompassSafetyListener;
     pollIntervalMs?: number;
+    runtimeTokenProvider?: CareCompassRuntimeTokenProvider;
     timeoutMs?: number;
 };
 export type CareCompassSendMessageOptions = {
+    /** Reuse this value only when retrying the same hosted submission. */
+    requestId?: string;
+    workflow?: CareCompassWorkflowId;
     context?: CareCompassContext;
 };
 export type CareCompassCore = {
+    exportAuditTrail: () => CareCompassAuditEvent[];
     getSnapshot: () => CareCompassCoreSnapshot;
+    recordSafetyDecision: (decision: Exclude<CareCompassSafetyDecision, "redacted" | "blocked">, source?: "tool_call" | "widget_action") => void;
+    recordToolCall: (outcome?: "completed" | "failed") => void;
+    recordWidgetAction: (outcome?: "recorded" | "completed") => void;
     subscribe: (listener: (snapshot: CareCompassCoreSnapshot) => void) => () => void;
+    subscribeAudit: (listener: CareCompassAuditListener) => () => void;
+    subscribeSafety: (listener: CareCompassSafetyListener) => () => void;
     setContext: (context: CareCompassContext | ((current: CareCompassContext) => CareCompassContext)) => void;
     sendMessage: (prompt: string, options?: CareCompassSendMessageOptions) => Promise<CareCompassCoreSnapshot>;
     streamMessage: (prompt: string, options?: CareCompassSendMessageOptions) => AsyncIterable<CareCompassCoreEvent>;

package/dist/core.js

@@ -1,4 +1,5 @@
 import { createCareCompassClient, } from "./client.js";
+import { phiSummary, resolveCareCompassCompliancePolicy, sanitizeCareCompassValue, } from "./compliance.js";
 const sleep = (durationMs) => new Promise((resolve) => setTimeout(resolve, durationMs));
 const errorFrom = (error, code = "request_failed") => ({
     code,
@@ -11,7 +12,16 @@ export function createCareCompassCore(config, options = {}) {
     const client = createCareCompassClient(config, {
         fetcher: options.fetcher,
         now,
+        runtimeTokenProvider: options.runtimeTokenProvider,
     });
+    const compliancePolicy = resolveCareCompassCompliancePolicy(config.compliance);
+    const auditEvents = [];
+    const auditListeners = new Set();
+    const safetyListeners = new Set();
+    if (options.onAuditEvent)
+        auditListeners.add(options.onAuditEvent);
+    if (options.onSafetyEvent)
+        safetyListeners.add(options.onSafetyEvent);
     const listeners = new Set();
     let sequence = 0;
     let disposed = false;
@@ -30,6 +40,44 @@ export function createCareCompassCore(config, options = {}) {
         },
     ];
     const nextId = (prefix) => `${prefix}-${now()}-${++sequence}`;
+    const emitAudit = (type, outcome, source, matches = []) => {
+        if (!compliancePolicy.auditEnabled)
+            return;
+        const auditEvent = {
+            id: nextId("audit"),
+            occurredAt: now(),
+            outcome,
+            phi: phiSummary(matches),
+            ...(source ? { source } : {}),
+            type,
+        };
+        auditEvents.push(auditEvent);
+        for (const listener of auditListeners)
+            listener(auditEvent);
+    };
+    const emitSafety = (decision, source, matches = []) => {
+        const safetyEvent = {
+            decision,
+            occurredAt: now(),
+            phi: phiSummary(matches),
+            source,
+        };
+        for (const listener of safetyListeners)
+            listener(safetyEvent);
+        emitAudit("safety_decision", decision === "policy_sensitive" ? "recorded" : decision, source, matches);
+    };
+    const applyPhiPolicy = (value, source) => {
+        const sanitized = sanitizeCareCompassValue(value, source, compliancePolicy, options.compliance?.phi);
+        if (sanitized.matches.length === 0)
+            return sanitized;
+        const decision = compliancePolicy.phiAction === "block"
+            ? "blocked"
+            : compliancePolicy.phiAction === "redact"
+                ? "redacted"
+                : "policy_sensitive";
+        emitSafety(decision, source, sanitized.matches);
+        return sanitized;
+    };
     const getSnapshot = () => ({
         messages: messages.map((message) => ({ ...message })),
         phase,
@@ -40,6 +88,8 @@ export function createCareCompassCore(config, options = {}) {
         retry: retry
             ? {
                 prompt: retry.prompt,
+                requestId: retry.requestId,
+                workflow: retry.workflow,
                 context: { ...retry.context },
                 attempts: retry.attempts,
             }
@@ -56,6 +106,7 @@ export function createCareCompassCore(config, options = {}) {
         error = coreError;
         phase = disposed ? "disposed" : "error";
         activeJobId = null;
+        emitAudit("error", "failed");
         notify();
         return event({ type: "error", error: coreError });
     };
@@ -72,14 +123,33 @@ export function createCareCompassCore(config, options = {}) {
         const prompt = promptInput.trim();
         if (!prompt)
             return;
-        const requestContext = {
+        const protectedPrompt = applyPhiPolicy(prompt, "message");
+        const protectedContext = applyPhiPolicy({
             ...context,
             ...(sendOptions.context ?? {}),
-        };
+        }, "context");
+        if (compliancePolicy.phiAction === "block" &&
+            (protectedPrompt.matches.length > 0 ||
+                protectedContext.matches.length > 0)) {
+            emitAudit("message", "blocked", "message", protectedPrompt.matches);
+            const blocked = {
+                code: "safety_blocked",
+                message: "CareCompass blocked this request because detectable PHI is not allowed in strict compliance mode.",
+            };
+            retry = null;
+            yield fail(blocked);
+            throw new Error(blocked.message);
+        }
+        const requestContext = protectedContext.value;
+        const protectedPromptValue = protectedPrompt.value;
+        const requestId = sendOptions.requestId ??
+            (typeof globalThis.crypto?.randomUUID === "function"
+                ? globalThis.crypto.randomUUID()
+                : nextId("request"));
         const userMessage = {
             id: nextId("user"),
             role: "user",
-            text: prompt,
+            text: protectedPromptValue,
             createdAt: now(),
             status: "complete",
         };
@@ -89,12 +159,18 @@ export function createCareCompassCore(config, options = {}) {
         activeJobId = null;
         retry = null;
         notify();
+        emitAudit("message", protectedPrompt.matches.length > 0 &&
+            compliancePolicy.phiAction === "redact"
+            ? "redacted"
+            : "submitted", "message", protectedPrompt.matches);
         yield event({ type: "message_submitted", message: userMessage });
         const startedAt = now();
         let failureAlreadyCaptured = false;
         try {
             const { jobId } = await client.ask({
-                prompt,
+                prompt: protectedPromptValue,
+                requestId,
+                workflow: sendOptions.workflow,
                 userContext: requestContext,
             });
             activeJobId = jobId;
@@ -104,12 +180,25 @@ export function createCareCompassCore(config, options = {}) {
                 const status = await client.status(jobId);
                 yield event({ type: "status", jobId, status: status.status });
                 if (status.status === "complete" && status.result) {
+                    const protectedResponse = applyPhiPolicy(status.result, "response");
+                    if (compliancePolicy.phiAction === "block" &&
+                        protectedResponse.matches.length > 0) {
+                        const blocked = {
+                            code: "safety_blocked",
+                            message: "CareCompass blocked a response because detectable PHI is not allowed in strict compliance mode.",
+                        };
+                        retry = null;
+                        yield fail(blocked);
+                        failureAlreadyCaptured = true;
+                        throw new Error(blocked.message);
+                    }
                     const assistantMessage = {
                         id: nextId("assistant"),
                         role: "assistant",
-                        text: status.result,
+                        text: protectedResponse.value,
                         createdAt: now(),
                         status: "complete",
+                        retrieval: status.retrieval,
                     };
                     messages = [...messages, assistantMessage];
                     phase = "complete";
@@ -117,6 +206,10 @@ export function createCareCompassCore(config, options = {}) {
                     activeJobId = null;
                     retry = null;
                     notify();
+                    emitAudit("message", protectedResponse.matches.length > 0 &&
+                        compliancePolicy.phiAction === "redact"
+                        ? "redacted"
+                        : "completed", "response", protectedResponse.matches);
                     yield event({
                         type: "message_completed",
                         message: assistantMessage,
@@ -125,7 +218,12 @@ export function createCareCompassCore(config, options = {}) {
                 }
                 if (status.status === "failed") {
                     const failed = errorFrom(new Error(status.result ?? config.labels.errorMessage));
-                    retry = { prompt, context: requestContext, attempts: 0 };
+                    retry = {
+                        prompt: protectedPromptValue,
+                        workflow: sendOptions.workflow,
+                        context: requestContext,
+                        attempts: 0,
+                    };
                     yield fail(failed);
                     failureAlreadyCaptured = true;
                     throw new Error(failed.message);
@@ -135,7 +233,13 @@ export function createCareCompassCore(config, options = {}) {
             }
             client.recordInferenceTimeout(jobId, now() - startedAt);
             const timedOut = errorFrom(new Error("CareCompass request timed out."), "timeout");
-            retry = { prompt, context: requestContext, attempts: 0 };
+            retry = {
+                prompt: protectedPromptValue,
+                requestId,
+                workflow: sendOptions.workflow,
+                context: requestContext,
+                attempts: 0,
+            };
             yield fail(timedOut);
             failureAlreadyCaptured = true;
             throw new Error(timedOut.message);
@@ -143,20 +247,44 @@ export function createCareCompassCore(config, options = {}) {
         catch (caught) {
             if (failureAlreadyCaptured)
                 throw caught;
-            retry = { prompt, context: requestContext, attempts: 0 };
+            retry = {
+                prompt: protectedPromptValue,
+                requestId,
+                workflow: sendOptions.workflow,
+                context: requestContext,
+                attempts: 0,
+            };
             const requestError = errorFrom(caught);
             yield fail(requestError);
             throw caught instanceof Error ? caught : new Error(requestError.message);
         }
     }
     return {
+        exportAuditTrail: () => auditEvents.map((auditEvent) => ({
+            ...auditEvent,
+            phi: {
+                categories: [...auditEvent.phi.categories],
+                count: auditEvent.phi.count,
+            },
+        })),
         getSnapshot,
+        recordSafetyDecision: (decision, source = "tool_call") => emitSafety(decision, source),
+        recordToolCall: (outcome = "completed") => emitAudit("tool_call", outcome, "tool_call"),
+        recordWidgetAction: (outcome = "recorded") => emitAudit("widget_action", outcome, "widget_action"),
         subscribe: (listener) => {
             listeners.add(listener);
             return () => {
                 listeners.delete(listener);
             };
         },
+        subscribeAudit: (listener) => {
+            auditListeners.add(listener);
+            return () => auditListeners.delete(listener);
+        },
+        subscribeSafety: (listener) => {
+            safetyListeners.add(listener);
+            return () => safetyListeners.delete(listener);
+        },
         setContext: (nextContext) => {
             ensureAvailable();
             context =
@@ -206,10 +334,14 @@ export function createCareCompassCore(config, options = {}) {
             phase = "disposed";
             activeJobId = null;
             listeners.clear();
+            auditListeners.clear();
+            safetyListeners.clear();
         },
     };
     async function streamRetry(retryRequest) {
         const iterator = streamMessage(retryRequest.prompt, {
+            requestId: retryRequest.requestId,
+            workflow: retryRequest.workflow,
             context: retryRequest.context,
         })[Symbol.asyncIterator]();
         while (!(await iterator.next()).done) {

package/dist/index.d.ts

@@ -1,13 +1,19 @@
 export { createCareCompassClient } from "./client.js";
-export type { CareCompassAskRequest, CareCompassAskResponse, CareCompassStatusResponse, } from "./client.js";
-export { CareCompassChat, CareCompassEmbed } from "./component.js";
-export type { CareCompassChatProps } from "./component.js";
+export type { CareCompassAskRequest, CareCompassAskResponse, CareCompassClientOptions, CareCompassRetrievalMetadata, CareCompassRetrievalReference, CareCompassRuntimeTokenProvider, CareCompassRuntimeTokenRequest, CareCompassStatusResponse, CareCompassWorkflowId, } from "./client.js";
+export { CareCompassChat, CareCompassEmbed, useCareCompass, } from "./component.js";
+export type { CareCompassChatProps, CareCompassReactController, UseCareCompassOptions, } from "./component.js";
 export { createCareCompassCore } from "./core.js";
 export type { CareCompassContext, CareCompassCore, CareCompassCoreError, CareCompassCoreErrorCode, CareCompassCoreEvent, CareCompassCoreOptions, CareCompassCoreSnapshot, CareCompassLifecyclePhase, CareCompassMessage, CareCompassRetryMetadata, CareCompassSendMessageOptions, } from "./core.js";
+export { CARECOMPASS_RCM_SYNTHETIC_DEMO, createRcmCodingWorkflow, RcmCodingAssistant, } from "./rcm.js";
+export type { RcmCodeRecommendation, RcmCodeSystem, RcmCodingAssistanceInput, RcmCodingAssistanceResult, RcmCodingAssistantProps, RcmCodingWorkflow, RcmCodingWorkflowOptions, RcmConfidence, RcmCustomerRules, RcmPolicyReference, RcmPolicyRetriever, RcmReviewDisposition, } from "./rcm.js";
 export { mountCareCompass } from "./mount.js";
+export { CARECOMPASS_ELEMENT_TAG, defineCareCompassElement, } from "./web-component.js";
+export type { CareCompassWebComponentElement } from "./web-component.js";
 export { generateCareCompassIframeSnippet, generateCareCompassSnippet, } from "./snippet.js";
-export { careCompassApiBaseUrlSchema, careCompassConfigSchema, createDefaultCareCompassConfig, validateCareCompassConfig, } from "./schema.js";
-export type { CareCompassConfig, CareCompassConfigInput, CareCompassLabels, CareCompassPromptConfig, CareCompassTheme, CareCompassValidationResult, } from "./schema.js";
+export { careCompassApiBaseUrlSchema, careCompassComplianceConfigSchema, careCompassConfigSchema, careCompassFeatureFlagsSchema, careCompassModelConfigSchema, createDefaultCareCompassConfig, validateCareCompassConfig, } from "./schema.js";
+export type { CareCompassComplianceConfig, CareCompassConfig, CareCompassConfigInput, CareCompassFeatureFlags, CareCompassLabels, CareCompassModelConfig, CareCompassPromptConfig, CareCompassTheme, CareCompassValidationResult, } from "./schema.js";
+export { CARECOMPASS_COMPLIANCE_PRESETS, detectCareCompassPhi, redactCareCompassPhi, resolveCareCompassCompliancePolicy, } from "./compliance.js";
+export type { CareCompassAuditEvent, CareCompassAuditEventType, CareCompassAuditListener, CareCompassAuditOutcome, CareCompassAuditSource, CareCompassCompliancePolicy, CareCompassCompliancePreset, CareCompassComplianceRuntimeOptions, CareCompassPhiAction, CareCompassPhiCategory, CareCompassPhiDetectionContext, CareCompassPhiDetector, CareCompassPhiHooks, CareCompassPhiMatch, CareCompassPhiRedactor, CareCompassPhiSource, CareCompassSafetyDecision, CareCompassSafetyEvent, CareCompassSafetyListener, } from "./compliance.js";
 export { CARECOMPASS_TELEMETRY_ERROR_CODES, CARECOMPASS_TELEMETRY_EVENTS, careCompassTelemetryDurationBucket, createCareCompassCliTelemetry, createCareCompassTelemetry, } from "./telemetry.js";
 export type { CareCompassTelemetry, CareCompassTelemetryCaptureOptions, CareCompassTelemetryDurationBucket, CareCompassTelemetryErrorCode, CareCompassTelemetryEvent, CareCompassTelemetryFailureCategory, } from "./telemetry.js";
 export { CARECOMPASS_COMPONENT_VERSION, CARECOMPASS_SDK_VERSION, CARECOMPASS_TELEMETRY_CONTRACT_VERSION, } from "./version.js";

package/dist/index.js

@@ -1,8 +1,11 @@
 export { createCareCompassClient } from "./client.js";
-export { CareCompassChat, CareCompassEmbed } from "./component.js";
+export { CareCompassChat, CareCompassEmbed, useCareCompass, } from "./component.js";
 export { createCareCompassCore } from "./core.js";
+export { CARECOMPASS_RCM_SYNTHETIC_DEMO, createRcmCodingWorkflow, RcmCodingAssistant, } from "./rcm.js";
 export { mountCareCompass } from "./mount.js";
+export { CARECOMPASS_ELEMENT_TAG, defineCareCompassElement, } from "./web-component.js";
 export { generateCareCompassIframeSnippet, generateCareCompassSnippet, } from "./snippet.js";
-export { careCompassApiBaseUrlSchema, careCompassConfigSchema, createDefaultCareCompassConfig, validateCareCompassConfig, } from "./schema.js";
+export { careCompassApiBaseUrlSchema, careCompassComplianceConfigSchema, careCompassConfigSchema, careCompassFeatureFlagsSchema, careCompassModelConfigSchema, createDefaultCareCompassConfig, validateCareCompassConfig, } from "./schema.js";
+export { CARECOMPASS_COMPLIANCE_PRESETS, detectCareCompassPhi, redactCareCompassPhi, resolveCareCompassCompliancePolicy, } from "./compliance.js";
 export { CARECOMPASS_TELEMETRY_ERROR_CODES, CARECOMPASS_TELEMETRY_EVENTS, careCompassTelemetryDurationBucket, createCareCompassCliTelemetry, createCareCompassTelemetry, } from "./telemetry.js";
 export { CARECOMPASS_COMPONENT_VERSION, CARECOMPASS_SDK_VERSION, CARECOMPASS_TELEMETRY_CONTRACT_VERSION, } from "./version.js";

package/dist/markdown.d.ts

@@ -1,3 +1,4 @@
+import React from "react";
 export declare function CareCompassMarkdown({ text }: {
     text: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

package/dist/mount.d.ts

@@ -1,4 +1,7 @@
+import type { CareCompassRuntimeTokenProvider } from "./client.js";
 import type { CareCompassConfig } from "./schema.js";
-export declare function mountCareCompass(element: Element | null, config: CareCompassConfig): {
+export declare function mountCareCompass(element: Element | null, config: CareCompassConfig, options?: {
+    runtimeTokenProvider?: CareCompassRuntimeTokenProvider;
+}): {
     unmount: () => void;
 };

package/dist/mount.js

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createRoot } from "react-dom/client";
 import { CareCompassEmbed } from "./component.js";
 import { CARECOMPASS_TELEMETRY_ERROR_CODES, CARECOMPASS_TELEMETRY_EVENTS, createCareCompassTelemetry, } from "./telemetry.js";
-export function mountCareCompass(element, config) {
+export function mountCareCompass(element, config, options = {}) {
     if (!element) {
         // Missing mount points usually mean a copied snippet and page markup drifted
         // apart, so capture the setup error before throwing to the caller.
@@ -13,7 +13,7 @@ export function mountCareCompass(element, config) {
         throw new Error("CareCompass mount element was not found.");
     }
     const root = createRoot(element);
-    root.render(_jsx(CareCompassEmbed, { config: config }));
+    root.render(_jsx(CareCompassEmbed, { config: config, runtimeTokenProvider: options.runtimeTokenProvider }));
     return {
         // Return the small React root facade so non-React hosts can clean up embeds.
         unmount: () => root.unmount(),

package/dist/rcm.d.ts

@@ -0,0 +1,93 @@
+import React from "react";
+import { type CareCompassCore, type CareCompassCoreOptions } from "./core.js";
+import type { CareCompassAuditListener, CareCompassSafetyListener } from "./compliance.js";
+import type { CareCompassConfig } from "./schema.js";
+/** A narrow, structured input for coding review. Do not include direct patient identifiers. */
+export type RcmCodingAssistanceInput = {
+    encounterId: string;
+    diagnosisNarrative: string;
+    procedureNarrative?: string;
+    serviceDate?: string;
+    placeOfService?: string;
+    claimContext?: {
+        payerName?: string;
+        submittedCodes?: string[];
+    };
+};
+export type RcmCodeSystem = "ICD-10-CM" | "CPT" | "HCPCS";
+export type RcmConfidence = "low" | "medium" | "high";
+export type RcmReviewDisposition = "review_required" | "abstain" | "escalate";
+export type RcmPolicyReference = {
+    corpusId: string;
+    id: string;
+    title: string;
+    excerpt: string;
+    version?: string;
+};
+export type RcmCodeRecommendation = {
+    code: string;
+    codeSystem: RcmCodeSystem;
+    confidence: RcmConfidence;
+    rationale: string;
+    policyReferenceIds: string[];
+};
+export type RcmCodingAssistanceResult = {
+    disposition: RcmReviewDisposition;
+    humanReviewRequired: true;
+    recommendations: RcmCodeRecommendation[];
+    documentationGaps: string[];
+    policyReferences: RcmPolicyReference[];
+    rationale: string;
+    /** A host-facing, measurable pilot hypothesis—not a claim of realized savings. */
+    operationalHypothesis: {
+        metric: "manual_research_minutes_per_case";
+        target: "Measure whether assisted review reduces manual research time by 25% or more.";
+    };
+    processingTimeMs: number;
+};
+export type RcmCustomerRules = {
+    allowedCodeSystems?: RcmCodeSystem[];
+    escalateOnLowConfidence?: boolean;
+    requirePolicySupport?: boolean;
+};
+export type RcmPolicyRetriever = {
+    /** Corpus IDs are allowlisted by the embed owner; retrieval stays in the host's trusted boundary. */
+    approvedCorpusIds: readonly string[];
+    search: (request: {
+        input: RcmCodingAssistanceInput;
+        query: string;
+    }) => Promise<RcmPolicyReference[]>;
+};
+export type RcmCodingWorkflowOptions = {
+    core?: CareCompassCore;
+    coreOptions?: CareCompassCoreOptions;
+    customerRules?: RcmCustomerRules;
+    now?: () => number;
+    onResult?: (result: RcmCodingAssistanceResult) => void;
+    /**
+     * `hosted` delegates retrieval to the tenant-authorized CareCompass runtime.
+     * The browser never supplies policy text or corpus identifiers in that mode.
+     */
+    retrieval?: RcmPolicyRetriever | "hosted";
+};
+export type RcmCodingWorkflow = {
+    core: CareCompassCore;
+    review: (input: RcmCodingAssistanceInput) => Promise<RcmCodingAssistanceResult>;
+};
+/**
+ * Creates a narrow RCM coding-review workflow on the shared CareCompass core.
+ * Retrieval can run in the CareCompass tenant boundary or be injected by a
+ * customer that maintains its own approved, server-side retrieval boundary.
+ */
+export declare function createRcmCodingWorkflow(config: CareCompassConfig, options?: RcmCodingWorkflowOptions): RcmCodingWorkflow;
+export declare const CARECOMPASS_RCM_SYNTHETIC_DEMO: RcmCodingAssistanceInput;
+export type RcmCodingAssistantProps = {
+    config: CareCompassConfig;
+    initialInput?: RcmCodingAssistanceInput;
+    onAuditEvent?: CareCompassAuditListener;
+    onResult?: (result: RcmCodingAssistanceResult) => void;
+    onSafetyEvent?: CareCompassSafetyListener;
+    workflowOptions?: Omit<RcmCodingWorkflowOptions, "core" | "coreOptions" | "onResult">;
+};
+/** A small branded form suitable for embedding the pilot workflow in a host app. */
+export declare function RcmCodingAssistant({ config, initialInput, onAuditEvent, onResult, onSafetyEvent, workflowOptions, }: RcmCodingAssistantProps): React.JSX.Element;