@cms.ai/brand_brain 0.0.1 → 0.1.0

package/dist/react/index.cjs

@@ -1387,7 +1387,11 @@ const SSEMessageType = {
 	TextMessageEnd: "TEXT_MESSAGE_END",
 	Custom: "CUSTOM"
 };
-/** The `name` on `CUSTOM` guide events (skill payloads). */
+/**
+* The `name` on `CUSTOM` guide events (skill payloads). `SkillGate` and
+* `SkillError` never surface as `skill` stream events — the SDK re-maps them to
+* the dedicated `gate` / `error` {@link GuideStreamEvent} variants.
+*/
 const GuideEvent = {
 	SkillStart: "skill_start",
 	SkillContent: "skill_content",
@@ -1407,8 +1411,17 @@ const GuideEvent = {
 	SkillSolutionDesignDiagram: "skill_solutiondesign_diagram",
 	SkillEnd: "skill_end",
 	SkillError: "skill_error",
-	SkillGate: "skill_gate",
-	InputSuggestions: "input_suggestions"
+	SkillGate: "skill_gate"
+};
+/** The guide skill types. `answer` is always on; the rest are enabled per-guide. */
+const SkillResponseType = {
+	Answer: "answer",
+	HowTo: "howto",
+	Diagnose: "diagnose",
+	Recommend: "recommend",
+	Playlist: "playlist",
+	BusinessCase: "businesscase",
+	SolutionDesign: "solutiondesign"
 };
 /** Analytics events fired by the SDK bootstrap. */
 const EmbedTrackingEvent = {
@@ -1445,7 +1458,13 @@ async function* streamConversation(params) {
 		body: JSON.stringify(body),
 		signal
 	});
-	if (!response.ok || !response.body) throw new Error(`[brand_brain] Conversation request failed with status ${response.status}`);
+	if (!response.ok || !response.body) {
+		let detail = "";
+		try {
+			detail = (await response.text()).trim();
+		} catch {}
+		throw new Error(`[brand_brain] Conversation request failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+	}
 	const reader = response.body.getReader();
 	const decoder = new TextDecoder();
 	let buffer = "";
@@ -1504,6 +1523,13 @@ function mapFrame(frame) {
 		default: return null;
 	}
 }
+/**
+* Names that surface as typed `skill` events. `SkillGate`/`SkillError` are
+* re-mapped to the `gate`/`error` variants below, so they are excluded here;
+* any name outside this set is a server event this SDK version predates and
+* flows through as `skill-unknown`.
+*/
+const SKILL_EVENT_NAMES = new Set(Object.values(GuideEvent).filter((name) => name !== GuideEvent.SkillGate && name !== GuideEvent.SkillError));
 function mapCustomFrame(frame) {
 	if (!frame.name) return null;
 	const value = frame.value ?? {};
@@ -1516,20 +1542,42 @@ function mapCustomFrame(frame) {
 	if (frame.name === GuideEvent.SkillError) return {
 		type: "error",
 		message: value.message ?? "Skill error",
-		code: value.errorType
+		code: value.errorType,
+		retryable: value.retryable,
+		retryHint: value.retryHint
 	};
-	return {
+	if (SKILL_EVENT_NAMES.has(frame.name)) return {
 		type: "skill",
 		name: frame.name,
 		value
 	};
+	return {
+		type: "skill-unknown",
+		name: frame.name,
+		value
+	};
 }
 //#endregion
 //#region src/GuideClient.ts
+/**
+* The account is resolved by the branded host the SDK talks to, and that host
+* must be same-site with `baseUrl` for the visitor cookies to attach — so the
+* `baseUrl` hostname IS the registered account domain. Derive it from there
+* rather than the host page's `window.location`, which is an unrelated origin
+* for cross-site embeds and produces a "Domain not found" 404 on resolve.
+*/
 function resolveDomain(config) {
 	if (config.domain) return config.domain;
-	if (typeof window !== "undefined") return window.location.hostname;
-	throw new Error("[brand_brain] `domain` is required when running without a browser `window`.");
+	return hostnameFromBaseUrl(config.baseUrl);
+}
+/**
+* Normalize `baseUrl` to the bare host the server stores: lowercased, no port,
+* no leading `www.` (the domain write-path strips it, so a `www.` host can
+* never match). Accepts a bare host too, in case `baseUrl` omits the protocol.
+*/
+function hostnameFromBaseUrl(baseUrl) {
+	const withProtocol = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseUrl) ? baseUrl : `https://${baseUrl}`;
+	return new URL(withProtocol).hostname.toLowerCase().replace(/^www\./, "");
 }
 /**
 * The client returned by {@link initGuide}. Holds the resolved guide, the
@@ -1583,7 +1631,9 @@ var GuideClient = class GuideClient {
 		this.#api = createApiClient(this.apiBaseUrl, this.fetchImpl);
 	}
 	static async init(config) {
-		const fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+		const globalFetch = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+		const fetchImpl = config.fetch ?? globalFetch;
+		if (!fetchImpl) throw new Error("[brand_brain] No `fetch` is available — pass `config.fetch` when running without a global fetch.");
 		const apiBaseUrl = toApiBaseUrl(config.baseUrl);
 		const domain = resolveDomain(config);
 		const guide = await createApiClient(apiBaseUrl, fetchImpl).guides.resolve({
@@ -1722,26 +1772,181 @@ async function initGuide(config) {
 	return GuideClient.init(config);
 }
 //#endregion
+//#region src/skill-state.ts
+/** A fresh, empty turn state. */
+function createSkillTurn() {
+	return {
+		skill: null,
+		status: "streaming",
+		messageId: null,
+		diagnoseSubtype: null,
+		followUpSkill: null,
+		content: "",
+		documents: [],
+		contentRecommendations: [],
+		followUpRecommendations: [],
+		ctas: [],
+		diagnoseHeader: null,
+		diagnoseQuestions: [],
+		playlistHeader: null,
+		playlistItems: [],
+		howToOutline: null,
+		howToSteps: [],
+		businessCaseFormats: [],
+		businessCaseDrafts: {},
+		businessCaseContent: {},
+		solutionDesignHeader: null,
+		solutionDesignNodes: [],
+		solutionDesignEdges: [],
+		skillInstanceId: null
+	};
+}
+/** A recommendations payload is content cards iff its entries carry `targetSkill`. */
+function isContentRecommendations(recommendations) {
+	return recommendations.length > 0 && "targetSkill" in recommendations[0];
+}
+/**
+* Fold one `skill` stream event into the turn state. Pure and immutable — the
+* returned object is a new reference whenever anything changed, so the result
+* can back React state directly:
+*
+* ```ts
+* let turn = createSkillTurn();
+* for await (const event of client.ask(message)) {
+*   if (event.type === "skill") turn = reduceSkillEvent(turn, event);
+* }
+* ```
+*/
+function reduceSkillEvent(turn, event) {
+	switch (event.name) {
+		case GuideEvent.SkillStart: return {
+			...event.value.skill === SkillResponseType.BusinessCase && turn.skill === SkillResponseType.BusinessCase ? {
+				...createSkillTurn(),
+				businessCaseFormats: turn.businessCaseFormats,
+				businessCaseDrafts: turn.businessCaseDrafts,
+				businessCaseContent: turn.businessCaseContent
+			} : createSkillTurn(),
+			skill: event.value.skill,
+			messageId: event.value.messageId,
+			diagnoseSubtype: event.value.diagnoseSubtype ?? null,
+			followUpSkill: event.value.followUpSkill ?? null
+		};
+		case GuideEvent.SkillContent: return {
+			...turn,
+			content: turn.content + event.value.delta
+		};
+		case GuideEvent.SkillDocuments: return {
+			...turn,
+			documents: event.value.documents
+		};
+		case GuideEvent.SkillRecommendations: return isContentRecommendations(event.value.recommendations) ? {
+			...turn,
+			contentRecommendations: event.value.recommendations
+		} : {
+			...turn,
+			followUpRecommendations: event.value.recommendations
+		};
+		case GuideEvent.SkillCTAs: return {
+			...turn,
+			ctas: event.value.ctas
+		};
+		case GuideEvent.SkillDiagnoseHeader: return {
+			...turn,
+			diagnoseHeader: event.value.header
+		};
+		case GuideEvent.SkillDiagnoseQuestion: return {
+			...turn,
+			diagnoseQuestions: [...turn.diagnoseQuestions, event.value.question]
+		};
+		case GuideEvent.SkillPlaylistHeader: return {
+			...turn,
+			playlistHeader: event.value.header
+		};
+		case GuideEvent.SkillPlaylistItems: return {
+			...turn,
+			playlistItems: event.value.items
+		};
+		case GuideEvent.SkillPlaylistRationale: return {
+			...turn,
+			playlistItems: turn.playlistItems.map((item) => item.id === event.value.itemId ? {
+				...item,
+				rationale: event.value.rationale
+			} : item)
+		};
+		case GuideEvent.SkillHowToOutline: return {
+			...turn,
+			howToOutline: event.value.outline,
+			skillInstanceId: event.value.skillInstanceId ?? turn.skillInstanceId
+		};
+		case GuideEvent.SkillHowToSteps: return {
+			...turn,
+			howToSteps: event.value.steps
+		};
+		case GuideEvent.SkillBusinessCaseChooser: return {
+			...turn,
+			businessCaseFormats: event.value.formats,
+			businessCaseDrafts: event.value.drafts
+		};
+		case GuideEvent.SkillBusinessCaseDelta: {
+			const existing = turn.businessCaseContent[event.value.subType] ?? "";
+			return {
+				...turn,
+				businessCaseContent: {
+					...turn.businessCaseContent,
+					[event.value.subType]: existing + event.value.delta
+				}
+			};
+		}
+		case GuideEvent.SkillSolutionDesignHeader: return {
+			...turn,
+			solutionDesignHeader: event.value.header
+		};
+		case GuideEvent.SkillSolutionDesignDiagram: return {
+			...turn,
+			solutionDesignNodes: event.value.nodes,
+			solutionDesignEdges: event.value.edges
+		};
+		case GuideEvent.SkillEnd: return {
+			...turn,
+			status: "complete",
+			skillInstanceId: event.value.skillInstanceId ?? event.value.skillResponseId ?? turn.skillInstanceId
+		};
+		default: return event;
+	}
+}
+//#endregion
 //#region src/react/useGuide.ts
 /**
 * React binding over {@link initGuide}. Bootstraps once per `baseUrl`+`slug`,
-* mirrors the streamed reply into state, and ends the session on unmount —
+* mirrors the streamed reply into `messages`, folds structured skill events
+* into `skillTurn`, surfaces email gates, and ends the session on unmount —
 * encapsulating the streaming/cleanup patterns so generated UIs stay correct.
 */
 function useGuide(config) {
 	const [client, setClient] = (0, react.useState)(null);
 	const [messages, setMessages] = (0, react.useState)([]);
+	const [skillTurn, setSkillTurn] = (0, react.useState)(null);
+	const [gate, setGate] = (0, react.useState)(null);
 	const [isStreaming, setIsStreaming] = (0, react.useState)(false);
 	const [error, setError] = (0, react.useState)(null);
 	const { baseUrl, slug } = config;
 	const configRef = (0, react.useRef)(config);
 	configRef.current = config;
+	const turnRef = (0, react.useRef)(null);
+	const lastAskRef = (0, react.useRef)(null);
 	(0, react.useEffect)(() => {
 		let active = true;
 		let created = null;
+		setClient(null);
+		setMessages([]);
+		setSkillTurn(null);
+		setGate(null);
+		setError(null);
+		turnRef.current = null;
+		lastAskRef.current = null;
 		initGuide(configRef.current).then((instance) => {
 			if (!active) {
-				instance.endSession();
+				instance.endSession().catch(() => {});
 				return;
 			}
 			created = instance;
@@ -1752,15 +1957,32 @@ function useGuide(config) {
 		});
 		return () => {
 			active = false;
-			created?.endSession();
+			created?.endSession().catch(() => {});
 		};
 	}, [baseUrl, slug]);
 	const ask = (0, react.useCallback)(async (message, options) => {
 		if (!client) return;
+		lastAskRef.current = {
+			message,
+			options
+		};
 		setIsStreaming(true);
 		setError(null);
+		setGate(null);
 		try {
-			for await (const event of client.ask(message, options)) if (event.type === "text" || event.type === "message-start") setMessages([...client.messages]);
+			for await (const event of client.ask(message, options)) {
+				configRef.current.onEvent?.(event);
+				if (event.type === "text" || event.type === "message-start") setMessages([...client.messages]);
+				else if (event.type === "skill") {
+					turnRef.current = reduceSkillEvent(turnRef.current ?? createSkillTurn(), event);
+					setSkillTurn(turnRef.current);
+				} else if (event.type === "gate") setGate({
+					skill: event.skill,
+					prompt: event.prompt,
+					skillInstanceId: event.skillInstanceId
+				});
+				else if (event.type === "error") setError(new Error(event.message));
+			}
 			setMessages([...client.messages]);
 		} catch (err) {
 			setError(err instanceof Error ? err : new Error(String(err)));
@@ -1768,18 +1990,44 @@ function useGuide(config) {
 			setIsStreaming(false);
 		}
 	}, [client]);
+	const submitGate = (0, react.useCallback)(async (email, options) => {
+		if (!client) throw new Error("[brand_brain] Guide is not ready yet — wait for isReady before submitting the gate.");
+		const pending = gate;
+		const result = await client.submitGate(email, {
+			...pending && {
+				skill: pending.skill,
+				prompt: pending.prompt,
+				skillInstanceId: pending.skillInstanceId
+			},
+			...options
+		});
+		if (result.success) setGate(null);
+		return result;
+	}, [client, gate]);
+	const retryLastAsk = (0, react.useCallback)(async () => {
+		const last = lastAskRef.current;
+		if (last) await ask(last.message, last.options);
+	}, [ask]);
 	const reset = (0, react.useCallback)(() => {
 		client?.reset();
 		setMessages([]);
+		setSkillTurn(null);
+		setGate(null);
+		turnRef.current = null;
+		lastAskRef.current = null;
 	}, [client]);
 	return {
 		client,
 		guide: client?.guide ?? null,
 		messages,
+		skillTurn,
+		gate,
 		isReady: client !== null,
 		isStreaming,
 		error,
 		ask,
+		submitGate,
+		retryLastAsk,
 		reset
 	};
 }