@newfold/wp-module-ai-chat 1.0.0

package/src/utils/markdownParser.js

@@ -0,0 +1,319 @@
+/**
+ * Simple Markdown Parser
+ *
+ * Converts common markdown syntax to HTML for chat messages.
+ * Handles: headers, bold, italic, code, lists, links, and line breaks.
+ */
+
+/**
+ * Words to strip from the end of a URL when they were incorrectly included
+ * (e.g. ?p=58Is, path/If, or after newline). Primary fix: words *after* the URL.
+ * Also used for leading cases: Wordhttp:// and markdown [Word http](url).
+ */
+const SENTENCE_STARTER_WORDS_AFTER_URL = [
+	"Would",
+	"If",
+	"Like",
+	"And",
+	"But",
+	"Or",
+	"So",
+	"Maybe",
+	"Perhaps",
+	"Well",
+	"Yes",
+	"No",
+	"When",
+	"Where",
+	"How",
+	"Why",
+	"It",
+	"To",
+	"We",
+	"Do",
+	"Be",
+	"As",
+	"An",
+	"The",
+	"You",
+	"In",
+	"On",
+	"At",
+	"By",
+	"Is",
+];
+
+/** Word immediately followed by http(s) (no space) - pre-pass insert space. */
+const WORD_BEFORE_URL_NO_SPACE = new RegExp(
+	`\\b(${SENTENCE_STARTER_WORDS_AFTER_URL.join("|")})(https?:\\/\\/)`,
+	"gi"
+);
+
+/** One or more prose words + spaces, then rest - for trimming markdown link text. */
+const PROSE_WORDS_THEN_URL = new RegExp(
+	`^((${SENTENCE_STARTER_WORDS_AFTER_URL.join("|")})\\s+)+(.+)$`,
+	"i"
+);
+
+/** Trailing /Word at end of URL (e.g. path/If) - strip Word from URL. */
+const TRAILING_SLASH_WORD = new RegExp(
+	`\\/(${SENTENCE_STARTER_WORDS_AFTER_URL.join("|")})$`,
+	"i"
+);
+
+/** Trailing digit+Word at end of URL (e.g. ?p=58Is) - strip Word from URL. */
+const TRAILING_DIGIT_WORD = new RegExp(
+	`(\\d)(${SENTENCE_STARTER_WORDS_AFTER_URL.join("|")})$`,
+	"i"
+);
+
+const URL_ONLY_PATTERN = /^https?:\/\/[^\s<>"]+$/;
+
+/**
+ * Check if a string contains markdown syntax
+ *
+ * @param {string} text - The text to check
+ * @return {boolean} True if markdown is detected
+ */
+export function containsMarkdown(text) {
+	if (!text || typeof text !== "string") {
+		return false;
+	}
+
+	// Check for common markdown patterns
+	const markdownPatterns = [
+		/^#{1,6}\s/m, // Headers
+		/\*\*[^*]+\*\*/, // Bold
+		/\*[^*]+\*/, // Italic
+		/__[^_]+__/, // Bold (underscore)
+		/_[^_]+_/, // Italic (underscore)
+		/`[^`]+`/, // Inline code
+		/```[\s\S]*?```/, // Code blocks
+		/^\s*[-*+]\s/m, // Unordered lists
+		/^\s*\d+\.\s/m, // Ordered lists
+		/\[([^\]]+)\]\(([^)]+)\)/, // Links
+	];
+
+	return markdownPatterns.some((pattern) => pattern.test(text));
+}
+
+/**
+ * Parse markdown text to HTML
+ *
+ * @param {string} text - The markdown text to parse
+ * @return {string} HTML string
+ */
+export function parseMarkdown(text) {
+	if (!text || typeof text !== "string") {
+		return "";
+	}
+
+	let html = text;
+
+	// Escape HTML entities first (but preserve existing HTML)
+	html = html
+		.replace(/&(?![\w#]+;)/g, "&amp;")
+		.replace(/<(?![a-zA-Z/])/g, "&lt;")
+		.replace(/(?<![a-zA-Z"])>/g, "&gt;");
+
+	// Code blocks (``` ... ```) - must be done before other processing
+	html = html.replace(/```(\w*)\n?([\s\S]*?)```/g, (match, lang, code) => {
+		const escapedCode = code.trim().replace(/</g, "&lt;").replace(/>/g, "&gt;");
+		return `<pre><code class="language-${lang || "plaintext"}">${escapedCode}</code></pre>`;
+	});
+
+	// Inline code (` ... `)
+	html = html.replace(/`([^`]+)`/g, '<code class="inline-code">$1</code>');
+
+	// Headers (### ... )
+	html = html.replace(/^######\s+(.+)$/gm, '<h6 class="chat-h6">$1</h6>');
+	html = html.replace(/^#####\s+(.+)$/gm, '<h5 class="chat-h5">$1</h5>');
+	html = html.replace(/^####\s+(.+)$/gm, '<h4 class="chat-h4">$1</h4>');
+	html = html.replace(/^###\s+(.+)$/gm, '<h3 class="chat-h3">$1</h3>');
+	html = html.replace(/^##\s+(.+)$/gm, '<h2 class="chat-h2">$1</h2>');
+	html = html.replace(/^#\s+(.+)$/gm, '<h1 class="chat-h1">$1</h1>');
+
+	// Bold (**text** or __text__)
+	html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+	html = html.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+
+	// Italic (*text* or _text_) - but not inside URLs or code
+	html = html.replace(/(?<![*_])\*(?!\*)([^*\n]+)(?<!\*)\*(?!\*)/g, "<em>$1</em>");
+	html = html.replace(/(?<![_*])_(?!_)([^_\n]+)(?<!_)_(?!_)/g, "<em>$1</em>");
+
+	// Links [text](url) - trim leading prose words from link text when rest is a URL
+	html = html.replace(
+		/\[([^\]]+)\]\(([^)]+)\)/g,
+		(match, text, url) => {
+			const trimmedText = text.trim();
+			const leadingMatch = trimmedText.match(PROSE_WORDS_THEN_URL);
+			const rest = leadingMatch ? leadingMatch[3].trim() : "";
+			const isRestUrl =
+				rest && (URL_ONLY_PATTERN.test(rest) || /^https?:\/\//.test(rest));
+			const safeHref = url.replace(/"/g, "&quot;");
+			if (leadingMatch && isRestUrl) {
+				const leadingWords = leadingMatch[1];
+				const safeUrlText = rest
+					.replace(/&/g, "&amp;")
+					.replace(/</g, "&lt;")
+					.replace(/>/g, "&gt;")
+					.replace(/"/g, "&quot;");
+				return `${leadingWords}<a href="${safeHref}" target="_blank" rel="noopener noreferrer">${safeUrlText}</a>`;
+			}
+			const safeText = text
+				.replace(/&/g, "&amp;")
+				.replace(/</g, "&lt;")
+				.replace(/>/g, "&gt;")
+				.replace(/"/g, "&quot;");
+			return `<a href="${safeHref}" target="_blank" rel="noopener noreferrer">${safeText}</a>`;
+		}
+	);
+
+	// Unordered lists - collect consecutive list items
+	html = html.replace(/^(\s*)[-*+]\s+(.+)$/gm, (match, indent, content) => {
+		const level = Math.floor(indent.length / 2);
+		return `<li class="chat-li" data-level="${level}">${content}</li>`;
+	});
+
+	// Wrap consecutive list items in <ul>
+	html = html.replace(/((?:<li[^>]*>.*?<\/li>\s*)+)/g, (match) => {
+		const cleanedItems = match.replace(/(<\/li>)\s+(<li)/g, "$1$2");
+		return `<ul class="chat-ul">${cleanedItems}</ul>`;
+	});
+
+	// Ordered lists
+	html = html.replace(/^(\s*)\d+\.\s+(.+)$/gm, (match, indent, content) => {
+		const level = Math.floor(indent.length / 2);
+		return `<oli class="chat-oli" data-level="${level}">${content}</oli>`;
+	});
+
+	// Wrap consecutive ordered list items in <ol>
+	html = html.replace(/((?:<oli[^>]*>.*?<\/oli>\s*)+)/g, (match) => {
+		const cleanedItems = match
+			.replace(/(<\/oli>)\s+(<oli)/g, "$1$2")
+			.replace(/<\/?oli/g, (m) => m.replace("oli", "li"));
+		return `<ol class="chat-ol">${cleanedItems}</ol>`;
+	});
+
+	// Horizontal rules
+	html = html.replace(/^---+$/gm, '<hr class="chat-hr" />');
+
+	// Blockquotes
+	html = html.replace(/^>\s+(.+)$/gm, '<blockquote class="chat-blockquote">$1</blockquote>');
+
+	// Paragraphs - wrap text blocks that aren't already wrapped
+	const blocks = html.split(/\n\n+/);
+	html = blocks
+		.map((block) => {
+			const trimmed = block.trim();
+			if (
+				trimmed.startsWith("<h") ||
+				trimmed.startsWith("<ul") ||
+				trimmed.startsWith("<ol") ||
+				trimmed.startsWith("<pre") ||
+				trimmed.startsWith("<blockquote") ||
+				trimmed.startsWith("<hr") ||
+				trimmed.startsWith("<p")
+			) {
+				return trimmed;
+			}
+			if (trimmed) {
+				return `<p class="chat-p">${trimmed}</p>`;
+			}
+			return "";
+		})
+		.filter(Boolean)
+		.join("");
+
+	// Convert single line breaks within paragraphs to <br>
+	html = html.replace(/<p([^>]*)>([\s\S]*?)<\/p>/g, (match, attrs, content) => {
+		const processedContent = content.trim().replace(/\n/g, "<br>");
+		return `<p${attrs}>${processedContent}</p>`;
+	});
+
+	// Clean up stray <br> tags between block elements
+	html = html.replace(/<br\s*\/?>\s*(<\/?(ul|ol|li|p|h[1-6]|pre|blockquote|hr))/gi, "$1");
+	html = html.replace(/(<\/(ul|ol|li|p|h[1-6]|pre|blockquote)>)\s*<br\s*\/?>/gi, "$1");
+
+	// Remove empty paragraphs
+	html = html.replace(/<p[^>]*>\s*<\/p>/g, "");
+
+	// Clean up multiple consecutive <br> tags
+	html = html.replace(/(<br\s*\/?>){2,}/g, "<br>");
+
+	// Linkify any remaining bare URLs in text content (e.g. inside list items)
+	html = linkifyBareUrlsInHtml(html);
+
+	return html;
+}
+
+/**
+ * Linkify bare http(s) URLs that appear in HTML text nodes (between > and <).
+ * Avoids touching URLs inside existing href attributes.
+ *
+ * @param {string} html - HTML string (e.g. from parseMarkdown)
+ * @return {string} HTML with bare URLs in text wrapped in <a> tags
+ */
+function linkifyBareUrlsInHtml(html) {
+	if (!html || typeof html !== "string") {
+		return "";
+	}
+	return html.replace(/>([^<]*)</g, (match, textNode) => ">" + linkifyUrls(textNode) + "<");
+}
+
+/**
+ * Replace bare http(s) URLs in plain text with clickable anchor tags.
+ * Use only on plain text (no existing HTML) so we don't double-wrap or break attributes.
+ *
+ * @param {string} text - Plain text that may contain URLs
+ * @return {string} Text with URLs wrapped in <a href="..." target="_blank" rel="noopener noreferrer">...</a>
+ */
+export function linkifyUrls(text) {
+	if (!text || typeof text !== "string") {
+		return "";
+	}
+	// Pre-pass: insert space between leading word and "http(s)://" so "Wouldhttp://" -> "Would http://"
+	let normalizedText = text.replace(
+		WORD_BEFORE_URL_NO_SPACE,
+		"$1 $2"
+	);
+	// Match URL only at start or after whitespace/opening punctuation (word boundary)
+	const urlPatternWithBoundary =
+		/(^|[\s(\["'])(https?:\/\/[^\s<>"]*(?:\n[^\s<>"]*)*)/g;
+	return normalizedText.replace(
+		urlPatternWithBoundary,
+		(fullMatch, before, url) => {
+			// Normalize: remove internal whitespace/newlines so href is valid
+			const normalized = url.replace(/\s+/g, "").trim();
+			let trimmed = normalized.replace(/[.,;:!?)\]]+$/, "");
+			let wordAfterLink = "";
+			// Strip trailing /Word or digit+Word (words after URL glued in - e.g. ".../If" or "?p=58Is")
+			const slashMatch = trimmed.match(TRAILING_SLASH_WORD);
+			if (slashMatch) {
+				wordAfterLink = slashMatch[1];
+				trimmed = trimmed.replace(TRAILING_SLASH_WORD, "");
+			}
+			const digitWordMatch = trimmed.match(TRAILING_DIGIT_WORD);
+			if (digitWordMatch) {
+				wordAfterLink = digitWordMatch[2];
+				trimmed = trimmed.replace(TRAILING_DIGIT_WORD, "$1");
+			}
+			if (!trimmed) {
+				return fullMatch;
+			}
+			const safeHref = trimmed.replace(/"/g, "&quot;");
+			const safeText = trimmed
+				.replace(/&/g, "&amp;")
+				.replace(/</g, "&lt;")
+				.replace(/>/g, "&gt;")
+				.replace(/"/g, "&quot;");
+			return `${before ?? ""}<a href="${safeHref}" target="_blank" rel="noopener noreferrer">${safeText}</a>${wordAfterLink ? " " + wordAfterLink : ""}`;
+		}
+	);
+}
+
+export default {
+	containsMarkdown,
+	parseMarkdown,
+	linkifyUrls,
+};

package/src/utils/nfdAgents/archiveConversation.js

@@ -0,0 +1,82 @@
+/**
+ * Archive a conversation to localStorage for later retrieval in chat history.
+ * Called when user clicks "New Chat" to preserve the current conversation.
+ *
+ * @param {Array}  messages                    - Array of message objects
+ * @param {string} sessionId                   - Session ID for the conversation
+ * @param {string} conversationId              - Conversation ID from backend
+ * @param {string} consumer                    - Consumer identifier (must match useNfdAgentsWebSocket for same surface)
+ * @param {Object} [options]                   - Optional settings
+ * @param {number} [options.maxHistoryItems=3] - Max number of chats to keep in archive
+ * @return {void}
+ */
+import { getChatHistoryStorageKeys } from "../../constants/nfdAgents/storageKeys";
+
+export function archiveConversation(messages, sessionId, conversationId, consumer, options = {}) {
+	if (!messages || messages.length === 0) {
+		return;
+	}
+
+	const hasMeaningful = messages.some(
+		(m) => (m.role === "user" || m.type === "user") && m.content && String(m.content).trim()
+	);
+	if (!hasMeaningful) {
+		return;
+	}
+
+	// Never archive with both ids null; avoids dedupe removing existing entries
+	if (sessionId === null && conversationId === null) {
+		return;
+	}
+
+	const maxHistoryItems = options.maxHistoryItems ?? 3;
+	const keys = getChatHistoryStorageKeys(consumer);
+
+	try {
+		const archive = JSON.parse(window.localStorage.getItem(keys.archive) || "[]");
+		const newEntry = {
+			sessionId,
+			conversationId,
+			messages: messages.map((m) => ({
+				...m,
+				timestamp: m.timestamp instanceof Date ? m.timestamp.toISOString() : m.timestamp,
+			})),
+			archivedAt: new Date().toISOString(),
+		};
+		// Dedupe so the same conversation doesn't appear multiple times: by conversationId when set, else by sessionId.
+		// This keeps the latest 3 distinct chats and avoids wiping older history when conversationId is null.
+		const filtered =
+			conversationId !== null && conversationId !== undefined
+				? archive.filter((entry) => entry.conversationId !== conversationId)
+				: archive.filter((entry) => entry.sessionId !== sessionId);
+		filtered.unshift(newEntry);
+		window.localStorage.setItem(keys.archive, JSON.stringify(filtered.slice(0, maxHistoryItems)));
+	} catch (err) {
+		// eslint-disable-next-line no-console
+		console.warn("[Chat History] Failed to archive conversation:", err);
+	}
+}
+
+/**
+ * Remove a conversation from the archive (e.g. when user clears the chat).
+ *
+ * @param {string} conversationId - Conversation ID to remove (can be null)
+ * @param {string} sessionId      - Session ID to remove (can be null)
+ * @param {string} consumer       - Consumer identifier (must match useNfdAgentsWebSocket for same surface)
+ * @return {void}
+ */
+export function removeConversationFromArchive(conversationId, sessionId, consumer) {
+	const keys = getChatHistoryStorageKeys(consumer);
+	try {
+		const archive = JSON.parse(window.localStorage.getItem(keys.archive) || "[]");
+		const filtered = archive.filter(
+			(entry) => entry.conversationId !== conversationId || entry.sessionId !== sessionId
+		);
+		if (filtered.length !== archive.length) {
+			window.localStorage.setItem(keys.archive, JSON.stringify(filtered));
+		}
+	} catch (err) {
+		// eslint-disable-next-line no-console
+		console.warn("[Chat History] Failed to remove conversation from archive:", err);
+	}
+}

package/src/utils/nfdAgents/chatHistoryList.js

@@ -0,0 +1,130 @@
+/**
+ * Pure helpers for ChatHistoryList: conversation filtering and extraction.
+ * No React or i18n; safe to unit test.
+ */
+
+/**
+ * True if the conversation has at least one user message with non-empty content.
+ *
+ * @param {Object} conversation - Conversation with messages array
+ * @return {boolean} True if at least one meaningful user message exists.
+ */
+export function hasMeaningfulUserMessage(conversation) {
+	const msgs = conversation.messages || conversation;
+	return (
+		Array.isArray(msgs) &&
+		msgs.some(
+			(m) => (m.role === "user" || m.type === "user") && m.content && String(m.content).trim()
+		)
+	);
+}
+
+/**
+ * Extract conversations from legacy messages (without sessionId) using time-based grouping.
+ * Messages more than 5 minutes apart start a new conversation.
+ *
+ * @param {Array} messages - Messages array
+ * @return {Array} Array of conversation objects with sessionId and messages.
+ */
+export function extractLegacyConversations(messages) {
+	const conversations = [];
+	let currentConversation = [];
+	let lastTimestamp = null;
+
+	messages.forEach((msg) => {
+		const msgTimestamp = msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now();
+
+		if (lastTimestamp && msgTimestamp - lastTimestamp > 5 * 60 * 1000) {
+			if (currentConversation.length > 0) {
+				conversations.push({
+					sessionId: null,
+					messages: [...currentConversation],
+				});
+				currentConversation = [];
+			}
+		}
+
+		currentConversation.push(msg);
+		lastTimestamp = msgTimestamp;
+	});
+
+	if (currentConversation.length > 0) {
+		conversations.push({
+			sessionId: null,
+			messages: currentConversation,
+		});
+	}
+
+	return conversations.reverse();
+}
+
+/**
+ * Extract conversation sessions from stored messages (by sessionId, with legacy fallback).
+ *
+ * @param {Array}  messages        - Array of message objects with timestamps and optional sessionId
+ * @param {number} maxHistoryItems - Max conversations to return
+ * @return {Array} Array of conversation objects (sessionId, messages).
+ */
+export function extractConversations(messages, maxHistoryItems) {
+	if (!Array.isArray(messages) || messages.length === 0) {
+		return [];
+	}
+
+	const sessionGroups = {};
+	const legacyMessages = [];
+
+	messages.forEach((msg) => {
+		if (msg.sessionId) {
+			if (!sessionGroups[msg.sessionId]) {
+				sessionGroups[msg.sessionId] = {
+					sessionId: msg.sessionId,
+					messages: [],
+					timestamp: msg.timestamp ? new Date(msg.timestamp).getTime() : 0,
+				};
+			}
+			sessionGroups[msg.sessionId].messages.push(msg);
+			const msgTime = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+			if (msgTime > sessionGroups[msg.sessionId].timestamp) {
+				sessionGroups[msg.sessionId].timestamp = msgTime;
+			}
+		} else {
+			legacyMessages.push(msg);
+		}
+	});
+
+	let conversations = Object.values(sessionGroups)
+		.sort((a, b) => b.timestamp - a.timestamp)
+		.map((session) => ({
+			sessionId: session.sessionId,
+			messages: session.messages,
+		}));
+
+	if (legacyMessages.length > 0 && conversations.length < maxHistoryItems) {
+		const legacyConversations = extractLegacyConversations(legacyMessages);
+		conversations = [...conversations, ...legacyConversations];
+	}
+
+	conversations = conversations.filter(hasMeaningfulUserMessage);
+	return conversations.slice(0, maxHistoryItems);
+}
+
+/**
+ * Get the latest message timestamp for relative time (legacy conversations without archivedAt).
+ *
+ * @param {Object} conversation - Conversation with messages
+ * @return {Date|null} Latest message date or null.
+ */
+export function getLatestMessageTime(conversation) {
+	const messages = conversation.messages || conversation;
+	if (!Array.isArray(messages) || messages.length === 0) {
+		return null;
+	}
+	let latest = 0;
+	messages.forEach((msg) => {
+		const t = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+		if (t > latest) {
+			latest = t;
+		}
+	});
+	return latest ? new Date(latest) : null;
+}

package/src/utils/nfdAgents/configFetcher.js

@@ -0,0 +1,137 @@
+/**
+ * NFD Agents Config Fetcher
+ *
+ * Fetches agent configuration from the REST API endpoint.
+ * Always uses rest_route parameter for REST API calls (never wp-json directly)
+ * so that requests work when permalinks are not set.
+ * Handles URL parsing (full URL vs relative REST path), apiFetch calls,
+ * and maps all known error codes to i18n error messages.
+ */
+
+import { __, sprintf } from "@wordpress/i18n";
+import apiFetch from "@wordpress/api-fetch";
+import { buildRestApiUrl, convertWpJsonToRestRoute } from "../restApi.js";
+
+/**
+ * Get base URL for the current site (origin or home URL including subdirectory).
+ *
+ * @return {string} Base URL
+ */
+function getBaseUrl() {
+	if (typeof window === "undefined") {
+		return "";
+	}
+	const config = window.nfdAIChat || {};
+	return config.homeUrl || window.location.origin;
+}
+
+/**
+ * Fetch agent configuration from the backend.
+ * Uses rest_route query parameter for the request so it works regardless of permalink settings.
+ *
+ * @param {Object} options
+ * @param {string} options.configEndpoint REST API endpoint (full URL or relative path). Example full URL: 'https://example.com/wp-json/nfd-agents/chat/v1/config'. Example relative path: 'nfd-agents/chat/v1/config'.
+ * @param {string} options.consumer       Consumer identifier (required). Sent as query param `consumer`. Valid values are defined by the backend.
+ * @return {Promise<Object>} Config object from backend
+ * @throws {Error} With i18n message on failure
+ */
+export async function fetchAgentConfig({ configEndpoint, consumer }) {
+	try {
+		// Extract REST path from configEndpoint (e.g. 'nfd-agents/chat/v1/config')
+		let path = configEndpoint;
+		let baseUrl = getBaseUrl();
+		let useWpJsonConversion = false;
+		let wpJsonBaseUrl = "";
+
+		if (configEndpoint.startsWith("http://") || configEndpoint.startsWith("https://")) {
+			const urlObj = new URL(configEndpoint);
+			if (urlObj.searchParams.has("rest_route")) {
+				path = urlObj.searchParams.get("rest_route");
+			} else if (urlObj.pathname.includes("/wp-json/")) {
+				path = urlObj.pathname.replace(/^\/wp-json\//, "").replace(/^\/wp-json/, "");
+				useWpJsonConversion = true;
+				const beforeWpJson = urlObj.pathname.split("/wp-json")[0].replace(/\/$/, "");
+				wpJsonBaseUrl = urlObj.origin + (beforeWpJson || "/");
+			} else {
+				path = urlObj.pathname.replace(/^\//, "");
+			}
+			// Base URL for rest_route: origin + pathname (without query), or path before /wp-json
+			if (!useWpJsonConversion) {
+				if (urlObj.pathname.includes("/wp-json")) {
+					const beforeWpJson = urlObj.pathname.split("/wp-json")[0].replace(/\/$/, "");
+					baseUrl = urlObj.origin + (beforeWpJson || "/");
+				} else {
+					baseUrl = urlObj.origin + (urlObj.pathname || "/");
+				}
+			}
+		}
+
+		const cleanPath = path.replace(/^\//, "");
+
+		let url;
+		if (useWpJsonConversion) {
+			url = convertWpJsonToRestRoute(configEndpoint, wpJsonBaseUrl);
+		} else {
+			const lastSlash = cleanPath.lastIndexOf("/");
+			const namespace = lastSlash === -1 ? "" : cleanPath.slice(0, lastSlash);
+			const route = lastSlash === -1 ? cleanPath : cleanPath.slice(lastSlash + 1);
+			url = buildRestApiUrl(namespace, route, baseUrl);
+		}
+		url = `${url}&consumer=${encodeURIComponent(consumer)}`;
+
+		const config = await apiFetch({
+			url,
+			parse: true,
+		});
+
+		return config;
+	} catch (err) {
+		// eslint-disable-next-line no-console
+		console.error("[AI Chat] Failed to fetch config:", err);
+		// eslint-disable-next-line no-console
+		console.error("[AI Chat] Error details:", {
+			message: err.message,
+			code: err.code,
+			data: err.data,
+			status: err.data?.status,
+			statusText: err.data?.statusText,
+		});
+
+		// Handle apiFetch errors
+		let errorMessage = err.message || __("Failed to connect", "wp-module-ai-chat");
+
+		if (err.data?.message) {
+			errorMessage = err.data.message;
+		} else if (err.message && err.message !== "Could not get a valid response from the server.") {
+			errorMessage = err.message;
+		}
+
+		if (err.code === "rest_forbidden" || err.data?.status === 403) {
+			errorMessage = __("Access denied. Please check your capabilities.", "wp-module-ai-chat");
+		} else if (err.code === "rest_no_route" || err.data?.status === 404) {
+			errorMessage = __(
+				"Config endpoint not found. Please ensure the backend is deployed.",
+				"wp-module-ai-chat"
+			);
+		} else if (err.code === "gateway_url_not_configured") {
+			errorMessage = __(
+				"Gateway URL not configured. Set NFD_AGENTS_CHAT_GATEWAY_URL in wp-config.php.",
+				"wp-module-ai-chat"
+			);
+		} else if (err.code === "jarvis_jwt_fetch_failed" || err.code === "huapi_token_fetch_failed") {
+			errorMessage = __(
+				"Failed to fetch authentication token from Hiive. Check your connection or set NFD_AGENTS_CHAT_DEBUG_TOKEN for local development.",
+				"wp-module-ai-chat"
+			);
+		} else if (err.data?.status) {
+			errorMessage = sprintf(
+				/* translators: %1$s: HTTP status, %2$s: status text */
+				__("Failed to fetch config: %1$s %2$s", "wp-module-ai-chat"),
+				err.data.status,
+				err.data.statusText || errorMessage
+			);
+		}
+
+		throw new Error(errorMessage);
+	}
+}