@123toto/ai-app-assistant-server 0.1.1 → 0.2.0

package/dist/index.js

@@ -6,14 +6,14 @@ import {
   testAiSdkConnection
 } from "./chunk-NIF6AW6I.js";
 import {
-  AiDocsRequestError,
-  createAiDocsFetchHandlers
-} from "./chunk-OA7OXUK7.js";
+  AiAppAssistantRequestError,
+  createAiAppAssistantFetchHandlers
+} from "./chunk-Z4IVCZ5M.js";
 
 // src/assistant.ts
 import {
   PROTOCOL_VERSION,
-  askDocumentationRequestSchema,
+  aiAppAssistantRequestSchema,
   generatedAnswerSchema
 } from "@123toto/ai-app-assistant-contracts";
 
@@ -81,7 +81,7 @@ function round(value) {
 var FALLBACK_CONTEXT_WINDOW_TOKENS = 128e3;
 var FALLBACK_OUTPUT_TOKENS = 8e3;
 var FALLBACK_CHARACTERS_PER_TOKEN = 2;
-function createDocsAssistant(options) {
+function createAiAppAssistant(options) {
   const minimumEvidence = clampInteger(
     options.policies?.minimumEvidence ?? 1,
     1,
@@ -89,7 +89,7 @@ function createDocsAssistant(options) {
   );
   const documents = prepareDocuments(options.documents ?? []);
   const prepare = (request) => {
-    const validated = askDocumentationRequestSchema.parse(request);
+    const validated = aiAppAssistantRequestSchema.parse(request);
     return { validated, bundle: prepareBundle(validated, documents, options) };
   };
   const finalize = (validated, bundle, generatedInput, startedAt) => {
@@ -233,7 +233,7 @@ function prepareBundle(request, documents, options) {
       content: boundEvidence(
         request.selectedElementHtml,
         selectedLimit,
-        "AI_DOCS_SELECTED_ELEMENT_TRUNCATED"
+        "AI_APP_ASSISTANT_SELECTED_ELEMENT_TRUNCATED"
       ),
       relevance: 1
     });
@@ -248,7 +248,7 @@ function prepareBundle(request, documents, options) {
   for (const document of documents) {
     if (remainingDocuments <= 0) break;
     const limit = Math.min(documentLimit, remainingDocuments);
-    const content = boundEvidence(document.content, limit, "AI_DOCS_DOCUMENT_TRUNCATED");
+    const content = boundEvidence(document.content, limit, "AI_APP_ASSISTANT_DOCUMENT_TRUNCATED");
     remainingDocuments -= content.length;
     items.push({
       source: "document",
@@ -275,7 +275,7 @@ function serializeDocumentationContent(content) {
 function boundHtml(content, maxChars, alreadyTruncated) {
   const limit = optionalBound(maxChars, 1e3, 8e6);
   return alreadyTruncated ? `${content.slice(0, limit)}
-<!-- AI_DOCS_HTML_TRUNCATED -->` : boundEvidence(content, limit, "AI_DOCS_HTML_TRUNCATED");
+<!-- AI_APP_ASSISTANT_HTML_TRUNCATED -->` : boundEvidence(content, limit, "AI_APP_ASSISTANT_HTML_TRUNCATED");
 }
 function boundEvidence(content, limit, marker) {
   if (content.length <= limit) return content;
@@ -319,15 +319,15 @@ function insufficientResponse(requestId, model, durationMs) {
 }
 
 // src/node-http.ts
-function createAiDocsNodeHttpListener(handlers, options = {}) {
+function createAiAppAssistantNodeHttpListener(handlers, options = {}) {
   return async (request, response) => {
     try {
       const webRequest = await toRequest(request, options);
       const handle = handlers.handle;
       await writeResponse(response, await handle(webRequest, request));
     } catch (error) {
-      const status = error instanceof AiDocsRequestError ? error.status : 500;
-      const code = error instanceof AiDocsRequestError ? error.code : "assistant_error";
+      const status = error instanceof AiAppAssistantRequestError ? error.status : 500;
+      const code = error instanceof AiAppAssistantRequestError ? error.code : "assistant_error";
       response.statusCode = status;
       response.setHeader("content-type", "application/json; charset=utf-8");
       response.end(JSON.stringify({ error: code }));
@@ -357,7 +357,7 @@ async function readBody(request, maxBodyBytes) {
     const bytes = typeof chunk === "string" ? Buffer.from(chunk) : new Uint8Array(chunk);
     size += bytes.byteLength;
     if (size > maxBodyBytes) {
-      throw new AiDocsRequestError(413, "request_too_large", "Request body is too large");
+      throw new AiAppAssistantRequestError(413, "request_too_large", "Request body is too large");
     }
     chunks.push(bytes);
   }
@@ -384,22 +384,22 @@ async function writeResponse(response, webResponse) {
 }
 
 // src/server.ts
-function createAiDocsServer(options) {
+function createAiAppAssistantServer(options) {
   const generator = options.generator ?? createGenerator(options);
-  const assistant = createDocsAssistant({
+  const assistant = createAiAppAssistant({
     generator,
     ...options.documents ? { documents: options.documents } : {},
     ...options.policies ? { policies: options.policies } : {}
   });
   return {
     assistant,
-    fetch: createAiDocsFetchHandlers({ assistant, ...options.http }),
+    fetch: createAiAppAssistantFetchHandlers({ assistant, ...options.http }),
     options: Object.freeze({ ...options })
   };
 }
 function createGenerator(options) {
   if (!options.model?.trim()) {
-    throw new TypeError("createAiDocsServer requires either generator or model");
+    throw new TypeError("createAiAppAssistantServer requires either generator or model");
   }
   const generatorOptions = {
     model: options.model,
@@ -417,10 +417,10 @@ import { createHash as createHash2, randomUUID } from "crypto";
 // src/configuration.ts
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
 import { z } from "zod";
-var AiDocsConfigurationConflictError = class extends Error {
+var AiAppAssistantConfigurationConflictError = class extends Error {
   constructor() {
-    super("AI Docs configuration changed concurrently; retry the operation");
-    this.name = "AiDocsConfigurationConflictError";
+    super("AI App Assistant configuration changed concurrently; retry the operation");
+    this.name = "AiAppAssistantConfigurationConflictError";
   }
 };
 var accessRuleSchema = z.discriminatedUnion("mode", [
@@ -464,8 +464,8 @@ var persistedConfigurationSchema = z.object({
   maxConversationTurns: z.number().int().min(1).max(10).optional(),
   administration: administrationSchema.optional()
 });
-function createAiDocsConfigurationRepository(options) {
-  const key = options.key?.trim() || "ai-docs:configuration";
+function createAiAppAssistantConfigurationRepository(options) {
+  const key = options.key?.trim() || "ai-app-assistant:configuration";
   const deserialize = async (serialized) => {
     if (!serialized) return void 0;
     const stored = persistedConfigurationSchema.parse(JSON.parse(serialized));
@@ -523,14 +523,14 @@ function createAiDocsConfigurationRepository(options) {
           return toConfigurationView(normalized);
         }
       }
-      throw new AiDocsConfigurationConflictError();
+      throw new AiAppAssistantConfigurationConflictError();
     },
     async clear() {
       await options.store.delete(key);
     }
   };
 }
-async function validateAndSaveAiDocsConfiguration(repository, configuration, options) {
+async function validateAndSaveAiAppAssistantConfiguration(repository, configuration, options) {
   const normalized = normalizeConfiguration(configuration);
   const connection = await testAiSdkConnection({
     model: `${normalized.provider}:${normalized.model}`,
@@ -550,7 +550,7 @@ function createAes256GcmSecretProtector(base64Key) {
   if (key.length !== 32) {
     throw new TypeError("The secret protection key must contain exactly 32 base64-encoded bytes");
   }
-  const additionalData = Buffer.from("ai-docs-configuration:v1", "utf8");
+  const additionalData = Buffer.from("ai-app-assistant-configuration:v1", "utf8");
   return {
     protect(secret) {
       const iv = randomBytes(12);
@@ -580,7 +580,7 @@ function createDisabledSecretProtector() {
   };
   return { protect: unavailable2, unprotect: unavailable2 };
 }
-function createMemoryAiDocsStore() {
+function createMemoryAiAppAssistantStore() {
   const values = /* @__PURE__ */ new Map();
   return {
     async get(key) {
@@ -600,8 +600,8 @@ function createMemoryAiDocsStore() {
     }
   };
 }
-function createRedisAiDocsStore(client, options) {
-  const prefix = options?.prefix ?? "ai-docs:";
+function createRedisAiAppAssistantStore(client, options) {
+  const prefix = options?.prefix ?? "ai-app-assistant:";
   const namespaced = (key) => `${prefix}${key}`;
   return {
     get: (key) => client.get(namespaced(key)),
@@ -679,7 +679,7 @@ function toConfigurationView(configuration) {
 
 // src/quota.ts
 import { createHash } from "crypto";
-function createMemoryAiDocsQuotaStore() {
+function createMemoryAiAppAssistantQuotaStore() {
   const counters = /* @__PURE__ */ new Map();
   return {
     async consume(subject, policy) {
@@ -696,8 +696,8 @@ function createMemoryAiDocsQuotaStore() {
     }
   };
 }
-function createRedisAiDocsQuotaStore(client, options) {
-  const prefix = options?.prefix ?? "ai-docs:quota:";
+function createRedisAiAppAssistantQuotaStore(client, options) {
+  const prefix = options?.prefix ?? "ai-app-assistant:quota:";
   return {
     async consume(subject, policy) {
       const normalized = normalizePolicy(policy);
@@ -868,19 +868,19 @@ function isRecord(value) {
 }
 
 // src/management.ts
-var AiDocsManagementError = class extends Error {
+var AiAppAssistantManagementError = class extends Error {
   constructor(status, code, message, details) {
     super(message);
     this.status = status;
     this.code = code;
     this.details = details;
-    this.name = "AiDocsManagementError";
+    this.name = "AiAppAssistantManagementError";
   }
   status;
   code;
   details;
 };
-var AiDocsConfigurationManager = class {
+var AiAppAssistantConfigurationManager = class {
   #repository;
   #quotaStore;
   #options;
@@ -894,7 +894,7 @@ var AiDocsConfigurationManager = class {
   constructor(options) {
     this.#options = options;
     this.#repository = options.repository;
-    this.#quotaStore = options.quotaStore ?? createMemoryAiDocsQuotaStore();
+    this.#quotaStore = options.quotaStore ?? createMemoryAiAppAssistantQuotaStore();
   }
   /** Returns the built-in provider catalogue; no credentials are exposed. */
   listProviders() {
@@ -1017,7 +1017,7 @@ var AiDocsConfigurationManager = class {
   async save(rawInput, actor) {
     const input = normalizeInput(rawInput);
     if (input.apiKey && !this.#options.apiKeyStorageAvailable) {
-      throw new AiDocsManagementError(
+      throw new AiAppAssistantManagementError(
         503,
         "secret_storage_unavailable",
         "Secure API key storage is not configured"
@@ -1091,8 +1091,8 @@ var AiDocsConfigurationManager = class {
       if (error instanceof ConnectionRejectedError) {
         return { saved: false, connection: error.connection, reloadRequired: false };
       }
-      if (error instanceof AiDocsConfigurationConflictError) {
-        throw new AiDocsManagementError(409, "conflict", error.message);
+      if (error instanceof AiAppAssistantConfigurationConflictError) {
+        throw new AiAppAssistantManagementError(409, "conflict", error.message);
       }
       throw error;
     }
@@ -1123,7 +1123,7 @@ var AiDocsConfigurationManager = class {
     try {
       await persist((previous) => {
         if (!previous?.apiKey) {
-          throw new AiDocsManagementError(400, "not_configured", "No manually configured API key is available to revoke");
+          throw new AiAppAssistantManagementError(400, "not_configured", "No manually configured API key is available to revoke");
         }
         const owner = previous.administration?.keyCreatedBy;
         if (owner && owner.id !== actor.id) {
@@ -1157,8 +1157,8 @@ var AiDocsConfigurationManager = class {
         };
       });
     } catch (error) {
-      if (error instanceof AiDocsConfigurationConflictError) {
-        throw new AiDocsManagementError(409, "conflict", error.message);
+      if (error instanceof AiAppAssistantConfigurationConflictError) {
+        throw new AiAppAssistantManagementError(409, "conflict", error.message);
       }
       throw error;
     }
@@ -1278,7 +1278,7 @@ var AiDocsConfigurationManager = class {
     }
     const quota = await this.consumeQuota(identity);
     if (!quota.allowed) {
-      throw new AiDocsManagementError(
+      throw new AiAppAssistantManagementError(
         429,
         "quota_reached",
         "AI assistant quota reached",
@@ -1403,8 +1403,8 @@ var AiDocsConfigurationManager = class {
     await Promise.all([...this.#listeners].map((listener) => listener(event)));
   }
 };
-function createPollingAiDocsConfigurationSynchronizer(store, options = {}) {
-  const key = options.key?.trim() || "ai-docs:configuration-revision";
+function createPollingAiAppAssistantConfigurationSynchronizer(store, options = {}) {
+  const key = options.key?.trim() || "ai-app-assistant:configuration-revision";
   const intervalMs = Math.max(250, Math.round(options.intervalMs ?? 2e3));
   let current;
   return {
@@ -1516,11 +1516,11 @@ function configurationChanges(previous, input, allowModelChangesByOthers) {
   return changes;
 }
 function forbidden(message) {
-  return new AiDocsManagementError(403, "forbidden", message);
+  return new AiAppAssistantManagementError(403, "forbidden", message);
 }
 
 // src/telemetry.ts
-function createMemoryAiDocsTelemetryStore(options) {
+function createMemoryAiAppAssistantTelemetryStore(options) {
   const recentFailureLimit = normalizeLimit(options?.recentFailureLimit, 100);
   const aggregate = emptySummary();
   const failures = [];
@@ -1546,8 +1546,8 @@ function createMemoryAiDocsTelemetryStore(options) {
     }
   };
 }
-function createRedisAiDocsTelemetryStore(client, options) {
-  const prefix = options?.prefix ?? "ai-docs:telemetry:";
+function createRedisAiAppAssistantTelemetryStore(client, options) {
+  const prefix = options?.prefix ?? "ai-app-assistant:telemetry:";
   const summaryKey = `${prefix}summary`;
   const failuresKey = `${prefix}failures`;
   const recentFailureLimit = normalizeLimit(options?.recentFailureLimit, 100);
@@ -1607,7 +1607,7 @@ function createRedisAiDocsTelemetryStore(client, options) {
     }
   };
 }
-function createAiDocsFailureEvent(input) {
+function createAiAppAssistantFailureEvent(input) {
   const failure = input.error instanceof AiSdkGenerationError ? input.error : normalizeAiSdkGenerationError(input.error, 1);
   return {
     outcome: "failure",
@@ -1675,7 +1675,7 @@ function redisPairs(value) {
 }
 
 // src/managed-runtime.ts
-function createManagedAiDocsRuntime(options) {
+function createManagedAiAppAssistantRuntime(options) {
   let assistant;
   let activeGenerator;
   let documents = [...options.documents ?? []];
@@ -1706,7 +1706,7 @@ function createManagedAiDocsRuntime(options) {
       ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}
     });
     activeGenerator = generator;
-    assistant = createDocsAssistant({
+    assistant = createAiAppAssistant({
       generator,
       documents,
       ...options.policies ? { policies: options.policies } : {}
@@ -1748,7 +1748,7 @@ function createManagedAiDocsRuntime(options) {
     async setDocuments(nextDocuments) {
       documents = [...nextDocuments];
       if (!activeGenerator) return;
-      assistant = createDocsAssistant({
+      assistant = createAiAppAssistant({
         generator: activeGenerator,
         documents,
         ...options.policies ? { policies: options.policies } : {}
@@ -1774,7 +1774,7 @@ function createManagedAiDocsRuntime(options) {
         }, identity);
         return response;
       } catch (error) {
-        await observe(createAiDocsFailureEvent({
+        await observe(createAiAppAssistantFailureEvent({
           error,
           requestId: input.requestId,
           operation: "answer",
@@ -1816,7 +1816,7 @@ function createManagedAiDocsRuntime(options) {
           yield event;
         }
       } catch (error) {
-        await observe(createAiDocsFailureEvent({
+        await observe(createAiAppAssistantFailureEvent({
           error,
           requestId: input.requestId,
           operation: "stream",
@@ -1830,7 +1830,7 @@ function createManagedAiDocsRuntime(options) {
   };
 }
 function unavailable() {
-  return new AiDocsManagementError(
+  return new AiAppAssistantManagementError(
     503,
     "not_configured",
     "AI assistant is not configured or connected"
@@ -1839,23 +1839,23 @@ function unavailable() {
 
 // src/managed-http.ts
 import {
-  aiDocsConfigurationInputSchema,
-  aiDocsConnectionTestInputSchema,
-  aiDocsCredentialsSchema,
-  askDocumentationRequestSchema as askDocumentationRequestSchema2
+  aiAppAssistantConfigurationInputSchema,
+  aiAppAssistantConnectionTestInputSchema,
+  aiAppAssistantCredentialsSchema,
+  aiAppAssistantRequestSchema as aiAppAssistantRequestSchema2
 } from "@123toto/ai-app-assistant-contracts";
 import { ZodError } from "zod";
-function createManagedAiDocsFetchHandlers(options) {
+function createManagedAiAppAssistantFetchHandlers(options) {
   const identity = async (request, nativeContext) => {
     if (options.resolveIdentity) return options.resolveIdentity(request, nativeContext);
     if (options.allowAnonymous) {
       return { id: "anonymous", label: "Anonymous", roles: [] };
     }
-    throw new AiDocsManagementError(401, "unauthorized", "Authentication is required");
+    throw new AiAppAssistantManagementError(401, "unauthorized", "Authentication is required");
   };
   const admin = async (request, resolved, nativeContext) => {
     if (!options.authorizeAdministration) {
-      throw new AiDocsManagementError(403, "forbidden", "Administration access is not configured");
+      throw new AiAppAssistantManagementError(403, "forbidden", "Administration access is not configured");
     }
     await options.authorizeAdministration(resolved, request, nativeContext);
   };
@@ -1869,13 +1869,13 @@ function createManagedAiDocsFetchHandlers(options) {
           return json(await options.runtime.configuration.getAccess(currentIdentity));
         }
         if (request.method === "POST" && path.endsWith("/ask/stream")) {
-          const input = askDocumentationRequestSchema2.parse(await readJson(request, options.maxBodyBytes));
+          const input = aiAppAssistantRequestSchema2.parse(await readJson(request, options.maxBodyBytes));
           const generation = options.runtime.stream(input, currentIdentity, request.signal);
           const first = await generation.next();
           return streamResponse(generation, first, input.requestId);
         }
         if (request.method === "POST" && path.endsWith("/ask")) {
-          const input = askDocumentationRequestSchema2.parse(await readJson(request, options.maxBodyBytes));
+          const input = aiAppAssistantRequestSchema2.parse(await readJson(request, options.maxBodyBytes));
           return json(await options.runtime.answer(input, currentIdentity));
         }
         await admin(request, currentIdentity, nativeContext);
@@ -1909,22 +1909,22 @@ function createManagedAiDocsFetchHandlers(options) {
           return json({ roles, users });
         }
         if (request.method === "POST" && path.endsWith("/models")) {
-          const input = aiDocsCredentialsSchema.parse(await readJson(request, options.maxBodyBytes));
+          const input = aiAppAssistantCredentialsSchema.parse(await readJson(request, options.maxBodyBytes));
           return json(await options.runtime.configuration.listModels(input));
         }
         if (request.method === "POST" && path.endsWith("/configuration/test")) {
-          const input = aiDocsConnectionTestInputSchema.parse(await readJson(request, options.maxBodyBytes));
+          const input = aiAppAssistantConnectionTestInputSchema.parse(await readJson(request, options.maxBodyBytes));
           return json(await options.runtime.configuration.testConnection(input));
         }
         if (request.method === "PUT" && path.endsWith("/configuration")) {
-          const input = aiDocsConfigurationInputSchema.parse(await readJson(request, options.maxBodyBytes));
+          const input = aiAppAssistantConfigurationInputSchema.parse(await readJson(request, options.maxBodyBytes));
           const { reloadRequired: _reloadRequired, ...result } = await options.runtime.configuration.save(input, currentIdentity);
           return json(result);
         }
         if (request.method === "DELETE" && path.endsWith("/configuration/api-key")) {
           return json(await options.runtime.configuration.revokeApiKey(currentIdentity));
         }
-        return json({ error: "not_found", message: "AI Docs endpoint not found" }, 404);
+        return json({ error: "not_found", message: "AI App Assistant endpoint not found" }, 404);
       } catch (error) {
         if (options.onError) return options.onError(error, request, nativeContext);
         return mapError(error);
@@ -1935,11 +1935,11 @@ function createManagedAiDocsFetchHandlers(options) {
 async function readJson(request, maxBodyBytes = 86e5) {
   const declaredSize = Number(request.headers.get("content-length"));
   if (Number.isFinite(declaredSize) && declaredSize > maxBodyBytes) {
-    throw new AiDocsManagementError(413, "invalid_request", "Request body is too large");
+    throw new AiAppAssistantManagementError(413, "invalid_request", "Request body is too large");
   }
   const text = await request.text();
   if (new TextEncoder().encode(text).byteLength > maxBodyBytes) {
-    throw new AiDocsManagementError(413, "invalid_request", "Request body is too large");
+    throw new AiAppAssistantManagementError(413, "invalid_request", "Request body is too large");
   }
   return JSON.parse(text);
 }
@@ -1960,9 +1960,9 @@ function streamResponse(generation, first, requestId) {
         const failure = normalizeAiSdkGenerationError(error, 1);
         controller.enqueue(encoder.encode(`${JSON.stringify({
           type: "error",
-          message: error instanceof AiDocsManagementError ? error.message : "The assistant response could not be generated.",
-          retryable: error instanceof AiDocsManagementError ? false : failure.retryable,
-          ...error instanceof AiDocsManagementError ? {} : {
+          message: error instanceof AiAppAssistantManagementError ? error.message : "The assistant response could not be generated.",
+          retryable: error instanceof AiAppAssistantManagementError ? false : failure.retryable,
+          ...error instanceof AiAppAssistantManagementError ? {} : {
             code: failure.code,
             requestId
           }
@@ -1982,7 +1982,7 @@ function streamResponse(generation, first, requestId) {
   });
 }
 function mapError(error) {
-  if (error instanceof AiDocsManagementError) {
+  if (error instanceof AiAppAssistantManagementError) {
     return json({ error: error.code, message: error.message, ...error.details }, error.status);
   }
   if (error instanceof ZodError || error instanceof SyntaxError) {
@@ -2002,16 +2002,16 @@ function json(value, status = 200) {
 }
 
 // src/managed-server.ts
-function createManagedAiDocsServer(options) {
+function createManagedAiAppAssistantServer(options) {
   const telemetry = resolveTelemetry(options.configuration, options.telemetry);
   const configuration = resolveConfiguration(options.configuration);
-  const runtime = createManagedAiDocsRuntime({
+  const runtime = createManagedAiAppAssistantRuntime({
     configuration,
     ...options.documents ? { documents: options.documents } : {},
     ...options.runtime,
     ...telemetry ? { telemetryStore: telemetry } : {}
   });
-  const fetch = createManagedAiDocsFetchHandlers({
+  const fetch = createManagedAiAppAssistantFetchHandlers({
     runtime,
     ...options.http
   });
@@ -2029,19 +2029,19 @@ function resolveTelemetry(configuration, telemetry) {
   if (telemetry === false) return void 0;
   if (telemetry?.store) return telemetry.store;
   const recentFailureLimit = telemetry?.recentFailureLimit;
-  if (!(configuration instanceof AiDocsConfigurationManager) && !("repository" in configuration) && configuration.storage?.type === "redis") {
-    return createRedisAiDocsTelemetryStore(configuration.storage.client, {
-      prefix: `${configuration.storage.prefix ?? "ai-docs:"}telemetry:`,
+  if (!(configuration instanceof AiAppAssistantConfigurationManager) && !("repository" in configuration) && configuration.storage?.type === "redis") {
+    return createRedisAiAppAssistantTelemetryStore(configuration.storage.client, {
+      prefix: `${configuration.storage.prefix ?? "ai-app-assistant:"}telemetry:`,
       ...recentFailureLimit !== void 0 ? { recentFailureLimit } : {}
     });
   }
-  return createMemoryAiDocsTelemetryStore(
+  return createMemoryAiAppAssistantTelemetryStore(
     recentFailureLimit !== void 0 ? { recentFailureLimit } : void 0
   );
 }
 function resolveConfiguration(configuration) {
-  if (configuration instanceof AiDocsConfigurationManager) return configuration;
-  if ("repository" in configuration) return new AiDocsConfigurationManager(configuration);
+  if (configuration instanceof AiAppAssistantConfigurationManager) return configuration;
+  if ("repository" in configuration) return new AiAppAssistantConfigurationManager(configuration);
   const {
     storage = { type: "memory" },
     encryptionKey,
@@ -2052,20 +2052,20 @@ function resolveConfiguration(configuration) {
     apiKeyStorageAvailable,
     ...manager
   } = configuration;
-  const prefix = storage.type === "redis" ? storage.prefix ?? "ai-docs:" : "ai-docs:";
-  const store = storage.type === "redis" ? createRedisAiDocsStore(storage.client, { prefix: `${prefix}persistent:` }) : createMemoryAiDocsStore();
+  const prefix = storage.type === "redis" ? storage.prefix ?? "ai-app-assistant:" : "ai-app-assistant:";
+  const store = storage.type === "redis" ? createRedisAiAppAssistantStore(storage.client, { prefix: `${prefix}persistent:` }) : createMemoryAiAppAssistantStore();
   const protector = secretProtector ?? (encryptionKey ? createAes256GcmSecretProtector(encryptionKey) : createDisabledSecretProtector());
-  return new AiDocsConfigurationManager({
+  return new AiAppAssistantConfigurationManager({
     ...manager,
-    repository: createAiDocsConfigurationRepository({
+    repository: createAiAppAssistantConfigurationRepository({
       store,
       secretProtector: protector,
       ...repositoryKey ? { key: repositoryKey } : {}
     }),
-    quotaStore: quotaStore ?? (storage.type === "redis" ? createRedisAiDocsQuotaStore(storage.client, { prefix: `${prefix}quota:` }) : createMemoryAiDocsQuotaStore()),
+    quotaStore: quotaStore ?? (storage.type === "redis" ? createRedisAiAppAssistantQuotaStore(storage.client, { prefix: `${prefix}quota:` }) : createMemoryAiAppAssistantQuotaStore()),
     apiKeyStorageAvailable: apiKeyStorageAvailable ?? Boolean(secretProtector || encryptionKey),
     ...synchronizer ? { synchronizer } : storage.type === "redis" ? {
-      synchronizer: createPollingAiDocsConfigurationSynchronizer(store, {
+      synchronizer: createPollingAiAppAssistantConfigurationSynchronizer(store, {
         key: "configuration-revision",
         intervalMs: storage.synchronizationIntervalMs ?? 2e3
       })
@@ -2074,17 +2074,17 @@ function resolveConfiguration(configuration) {
 }
 
 // src/deployment-defaults.ts
-function createAiDocsDeploymentDefaults(options) {
+function createAiAppAssistantDeploymentDefaults(options) {
   const apiKeys = Object.fromEntries(
     Object.entries(options.apiKeys ?? {}).map(([provider2, value]) => [provider2, value?.trim() || void 0])
   );
   const resolveApiKey = (provider2) => apiKeys[provider2];
   if (!options.enabled || !options.model?.trim()) return { resolveApiKey };
   const match = options.model.trim().match(/^([^:/]+)[:/](.+)$/);
-  if (!match) throw new TypeError(`Invalid AI Docs model identifier: ${options.model}`);
+  if (!match) throw new TypeError(`Invalid AI App Assistant model identifier: ${options.model}`);
   const provider = match[1] === "gemini" ? "google" : match[1];
   if (!listAiProviders().some((candidate) => candidate.id === provider)) {
-    throw new TypeError(`Unsupported AI Docs provider: ${match[1]}`);
+    throw new TypeError(`Unsupported AI App Assistant provider: ${match[1]}`);
   }
   const apiKey = resolveApiKey(provider);
   const baseURL = options.baseURLs?.[provider]?.trim() || void 0;
@@ -2303,70 +2303,70 @@ function clampInteger2(value, minimum, maximum) {
 // src/index.ts
 import {
   PROTOCOL_VERSION as PROTOCOL_VERSION2,
-  aiDocsAccessRuleSchema,
-  aiDocsConfigurationInputSchema as aiDocsConfigurationInputSchema2,
-  aiDocsConfigurationOptionsSchema,
-  aiDocsConfigurationSaveResultSchema,
-  aiDocsConnectionResultSchema,
-  aiDocsConnectionTestInputSchema as aiDocsConnectionTestInputSchema2,
-  aiDocsCredentialsSchema as aiDocsCredentialsSchema2,
-  aiDocsManagedConfigurationViewSchema,
-  aiDocsModelInfoSchema,
-  aiDocsProviderSchema,
-  aiDocsProviderInfoSchema,
-  askDocumentationRequestSchema as askDocumentationRequestSchema3,
-  askDocumentationResponseSchema,
-  askDocumentationStreamEventSchema
+  aiAppAssistantAccessRuleSchema,
+  aiAppAssistantConfigurationInputSchema as aiAppAssistantConfigurationInputSchema2,
+  aiAppAssistantConfigurationOptionsSchema,
+  aiAppAssistantConfigurationSaveResultSchema,
+  aiAppAssistantConnectionResultSchema,
+  aiAppAssistantConnectionTestInputSchema as aiAppAssistantConnectionTestInputSchema2,
+  aiAppAssistantCredentialsSchema as aiAppAssistantCredentialsSchema2,
+  aiAppAssistantManagedConfigurationViewSchema,
+  aiAppAssistantModelInfoSchema,
+  aiAppAssistantProviderSchema,
+  aiAppAssistantProviderInfoSchema,
+  aiAppAssistantRequestSchema as aiAppAssistantRequestSchema3,
+  aiAppAssistantResponseSchema,
+  aiAppAssistantTransportEventSchema
 } from "@123toto/ai-app-assistant-contracts";
 export {
-  AiDocsConfigurationConflictError,
-  AiDocsConfigurationManager,
-  AiDocsManagementError,
-  AiDocsRequestError,
+  AiAppAssistantConfigurationConflictError,
+  AiAppAssistantConfigurationManager,
+  AiAppAssistantManagementError,
+  AiAppAssistantRequestError,
   AiModelDiscoveryError,
   AiSdkConfigurationError,
   AiSdkGenerationError,
   PROTOCOL_VERSION2 as PROTOCOL_VERSION,
-  aiDocsAccessRuleSchema,
-  aiDocsConfigurationInputSchema2 as aiDocsConfigurationInputSchema,
-  aiDocsConfigurationOptionsSchema,
-  aiDocsConfigurationSaveResultSchema,
-  aiDocsConnectionResultSchema,
-  aiDocsConnectionTestInputSchema2 as aiDocsConnectionTestInputSchema,
-  aiDocsCredentialsSchema2 as aiDocsCredentialsSchema,
-  aiDocsManagedConfigurationViewSchema,
-  aiDocsModelInfoSchema,
-  aiDocsProviderInfoSchema,
-  aiDocsProviderSchema,
-  askDocumentationRequestSchema3 as askDocumentationRequestSchema,
-  askDocumentationResponseSchema,
-  askDocumentationStreamEventSchema,
+  aiAppAssistantAccessRuleSchema,
+  aiAppAssistantConfigurationInputSchema2 as aiAppAssistantConfigurationInputSchema,
+  aiAppAssistantConfigurationOptionsSchema,
+  aiAppAssistantConfigurationSaveResultSchema,
+  aiAppAssistantConnectionResultSchema,
+  aiAppAssistantConnectionTestInputSchema2 as aiAppAssistantConnectionTestInputSchema,
+  aiAppAssistantCredentialsSchema2 as aiAppAssistantCredentialsSchema,
+  aiAppAssistantManagedConfigurationViewSchema,
+  aiAppAssistantModelInfoSchema,
+  aiAppAssistantProviderInfoSchema,
+  aiAppAssistantProviderSchema,
+  aiAppAssistantRequestSchema3 as aiAppAssistantRequestSchema,
+  aiAppAssistantResponseSchema,
+  aiAppAssistantTransportEventSchema,
   createAes256GcmSecretProtector,
-  createAiDocsConfigurationRepository,
-  createAiDocsDeploymentDefaults,
-  createAiDocsFailureEvent,
-  createAiDocsFetchHandlers,
-  createAiDocsNodeHttpListener,
-  createAiDocsServer,
+  createAiAppAssistant,
+  createAiAppAssistantConfigurationRepository,
+  createAiAppAssistantDeploymentDefaults,
+  createAiAppAssistantFailureEvent,
+  createAiAppAssistantFetchHandlers,
+  createAiAppAssistantNodeHttpListener,
+  createAiAppAssistantServer,
   createAiSdkGenerator,
   createDisabledSecretProtector,
-  createDocsAssistant,
-  createManagedAiDocsFetchHandlers,
-  createManagedAiDocsRuntime,
-  createManagedAiDocsServer,
-  createMemoryAiDocsQuotaStore,
-  createMemoryAiDocsStore,
-  createMemoryAiDocsTelemetryStore,
+  createManagedAiAppAssistantFetchHandlers,
+  createManagedAiAppAssistantRuntime,
+  createManagedAiAppAssistantServer,
+  createMemoryAiAppAssistantQuotaStore,
+  createMemoryAiAppAssistantStore,
+  createMemoryAiAppAssistantTelemetryStore,
   createOpenAiCompatibleGenerator,
-  createPollingAiDocsConfigurationSynchronizer,
-  createRedisAiDocsQuotaStore,
-  createRedisAiDocsStore,
-  createRedisAiDocsTelemetryStore,
+  createPollingAiAppAssistantConfigurationSynchronizer,
+  createRedisAiAppAssistantQuotaStore,
+  createRedisAiAppAssistantStore,
+  createRedisAiAppAssistantTelemetryStore,
   filterOpenApiContext,
   listAiModels,
   listAiProviders,
   normalizeAiSdkGenerationError,
   testAiSdkConnection,
-  validateAndSaveAiDocsConfiguration
+  validateAndSaveAiAppAssistantConfiguration
 };
 //# sourceMappingURL=index.js.map