@lenne.tech/nuxt-extensions 1.6.0 → 1.7.1

package/CLAUDE.md

@@ -10,9 +10,9 @@ src/
 ├── runtime/
 │   ├── composables/       # Auto-imported composables
 │   ├── components/        # Auto-imported components
-│   ├── lib/               # Library exports (auth-client, helpers)
-│   ├── middleware/         # Route middleware (auth)
-│   ├── plugins/           # Nuxt plugins (auth initialization)
+│   ├── lib/               # Library exports (auth-client, auth-state, ai)
+│   ├── middleware/        # Route middleware (system setup)
+│   ├── plugins/           # Nuxt plugins (auth interceptor, error translation)
 │   ├── server/            # Nitro server routes (auth proxy)
 │   ├── testing/           # Playwright test helpers
 │   ├── types/             # TypeScript type definitions
@@ -21,32 +21,70 @@ src/
 
 ## Key Composables
 
+### Auth + uploads + utilities
+
+| Composable | Purpose |
+|-----------|---------|
+| `useLtAuth()` | Authentication state, login, logout, session management |
+| `useLtAuthClient()` | Raw Better Auth client access |
+| `useSystemSetup()` | First-admin setup flow |
+| `useLtTusUpload()` | TUS resumable file uploads |
+| `useLtFile()` | File utilities (size formatting, URLs) |
+| `useLtShare()` | Web Share API with clipboard fallback |
+| `useLtErrorTranslation()` | Translate backend error codes |
+
+### AI assistant (nest-server AI module)
+
 | Composable | Purpose |
 |-----------|---------|
-| `useBetterAuth()` | Authentication state, login, logout, session management |
-| `useAuthClient()` | Raw Better Auth client access |
-| `useTusUpload()` | TUS resumable file uploads |
+| `useLtAi()` | One-shot `prompt()` + streaming `promptStream()` (POST `/ai/prompt` / `/ai/stream`) |
+| `useLtAiChat()` | Multi-turn chat: streaming, budget summary, confirmation gate, `stop()`/`clear()`, optional `maxMessages` cap, auto-stop on unmount |
+| `useLtAiConnections()` | User-facing list of available connections + `select()` |
+| `useLtAiUsage()` | Full token/prompt usage breakdown (`GET /ai/usage`) |
+| `useLtAiPrompts()` | User-facing CRUD for re-usable prompt snippets ("Vorlagen", `scope: 'user'` / `'tenant'`) |
+| `useLtAiPlaceholders()` | Loads the backend's `{{placeholder}}` registry for editor sidebars |
+| `useLtAiAdmin()` | Admin CRUD: connections, preferences, budget limits, slots, prompt hints, interactions — server-gated |
 
 ## Module Configuration
 
-Configure in `nuxt.config.ts`:
+Configure in `nuxt.config.ts` (top-level key is `ltExtensions`):
 
 ```typescript
 export default defineNuxtConfig({
   modules: ['@lenne.tech/nuxt-extensions'],
-  lennetech: {
-    // API base URL for auth proxy
-    apiUrl: 'http://localhost:3000',
-    // Enable/disable features
-    betterAuth: true,
-    tusUpload: true,
-  }
-})
+  ltExtensions: {
+    auth: {
+      enabled: true,
+      basePath: '/iam',              // Better-Auth endpoint prefix
+      loginPath: '/auth/login',
+      enableAdmin: true,
+      enablePasskey: true,
+      enableTwoFactor: true,
+    },
+    errorTranslation: {
+      enabled: true,
+      defaultLocale: 'de',
+    },
+    tus: {
+      defaultEndpoint: '/files/upload',
+      defaultChunkSize: 5 * 1024 * 1024,  // 5MB
+    },
+    i18n: {
+      autoMerge: true,
+    },
+    ai: {
+      enabled: true,
+      basePath: '/ai',               // Must match the nest-server AI controller
+    },
+  },
+});
 ```
 
