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

package/dist/core.js

@@ -0,0 +1,352 @@
+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,
+    message: error instanceof Error ? error.message : String(error),
+});
+export function createCareCompassCore(config, options = {}) {
+    const now = options.now ?? Date.now;
+    const pollIntervalMs = options.pollIntervalMs ?? 1500;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    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;
+    let context = { ...(options.initialContext ?? {}) };
+    let phase = "idle";
+    let error = null;
+    let activeJobId = null;
+    let retry = null;
+    let messages = [
+        {
+            id: "welcome",
+            role: "assistant",
+            text: config.prompt.welcomeMessage,
+            createdAt: now(),
+            status: "complete",
+        },
+    ];
+    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,
+        loading: phase === "submitting" || phase === "streaming",
+        error: error ? { ...error } : null,
+        context: { ...context },
+        canRetry: !disposed && retry !== null && phase === "error",
+        retry: retry
+            ? {
+                prompt: retry.prompt,
+                requestId: retry.requestId,
+                workflow: retry.workflow,
+                context: { ...retry.context },
+                attempts: retry.attempts,
+            }
+            : null,
+        activeJobId,
+    });
+    const notify = () => {
+        const snapshot = getSnapshot();
+        for (const listener of listeners)
+            listener(snapshot);
+    };
+    const event = (value) => ({ ...value, snapshot: getSnapshot() });
+    const fail = (coreError) => {
+        error = coreError;
+        phase = disposed ? "disposed" : "error";
+        activeJobId = null;
+        emitAudit("error", "failed");
+        notify();
+        return event({ type: "error", error: coreError });
+    };
+    const ensureAvailable = () => {
+        if (!disposed)
+            return;
+        throw new Error("CareCompass core is disposed.");
+    };
+    async function* streamMessage(promptInput, sendOptions = {}) {
+        ensureAvailable();
+        if (phase === "submitting" || phase === "streaming") {
+            throw new Error("CareCompass request is already in progress.");
+        }
+        const prompt = promptInput.trim();
+        if (!prompt)
+            return;
+        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: protectedPromptValue,
+            createdAt: now(),
+            status: "complete",
+        };
+        messages = [...messages, userMessage];
+        phase = "submitting";
+        error = null;
+        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: protectedPromptValue,
+                requestId,
+                workflow: sendOptions.workflow,
+                userContext: requestContext,
+            });
+            activeJobId = jobId;
+            phase = "streaming";
+            notify();
+            while (now() - startedAt < timeoutMs) {
+                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: protectedResponse.value,
+                        createdAt: now(),
+                        status: "complete",
+                        retrieval: status.retrieval,
+                    };
+                    messages = [...messages, assistantMessage];
+                    phase = "complete";
+                    error = null;
+                    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,
+                    });
+                    return;
+                }
+                if (status.status === "failed") {
+                    const failed = errorFrom(new Error(status.result ?? config.labels.errorMessage));
+                    retry = {
+                        prompt: protectedPromptValue,
+                        workflow: sendOptions.workflow,
+                        context: requestContext,
+                        attempts: 0,
+                    };
+                    yield fail(failed);
+                    failureAlreadyCaptured = true;
+                    throw new Error(failed.message);
+                }
+                if (pollIntervalMs > 0)
+                    await sleep(pollIntervalMs);
+            }
+            client.recordInferenceTimeout(jobId, now() - startedAt);
+            const timedOut = errorFrom(new Error("CareCompass request timed out."), "timeout");
+            retry = {
+                prompt: protectedPromptValue,
+                requestId,
+                workflow: sendOptions.workflow,
+                context: requestContext,
+                attempts: 0,
+            };
+            yield fail(timedOut);
+            failureAlreadyCaptured = true;
+            throw new Error(timedOut.message);
+        }
+        catch (caught) {
+            if (failureAlreadyCaptured)
+                throw caught;
+            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 =
+                typeof nextContext === "function"
+                    ? { ...nextContext({ ...context }) }
+                    : { ...context, ...nextContext };
+            notify();
+        },
+        sendMessage: async (prompt, sendOptions) => {
+            const iterator = streamMessage(prompt, sendOptions)[Symbol.asyncIterator]();
+            while (!(await iterator.next()).done) {
+                // Consumers that only need the final state can use sendMessage.
+            }
+            return getSnapshot();
+        },
+        streamMessage,
+        retryLast: async () => {
+            ensureAvailable();
+            if (!retry)
+                return getSnapshot();
+            const retryRequest = retry;
+            retry = null;
+            return await streamRetry({
+                ...retryRequest,
+                attempts: retryRequest.attempts + 1,
+            });
+        },
+        reset: () => {
+            ensureAvailable();
+            messages = [
+                {
+                    id: "welcome",
+                    role: "assistant",
+                    text: config.prompt.welcomeMessage,
+                    createdAt: now(),
+                    status: "complete",
+                },
+            ];
+            phase = "idle";
+            error = null;
+            activeJobId = null;
+            retry = null;
+            notify();
+        },
+        dispose: () => {
+            disposed = true;
+            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) {
+            // Drain retry events.
+        }
+        return getSnapshot();
+    }
+}

