@lenne.tech/nuxt-extensions 1.6.0 → 1.7.0

package/dist/runtime/composables/use-lt-ai-prompts.js

@@ -0,0 +1,70 @@
+import { readonly, ref } from "#imports";
+import { ltAiRequest } from "../lib/ai.js";
+export function useLtAiPrompts() {
+  const prompts = ref([]);
+  const loading = ref(false);
+  const error = ref(null);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      prompts.value = await ltAiRequest("GET", "/prompts") || [];
+    } catch (err) {
+      error.value = err.message;
+      prompts.value = [];
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function create(input) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const created = await ltAiRequest("POST", "/prompts", input);
+      await load();
+      return created;
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function update(id, input) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const updated = await ltAiRequest("PUT", `/prompts/${encodeURIComponent(id)}`, input);
+      await load();
+      return updated;
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function remove(id) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const removed = await ltAiRequest("DELETE", `/prompts/${encodeURIComponent(id)}`);
+      await load();
+      return removed;
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    create,
+    error: readonly(error),
+    load,
+    loading: readonly(loading),
+    prompts: readonly(prompts),
+    remove,
+    update
+  };
+}

package/dist/runtime/composables/use-lt-ai-usage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Token/prompt usage for the current user (and tenant), from `GET /ai/usage`.
+ * The compact per-response budget is also available on every prompt response
+ * (see {@link useLtAiChat}); this composable loads the full breakdown on demand.
+ */
+import type { UseLtAiUsageReturn } from '../types/ai.js';
+export declare function useLtAiUsage(): UseLtAiUsageReturn;

package/dist/runtime/composables/use-lt-ai-usage.js

@@ -0,0 +1,19 @@
+import { readonly, ref } from "#imports";
+import { ltAiRequest } from "../lib/ai.js";
+export function useLtAiUsage() {
+  const usage = ref(null);
+  const loading = ref(false);
+  const error = ref(null);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      usage.value = await ltAiRequest("GET", "/usage");
+    } catch (err) {
+      error.value = err.message;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return { error: readonly(error), load, loading: readonly(loading), usage: readonly(usage) };
+}

package/dist/runtime/composables/use-lt-ai.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core AI composable: one-shot prompts and SSE streaming against the
+ * @lenne.tech/nest-server AI module (`/ai/prompt`, `/ai/stream`).
+ *
+ * Headless — pair it with your own UI, or use the higher-level {@link useLtAiChat}.
+ */
+import type { UseLtAiReturn } from '../types/ai.js';
+export declare function useLtAi(): UseLtAiReturn;

package/dist/runtime/composables/use-lt-ai.js

