@lenne.tech/ng-base 18.1.3 → 22.0.1

package/fesm2022/lenne.tech-ng-base-ai.mjs

@@ -0,0 +1,771 @@
+import * as i0 from "@angular/core";
+import { DestroyRef, InjectionToken, PLATFORM_ID, PendingTasks, Service, TransferState, assertInInjectionContext, computed, inject, isSignal, linkedSignal, makeEnvironmentProviders, makeStateKey, signal } from "@angular/core";
+import { LT_FETCH, LT_RUNTIME_CONFIG, LtApiUrlService, mergeLtFeatureOptions } from "@lenne.tech/ng-base";
+import { isPlatformServer } from "@angular/common";
+const LT_AI_INPUT_OPTIONS = new InjectionToken("LT_AI_INPUT_OPTIONS", { factory: () => ({}) });
+const LT_AI_OPTIONS = new InjectionToken("LT_AI_OPTIONS", { factory: () => mergeLtFeatureOptions({ basePath: "/ai" }, inject(LT_AI_INPUT_OPTIONS), inject(LT_RUNTIME_CONFIG, { optional: true })?.lt.ai) });
+function provideLtAi(options = {}) {
+	return makeEnvironmentProviders([{
+		provide: LT_AI_INPUT_OPTIONS,
+		useValue: options
+	}]);
+}
+const LT_AI_SSE_MAX_LINE = 1048576;
+var LtAiHttpService = class LtAiHttpService {
+	api = inject(LtApiUrlService);
+	fetch = inject(LT_FETCH);
+	options = inject(LT_AI_OPTIONS);
+	basePath() {
+		return this.options.basePath;
+	}
+	buildUrl(path) {
+		return this.api.buildUrl(`${this.options.basePath}${path.startsWith("/") ? path : `/${path}`}`);
+	}
+	async request(method, path, body, options = {}) {
+		const init = {
+			headers: { accept: "application/json" },
+			method,
+			signal: options.signal
+		};
+		if (body !== void 0) {
+			init.body = JSON.stringify(body);
+			init.headers = {
+				...init.headers,
+				"content-type": "application/json"
+			};
+		}
+		const response = await this.fetch(this.buildUrl(path), init);
+		if (!response.ok) throw await ltAiResponseError(response);
+		if (response.status === 204) return;
+		const text = await response.text();
+		return text ? JSON.parse(text) : void 0;
+	}
+	stream(path, body, options = {}) {
+		return this.fetch(this.buildUrl(path), {
+			body: JSON.stringify(body),
+			headers: {
+				accept: "text/event-stream",
+				"content-type": "application/json"
+			},
+			method: "POST",
+			signal: options.signal
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiHttpService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiHttpService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiHttpService,
+	decorators: [{ type: Service }]
+});
+async function ltAiResponseError(response) {
+	let message = `${response.status} ${response.statusText}`.trim();
+	try {
+		const body = await response.json();
+		const raw = body?.message ?? body?.error;
+		if (Array.isArray(raw)) message = raw.map(String).join(", ");
+		else if (typeof raw === "string" && raw) message = raw;
+	} catch {}
+	const error = new Error(message.slice(0, 1024));
+	error.status = response.status;
+	return error;
+}
+async function parseLtAiSseStream(response, onEvent, options = {}) {
+	const body = response.body;
+	if (!body) throw new Error("AI stream response has no body");
+	const signal = options.signal;
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let finished = false;
+	const cancel = () => {
+		reader.cancel().catch(() => void 0);
+	};
+	const tooLong = () => /* @__PURE__ */ new Error("AI stream line exceeds maximum allowed size");
+	const handleLine = (line) => {
+		if (line.length > 1048576) throw tooLong();
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("data:")) return;
+		const payload = trimmed.slice(5).trim();
+		if (!payload || payload === "[DONE]") return;
+		let event;
+		try {
+			event = JSON.parse(payload);
+		} catch {
+			return;
+		}
+		onEvent(event);
+	};
+	signal?.addEventListener("abort", cancel, { once: true });
+	try {
+		if (signal?.aborted) return;
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (signal?.aborted) return;
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				handleLine(line);
+				if (signal?.aborted) return;
+			}
+			if (buffer.length > 1048576) throw tooLong();
+		}
+		buffer += decoder.decode();
+		finished = true;
+		if (buffer) handleLine(buffer);
+	} finally {
+		signal?.removeEventListener("abort", cancel);
+		if (!finished) cancel();
+		reader.releaseLock();
+	}
+}
+var LtAiCallState = class {
+	pending = signal(0, ...ngDevMode ? [{ debugName: "pending" }] : /* istanbul ignore next */ []);
+	lastError = signal(null, ...ngDevMode ? [{ debugName: "lastError" }] : /* istanbul ignore next */ []);
+	loading = computed(() => this.pending() > 0, ...ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []);
+	error = this.lastError.asReadonly();
+	async run(call) {
+		this.pending.update((count) => count + 1);
+		this.lastError.set(null);
+		try {
+			return await call();
+		} catch (error) {
+			this.lastError.set(ltAiErrorMessage(error));
+			throw error;
+		} finally {
+			this.pending.update((count) => Math.max(0, count - 1));
+		}
+	}
+	async runQuietly(call) {
+		try {
+			return await this.run(call);
+		} catch {
+			return;
+		}
+	}
+	setError(message) {
+		this.lastError.set(message);
+	}
+};
+function ltAiErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isLtAiAbortError(error) {
+	return error?.name === "AbortError";
+}
+async function runLtAiStream(http, input, handlers, options = {}) {
+	const response = await http.stream("/stream", input, options);
+	if (!response.ok) throw await ltAiResponseError(response);
+	let final;
+	await parseLtAiSseStream(response, (event) => {
+		handlers?.onEvent?.(event);
+		switch (event.type) {
+			case "action":
+				handlers?.onAction?.(event.action);
+				break;
+			case "error":
+				handlers?.onError?.(event.message);
+				break;
+			case "final":
+				final = event.response;
+				handlers?.onFinal?.(event.response);
+				break;
+			case "token": handlers?.onToken?.(event.token);
+		}
+	}, options);
+	if (options.signal?.aborted) throw abortReason(options.signal);
+	return final;
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error || typeof DOMException !== "undefined" && reason instanceof DOMException) return reason;
+	const error = /* @__PURE__ */ new Error("The operation was aborted.");
+	error.name = "AbortError";
+	return error;
+}
+function injectLtAiChat(options = {}) {
+	assertInInjectionContext(injectLtAiChat);
+	const http = inject(LtAiHttpService);
+	const messages = signal([], ...ngDevMode ? [{ debugName: "messages" }] : /* istanbul ignore next */ []);
+	const conversationId = linkedSignal(() => isSignal(options.conversationId) ? options.conversationId() : options.conversationId, ...ngDevMode ? [{ debugName: "conversationId" }] : /* istanbul ignore next */ []);
+	const budget = signal(null, ...ngDevMode ? [{ debugName: "budget" }] : /* istanbul ignore next */ []);
+	const contextWindow = signal(null, ...ngDevMode ? [{ debugName: "contextWindow" }] : /* istanbul ignore next */ []);
+	const error = signal(null, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	const streaming = signal(false, ...ngDevMode ? [{ debugName: "streaming" }] : /* istanbul ignore next */ []);
+	let busy = false;
+	let turnSequence = 0;
+	let controller;
+	let lastPrompt = "";
+	const requiresConfirmation = computed(() => {
+		const list = messages();
+		const last = list[list.length - 1];
+		return !!last && last.role === "assistant" && !!last.requiresConfirmation;
+	}, ...ngDevMode ? [{ debugName: "requiresConfirmation" }] : /* istanbul ignore next */ []);
+	function resolveConnectionId() {
+		const value = options.connectionId;
+		return (isSignal(value) ? value() : value) || void 0;
+	}
+	function push(message) {
+		messages.update((list) => {
+			const next = [...list, message];
+			return options.maxMessages && options.maxMessages > 0 && next.length > options.maxMessages ? next.slice(next.length - options.maxMessages) : next;
+		});
+	}
+	function buildInput(prompt, confirm) {
+		const input = {
+			connectionId: resolveConnectionId(),
+			conversationId: conversationId(),
+			metadata: options.metadata?.(),
+			mode: isSignal(options.mode) ? options.mode() : options.mode,
+			prompt
+		};
+		if (confirm) input.confirm = true;
+		return input;
+	}
+	async function runTurn(input) {
+		const turn = ++turnSequence;
+		const isCurrent = () => turn === turnSequence;
+		error.set(null);
+		let assistant = {
+			content: "",
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			pending: true,
+			role: "assistant"
+		};
+		push(assistant);
+		const patch = (changes) => {
+			const previous = assistant;
+			assistant = {
+				...previous,
+				...changes
+			};
+			const next = assistant;
+			messages.update((list) => list.includes(previous) ? list.map((message) => message === previous ? next : message) : list);
+		};
+		const applyFinal = (response) => {
+			patch({
+				actions: response.actions,
+				budget: response.budget,
+				content: response.text || assistant.content,
+				denied: response.denied,
+				pending: false,
+				pendingActions: response.pendingActions,
+				requiresConfirmation: response.requiresConfirmation
+			});
+			if (!isCurrent()) return;
+			if (response.budget) budget.set(response.budget);
+			if (response.contextWindow) contextWindow.set(response.contextWindow);
+			if (response.conversationId) conversationId.set(response.conversationId);
+		};
+		const fail = (message) => {
+			patch({
+				content: assistant.content || message,
+				error: true,
+				pending: false
+			});
+			if (isCurrent()) error.set(message);
+		};
+		const abort = new AbortController();
+		controller = abort;
+		busy = true;
+		const stream = options.stream !== false;
+		streaming.set(stream);
+		try {
+			if (stream) {
+				let streamError;
+				await runLtAiStream(http, input, {
+					onError: (message) => streamError = message,
+					onFinal: applyFinal,
+					onToken: (token) => patch({ content: assistant.content + token })
+				}, { signal: abort.signal });
+				if (streamError !== void 0) fail(streamError);
+				else if (assistant.pending) patch({ pending: false });
+			} else applyFinal(await http.request("POST", "/prompt", input, { signal: abort.signal }));
+		} catch (caught) {
+			if (isLtAiAbortError(caught)) patch({ pending: false });
+			else fail(ltAiErrorMessage(caught));
+		} finally {
+			if (isCurrent()) {
+				controller = void 0;
+				busy = false;
+				streaming.set(false);
+			}
+		}
+	}
+	async function send(content) {
+		const text = content.trim();
+		if (!text || busy) return;
+		lastPrompt = text;
+		push({
+			content: text,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			role: "user"
+		});
+		await runTurn(buildInput(text, false));
+	}
+	async function confirm() {
+		if (!requiresConfirmation() || !lastPrompt || busy) return;
+		await runTurn(buildInput(lastPrompt, true));
+	}
+	function stop() {
+		controller?.abort();
+		controller = void 0;
+		if (busy) {
+			turnSequence++;
+			busy = false;
+			streaming.set(false);
+		}
+	}
+	function clear() {
+		stop();
+		messages.set([]);
+		budget.set(null);
+		contextWindow.set(null);
+		error.set(null);
+		lastPrompt = "";
+	}
+	inject(DestroyRef).onDestroy(() => stop());
+	return {
+		budget: budget.asReadonly(),
+		clear,
+		confirm,
+		contextWindow: contextWindow.asReadonly(),
+		conversationId: conversationId.asReadonly(),
+		error: error.asReadonly(),
+		messages: messages.asReadonly(),
+		requiresConfirmation,
+		send,
+		stop,
+		streaming: streaming.asReadonly()
+	};
+}
+var LtAiAdminService = class LtAiAdminService {
+	http = inject(LtAiHttpService);
+	listConnections = () => this.http.request("GET", "/connections");
+	createConnection = (input) => this.http.request("POST", "/connections", input);
+	getConnection = (id) => this.http.request("GET", `/connections/${encodeURIComponent(id)}`);
+	updateConnection = (id, input) => this.http.request("PUT", `/connections/${encodeURIComponent(id)}`, input);
+	deleteConnection = (id) => this.http.request("DELETE", `/connections/${encodeURIComponent(id)}`);
+	detectCapabilities = (id) => this.http.request("POST", `/connections/${encodeURIComponent(id)}/detect-capabilities`);
+	listPreferences = () => this.http.request("GET", "/connections/preferences");
+	setPreference = (input) => this.http.request("POST", "/connections/preferences", input);
+	deletePreference = (id) => this.http.request("DELETE", `/connections/preferences/${encodeURIComponent(id)}`);
+	listBudgetLimits = () => this.http.request("GET", "/budget-limits");
+	createBudgetLimit = (input) => this.http.request("POST", "/budget-limits", input);
+	updateBudgetLimit = (id, input) => this.http.request("PUT", `/budget-limits/${encodeURIComponent(id)}`, input);
+	deleteBudgetLimit = (id) => this.http.request("DELETE", `/budget-limits/${encodeURIComponent(id)}`);
+	listSlots = () => this.http.request("GET", "/slots");
+	listEffectiveSlots = () => this.http.request("GET", "/slots/effective");
+	createSlot = (input) => this.http.request("POST", "/slots", input);
+	updateSlot = (id, input) => this.http.request("PUT", `/slots/${encodeURIComponent(id)}`, input);
+	deleteSlot = (id) => this.http.request("DELETE", `/slots/${encodeURIComponent(id)}`);
+	resetSlot = (id) => this.http.request("POST", `/slots/${encodeURIComponent(id)}/reset`);
+	listPromptHints = () => this.http.request("GET", "/prompt-hints");
+	createPromptHint = (input) => this.http.request("POST", "/prompt-hints", input);
+	updatePromptHint = (id, input) => this.http.request("PUT", `/prompt-hints/${encodeURIComponent(id)}`, input);
+	deletePromptHint = (id) => this.http.request("DELETE", `/prompt-hints/${encodeURIComponent(id)}`);
+	listInteractions = () => this.http.request("GET", "/interactions");
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiAdminService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiAdminService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiAdminService,
+	decorators: [{ type: Service }]
+});
+var LtAiConnectionsService = class LtAiConnectionsService {
+	http = inject(LtAiHttpService);
+	calls = new LtAiCallState();
+	list = signal([], ...ngDevMode ? [{ debugName: "list" }] : /* istanbul ignore next */ []);
+	connections = this.list.asReadonly();
+	error = this.calls.error;
+	loading = this.calls.loading;
+	locked = computed(() => this.list().some((connection) => connection.locked), ...ngDevMode ? [{ debugName: "locked" }] : /* istanbul ignore next */ []);
+	selected = computed(() => this.list().find((connection) => connection.selected), ...ngDevMode ? [{ debugName: "selected" }] : /* istanbul ignore next */ []);
+	async load() {
+		await this.calls.runQuietly(async () => {
+			this.list.set(await this.http.request("GET", "/connections/available") ?? []);
+		});
+	}
+	async select(connectionId) {
+		await this.calls.run(async () => {
+			this.list.set(await this.http.request("POST", "/connections/select", { connectionId }) ?? []);
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiConnectionsService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiConnectionsService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiConnectionsService,
+	decorators: [{ type: Service }]
+});
+var LtAiPlaceholdersService = class LtAiPlaceholdersService {
+	http = inject(LtAiHttpService);
+	calls = new LtAiCallState();
+	list = signal([], ...ngDevMode ? [{ debugName: "list" }] : /* istanbul ignore next */ []);
+	error = this.calls.error;
+	loading = this.calls.loading;
+	placeholders = this.list.asReadonly();
+	async load() {
+		try {
+			await this.calls.run(async () => {
+				this.list.set(await this.http.request("GET", "/placeholders") ?? []);
+			});
+		} catch {
+			this.list.set([]);
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiPlaceholdersService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiPlaceholdersService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiPlaceholdersService,
+	decorators: [{ type: Service }]
+});
+var LtAiPromptsService = class LtAiPromptsService {
+	http = inject(LtAiHttpService);
+	calls = new LtAiCallState();
+	list = signal([], ...ngDevMode ? [{ debugName: "list" }] : /* istanbul ignore next */ []);
+	loadSequence = 0;
+	includeDisabled = false;
+	error = this.calls.error;
+	loading = this.calls.loading;
+	prompts = this.list.asReadonly();
+	enabledPrompts = computed(() => this.list().filter((prompt) => prompt.enabled !== false), ...ngDevMode ? [{ debugName: "enabledPrompts" }] : /* istanbul ignore next */ []);
+	async load(options = {}) {
+		const sequence = ++this.loadSequence;
+		this.includeDisabled = options.includeDisabled === true;
+		const path = this.includeDisabled ? "/prompts?includeDisabled=true" : "/prompts";
+		try {
+			const prompts = await this.calls.run(() => this.http.request("GET", path));
+			if (sequence === this.loadSequence) this.list.set(prompts ?? []);
+		} catch {
+			if (sequence === this.loadSequence) this.list.set([]);
+		}
+	}
+	async create(input) {
+		return this.mutate(() => this.http.request("POST", "/prompts", input));
+	}
+	async update(id, input) {
+		return this.mutate(() => this.http.request("PUT", `/prompts/${encodeURIComponent(id)}`, input));
+	}
+	async remove(id) {
+		return this.mutate(() => this.http.request("DELETE", `/prompts/${encodeURIComponent(id)}`));
+	}
+	async mutate(call) {
+		return this.calls.run(async () => {
+			const result = await call();
+			await this.load({ includeDisabled: this.includeDisabled });
+			return result;
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiPromptsService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiPromptsService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiPromptsService,
+	decorators: [{ type: Service }]
+});
+var LtAiService = class LtAiService {
+	http = inject(LtAiHttpService);
+	calls = new LtAiCallState();
+	streams = signal(0, ...ngDevMode ? [{ debugName: "streams" }] : /* istanbul ignore next */ []);
+	error = this.calls.error;
+	loading = this.calls.loading;
+	streaming = computed(() => this.streams() > 0, ...ngDevMode ? [{ debugName: "streaming" }] : /* istanbul ignore next */ []);
+	async prompt(input) {
+		return this.calls.run(() => this.http.request("POST", "/prompt", input));
+	}
+	async promptStream(input, handlers, options = {}) {
+		this.streams.update((count) => count + 1);
+		this.calls.setError(null);
+		try {
+			return await runLtAiStream(this.http, input, {
+				...handlers,
+				onError: (message) => {
+					this.calls.setError(message);
+					handlers?.onError?.(message);
+				}
+			}, options);
+		} catch (error) {
+			if (!isLtAiAbortError(error)) this.calls.setError(ltAiErrorMessage(error));
+			throw error;
+		} finally {
+			this.streams.update((count) => Math.max(0, count - 1));
+		}
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiService,
+	decorators: [{ type: Service }]
+});
+var LtAiSettingsService = class LtAiSettingsService {
+	http = inject(LtAiHttpService);
+	calls = new LtAiCallState();
+	current = signal(null, ...ngDevMode ? [{ debugName: "current" }] : /* istanbul ignore next */ []);
+	enforced = computed(() => this.current()?.mcpConfirmationEnforced === true, ...ngDevMode ? [{ debugName: "enforced" }] : /* istanbul ignore next */ []);
+	error = this.calls.error;
+	loading = this.calls.loading;
+	settings = this.current.asReadonly();
+	async load() {
+		await this.calls.runQuietly(async () => {
+			this.current.set(await this.http.request("GET", "/settings") ?? null);
+		});
+	}
+	async update(input) {
+		await this.calls.run(async () => {
+			this.current.set(await this.http.request("PUT", "/settings", input) ?? null);
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiSettingsService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiSettingsService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiSettingsService,
+	decorators: [{ type: Service }]
+});
+const LT_AI_STATUS_STATE_KEY = makeStateKey("lt-ai-status");
+const LT_AI_STATUS_TIMEOUT_MS = 5e3;
+const INITIAL_STATUS = {
+	enabled: false,
+	error: null,
+	loaded: false,
+	mcp: false
+};
+var LtAiStatusService = class LtAiStatusService {
+	http = inject(LtAiHttpService);
+	transferState = inject(TransferState);
+	pendingTasks = inject(PendingTasks);
+	isServer = isPlatformServer(inject(PLATFORM_ID));
+	state = signal(this.readTransferred(), ...ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []);
+	inflight = null;
+	enabled = computed(() => this.state().enabled, ...ngDevMode ? [{ debugName: "enabled" }] : /* istanbul ignore next */ []);
+	error = computed(() => this.state().error, ...ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []);
+	loaded = computed(() => this.state().loaded, ...ngDevMode ? [{ debugName: "loaded" }] : /* istanbul ignore next */ []);
+	mcp = computed(() => this.state().mcp, ...ngDevMode ? [{ debugName: "mcp" }] : /* istanbul ignore next */ []);
+	load(options = {}) {
+		if (this.state().loaded && !options.force) return Promise.resolve();
+		if (this.inflight) return this.inflight;
+		const done = this.isServer ? this.pendingTasks.add() : void 0;
+		const request = this.fetchStatus().then((status) => {
+			this.state.set(status);
+			if (this.isServer) this.transferState.set(LT_AI_STATUS_STATE_KEY, status);
+		}).finally(() => {
+			this.inflight = null;
+			done?.();
+		});
+		this.inflight = request;
+		return request;
+	}
+	async fetchStatus() {
+		const failed = (error) => ({
+			enabled: false,
+			error,
+			loaded: true,
+			mcp: false
+		});
+		let response;
+		try {
+			response = await fetch(this.http.buildUrl("/status"), {
+				credentials: "omit",
+				headers: { accept: "application/json" },
+				signal: AbortSignal.timeout(LT_AI_STATUS_TIMEOUT_MS)
+			});
+		} catch (error) {
+			return failed(error?.name === "TimeoutError" ? "AI status request timed out" : "AI status request failed");
+		}
+		if (response.status === 404) return {
+			enabled: false,
+			error: null,
+			loaded: true,
+			mcp: false
+		};
+		if (!response.ok) return failed(`HTTP ${response.status}`);
+		try {
+			const body = await response.json();
+			if (typeof body?.mcp === "boolean") return {
+				enabled: true,
+				error: null,
+				loaded: true,
+				mcp: body.mcp
+			};
+		} catch {}
+		return failed("Unexpected AI status response");
+	}
+	readTransferred() {
+		const transferred = this.transferState.get(LT_AI_STATUS_STATE_KEY, null);
+		if (!transferred || transferred.loaded !== true) return INITIAL_STATUS;
+		return {
+			enabled: transferred.enabled === true,
+			error: typeof transferred.error === "string" ? transferred.error : null,
+			loaded: true,
+			mcp: transferred.enabled === true && transferred.mcp === true
+		};
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiStatusService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiStatusService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiStatusService,
+	decorators: [{ type: Service }]
+});
+var LtAiUsageService = class LtAiUsageService {
+	http = inject(LtAiHttpService);
+	calls = new LtAiCallState();
+	current = signal(null, ...ngDevMode ? [{ debugName: "current" }] : /* istanbul ignore next */ []);
+	error = this.calls.error;
+	loading = this.calls.loading;
+	usage = this.current.asReadonly();
+	async load() {
+		await this.calls.runQuietly(async () => {
+			this.current.set(await this.http.request("GET", "/usage") ?? null);
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiUsageService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtAiUsageService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtAiUsageService,
+	decorators: [{ type: Service }]
+});
+export { LT_AI_OPTIONS, LT_AI_SSE_MAX_LINE, LT_AI_STATUS_STATE_KEY, LT_AI_STATUS_TIMEOUT_MS, LtAiAdminService, LtAiConnectionsService, LtAiHttpService, LtAiPlaceholdersService, LtAiPromptsService, LtAiService, LtAiSettingsService, LtAiStatusService, LtAiUsageService, injectLtAiChat, ltAiResponseError, parseLtAiSseStream, provideLtAi };
+
+//# sourceMappingURL=lenne.tech-ng-base-ai.mjs.map