@copilotkit/learning 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1126 @@
+//#region src/types.ts
+/** Event names the collector and CopilotKit Core emit. `emit()` rejects them. */
+const BUILT_IN_EVENT_NAMES = [
+	"page",
+	"navigation",
+	"click",
+	"input",
+	"network",
+	"thread.linked",
+	"agent.run",
+	"agent.message",
+	"tool.call"
+];
+/** Replaces values that never leave the browser, even with full capture: passwords and credentials. */
+const REDACTED = "[redacted]";
+
+//#endregion
+//#region src/redact.ts
+const CREDENTIAL = /password|passwd|passphrase|passcode|credential|api(key|token)|privatekey|subscriptionkey|(access|refresh|auth|session)token|clientsecret/;
+const CREDENTIAL_WORD = / (secret|id ?token)s? | (authorization|cookies?|jwt|bearer ?token|[cx]srf ?token) $|^ (pwd|pass|token|otp) $/;
+const METADATA = / (ids?|at|in|expires?|expiry|length|count|enabled|required|policy|hint|type) $/;
+const PASSWORD_AUTOCOMPLETE = /(current|new)-password|one-time-code/;
+const TOKEN = /"((?:\\[\s\S]|[^"\\])*)("?)(\s*:\s*)?/g;
+const STRING = /"(?:\\[\s\S]?|[^"\\])*"?/y;
+const PAIR = /([\w$.%+[\]-]{1,64})(\s*(?:=|:(?=\s|$))\s*)((?:(?:basic|bearer|digest|token) +)?[^\s&,;)}\]]*)/gi;
+const USERINFO = /([a-z][\w+.-]{0,31}:\/\/)[^\s/?#"]*@/gi;
+/** Text beyond this is neither redacted nor kept; snapshots keep 4 KiB of the result. */
+const TEXT_LIMIT = 16 * 1024;
+const REMEMBERED_VALUES = 20;
+const isCredentialKey = (key) => {
+	const words = ` ${key.replace(/%([\da-f]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/([a-z\d])(?=[A-Z])/g, "$1 ").toLowerCase().split(/[^a-z\d]+/).filter(Boolean).join(" ")} `;
+	return !METADATA.test(words) && (CREDENTIAL.test(words.replace(/ /g, "")) || CREDENTIAL_WORD.test(words));
+};
+const decode = (body) => {
+	try {
+		return JSON.parse(`"${body}"`);
+	} catch {
+		return body;
+	}
+};
+/** The end of the JSON value at `start`: a string, a balanced object or array, or a bare literal. */
+const endOfValue = (text, start) => {
+	let depth = 0;
+	for (let i = start; i < text.length; i++) {
+		const char = text[i];
+		if (char === "\"") {
+			STRING.lastIndex = i;
+			STRING.test(text);
+			i = STRING.lastIndex - 1;
+		} else if (char === "{" || char === "[") {
+			depth++;
+			continue;
+		} else if (char === "}" || char === "]") {
+			if (--depth < 0) return i;
+		} else {
+			if (!depth && (char === "," || /\s/.test(char))) return i;
+			continue;
+		}
+		if (!depth) return i + 1;
+	}
+	return text.length;
+};
+/**
+* Redacts credential values in JSON (valid or cut off) and in key/value text,
+* and recurses into string values that hold JSON, forms, or URLs. Unchanged
+* parts keep their exact original text.
+*/
+const redactText = (text, depth = 0) => {
+	const token = new RegExp(TOKEN);
+	let pending = false;
+	const pairs = (part) => {
+		const segment = part.replace(USERINFO, "$1");
+		return segment.replace(PAIR, (pair, key, separator, value, offset) => {
+			if (!isCredentialKey(key)) return pair;
+			if (offset + pair.length === segment.length) {
+				pending = true;
+				if (!value) return pair;
+			}
+			return key + separator + REDACTED;
+		});
+	};
+	let out = "";
+	let last = 0;
+	let match;
+	while (match = token.exec(text)) {
+		const [raw, body, closed, colon] = match;
+		pending = false;
+		out += pairs(text.slice(last, match.index));
+		let end = token.lastIndex;
+		let replacement = raw;
+		const value = body.includes("\\") ? decode(body) : body;
+		if (colon) {
+			if (isCredentialKey(value)) {
+				const valueEnd = endOfValue(text, end);
+				if (!/^(true|false|null|)$/.test(text.slice(end, valueEnd))) {
+					replacement += `"${REDACTED}"`;
+					end = valueEnd;
+				}
+			}
+		} else if (pending) replacement = `"${REDACTED}"`;
+		else if (depth < 4 && /[=:"]/.test(value)) {
+			const redacted = redactText(value, depth + 1);
+			if (redacted !== value) replacement = JSON.stringify(redacted).slice(0, closed ? void 0 : -1);
+		}
+		out += replacement;
+		last = token.lastIndex = end;
+	}
+	return out + pairs(text.slice(last));
+};
+/** Per-session redaction state: password-like fields and the values typed into them. */
+function createRedactor() {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const remembered = /* @__PURE__ */ new Map();
+	let observer;
+	const toggled = (records) => {
+		for (const record of records) if (record.oldValue?.toLowerCase() === "password") seen.add(record.target);
+	};
+	/** Replaces remembered values, raw and in their JSON and URL encodings. */
+	const scrub = (text) => {
+		for (const value of [...remembered.values()].sort((a, b) => b.length - a.length)) for (const form of [
+			value,
+			JSON.stringify(value).slice(1, -1),
+			encodeURIComponent(value),
+			new URLSearchParams({ v: value }).toString().slice(2)
+		]) text = /^\d+$/.test(form) ? text.replace(RegExp(`(?<!\\d)${form}(?!\\d)`, "g"), REDACTED) : text.split(form).join(REDACTED);
+		return text;
+	};
+	/** True for current, former (show-password toggles), and autocomplete password fields. */
+	const isPassword = (element) => {
+		if (observer) toggled(observer.takeRecords());
+		if (!(element instanceof HTMLInputElement) || !(element.type === "password" || seen.has(element) || isCredentialKey(element.name) || PASSWORD_AUTOCOMPLETE.test(element.getAttribute("autocomplete") ?? ""))) return false;
+		seen.add(element);
+		if (element.value.length >= 4) {
+			remembered.delete(element);
+			remembered.set(element, element.value);
+			if (remembered.size > REMEMBERED_VALUES) remembered.delete(remembered.keys().next().value);
+		}
+		return true;
+	};
+	return {
+		isPassword,
+		watch() {
+			try {
+				for (const input of document.querySelectorAll("input[type=password]")) seen.add(input);
+			} catch {}
+			let current;
+			try {
+				current = new MutationObserver(toggled);
+				current.observe(document, {
+					subtree: true,
+					attributeFilter: ["type"],
+					attributeOldValue: true
+				});
+				observer = current;
+			} catch {
+				current = void 0;
+			}
+			const remember = (event) => {
+				try {
+					const [target] = event.composedPath();
+					if (target instanceof Element) isPassword(target);
+				} catch {}
+			};
+			for (const type of ["input", "change"]) window.addEventListener(type, remember, true);
+			return () => {
+				current?.disconnect();
+				if (current !== void 0 && observer === current) observer = void 0;
+				for (const type of ["input", "change"]) window.removeEventListener(type, remember, true);
+			};
+		},
+		field: (key, value) => isCredentialKey(key) ? REDACTED : scrub(redactText(value)),
+		body(text) {
+			try {
+				return scrub(redactText(text.slice(0, TEXT_LIMIT)));
+			} catch {
+				return;
+			}
+		},
+		url(value) {
+			try {
+				return scrub(value.replace(/[^#]+/g, (part) => redactText(part)));
+			} catch {
+				return REDACTED;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/clicks.ts
+const INTERACTIVE = "button, a[href], input, select, textarea, label, summary, [role], [data-copilotkit-action], [contenteditable]:not([contenteditable=\"false\"])";
+const RECOVERY_DISTANCE_PX = 5;
+const MAX_TEXT_LENGTH = 1e3;
+/** `closest()` that continues through shadow roots to their hosts. */
+function closestAcrossShadow(el, selector) {
+	let current = el;
+	while (current !== null) {
+		const match = current.closest(selector);
+		if (match !== null) return match;
+		const root = current.getRootNode();
+		current = root instanceof ShadowRoot ? root.host : null;
+	}
+	return null;
+}
+/**
+* Finds the nearest interactive element and retains its text, attributes, and value.
+* The explicit `data-copilotkit-ignore` opt-out still applies.
+*/
+function describeTarget(el, redact) {
+	if (closestAcrossShadow(el, "[data-copilotkit-ignore]") !== null) return null;
+	const element = el.closest(INTERACTIVE) ?? el;
+	const password = redact.isPassword(element);
+	return {
+		element,
+		target: {
+			tag: element.localName,
+			role: element.getAttribute("role"),
+			action: element.getAttribute("data-copilotkit-action"),
+			text: (element.textContent ?? "").slice(0, MAX_TEXT_LENGTH),
+			attributes: Object.fromEntries(Array.from(element.attributes, ({ name, value }) => [name, password && name === "value" || isCredentialKey(name.replace(/^data-/, "")) ? REDACTED : redact.url(value)])),
+			...readControlValue(element, redact)
+		}
+	};
+}
+/** Snapshot live control properties; HTML attributes do not reflect edited values. */
+function readControlValue(element, redact) {
+	if (element instanceof HTMLInputElement) return {
+		value: redact.isPassword(element) ? REDACTED : element.value,
+		...["checkbox", "radio"].includes(element.type) ? { checked: element.checked } : {},
+		...element.type === "file" ? { files: Array.from(element.files ?? [], (file) => ({
+			name: file.name,
+			type: file.type,
+			size: file.size,
+			lastModified: file.lastModified
+		})) } : {}
+	};
+	if (element instanceof HTMLSelectElement) return {
+		value: element.value,
+		selectedValues: Array.from(element.selectedOptions, (option) => option.value)
+	};
+	if (element instanceof HTMLTextAreaElement) return { value: element.value };
+	if (element.matches("[contenteditable]:not([contenteditable=\"false\"])")) return { value: element.textContent ?? "" };
+	return {};
+}
+function eventElement(event) {
+	const [first] = event.composedPath();
+	return first instanceof Element ? first : null;
+}
+function isRootOrDetached(el) {
+	return el.localName === "body" || el.localName === "html" || !el.isConnected;
+}
+function isNear(origin, event) {
+	return Math.abs(origin.x - event.clientX) <= RECOVERY_DISTANCE_PX && Math.abs(origin.y - event.clientY) <= RECOVERY_DISTANCE_PX;
+}
+/**
+* Listens for clicks in the capture phase on `window`, so handlers that stop
+* propagation do not hide them. The target is described at `pointerdown`,
+* because a re-render before `click` can move the click to `<body>`.
+*/
+function installClickCapture(params) {
+	const { emit, getRoute, enrich, isTrusted = (event) => event.isTrusted, redact = createRedactor() } = params;
+	let origin = null;
+	const onPointerDown = (event) => {
+		try {
+			if (event.isPrimary === false) return;
+			const el = eventElement(event);
+			origin = {
+				described: el === null ? null : describeTarget(el, redact),
+				x: event.clientX,
+				y: event.clientY
+			};
+		} catch {
+			origin = null;
+		}
+	};
+	const onClick = (event) => {
+		const pointerOrigin = origin;
+		origin = null;
+		try {
+			if (!isTrusted(event)) return;
+			const el = eventElement(event);
+			if (el === null) return;
+			const described = pointerOrigin !== null && isRootOrDetached(el) && isNear(pointerOrigin, event) ? pointerOrigin.described : describeTarget(el, redact);
+			if (described === null) return;
+			const input = event.detail === 0 ? "keyboard" : "pointer";
+			emit("click", {
+				target: {
+					...described.target,
+					input
+				},
+				route: getRoute(),
+				url: redact.url(location.href),
+				...enrich?.(described.element)
+			});
+		} catch {}
+	};
+	window.addEventListener("pointerdown", onPointerDown, {
+		capture: true,
+		passive: true
+	});
+	window.addEventListener("click", onClick, {
+		capture: true,
+		passive: true
+	});
+	return () => {
+		window.removeEventListener("pointerdown", onPointerDown, { capture: true });
+		window.removeEventListener("click", onClick, { capture: true });
+	};
+}
+
+//#endregion
+//#region src/inputs.ts
+/** Records user edits without changing the control or interfering with its listeners. */
+function installInputCapture(params) {
+	const { emit, isTrusted = (event) => event.isTrusted, redact = createRedactor() } = params;
+	const onInput = (event) => {
+		try {
+			if (!isTrusted(event)) return;
+			const [element] = event.composedPath();
+			if (!(element instanceof Element)) return;
+			const described = describeTarget(element, redact);
+			if (described === null) return;
+			const value = readControlValue(element, redact);
+			if (!("value" in value)) return;
+			emit("input", {
+				eventType: event.type,
+				target: {
+					...described.target,
+					...value
+				},
+				url: redact.url(location.href),
+				route: location.pathname
+			});
+		} catch {}
+	};
+	window.addEventListener("input", onInput, {
+		capture: true,
+		passive: true
+	});
+	window.addEventListener("change", onInput, {
+		capture: true,
+		passive: true
+	});
+	return () => {
+		window.removeEventListener("input", onInput, { capture: true });
+		window.removeEventListener("change", onInput, { capture: true });
+	};
+}
+
+//#endregion
+//#region src/navigation.ts
+function isNavigationTarget(value) {
+	return typeof value === "object" && value !== null && "addEventListener" in value && "removeEventListener" in value;
+}
+function getNavigation() {
+	const navigation = Reflect.get(window, "navigation");
+	return isNavigationTarget(navigation) ? navigation : null;
+}
+function toNavigationType(value) {
+	switch (value) {
+		case "replace":
+		case "traverse":
+		case "reload": return value;
+		default: return "push";
+	}
+}
+/**
+* Emits `navigation` when the full URL changes in a single-page app.
+* Uses the Navigation API when it exists. Otherwise patches `pushState` and
+* `replaceState` on the prototype and on the instance, because some routers
+* (Next.js) wrap the instance method.
+*/
+function installNavigationCapture(params) {
+	const { emit, redact = createRedactor() } = params;
+	let current = location.href;
+	const check = (navigationType) => {
+		try {
+			const next = location.href;
+			if (next === current) return;
+			emit("navigation", {
+				from: redact.url(current),
+				to: redact.url(next),
+				navigationType
+			});
+			current = next;
+		} catch {}
+	};
+	const navigation = getNavigation();
+	if (navigation !== null) {
+		const onEntryChange = (event) => check(toNavigationType(Reflect.get(event, "navigationType")));
+		navigation.addEventListener("currententrychange", onEntryChange);
+		return () => navigation.removeEventListener("currententrychange", onEntryChange);
+	}
+	return installHistoryFallback(check);
+}
+function installHistoryFallback(check) {
+	let active = true;
+	const restores = [];
+	const patch = (target, method) => {
+		const original = target[method];
+		const wrapper = function(...args) {
+			const result = original.apply(this, args);
+			if (active) check(method === "pushState" ? "push" : "replace");
+			return result;
+		};
+		target[method] = wrapper;
+		restores.push(() => {
+			if (target[method] === wrapper) target[method] = original;
+		});
+	};
+	for (const method of ["pushState", "replaceState"]) {
+		patch(History.prototype, method);
+		if (Object.prototype.hasOwnProperty.call(history, method)) patch(history, method);
+	}
+	const onPopState = () => check("traverse");
+	window.addEventListener("popstate", onPopState);
+	window.addEventListener("hashchange", onPopState);
+	return () => {
+		active = false;
+		window.removeEventListener("popstate", onPopState);
+		window.removeEventListener("hashchange", onPopState);
+		for (const restore of restores) restore();
+	};
+}
+
+//#endregion
+//#region src/network-body.ts
+const BODY_BYTES = 4096;
+const READ_TIMEOUT_MS = 1e3;
+const encoder = new TextEncoder();
+const redactionFailed = () => ({
+	status: "unavailable",
+	reason: "redaction-failed"
+});
+/** Redacts up to TEXT_LIMIT bytes of text first, then cuts the result to BODY_BYTES. */
+function snapshot(bytes, status, contentType, redact, reason) {
+	let text;
+	if (!isBinary(contentType)) try {
+		text = new TextDecoder("utf-8", { fatal: !contentType }).decode(bytes, { stream: status !== "complete" });
+	} catch {}
+	if (text !== void 0) {
+		text = redact(text);
+		if (text === void 0) return redactionFailed();
+		if (text.includes("\0")) {
+			bytes = encoder.encode(text);
+			text = void 0;
+		}
+	}
+	const binary = text === void 0;
+	text ??= btoa(String.fromCharCode(...bytes.subarray(0, BODY_BYTES)));
+	const result = {
+		status: status === "complete" && bytes.length === 0 ? "empty" : status,
+		text,
+		encoding: binary ? "base64" : "utf-8",
+		...reason ? { reason } : {}
+	};
+	if (encoder.encode(JSON.stringify(result)).length <= BODY_BYTES) return result;
+	result.status = status === "complete" ? "truncated" : status;
+	result.truncated = true;
+	let low = 0;
+	let high = text.length;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		result.text = text.slice(0, middle);
+		if (encoder.encode(JSON.stringify(result)).length <= BODY_BYTES) low = middle;
+		else high = middle - 1;
+	}
+	if (binary) low -= low % 4;
+	else if (low > 0 && /[\uD800-\uDBFF]/.test(text[low - 1])) low--;
+	result.text = text.slice(0, low);
+	return result;
+}
+function snapshotText(value, redact, status = "complete", reason) {
+	return snapshot(encoder.encode(value.slice(0, TEXT_LIMIT)), value.length > TEXT_LIMIT && status === "complete" ? "truncated" : status, "text/plain", redact, reason);
+}
+function isBinary(contentType) {
+	return contentType !== "" && !/(^text\/|json|xml|javascript|graphql|x-www-form-urlencoded|multipart\/form-data)/i.test(contentType);
+}
+/** Cancel only cloned/synthetic bodies. Cancelling a tee may wait for the app's branch. */
+function createBodyCapture(redact) {
+	const cancellations = /* @__PURE__ */ new Set();
+	let active = true;
+	const read = (stream, contentType = "") => {
+		if (!stream) return Promise.resolve({ status: "empty" });
+		if (!active) return Promise.resolve({
+			status: "unavailable",
+			reason: "capture-stopped"
+		});
+		let reader;
+		try {
+			reader = stream.getReader();
+		} catch {
+			return Promise.resolve({
+				status: "unavailable",
+				reason: "body-locked"
+			});
+		}
+		return new Promise((resolve) => {
+			const bytes = new Uint8Array(TEXT_LIMIT);
+			let length = 0;
+			let finished = false;
+			const finish = (status, reason) => {
+				if (finished) return;
+				finished = true;
+				clearTimeout(timer);
+				cancellations.delete(cancel);
+				resolve(snapshot(bytes.subarray(0, length), status, contentType, redact.body, reason));
+				reader.cancel().catch(() => {});
+			};
+			const cancel = () => finish("interrupted", "capture-stopped");
+			const timer = setTimeout(() => finish("timeout", "body-read-timeout"), READ_TIMEOUT_MS);
+			cancellations.add(cancel);
+			(async () => {
+				try {
+					for (;;) {
+						const chunk = await reader.read();
+						if (finished) break;
+						if (chunk.done) {
+							finish("complete");
+							break;
+						}
+						const kept = chunk.value.subarray(0, TEXT_LIMIT - length);
+						bytes.set(kept, length);
+						length += kept.length;
+						if (length === TEXT_LIMIT) {
+							finish("truncated");
+							break;
+						}
+					}
+				} catch {
+					finish("interrupted", "body-read-failed");
+				} finally {
+					try {
+						reader.releaseLock();
+					} catch {}
+				}
+			})();
+		});
+	};
+	const body = (value, contentType = "") => {
+		try {
+			if (value == null) return Promise.resolve({ status: "empty" });
+			if (value instanceof URLSearchParams) value = value.toString();
+			if (typeof value === "string") return Promise.resolve(snapshotText(value, redact.body));
+			if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) return Promise.resolve({
+				status: "unavailable",
+				reason: "caller-owned-stream"
+			});
+			if (value instanceof FormData) {
+				const form = new FormData();
+				value.forEach((field, key) => form.append(key, typeof field === "string" ? redact.field(key, field) : field));
+				value = form;
+			}
+			const response = new Response(value);
+			return read(response.body, contentType || response.headers.get("content-type") || "");
+		} catch {
+			return Promise.resolve({
+				status: "unavailable",
+				reason: "body-not-readable"
+			});
+		}
+	};
+	return {
+		read,
+		body,
+		text: (value, status, reason) => snapshotText(value, redact.body, status, reason),
+		stop() {
+			active = false;
+			for (const cancel of cancellations) cancel();
+		}
+	};
+}
+
+//#endregion
+//#region src/network.ts
+const emptyBody = () => Promise.resolve({ status: "empty" });
+const unavailableBody = (reason) => Promise.resolve({
+	status: "unavailable",
+	reason
+});
+const toAbsolute = (url) => new URL(url, location.href).href;
+const CREDENTIAL_HEADERS = new Set([
+	"x-amz-security-token",
+	"private-token",
+	"x-token"
+]);
+const headerValue = (name, value) => CREDENTIAL_HEADERS.has(name.toLowerCase()) || isCredentialKey(name) ? REDACTED : value;
+const headerValues = (headers) => Object.fromEntries(Array.from(headers.entries(), ([name, value]) => [name, headerValue(name, value)]));
+function isAbortError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+/** Records browser-visible request/response data without consuming the app's bodies. */
+function installNetworkCapture(params) {
+	let active = true;
+	const { redact = createRedactor() } = params;
+	const bodies = createBodyCapture(redact);
+	const ignoreUrls = params.ignoreUrls.map((pattern) => typeof pattern === "string" ? toAbsolute(pattern) : new RegExp(pattern.source, pattern.flags));
+	const isIgnored = (url) => ignoreUrls.some((pattern) => {
+		if (typeof pattern === "string") return url.startsWith(pattern);
+		pattern.lastIndex = 0;
+		return pattern.test(url);
+	});
+	const record = (transport, request, requestBody, startedAt, status, outcome, response) => {
+		const durationMs = Math.round(performance.now() - startedAt);
+		const completedAt = Date.now();
+		Promise.all([requestBody, response?.body ?? unavailableBody("no-response")]).then(([sent, received]) => {
+			if (!active) return;
+			const href = redact.url(request.url);
+			const url = new URL(href);
+			params.emit("network", {
+				transport,
+				method: request.method,
+				url: href,
+				origin: url.origin,
+				route: url.pathname,
+				status,
+				durationMs,
+				completedAt,
+				outcome,
+				request: {
+					headers: request.headers,
+					body: sent
+				},
+				response: {
+					...response?.url ? { url: redact.url(response.url) } : {},
+					headers: response?.headers ?? {},
+					body: received
+				}
+			});
+		}).catch(() => {});
+	};
+	const originalFetch = globalThis.fetch;
+	const wrappedFetch = (input, init) => {
+		if (!active) return originalFetch.call(globalThis, input, init);
+		let request;
+		let ignored;
+		try {
+			const source = typeof Request !== "undefined" && input instanceof Request ? input : void 0;
+			request = {
+				url: toAbsolute(source ? source.url : String(input)),
+				method: (init?.method ?? source?.method ?? "GET").toUpperCase(),
+				headers: headerValues(new Headers(init?.headers ?? source?.headers))
+			};
+			ignored = isIgnored(request.url);
+		} catch {
+			return originalFetch.call(globalThis, input, init);
+		}
+		if (ignored) return originalFetch.call(globalThis, input, init);
+		const startedAt = performance.now();
+		let requestBody;
+		try {
+			requestBody = init?.body != null ? bodies.body(init.body, request.headers["content-type"]) : typeof Request !== "undefined" && input instanceof Request ? bodies.read(input.clone().body, request.headers["content-type"]) : emptyBody();
+		} catch {
+			requestBody = unavailableBody("request-clone-failed");
+		}
+		const failed = (error) => record("fetch", request, requestBody, startedAt, null, isAbortError(error) ? "aborted" : "error");
+		let promise;
+		try {
+			promise = originalFetch.call(globalThis, input, init);
+		} catch (error) {
+			failed(error);
+			throw error;
+		}
+		promise.then((response) => {
+			if (!active) return;
+			let responseBody;
+			try {
+				responseBody = response.type === "opaque" || response.type === "opaqueredirect" ? unavailableBody("opaque-response") : bodies.read(response.clone().body, response.headers.get("content-type") ?? "");
+			} catch {
+				responseBody = unavailableBody("response-clone-failed");
+			}
+			record("fetch", request, requestBody, startedAt, response.status, "ok", {
+				url: response.url,
+				headers: headerValues(response.headers),
+				body: responseBody
+			});
+		}, failed).catch(() => {});
+		return promise;
+	};
+	if (typeof originalFetch === "function") globalThis.fetch = wrappedFetch;
+	const uninstallXhr = patchXhr(isIgnored, record, bodies);
+	return () => {
+		active = false;
+		bodies.stop();
+		if (globalThis.fetch === wrappedFetch) globalThis.fetch = originalFetch;
+		uninstallXhr();
+	};
+}
+function patchXhr(isIgnored, record, bodies) {
+	if (typeof XMLHttpRequest !== "function") return () => {};
+	const proto = XMLHttpRequest.prototype;
+	const originalOpen = proto.open;
+	const originalSend = proto.send;
+	const originalSetHeader = proto.setRequestHeader;
+	const requests = /* @__PURE__ */ new WeakMap();
+	const listeners = /* @__PURE__ */ new Set();
+	const inFlight = /* @__PURE__ */ new WeakMap();
+	let active = true;
+	const wrappedOpen = function(method, url, ...rest) {
+		inFlight.get(this)?.();
+		const result = Reflect.apply(originalOpen, this, [
+			method,
+			url,
+			...rest
+		]);
+		try {
+			requests.set(this, {
+				url: toAbsolute(String(url)),
+				method: method.toUpperCase(),
+				headers: {}
+			});
+		} catch {
+			requests.delete(this);
+		}
+		return result;
+	};
+	const wrappedSetHeader = function(name, value) {
+		const result = originalSetHeader.call(this, name, value);
+		const request = requests.get(this);
+		if (active && request) try {
+			const headers = new Headers(request.headers);
+			headers.append(name, value);
+			request.headers = headerValues(headers);
+		} catch {}
+		return result;
+	};
+	const wrappedSend = function(body) {
+		const request = requests.get(this);
+		if (!active || !request || isIgnored(request.url)) return originalSend.call(this, body);
+		const startedAt = performance.now();
+		let requestBody;
+		try {
+			requestBody = typeof Document !== "undefined" && body instanceof Document ? Promise.resolve(bodies.text(new XMLSerializer().serializeToString(body))) : bodies.body(body, request.headers["content-type"]);
+		} catch {
+			requestBody = unavailableBody("request-body-unavailable");
+		}
+		let aborted = false;
+		const onAbort = () => {
+			aborted = true;
+		};
+		const cleanup = () => {
+			this.removeEventListener("abort", onAbort);
+			this.removeEventListener("loadend", onEnd);
+			listeners.delete(cleanup);
+			if (inFlight.get(this) === cleanup) inFlight.delete(this);
+		};
+		const onEnd = () => {
+			cleanup();
+			if (!active) return;
+			const outcome = aborted ? "aborted" : this.status === 0 ? "error" : "ok";
+			const headers = {};
+			try {
+				for (const line of this.getAllResponseHeaders().split(/\r?\n/)) {
+					const split = line.indexOf(":");
+					if (split > 0) {
+						const name = line.slice(0, split).toLowerCase();
+						headers[name] = headerValue(name, line.slice(split + 1).trim());
+					}
+				}
+			} catch {}
+			let responseBody;
+			try {
+				if (this.responseType === "" || this.responseType === "text") responseBody = Promise.resolve(bodies.text(this.responseText, outcome === "ok" ? "complete" : "interrupted", outcome === "ok" ? void 0 : `request-${outcome}`));
+				else if (this.responseType === "json") responseBody = Promise.resolve(bodies.text(JSON.stringify(this.response)));
+				else if (this.responseType === "document") responseBody = this.responseXML ? Promise.resolve(bodies.text(new XMLSerializer().serializeToString(this.responseXML))) : unavailableBody("empty-document");
+				else responseBody = bodies.body(this.response, headers["content-type"] ?? "application/octet-stream");
+			} catch {
+				responseBody = unavailableBody("response-body-unavailable");
+			}
+			record("xhr", request, requestBody, startedAt, outcome === "ok" ? this.status : null, outcome, {
+				url: this.responseURL,
+				headers,
+				body: responseBody
+			});
+		};
+		this.addEventListener("abort", onAbort);
+		this.addEventListener("loadend", onEnd);
+		listeners.add(cleanup);
+		inFlight.set(this, cleanup);
+		try {
+			return originalSend.call(this, body);
+		} catch (error) {
+			cleanup();
+			record("xhr", request, requestBody, startedAt, null, isAbortError(error) ? "aborted" : "error");
+			throw error;
+		}
+	};
+	proto.open = wrappedOpen;
+	proto.send = wrappedSend;
+	proto.setRequestHeader = wrappedSetHeader;
+	return () => {
+		active = false;
+		for (const cleanup of listeners) cleanup();
+		if (proto.open === wrappedOpen) proto.open = originalOpen;
+		if (proto.send === wrappedSend) proto.send = originalSend;
+		if (proto.setRequestHeader === wrappedSetHeader) proto.setRequestHeader = originalSetHeader;
+	};
+}
+
+//#endregion
+//#region src/routes.ts
+/** Returns the original pathname. Capture no longer masks or categorizes routes. */
+function toRoute(pathname, _templates = []) {
+	return pathname;
+}
+/** Resolves a URL without removing path segments, query parameters, or fragments. */
+function toOriginAndRoute(url, _templates = [], base = globalThis.location?.href ?? "http://localhost/") {
+	const parsed = new URL(url, base);
+	return {
+		url: parsed.href,
+		origin: parsed.origin,
+		route: parsed.pathname
+	};
+}
+
+//#endregion
+//#region src/collector.ts
+const FLUSH_SIZE = 50;
+const FLUSH_INTERVAL_MS = 2e3;
+const BUILT_IN = new Set(BUILT_IN_EVENT_NAMES);
+/**
+* Creates a collector. Nothing is installed until `start()`: no listeners,
+* no patches, no timers, no buffer. `stop()` removes all of them and sends
+* queued events once, without retries.
+*
+* @example
+* const collector = createCollector({ sink: httpSink("/api/learning-events") });
+* collector.start({ trajectoryId: crypto.randomUUID() });
+*/
+function createCollector(options) {
+	const { sink, routes, beforeSend, enrich } = options;
+	const capture = {
+		clicks: true,
+		navigation: true,
+		network: true,
+		inputs: true,
+		...options.capture
+	};
+	let session = null;
+	let seq = 0;
+	const getRoute = () => toRoute(location.pathname, routes);
+	const flush = (sendOptions) => {
+		const current = session;
+		if (current === null) return;
+		if (current.queue.length === 0 && current.dropped === 0) return;
+		const events = current.queue.splice(0);
+		const dropped = current.dropped;
+		current.dropped = 0;
+		const batch = {
+			trajectoryId: current.trajectoryId,
+			learningContainerIds: current.learningContainerIds,
+			events,
+			dropped
+		};
+		const onFailure = () => {
+			if (session === current) current.dropped += events.length + dropped;
+		};
+		try {
+			Promise.resolve(sink(batch, sendOptions)).catch(onFailure);
+		} catch {
+			onFailure();
+		}
+	};
+	const record = (name, value) => {
+		const current = session;
+		if (current === null) return;
+		try {
+			seq += 1;
+			const event = {
+				type: "CUSTOM",
+				name,
+				value: {
+					...value,
+					seq
+				},
+				timestamp: Date.now()
+			};
+			const kept = beforeSend === void 0 ? event : beforeSend(event);
+			if (kept === null) return;
+			current.queue.push(kept);
+			if (current.queue.length >= FLUSH_SIZE) flush();
+		} catch {}
+	};
+	const start = ({ trajectoryId, learningContainerIds }) => {
+		if (session !== null) {
+			if (session.trajectoryId !== trajectoryId) console.warn(`[@copilotkit/learning] Trajectory "${session.trajectoryId}" is active. Stop it before you start "${trajectoryId}".`);
+			return;
+		}
+		if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+		const current = {
+			trajectoryId,
+			learningContainerIds,
+			queue: [],
+			dropped: 0,
+			uninstalls: [],
+			timer: void 0
+		};
+		session = current;
+		const recordCurrent = (name, value) => {
+			if (session === current) record(name, value);
+		};
+		const redact = createRedactor();
+		current.uninstalls.push(redact.watch());
+		const ignoreUrls = [...options.ignoreUrls ?? [], ...sink.url === void 0 ? [] : [sink.url]];
+		if (capture.clicks) current.uninstalls.push(installClickCapture({
+			emit: recordCurrent,
+			getRoute,
+			enrich,
+			redact
+		}));
+		if (capture.navigation) current.uninstalls.push(installNavigationCapture({
+			emit: recordCurrent,
+			routes,
+			redact
+		}));
+		if (capture.network) current.uninstalls.push(installNetworkCapture({
+			emit: recordCurrent,
+			routes,
+			ignoreUrls,
+			redact
+		}));
+		if (capture.inputs) current.uninstalls.push(installInputCapture({
+			emit: recordCurrent,
+			redact
+		}));
+		const onPageHide = () => flush({ beacon: true });
+		window.addEventListener("pagehide", onPageHide);
+		current.uninstalls.push(() => window.removeEventListener("pagehide", onPageHide));
+		current.timer = setInterval(() => flush(), FLUSH_INTERVAL_MS);
+		record("page", {
+			route: getRoute(),
+			url: redact.url(location.href),
+			title: document.title,
+			referrer: redact.url(document.referrer)
+		});
+	};
+	const stop = () => {
+		const current = session;
+		if (current === null) return;
+		clearInterval(current.timer);
+		for (const uninstall of current.uninstalls) uninstall();
+		flush();
+		session = null;
+	};
+	const emit = (name, value) => {
+		if (BUILT_IN.has(name)) {
+			console.warn(`[@copilotkit/learning] "${name}" is a built-in event name. Use your own name, such as "deal.approved".`);
+			return;
+		}
+		record(name, value);
+	};
+	const ɵemit = (name, value) => record(name, value);
+	return {
+		start,
+		stop,
+		emit,
+		ɵemit,
+		get trajectoryId() {
+			return session?.trajectoryId ?? null;
+		}
+	};
+}
+
+//#endregion
+//#region src/http-sink.ts
+/**
+* A sink that POSTs each batch as JSON to `url`.
+*
+* Uses `fetch` with `keepalive`. When the page is going away it uses
+* `navigator.sendBeacon`, which cannot send custom headers. There is no retry:
+* a failed send rejects, and the collector counts those events as dropped.
+*
+* @example createCollector({ sink: httpSink("/api/learning-events") })
+*/
+function httpSink(url, init = {}) {
+	const send = async (batch, options = {}) => {
+		const body = JSON.stringify(batch);
+		if (options.beacon === true && typeof navigator.sendBeacon === "function") {
+			if (!navigator.sendBeacon(url, new Blob([body], { type: "application/json" }))) throw new Error("sendBeacon refused the batch");
+			return;
+		}
+		const response = await fetch(url, {
+			method: "POST",
+			keepalive: true,
+			headers: {
+				"content-type": "application/json",
+				...init.headers
+			},
+			body
+		});
+		if (!response.ok) throw new Error(`Sink responded with ${response.status}`);
+	};
+	return Object.assign(send, { url });
+}
+
+//#endregion
+//#region src/trajectory-collector.ts
+const MAX_TRAJECTORY_EVENT_BYTES = 16 * 1024;
+const RESERVED_NAMES = new Set(BUILT_IN_EVENT_NAMES);
+function isJson(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (typeof value === "string") return !value.includes("\0");
+	if (value === null || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+	ancestors.add(value);
+	if (!Array.isArray(value) && Object.keys(value).some((key) => key.includes("\0"))) return false;
+	const values = Array.isArray(value) ? value : Object.values(value);
+	for (const item of values) if (!isJson(item, ancestors)) return false;
+	ancestors.delete(value);
+	return true;
+}
+/**
+* Captures outside-chat activity as plain AG-UI events, without a send queue.
+* Core starts this collector only after authentication and channel join.
+*/
+function createTrajectoryCollector(options) {
+	let active = false;
+	let uninstalls = [];
+	const report = (code, message) => {
+		try {
+			options.onError?.({
+				code,
+				message
+			});
+		} catch {}
+	};
+	const getRoute = () => toRoute(location.pathname);
+	const record = (name, value) => {
+		if (!active) return;
+		let payload;
+		try {
+			const event = {
+				type: "CUSTOM",
+				name,
+				timestamp: Date.now(),
+				value
+			};
+			const kept = options.beforeSend === void 0 ? event : options.beforeSend(event);
+			if (kept === null || !active) return;
+			if (kept.type !== "CUSTOM" || typeof kept.name !== "string" || !kept.name.trim() || kept.name.length > 200 || kept.name.includes("\0") || !Number.isFinite(kept.timestamp) || kept.timestamp <= 0 || kept.timestamp >= 0xe677d21fdc00 || !isJson(kept.value)) {
+				report("INVALID_EVENT", "The event must contain a name, timestamp, and JSON value.");
+				return;
+			}
+			const serialized = JSON.stringify({
+				type: kept.type,
+				name: kept.name,
+				timestamp: kept.timestamp,
+				value: kept.value
+			});
+			if (new TextEncoder().encode(serialized).byteLength > MAX_TRAJECTORY_EVENT_BYTES) {
+				report("EVENT_TOO_LARGE", "The serialized event exceeds 16 KiB.");
+				return;
+			}
+			payload = JSON.parse(serialized);
+		} catch {
+			report("INVALID_EVENT", "The event could not be serialized as JSON.");
+			return;
+		}
+		try {
+			options.send(payload);
+		} catch {
+			report("PERSISTENCE_UNKNOWN", "Event delivery failed. The event will not be retried.");
+		}
+	};
+	const capture = (name, value) => {
+		record(name, value);
+	};
+	const stop = () => {
+		active = false;
+		const installed = uninstalls;
+		uninstalls = [];
+		for (const uninstall of installed) uninstall();
+	};
+	return {
+		start() {
+			if (active || typeof window === "undefined") return;
+			active = true;
+			if (typeof window.addEventListener !== "function") return;
+			const redact = createRedactor();
+			try {
+				uninstalls.push(redact.watch());
+				if (options.capture?.clicks !== false) uninstalls.push(installClickCapture({
+					emit: capture,
+					getRoute,
+					redact
+				}));
+				if (options.capture?.navigation !== false) uninstalls.push(installNavigationCapture({
+					emit: capture,
+					redact
+				}));
+				if (options.capture?.inputs !== false) uninstalls.push(installInputCapture({
+					emit: capture,
+					redact
+				}));
+				if (options.capture?.network !== false) uninstalls.push(installNetworkCapture({
+					emit: capture,
+					ignoreUrls: options.ignoreUrls ?? [],
+					redact
+				}));
+				record("page", {
+					route: getRoute(),
+					url: redact.url(location.href),
+					title: document.title,
+					referrer: redact.url(document.referrer)
+				});
+			} catch {
+				stop();
+				report("CAPTURE_FAILED", "Browser capture could not start.");
+			}
+		},
+		stop,
+		emit(name, value) {
+			if (!active) return;
+			if (RESERVED_NAMES.has(name)) {
+				report("INVALID_EVENT", "Use a developer event name, not a reserved capture name.");
+				return;
+			}
+			record(name, value);
+		}
+	};
+}
+
+//#endregion
+export { BUILT_IN_EVENT_NAMES, MAX_TRAJECTORY_EVENT_BYTES, createCollector, createTrajectoryCollector, httpSink, toOriginAndRoute, toRoute };
+//# sourceMappingURL=index.mjs.map