@@ -0,0 +1,68 @@
+import { readonly, ref } from "#imports";
+import { buildLtAiUrl, ltAiRequest, ltAiResponseError, parseLtAiSseStream } from "../lib/ai.js";
+import { ltAuthFetch } from "../lib/auth-state.js";
+export function useLtAi() {
+  const loading = ref(false);
+  const streaming = ref(false);
+  const error = ref(null);
+  async function prompt(input) {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await ltAiRequest("POST", "/prompt", input);
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function promptStream(input, handlers, options) {
+    streaming.value = true;
+    error.value = null;
+    let final;
+    try {
+      const response = await ltAuthFetch(buildLtAiUrl("/stream"), {
+        body: JSON.stringify(input),
+        headers: { Accept: "text/event-stream", "Content-Type": "application/json" },
+        method: "POST",
+        signal: options?.signal
+      });
+      if (!response.ok) {
+        throw await ltAiResponseError(response);
+      }
+      await parseLtAiSseStream(response, (event) => {
+        handlers?.onEvent?.(event);
+        switch (event.type) {
+          case "action":
+            handlers?.onAction?.(event.action);
+            break;
+          case "error":
+            error.value = event.message;
+            handlers?.onError?.(event.message);
+            break;
+          case "final":
+            final = event.response;
+            handlers?.onFinal?.(event.response);
+            break;
+          case "token":
+            handlers?.onToken?.(event.token);
+            break;
+        }
+      });
+      return final;
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      streaming.value = false;
+    }
+  }
+  return {
+    error: readonly(error),
+    loading: readonly(loading),
+    prompt,
+    promptStream,
+    streaming: readonly(streaming)
+  };
+}

package/dist/runtime/lib/ai.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AI module client helpers: URL building, authenticated JSON requests, and a
+ * robust SSE stream parser for `POST /ai/stream`.
+ *
+ * All requests go through {@link ltAuthFetch} (Cookie/JWT dual-mode, 401 fallback)
+ * and {@link buildLtApiUrl} (SSR/proxy/direct URL resolution), so the AI client
+ * behaves exactly like the rest of the library.
+ */
+import type { LtAiStreamEvent } from '../types/ai.js';
+/** Resolve the AI base path from runtime config (default `/ai`). */
+export declare function getLtAiBasePath(): string;
+/** Build a full URL for an AI endpoint path (e.g. `/prompt`, `/connections/available`). */
+export declare function buildLtAiUrl(path: string): string;
+/**
+ * Turn a non-ok AI response into an Error using the backend's (translated) message.
+ *
+ * The resulting Error carries a numeric `status` field (the HTTP status code) so
+ * consumers can branch on response codes without re-parsing the message. The
+ * message is capped at ~1 KiB to bound downstream UI rendering / logging.
+ *
+ * Consumers should pipe the message through `useLtErrorTranslation()` for the
+ * user-facing localisation step — this helper preserves the raw backend string.
+ */
+export declare function ltAiResponseError(response: Response): Promise<Error & {
+    status: number;
+}>;
+/**
+ * Authenticated JSON request against an AI endpoint. Throws {@link ltAiResponseError}
+ * on a non-2xx response, otherwise returns the parsed body (or `undefined` for 204).
+ */
+export declare function ltAiRequest<T>(method: string, path: string, body?: unknown, options?: {
+    signal?: AbortSignal;
+}): Promise<T>;
+/**
+ * Parse a `text/event-stream` AI response, invoking `onEvent` for each parsed
+ * {@link LtAiStreamEvent}. Buffers partial lines across chunks and tolerates
+ * malformed/keep-alive lines.
+ *
+ * `options.signal` lets the caller stop parsing without cancelling the
+ * underlying fetch — useful for component-unmount races. When the signal fires
+ * the reader is cancelled and the function resolves cleanly.
+ *
+ * Throws when a single line exceeds `LT_AI_SSE_LINE_LIMIT` (1 MiB) — guards
+ * against a misbehaving proxy/backend that never delivers a newline.
+ */
+export declare function parseLtAiSseStream(response: Response, onEvent: (event: LtAiStreamEvent) => void, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;

package/dist/runtime/lib/ai.js

@@ -0,0 +1,96 @@
+import { useRuntimeConfig } from "#imports";
+import { buildLtApiUrl, ltAuthFetch } from "./auth-state.js";
+const LT_AI_SSE_LINE_LIMIT = 1024 * 1024;
+const LT_AI_ERROR_MESSAGE_LIMIT = 1024;
+export function getLtAiBasePath() {
+  try {
+    const rc = useRuntimeConfig();
+    const ext = rc.public.ltExtensions;
+    return ext?.ai?.basePath || "/ai";
+  } catch {
+    return "/ai";
+  }
+}
+export function buildLtAiUrl(path) {
+  return buildLtApiUrl(`${getLtAiBasePath()}${path}`);
+}
+export async function ltAiResponseError(response) {
+  let message = `HTTP ${response.status}`;
+  try {
+    const body = await response.json();
+    const detail = body?.message ?? body?.error;
+    if (detail) {
+      const raw = Array.isArray(detail) ? detail.join(", ") : String(detail);
+      message = raw.length > LT_AI_ERROR_MESSAGE_LIMIT ? `${raw.slice(0, LT_AI_ERROR_MESSAGE_LIMIT)}\u2026` : raw;
+    }
+  } catch {
+  }
+  const error = new Error(message);
+  error.status = response.status;
+  return error;
+}
+export async function ltAiRequest(method, path, body, options) {
+  const init = { method, signal: options?.signal };
+  if (body !== void 0) {
+    init.headers = { Accept: "application/json", "Content-Type": "application/json" };
+    init.body = JSON.stringify(body);
+  } else {
+    init.headers = { Accept: "application/json" };
+  }
+  const response = await ltAuthFetch(buildLtAiUrl(path), init);
+  if (!response.ok) {
+    throw await ltAiResponseError(response);
+  }
+  if (response.status === 204) {
+    return void 0;
+  }
+  return await response.json();
+}
+export async function parseLtAiSseStream(response, onEvent, options) {
+  const body = response.body;
+  if (!body) {
+    throw new Error("AI stream response has no body");
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const handleLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) {
+      return;
+    }
+    const payload = trimmed.slice(5).trim();
+    if (!payload || payload === "[DONE]") {
+      return;
+    }
+    try {
+      onEvent(JSON.parse(payload));
+    } catch {
+    }
+  };
+  try {
+    while (!options?.signal?.aborted) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      if (buffer.length > LT_AI_SSE_LINE_LIMIT) {
+        throw new Error("AI stream line exceeds maximum allowed size");
+      }
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        handleLine(line);
+      }
+    }
+    if (options?.signal?.aborted) {
+      reader.cancel().catch(() => {
+      });
+    } else if (buffer) {
+      handleLine(buffer);
+    }
+  } finally {
+    reader.releaseLock?.();
+  }
+}

