@cms.ai/brand_brain 0.0.1 → 0.1.0

package/dist/index.mjs

@@ -1385,7 +1385,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",
@@ -1405,8 +1409,7 @@ 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 = {
@@ -1432,6 +1435,74 @@ const EmbedTrackingEvent = {
 	EmbedSideTabClicked: "embed_side_tab_clicked",
 	EmbedSideTabDismissed: "embed_side_tab_dismissed"
 };
+/** How a brand kit colors the guide's skill icons. */
+const SkillIconColorMode = {
+	Default: "default",
+	Mono: "mono",
+	PerSkill: "per_skill"
+};
+/** Kind of content a document/playlist item points at. */
+const ContentType = {
+	PDF: "pdf",
+	DOCX: "docx",
+	PPTX: "pptx",
+	Image: "image",
+	VideoNative: "video_native",
+	VideoYouTube: "video_youtube",
+	VideoWistia: "video_wistia",
+	Document: "document",
+	URL: "url",
+	Text: "text",
+	Markdown: "markdown"
+};
+/** Confidence level attached to a content recommendation. */
+const Confidence = {
+	High: "high",
+	Medium: "medium",
+	Low: "low"
+};
+/** The render kind of a surfaced call-to-action. */
+const SkillCtaKind = {
+	Url: "url",
+	Form: "form",
+	Product: "product",
+	Scheduler: "scheduler"
+};
+/** Where a surfaced CTA renders. One slot today: below the skill response. */
+const CtaPlacement = { ResponseFooter: "response_footer" };
+/** Which scheduler embed a scheduler CTA loads. */
+const SchedulerProvider = {
+	HubSpot: "hubspot",
+	Calendly: "calendly"
+};
+/** Diagnose skill mode. */
+const DiagnoseSubtype = {
+	Standalone: "standalone",
+	ContextGathering: "context_gathering"
+};
+/** Answer option labels for diagnose questions. */
+const DiagnoseOptionLabel = {
+	A: "A",
+	B: "B",
+	C: "C",
+	D: "D"
+};
+/** Business case format sub-types. */
+const BusinessCaseSubType = {
+	RoiAnalysis: "roi-analysis",
+	StakeholderBrief: "stakeholder-brief",
+	VendorComparison: "vendor-comparison"
+};
+/** Node types in a solution design diagram. */
+const SolutionDesignNodeType = {
+	Process: "process",
+	Decision: "decision",
+	Datastore: "datastore",
+	External: "external",
+	Trigger: "trigger",
+	Start: "start",
+	End: "end"
+};
 //#endregion
 //#region src/chat-stream.ts
 const DATA_PREFIX = "data:";
@@ -1459,7 +1530,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 = "";
@@ -1518,6 +1595,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 ?? {};
@@ -1530,20 +1614,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
@@ -1597,7 +1703,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({
@@ -1736,6 +1844,149 @@ async function initGuide(config) {
 	return GuideClient.init(config);
 }
 //#endregion
-export { ConsentTier, EmbedTrackingEvent, GuideClient, GuideEvent, SSEMessageType, SkillResponseType, initGuide };
+//#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
+export { BusinessCaseSubType, Confidence, ConsentTier, ContentType, CtaPlacement, DiagnoseOptionLabel, DiagnoseSubtype, EmbedTrackingEvent, GuideClient, GuideEvent, SSEMessageType, SchedulerProvider, SkillCtaKind, SkillIconColorMode, SkillResponseType, SolutionDesignNodeType, createSkillTurn, initGuide, reduceSkillEvent };
 
 //# sourceMappingURL=index.mjs.map