+The API base URL is resolved at runtime from `NUXT_PUBLIC_API_URL` (client + SSR fallback) and the optional `NUXT_API_URL` (SSR-only, e.g. for internal cluster addresses). `NUXT_API_URL` is never promoted into the public bundle.
+
 ## Authentication (Better Auth)
 
-- SSR-safe session management via `useBetterAuth()`
+- SSR-safe session management via `useLtAuth()`
 - Auth proxy server route at `/api/auth/**` (proxies to backend)
 - Middleware `auth` for protected routes
 - Passkey (WebAuthn) support via `@better-auth/passkey` peer dependency
@@ -54,11 +92,18 @@ export default defineNuxtConfig({
 
 ### Auth Flow
 
-1. Frontend calls `useBetterAuth().signIn()` / `.signUp()`
+1. Frontend calls `useLtAuth().signIn()` / `.signUp()`
 2. Request goes through Nitro proxy at `/api/auth/**`
 3. Proxy forwards to backend Better Auth endpoints
 4. Session cookie set via `httpOnly` cookie (SSR-safe)
 
+## AI Assistant Flow
+
+- All AI composables route through `ltAuthFetch` (Cookie/JWT dual mode) and `buildLtAiUrl` (SSR/public URL resolution), so they inherit the same auth + URL behaviour as the rest of the library.
+- `useLtAi.promptStream()` and `useLtAiChat()` consume `POST /ai/stream` via `fetch` + `ReadableStream` (NOT `EventSource` — the endpoint is `POST` with auth). The SSE parser is robust against split chunks, keep-alive comments, malformed lines, and oversized lines (>1 MiB throws).
+- `useLtAiAdmin()` is exposed as a regular composable; admin gating is enforced server-side (`@Restricted(ADMIN)`). Render admin UI behind a frontend route guard for UX, but trust the backend for authorization.
+- The chat composable's `messages` ref is a shallow `Readonly<Ref<LtAiMessage[]>>` so child components can bind individual messages while preserving streaming reactivity.
+
 ## Testing Helpers
 
 Import from `@lenne.tech/nuxt-extensions/testing`:
@@ -110,6 +155,7 @@ export default defineNuxtRouteMiddleware((to) => {
 ## Development Rules
 
 1. **ALWAYS read source code** in `dist/runtime/` to understand available composables and components
-2. **Use `useBetterAuth()`** for authentication — never implement auth manually
+2. **Use `useLtAuth()`** for authentication — never implement auth manually
 3. **Check existing composables** before creating new ones — this module may already provide what you need
 4. **Peer dependencies** (`better-auth`, `@better-auth/passkey`, `tus-js-client`) must be installed in the consuming project
+5. **AI types collision pitfall:** `LtAiPromptInput` is the CRUD input for the user-facing `LtAiPrompt` entity (used by `useLtAiPrompts().create/update`). The execution payload for `useLtAi.prompt()` / `.promptStream()` is `LtAiPromptRunInput`. Do not conflate them.

package/README.md

@@ -144,6 +144,12 @@ export default defineNuxtConfig({
     i18n: {
       autoMerge: true,              // Auto-merge locales with @nuxtjs/i18n
     },
+
+    // AI module configuration
+    ai: {
+      enabled: true,                // Enable AI composables / auto-imports
+      basePath: '/ai',              // Must match the nest-server AI controller
+    },
   },
 });
 ```
@@ -344,6 +350,65 @@ const base64 = ltArrayBufferToBase64Url(buffer);
 const uint8 = ltBase64UrlToUint8Array(base64String);
 ```
 
+## AI Assistant
+
+Headless, provider-agnostic composables for the `@lenne.tech/nest-server` **AI module**
+(REST + SSE). All requests use the same auth-aware `ltAuthFetch` (Cookie/JWT) and URL
+resolution as the rest of the library. Configure via `ltExtensions.ai`:
+
+```typescript
+// nuxt.config.ts
+ltExtensions: {
+  ai: { enabled: true, basePath: '/ai' }, // basePath must match the nest-server AI controller
+}
+```
+
+### Chat (streaming, multi-turn)
+
+```vue
+<script setup lang="ts">
+const { budget, confirm, messages, requiresConfirmation, send, streaming } = useLtAiChat();
+</script>
+```
+
+`useLtAiChat()` streams the answer token-by-token, tracks the `conversationId`, exposes
+the per-response `budget` summary, and drives the confirmation flow for mutating/
+destructive actions (`requiresConfirmation` → `confirm()`).
+
+### User-facing prompts ("Vorlagen")
+
+```vue
+<script setup lang="ts">
+const { create, error, load, loading, prompts, remove, update } = useLtAiPrompts();
+await load();
+// create({ name: 'Summary', content: 'Summarize {{topic}}', scope: 'user' });
+</script>
+```
+
+`useLtAiPrompts()` lets any signed-in user manage re-usable prompt snippets. `scope: 'user'`
+is private to the owner; `scope: 'tenant'` is shared across the owner's tenant. The list
+returned by `load()` is already server-filtered to what the user is allowed to see.
+
+### Lower-level + supporting composables
+
+| Composable | Purpose |
+|------------|---------|
+| `useLtAi()` | One-shot `prompt(input)` and streaming `promptStream(input, handlers)` (POST `/ai/stream`) |
+| `useLtAiChat()` | Multi-turn chat state, streaming, budget, confirmation, `stop()`/`clear()`, optional `maxMessages` cap, auto-stop on component unmount |
+| `useLtAiConnections()` | User self-service: available connections + `select()` (`selected`/`locked`) |
+| `useLtAiUsage()` | Full token/prompt usage breakdown (`GET /ai/usage`) |
+| `useLtAiPrompts()` | User-facing CRUD for re-usable prompt snippets ("Vorlagen", `scope: 'user'` / `'tenant'`) |
+| `useLtAiPlaceholders()` | Loads `{{placeholder}}` registry from the backend so slot / prompt editors render a dynamic helper sidebar |
+| `useLtAiAdmin()` | Admin CRUD: connections (+ `detectCapabilities`), preferences, budget-limits, slots (incl. `listEffectiveSlots`/`resetSlot`), prompt hints, interactions |
+
+Helpers: `buildLtAiUrl(path)`, `ltAiRequest(method, path, body?)`, `parseLtAiSseStream(response, onEvent, options?)`.
+All AI DTOs are exported as `LtAi*` types. The streaming endpoint is consumed via a
+`fetch` + `ReadableStream` SSE reader (not `EventSource`, since it is a `POST` with auth).
+
+> **Security note:** `useLtAiAdmin()` is exposed as a regular composable; admin gating
+> is enforced server-side (`@Restricted(ADMIN)`). Render admin UI behind a frontend
+> route guard for UX, but trust the backend for authorization.
+
 ## i18n Support
 
 The package works **with or without** `@nuxtjs/i18n`:
@@ -368,6 +433,13 @@ The package works **with or without** `@nuxtjs/i18n`:
 | `useLtFile()` | File utilities (size formatting, URLs) |
 | `useLtShare()` | Web Share API with clipboard fallback |
 | `useSystemSetup()` | System setup flow for initial admin user creation |
+| `useLtAi()` | One-shot `prompt()` + streaming `promptStream()` for the nest-server AI module |
+| `useLtAiChat()` | Multi-turn chat state, streaming, budget summary, confirmation gate, `maxMessages` cap |
+| `useLtAiConnections()` | User self-service connection list + `select()` |
+| `useLtAiUsage()` | Token/prompt usage breakdown per user / tenant |
+| `useLtAiPrompts()` | User-facing prompt snippet CRUD (`'user'` / `'tenant'` scope) |
+| `useLtAiPlaceholders()` | Loads the backend's `{{placeholder}}` registry |
+| `useLtAiAdmin()` | Admin CRUD for connections, preferences, budget limits, slots, prompt hints, interactions |
 
 ### Components
 

package/dist/module.d.mts

@@ -1,9 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { LtExtensionsModuleOptions } from '../dist/runtime/types/index.js';
-export { LtAuthClientConfig, LtAuthMode, LtAuthResponse, LtAuthState, LtPasskeyAuthResult, LtPasskeyRegisterResult, LtUser, UseLtAuthReturn } from '../dist/runtime/types/auth.js';
-export { LtFileInfo, LtUploadItem, LtUploadOptions, LtUploadProgress, LtUploadStatus, UseLtFileReturn, UseLtTusUploadReturn } from '../dist/runtime/types/upload.js';
-export { LtAuthCookieNamesOptions, LtAuthModuleOptions, LtErrorTranslationModuleOptions, LtExtensionsModuleOptions, LtExtensionsPublicRuntimeConfig, LtI18nModuleOptions, LtSystemSetupModuleOptions, LtTusModuleOptions } from '../dist/runtime/types/module.js';
-export { LtErrorTranslationResponse, LtParsedError, UseLtErrorTranslationReturn } from '../dist/runtime/types/error.js';
+export * from '../dist/runtime/types/index.js';
 
 declare const name = "@lenne.tech/nuxt-extensions";
 declare const version = "1.5.2";

package/dist/module.mjs

@@ -6,6 +6,10 @@ const configKey = "ltExtensions";
 const DEFAULT_LT_AUTH_STATE_COOKIE = "lt-auth-state";
 const DEFAULT_LT_JWT_TOKEN_COOKIE = "lt-jwt-token";
 const defaultOptions = {
+  ai: {
+    basePath: "/ai",
+    enabled: true
+  },
   auth: {
     basePath: "/iam",
     baseURL: "",
@@ -51,6 +55,7 @@ const module$1 = defineNuxtModule({
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
     const resolvedOptions = {
+      ai: { ...defaultOptions.ai, ...options.ai },
       auth: {
         ...defaultOptions.auth,
         ...options.auth,
@@ -69,6 +74,10 @@ const module$1 = defineNuxtModule({
       rc.public.apiUrl = "";
     }
     nuxt.options.runtimeConfig.public.ltExtensions = {
+      ai: {
+        basePath: resolvedOptions.ai?.basePath || "/ai",
+        enabled: resolvedOptions.ai?.enabled ?? true
+      },
       auth: {
         basePath: resolvedOptions.auth?.basePath || "/iam",
         baseURL: resolvedOptions.auth?.baseURL || "",
@@ -137,6 +146,20 @@ const module$1 = defineNuxtModule({
       { name: "createLtAuthFetch", from: resolve("./runtime/lib/auth-state") },
       { name: "ltAuthFetch", from: resolve("./runtime/lib/auth-state") }
     ]);
+    if (resolvedOptions.ai?.enabled !== false) {
+      addImports([
+        { name: "useLtAi", from: resolve("./runtime/composables/use-lt-ai") },
+        { name: "useLtAiChat", from: resolve("./runtime/composables/use-lt-ai-chat") },
+        { name: "useLtAiConnections", from: resolve("./runtime/composables/use-lt-ai-connections") },
+        { name: "useLtAiUsage", from: resolve("./runtime/composables/use-lt-ai-usage") },
+        { name: "useLtAiPrompts", from: resolve("./runtime/composables/use-lt-ai-prompts") },
+        { name: "useLtAiPlaceholders", from: resolve("./runtime/composables/use-lt-ai-placeholders") },
+        { name: "useLtAiAdmin", from: resolve("./runtime/composables/use-lt-ai-admin") },
+        { name: "buildLtAiUrl", from: resolve("./runtime/lib/ai") },
+        { name: "ltAiRequest", from: resolve("./runtime/lib/ai") },
+        { name: "parseLtAiSseStream", from: resolve("./runtime/lib/ai") }
+      ]);
+    }
     const transitionComponents = ["LtTransitionFade", "LtTransitionSlide", "LtTransitionSlideBottom", "LtTransitionSlideRevert", "LtTransitionFadeScale"];
     for (const componentName of transitionComponents) {
       addComponent({

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

@@ -5,3 +5,10 @@ export { useLtTusUpload } from './use-lt-tus-upload.js';
 export { useLtFile } from './use-lt-file.js';
 export { useLtShare, type UseLtShareReturn } from './use-lt-share.js';
 export { useLtErrorTranslation } from './use-lt-error-translation.js';
+export { useLtAi } from './use-lt-ai.js';
+export { useLtAiChat } from './use-lt-ai-chat.js';
+export { useLtAiConnections } from './use-lt-ai-connections.js';
+export { useLtAiUsage } from './use-lt-ai-usage.js';
+export { useLtAiAdmin } from './use-lt-ai-admin.js';
+export { useLtAiPrompts } from './use-lt-ai-prompts.js';
+export { useLtAiPlaceholders } from './use-lt-ai-placeholders.js';

package/dist/runtime/composables/index.js

@@ -5,3 +5,10 @@ export { useLtTusUpload } from "./use-lt-tus-upload.js";
 export { useLtFile } from "./use-lt-file.js";
 export { useLtShare } from "./use-lt-share.js";
 export { useLtErrorTranslation } from "./use-lt-error-translation.js";
+export { useLtAi } from "./use-lt-ai.js";
+export { useLtAiChat } from "./use-lt-ai-chat.js";
+export { useLtAiConnections } from "./use-lt-ai-connections.js";
+export { useLtAiUsage } from "./use-lt-ai-usage.js";
+export { useLtAiAdmin } from "./use-lt-ai-admin.js";
+export { useLtAiPrompts } from "./use-lt-ai-prompts.js";
+export { useLtAiPlaceholders } from "./use-lt-ai-placeholders.js";

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

@@ -0,0 +1,9 @@
+/**
+ * Admin data layer for the AI module (headless): CRUD for connections,
+ * connection preferences and budget limits, capability auto-detection, and the
+ * interaction audit log. All endpoints are ADMIN-gated server-side.
+ *
+ * Pair with your own UI (the nuxt-base-starter ships a reference admin area).
+ */
+import type { UseLtAiAdminReturn } from '../types/ai.js';
+export declare function useLtAiAdmin(): UseLtAiAdminReturn;

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

@@ -0,0 +1,36 @@
+import { ltAiRequest } from "../lib/ai.js";
+const seg = (id) => encodeURIComponent(id);
+export function useLtAiAdmin() {
+  return {
+    // Connections
+    createConnection: (input) => ltAiRequest("POST", "/connections", input),
+    deleteConnection: (id) => ltAiRequest("DELETE", `/connections/${seg(id)}`),
+    detectCapabilities: (id) => ltAiRequest("POST", `/connections/${seg(id)}/detect-capabilities`),
+    getConnection: (id) => ltAiRequest("GET", `/connections/${seg(id)}`),
+    listConnections: () => ltAiRequest("GET", "/connections"),
+    updateConnection: (id, input) => ltAiRequest("PUT", `/connections/${seg(id)}`, input),
+    // Connection preferences
+    deletePreference: (id) => ltAiRequest("DELETE", `/connections/preferences/${seg(id)}`),
+    listPreferences: () => ltAiRequest("GET", "/connections/preferences"),
+    setPreference: (input) => ltAiRequest("POST", "/connections/preferences", input),
+    // Budget limits
+    createBudgetLimit: (input) => ltAiRequest("POST", "/budget-limits", input),
+    deleteBudgetLimit: (id) => ltAiRequest("DELETE", `/budget-limits/${seg(id)}`),
+    listBudgetLimits: () => ltAiRequest("GET", "/budget-limits"),
+    updateBudgetLimit: (id, input) => ltAiRequest("PUT", `/budget-limits/${seg(id)}`, input),
+    // System-prompt slots (admin-editable; tenant-scoped)
+    createSlot: (input) => ltAiRequest("POST", "/slots", input),
+    deleteSlot: (id) => ltAiRequest("DELETE", `/slots/${seg(id)}`),
+    listEffectiveSlots: () => ltAiRequest("GET", "/slots/effective"),
+    listSlots: () => ltAiRequest("GET", "/slots"),
+    resetSlot: (id) => ltAiRequest("POST", `/slots/${seg(id)}/reset`),
+    updateSlot: (id, input) => ltAiRequest("PUT", `/slots/${seg(id)}`, input),
+    // Learned prompt hints (governed self-improvement loop)
+    createPromptHint: (input) => ltAiRequest("POST", "/prompt-hints", input),
+    deletePromptHint: (id) => ltAiRequest("DELETE", `/prompt-hints/${seg(id)}`),
+    listPromptHints: () => ltAiRequest("GET", "/prompt-hints"),
+    updatePromptHint: (id, input) => ltAiRequest("PUT", `/prompt-hints/${seg(id)}`, input),
+    // Audit
+    listInteractions: () => ltAiRequest("GET", "/interactions")
+  };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Multi-turn chat composable built on {@link useLtAi}. Maintains the message
+ * list, streams assistant answers token-by-token, tracks the conversation id and
+ * the latest budget summary, and handles the confirmation flow for mutating /
+ * destructive actions.
+ */
+import type { UseLtAiChatOptions, UseLtAiChatReturn } from '../types/ai.js';
+export declare function useLtAiChat(options?: UseLtAiChatOptions): UseLtAiChatReturn;

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

@@ -0,0 +1,141 @@
+import { computed, getCurrentScope, onScopeDispose, reactive, readonly, ref, unref } from "#imports";
+import { useLtAi } from "./use-lt-ai.js";
+export function useLtAiChat(options = {}) {
+  const ai = useLtAi();
+  const messages = ref([]);
+  const conversationId = ref(options.conversationId);
+  const budget = ref(null);
+  const contextWindow = ref(null);
+  const error = ref(null);
+  const maxMessages = options.maxMessages;
+  let lastPrompt = "";
+  let controller;
+  const requiresConfirmation = computed(() => {
+    const last = messages.value[messages.value.length - 1];
+    return !!last && last.role === "assistant" && !!last.requiresConfirmation;
+  });
+  function resolveConnectionId() {
+    return unref(options.connectionId) ?? void 0;
+  }
+  function trimMessageHistory() {
+    if (maxMessages && messages.value.length > maxMessages) {
+      messages.value.splice(0, messages.value.length - maxMessages);
+    }
+  }
+  function applyFinal(assistant, response) {
+    assistant.pending = false;
+    assistant.content = response.text || assistant.content;
+    assistant.actions = response.actions;
+    assistant.budget = response.budget;
+    assistant.denied = response.denied;
+    assistant.requiresConfirmation = response.requiresConfirmation;
+    assistant.pendingActions = response.pendingActions;
+    if (response.budget) {
+      budget.value = response.budget;
+    }
+    if (response.contextWindow) {
+      contextWindow.value = response.contextWindow;
+    }
+    if (response.conversationId) {
+      conversationId.value = response.conversationId;
+    }
+  }
+  async function runTurn(input) {
+    error.value = null;
+    const assistant = reactive({ content: "", createdAt: (/* @__PURE__ */ new Date()).toISOString(), pending: true, role: "assistant" });
+    messages.value.push(assistant);
+    trimMessageHistory();
+    controller = new AbortController();
+    const useStream = options.stream !== false;
+    try {
+      if (useStream) {
+        await ai.promptStream(
+          input,
+          {
+            onToken: (token) => {
+              assistant.content += token;
+            },
+            onFinal: (response) => applyFinal(assistant, response)
+          },
+          { signal: controller.signal }
+        );
+        if (assistant.pending) {
+          assistant.pending = false;
+        }
+      } else {
+        applyFinal(assistant, await ai.prompt(input));
+      }
+    } catch (err) {
+      assistant.pending = false;
+      if (err.name === "AbortError") {
+        return;
+      }
+      assistant.error = true;
+      error.value = err.message;
+      if (!assistant.content) {
+        assistant.content = err.message;
+      }
+    } finally {
+      controller = void 0;
+    }
+  }
+  async function send(content) {
+    const text = content.trim();
+    if (!text || ai.streaming.value) {
+      return;
+    }
+    lastPrompt = text;
+    messages.value.push({ content: text, createdAt: (/* @__PURE__ */ new Date()).toISOString(), role: "user" });
+    trimMessageHistory();
+    await runTurn({
+      connectionId: resolveConnectionId(),
+      conversationId: conversationId.value,
+      metadata: options.metadata?.(),
+      mode: options.mode,
+      prompt: text
+    });
+  }
+  async function confirm() {
+    if (!requiresConfirmation.value || !lastPrompt) {
+      return;
+    }
+    await runTurn({
+      confirm: true,
+      connectionId: resolveConnectionId(),
+      conversationId: conversationId.value,
+      metadata: options.metadata?.(),
+      mode: options.mode,
+      prompt: lastPrompt
+    });
+  }
+  function stop() {
+    controller?.abort();
+    controller = void 0;
+  }
+  function clear() {
+    stop();
+    messages.value = [];
+    budget.value = null;
+    contextWindow.value = null;
+    error.value = null;
+    lastPrompt = "";
+  }
+  if (getCurrentScope()) {
+    onScopeDispose(() => stop());
+  }
+  return {
+    budget: readonly(budget),
+    contextWindow: readonly(contextWindow),
+    clear,
+    confirm,
+    conversationId: readonly(conversationId),
+    error: readonly(error),
+    // Returned as a shallow Readonly<Ref> (see UseLtAiChatReturn): consumers cannot
+    // reassign the ref but can bind individual messages to child components.
+    messages,
+    requiresConfirmation,
+    send,
+    stop,
+    streaming: ai.streaming
+  };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * User self-service for AI connections: list the connections the current
+ * user/tenant may use and pick a personal default. Backed by
+ * `GET /ai/connections/available` and `POST /ai/connections/select`.
+ */
+import type { UseLtAiConnectionsReturn } from '../types/ai.js';
+export declare function useLtAiConnections(): UseLtAiConnectionsReturn;

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

@@ -0,0 +1,33 @@
+import { computed, readonly, ref } from "#imports";
+import { ltAiRequest } from "../lib/ai.js";
+export function useLtAiConnections() {
+  const connections = ref([]);
+  const loading = ref(false);
+  const error = ref(null);
+  const selected = computed(() => connections.value.find((c) => c.selected));
+  const locked = computed(() => connections.value.some((c) => c.locked));
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      connections.value = await ltAiRequest("GET", "/connections/available");
+    } catch (err) {
+      error.value = err.message;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function select(connectionId) {
+    loading.value = true;
+    error.value = null;
+    try {
+      connections.value = await ltAiRequest("POST", "/connections/select", { connectionId });
+    } catch (err) {
+      error.value = err.message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return { connections: readonly(connections), error: readonly(error), load, loading: readonly(loading), locked, select, selected };
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Placeholder-list composable. Loads the runtime registry from the backend
+ * (`GET /ai/placeholders`) so slot / prompt editors can render a dynamic
+ * helper sidebar with the currently supported `{{placeholders}}` — without
+ * hard-coding any names in the frontend.
+ *
+ * Available to any signed-in user (S_USER on the endpoint).
+ */
+import type { UseLtAiPlaceholdersReturn } from '../types/ai.js';
+export declare function useLtAiPlaceholders(): UseLtAiPlaceholdersReturn;

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
+  };
+}