package/dist/runtime/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { attemptLtJwtSwitch, clearLtAuthCookies, createLtAuthFetch, getLtApiBase, getLtAuthCookieNames, getLtAuthMode, getLtJwtToken, isLtAuthenticated, LT_AUTH_STATE_COOKIE_DEFAULT, LT_JWT_TOKEN_COOKIE_DEFAULT, ltAuthFetch, setLtAuthMode, setLtJwtToken, } from './auth-state.js';
 export { clearLtAuthPluginRegistry, createLtAuthClient, getOrCreateLtAuthClient, getLtAuthPluginRegistry, registerLtAuthPlugins, resetLtAuthClientSingleton, type LtAuthClient, } from './auth-client.js';
+export { buildLtAiUrl, getLtAiBasePath, ltAiRequest, ltAiResponseError, parseLtAiSseStream } from './ai.js';

package/dist/runtime/lib/index.js

@@ -21,3 +21,4 @@ export {
   registerLtAuthPlugins,
   resetLtAuthClientSingleton
 } from "./auth-client.js";
+export { buildLtAiUrl, getLtAiBasePath, ltAiRequest, ltAiResponseError, parseLtAiSseStream } from "./ai.js";

package/dist/runtime/plugins/auth-interceptor.client.js

@@ -69,29 +69,33 @@ export default (nuxtApp) => {
       }, 1e3);
     }
   }
-  const originalFetch = globalThis.$fetch;
-  globalThis.$fetch = ((url, options) => {
-    return originalFetch(url, {
-      ...options,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      onResponseError: (context) => {
-        if (options?.onResponseError) {
-          options.onResponseError(context);
+  const wrapMarker = "__ltAuthFetchWrapped";
+  if (!globalThis[wrapMarker]) {
+    globalThis[wrapMarker] = true;
+    const originalFetch = globalThis.$fetch;
+    globalThis.$fetch = ((url, options) => {
+      return originalFetch(url, {
+        ...options,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        onResponseError: (context) => {
+          if (options?.onResponseError) {
+            options.onResponseError(context);
+          }
+          if (context.response?.status === 401) {
+            handleUnauthorized(url);
+          }
         }
-        if (context.response?.status === 401) {
-          handleUnauthorized(url);
-        }
-      }
+      });
     });
-  });
-  const originalNativeFetch = globalThis.fetch;
-  globalThis.fetch = async (input, init) => {
-    const response = await originalNativeFetch(input, init);
-    if (response.status === 401) {
-      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-      handleUnauthorized(url);
-    }
-    return response;
-  };
+    const originalNativeFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      const response = await originalNativeFetch(input, init);
+      if (response.status === 401) {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        handleUnauthorized(url);
+      }
+      return response;
+    };
+  }
   nuxtApp.provide("ltHandleUnauthorized", handleUnauthorized);
 };