@lenne.tech/nuxt-extensions 1.5.4 → 1.7.0

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

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

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

@@ -0,0 +1,13 @@
+/**
+ * User-facing prompt composable.
+ *
+ * Any signed-in user can author re-usable prompts ("Vorlagen") for themselves
+ * (`scope: 'user'` = private) or for their tenant (`scope: 'tenant'` = public).
+ * `load()` returns every prompt the current user is allowed to see (own +
+ * tenant), already filtered by the server.
+ *
+ * Pair this with your own prompt picker / settings UI. The nuxt-base-starter
+ * ships a reference picker inside the AI chat and a settings page.
+ */
+import type { UseLtAiPromptsReturn } from '../types/ai.js';
+export declare function useLtAiPrompts(): UseLtAiPromptsReturn;

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/auth-client.d.ts

@@ -226,8 +226,8 @@ export declare function createLtAuthClient(config?: LtAuthClientConfig): {
                 onResponse: ((context: import("better-auth/client").ResponseContext) => Promise<Response | void | import("better-auth/client").ResponseContext> | Response | import("better-auth/client").ResponseContext | void) | undefined;
             };
         })[];
-        cache?: RequestCache | undefined;
         priority?: RequestPriority | undefined;
+        cache?: RequestCache | undefined;
         credentials?: RequestCredentials;
         headers?: (HeadersInit & (HeadersInit | {
             accept: "application/json" | "text/plain" | "application/octet-stream";

package/dist/runtime/lib/auth-state.d.ts

@@ -12,6 +12,20 @@
  * The state is persisted in cookies for SSR compatibility.
  */
 import type { LtAuthMode } from '../types/index.js';
+/** Default name of the auth-state cookie. Used when the module config has not been resolved yet. */
+export declare const LT_AUTH_STATE_COOKIE_DEFAULT = "lt-auth-state";
+/** Default name of the JWT-token cookie. Used when the module config has not been resolved yet. */
+export declare const LT_JWT_TOKEN_COOKIE_DEFAULT = "lt-jwt-token";
+/**
+ * Resolve the configured auth cookie names from runtime config.
+ *
+ * Falls back to the defaults (`lt-auth-state`, `lt-jwt-token`) so callers
+ * keep working even outside a Nuxt context (tests, edge SSR boots).
+ */
+export declare function getLtAuthCookieNames(): {
+    state: string;
+    token: string;
+};
 /**
  * Determines if HTTP requests should use the Nuxt Vite dev proxy.
  *
@@ -95,7 +109,24 @@ export declare function getLtJwtToken(): string | null;
  */
 export declare function setLtJwtToken(token: string | null): void;
 /**
- * Update auth mode in the lt-auth-state cookie
+ * Hard-delete all auth cookies on logout.
+ *
+ * This is the single source of truth for "remove every auth cookie this
+ * module owns". It expires:
+ * - the configured auth-state cookie (default `lt-auth-state`)
+ * - the configured JWT token cookie (default `lt-jwt-token`)
+ * - the Better-Auth session fallbacks the client may have set
+ *
+ * Browsers only delete a cookie when the path / sameSite / secure
+ * attributes match the ones used when it was written, so we mirror the
+ * attributes from `setUser()` / `setLtJwtToken()`. The Better-Auth
+ * session cookies are httpOnly when set by the API and cannot be touched
+ * from JS — clearing them here is best-effort for any non-httpOnly
+ * variant the framework might have written client-side.
+ */
+export declare function clearLtAuthCookies(): void;
+/**
+ * Update auth mode in the auth-state cookie
  */
 export declare function setLtAuthMode(mode: LtAuthMode): void;
 /**
@@ -117,7 +148,7 @@ export declare function getLtApiBase(basePath?: string): string;
  */
 export declare function attemptLtJwtSwitch(basePath?: string): Promise<boolean>;
 /**
- * Check if user is authenticated (has lt-auth-state with user)
+ * Check if user is authenticated (has auth-state with user)
  */
 export declare function isLtAuthenticated(): boolean;
 /**

package/dist/runtime/lib/auth-state.js

@@ -1,4 +1,18 @@
 import { useRuntimeConfig } from "#imports";
+export const LT_AUTH_STATE_COOKIE_DEFAULT = "lt-auth-state";
+export const LT_JWT_TOKEN_COOKIE_DEFAULT = "lt-jwt-token";
+export function getLtAuthCookieNames() {
+  try {
+    const runtimeConfig = useRuntimeConfig();
+    const configured = runtimeConfig.public?.ltExtensions?.auth?.cookieNames;
+    return {
+      state: configured?.state || LT_AUTH_STATE_COOKIE_DEFAULT,
+      token: configured?.token || LT_JWT_TOKEN_COOKIE_DEFAULT
+    };
+  } catch {
+    return { state: LT_AUTH_STATE_COOKIE_DEFAULT, token: LT_JWT_TOKEN_COOKIE_DEFAULT };
+  }
+}
 let _proxyFallbackWarned = false;
 export function isLocalDevApiProxy() {
   if (import.meta.server) {
@@ -52,7 +66,8 @@ export function buildLtApiUrl(path) {
 export function getLtAuthMode() {
   if (import.meta.server) return "cookie";
   try {
-    const cookie = document.cookie.split("; ").find((row) => row.startsWith("lt-auth-state="));
+    const { state: stateCookieName } = getLtAuthCookieNames();
+    const cookie = document.cookie.split("; ").find((row) => row.startsWith(`${stateCookieName}=`));
     if (cookie) {
       const parts = cookie.split("=");
       const value = parts.length > 1 ? decodeURIComponent(parts.slice(1).join("=")) : "";
@@ -66,7 +81,8 @@ export function getLtAuthMode() {
 export function getLtJwtToken() {
   if (import.meta.server) return null;
   try {
-    const cookie = document.cookie.split("; ").find((row) => row.startsWith("lt-jwt-token="));
+    const { token: tokenCookieName } = getLtAuthCookieNames();
+    const cookie = document.cookie.split("; ").find((row) => row.startsWith(`${tokenCookieName}=`));
     if (cookie) {
       const parts = cookie.split("=");
       const value = parts.length > 1 ? decodeURIComponent(parts.slice(1).join("=")) : "";
@@ -81,18 +97,34 @@ export function getLtJwtToken() {
 }
 export function setLtJwtToken(token) {
   if (import.meta.server) return;
+  const { token: tokenCookieName } = getLtAuthCookieNames();
   const maxAge = 60 * 60 * 24 * 7;
   const secure = globalThis.location?.protocol === "https:" ? "; secure" : "";
   if (token) {
-    document.cookie = `lt-jwt-token=${encodeURIComponent(JSON.stringify(token))}; path=/; max-age=${maxAge}; samesite=lax${secure}`;
+    document.cookie = `${tokenCookieName}=${encodeURIComponent(JSON.stringify(token))}; path=/; max-age=${maxAge}; samesite=lax${secure}`;
   } else {
-    document.cookie = `lt-jwt-token=; path=/; max-age=0`;
+    document.cookie = `${tokenCookieName}=; path=/; max-age=0; samesite=lax${secure}`;
+  }
+}
+export function clearLtAuthCookies() {
+  if (import.meta.server) return;
+  const { state: stateCookieName, token: tokenCookieName } = getLtAuthCookieNames();
+  const secure = globalThis.location?.protocol === "https:" ? "; secure" : "";
+  document.cookie = `${stateCookieName}=; path=/; max-age=0; samesite=lax${secure}`;
+  document.cookie = `${tokenCookieName}=; path=/; max-age=0; samesite=lax${secure}`;
+  const sessionCookieNames = ["better-auth.session_token", "better-auth.session", "__Secure-better-auth.session_token", "session_token", "session"];
+  for (const name of sessionCookieNames) {
+    document.cookie = `${name}=; path=/; max-age=0`;
+    document.cookie = `${name}=; path=/api; max-age=0`;
+    document.cookie = `${name}=; path=/api/iam; max-age=0`;
+    document.cookie = `${name}=; path=/iam; max-age=0`;
   }
 }
 export function setLtAuthMode(mode) {
   if (import.meta.server) return;
   try {
-    const cookie = document.cookie.split("; ").find((row) => row.startsWith("lt-auth-state="));
+    const { state: stateCookieName } = getLtAuthCookieNames();
+    const cookie = document.cookie.split("; ").find((row) => row.startsWith(`${stateCookieName}=`));
     let state = { user: null, authMode: mode };
     if (cookie) {
       const parts = cookie.split("=");
@@ -101,7 +133,7 @@ export function setLtAuthMode(mode) {
     }
     const maxAge = 60 * 60 * 24 * 7;
     const secure = globalThis.location?.protocol === "https:" ? "; secure" : "";
-    document.cookie = `lt-auth-state=${encodeURIComponent(JSON.stringify(state))}; path=/; max-age=${maxAge}; samesite=lax${secure}`;
+    document.cookie = `${stateCookieName}=${encodeURIComponent(JSON.stringify(state))}; path=/; max-age=${maxAge}; samesite=lax${secure}`;
   } catch {
   }
 }
@@ -139,7 +171,8 @@ export async function attemptLtJwtSwitch(basePath = "/iam") {
 export function isLtAuthenticated() {
   if (import.meta.server) return false;
   try {
-    const cookie = document.cookie.split("; ").find((row) => row.startsWith("lt-auth-state="));
+    const { state: stateCookieName } = getLtAuthCookieNames();
+    const cookie = document.cookie.split("; ").find((row) => row.startsWith(`${stateCookieName}=`));
     if (cookie) {
       const parts = cookie.split("=");
       const value = parts.length > 1 ? decodeURIComponent(parts.slice(1).join("=")) : "";

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

@@ -1,2 +1,3 @@
-export { attemptLtJwtSwitch, createLtAuthFetch, getLtApiBase, getLtAuthMode, getLtJwtToken, isLtAuthenticated, ltAuthFetch, setLtAuthMode, setLtJwtToken } from './auth-state.js';
+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

@@ -1,4 +1,18 @@
-export { attemptLtJwtSwitch, createLtAuthFetch, getLtApiBase, getLtAuthMode, getLtJwtToken, isLtAuthenticated, ltAuthFetch, setLtAuthMode, setLtJwtToken } from "./auth-state.js";
+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,
@@ -7,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);
 };