package/dist/index.d.ts

@@ -1,10 +1,19 @@
 export { createCareCompassClient } from "./client.js";
-export type { CareCompassAskRequest, CareCompassAskResponse, CareCompassStatusResponse, } from "./client.js";
-export { CareCompassEmbed } 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,7 +1,11 @@
 export { createCareCompassClient } from "./client.js";
-export { 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

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

package/dist/markdown.js

@@ -0,0 +1,183 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+const markdownContainerStyle = {
+    alignItems: "stretch",
+    display: "flex",
+    flexDirection: "column",
+    gap: 10,
+    inlineSize: "100%",
+    lineHeight: 1.55,
+    textAlign: "start",
+};
+const compactBlockStyle = {
+    marginBlock: 0,
+    textAlign: "start",
+};
+const listStyle = {
+    display: "flex",
+    flexDirection: "column",
+    gap: 6,
+    marginBlock: 0,
+    paddingInlineStart: 22,
+    textAlign: "start",
+};
+const nestedListStyle = {
+    ...listStyle,
+    gap: 4,
+    marginBlockStart: 6,
+};
+const listItemStyle = {
+    paddingInlineStart: 2,
+    textAlign: "start",
+};
+const tableWrapStyle = {
+    marginBlock: 2,
+    overflowX: "auto",
+    textAlign: "start",
+};
+const tableStyle = {
+    borderCollapse: "collapse",
+    fontSize: "0.92em",
+    inlineSize: "100%",
+    textAlign: "start",
+};
+const cellStyle = {
+    border: "1px solid color-mix(in srgb, currentColor 18%, transparent)",
+    padding: "7px 9px",
+    textAlign: "start",
+    verticalAlign: "top",
+};
+const isTableSeparator = (line) => /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line);
+const isTableRow = (line) => line.includes("|");
+const splitTableRow = (line) => line
+    .trim()
+    .replace(/^\|/, "")
+    .replace(/\|$/, "")
+    .split("|")
+    .map((cell) => cell.trim());
+const isBlockStart = (line, nextLine) => /^#{1,6}\s+/.test(line) ||
+    /^\s*[-*]\s+/.test(line) ||
+    /^\s*\d+\.\s+/.test(line) ||
+    line.trim() === "---" ||
+    (isTableRow(line) && nextLine !== undefined && isTableSeparator(nextLine));
+function renderInline(text, keyPrefix) {
+    const parts = [];
+    const pattern = /\*\*([^*]+)\*\*/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            parts.push(text.slice(lastIndex, match.index));
+        }
+        parts.push(_jsx("strong", { style: { fontWeight: 700 }, children: match[1] }, `${keyPrefix}-strong-${match.index}`));
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        parts.push(text.slice(lastIndex));
+    }
+    return parts.length ? parts : text;
+}
+export function CareCompassMarkdown({ text }) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const blocks = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const heading = /^(#{1,6})\s+(.+)$/.exec(trimmed);
+        if (heading) {
+            const level = Math.min(heading[1].length, 6);
+            const tag = `h${level}`;
+            blocks.push(React.createElement(tag, {
+                key: `heading-${index}`,
+                style: {
+                    fontSize: level <= 3 ? "1.05em" : "0.98em",
+                    fontWeight: 700,
+                    lineHeight: 1.25,
+                    marginBlock: "2px 0",
+                    textAlign: "start",
+                },
+            }, renderInline(heading[2], `heading-${index}`)));
+            continue;
+        }
+        if (trimmed === "---") {
+            blocks.push(_jsx("hr", { style: {
+                    border: 0,
+                    borderBlockStart: "1px solid color-mix(in srgb, currentColor 18%, transparent)",
+                    inlineSize: "100%",
+                    marginBlock: 4,
+                } }, `hr-${index}`));
+            continue;
+        }
+        if (isTableRow(trimmed) &&
+            lines[index + 1] !== undefined &&
+            isTableSeparator(lines[index + 1])) {
+            const headers = splitTableRow(trimmed);
+            const rows = [];
+            index += 2;
+            while (index < lines.length && isTableRow(lines[index].trim())) {
+                rows.push(splitTableRow(lines[index]));
+                index += 1;
+            }
+            index -= 1;
+            blocks.push(_jsx("div", { style: tableWrapStyle, children: _jsxs("table", { style: tableStyle, children: [_jsx("thead", { children: _jsx("tr", { children: headers.map((header, headerIndex) => (_jsx("th", { scope: "col", style: { ...cellStyle, fontWeight: 700 }, children: renderInline(header, `header-${index}-${headerIndex}`) }, `header-${headerIndex}`))) }) }), _jsx("tbody", { children: rows.map((row, rowIndex) => (_jsx("tr", { children: headers.map((_, cellIndex) => (_jsx("td", { style: cellStyle, children: renderInline(row[cellIndex] ?? "", `cell-${index}-${rowIndex}-${cellIndex}`) }, `cell-${cellIndex}`))) }, `row-${rowIndex}`))) })] }) }, `table-wrap-${index}`));
+            continue;
+        }
+        if (/^\s*[-*]\s+/.test(line)) {
+            const items = [];
+            while (index < lines.length && /^\s*[-*]\s+/.test(lines[index])) {
+                items.push(lines[index].replace(/^\s*[-*]\s+/, ""));
+                index += 1;
+            }
+            index -= 1;
+            blocks.push(_jsx("ul", { style: listStyle, children: items.map((item, itemIndex) => (_jsx("li", { style: listItemStyle, children: renderInline(item, `ul-${index}-${itemIndex}`) }, `li-${itemIndex}`))) }, `ul-${index}`));
+            continue;
+        }
+        if (/^\s*\d+\.\s+/.test(line)) {
+            const items = [];
+            while (index < lines.length) {
+                const orderedMatch = /^\s*\d+\.\s+(.+)$/.exec(lines[index]);
+                if (!orderedMatch)
+                    break;
+                const item = {
+                    text: orderedMatch[1],
+                    bullets: [],
+                };
+                index += 1;
+                while (index < lines.length) {
+                    const next = lines[index];
+                    const nextTrimmed = next.trim();
+                    if (!nextTrimmed) {
+                        index += 1;
+                        continue;
+                    }
+                    if (/^\s*[-*]\s+/.test(next)) {
+                        item.bullets.push(next.replace(/^\s*[-*]\s+/, ""));
+                        index += 1;
+                        continue;
+                    }
+                    if (/^\s*\d+\.\s+/.test(next))
+                        break;
+                    if (isBlockStart(nextTrimmed, lines[index + 1]))
+                        break;
+                    item.bullets.push(nextTrimmed);
+                    index += 1;
+                }
+                items.push(item);
+            }
+            index -= 1;
+            blocks.push(_jsx("ol", { style: listStyle, children: items.map((item, itemIndex) => (_jsxs("li", { style: listItemStyle, children: [renderInline(item.text, `ol-${index}-${itemIndex}`), item.bullets.length ? (_jsx("ul", { style: nestedListStyle, children: item.bullets.map((bullet, bulletIndex) => (_jsx("li", { style: listItemStyle, children: renderInline(bullet, `ol-${index}-${itemIndex}-${bulletIndex}`) }, `bullet-${bulletIndex}`))) })) : null] }, `li-${itemIndex}`))) }, `ol-${index}`));
+            continue;
+        }
+        const paragraphLines = [trimmed];
+        while (index + 1 < lines.length &&
+            lines[index + 1].trim() &&
+            !isBlockStart(lines[index + 1].trim(), lines[index + 2])) {
+            index += 1;
+            paragraphLines.push(lines[index].trim());
+        }
+        blocks.push(_jsx("p", { style: compactBlockStyle, children: renderInline(paragraphLines.join(" "), `p-${index}`) }, `p-${index}`));
+    }
+    return _jsx("div", { style: markdownContainerStyle, children: blocks });
+}

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(),