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

package/dist/index.cjs

@@ -20,55 +20,55 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AiDocsConfigurationConflictError: () => AiDocsConfigurationConflictError,
-  AiDocsConfigurationManager: () => AiDocsConfigurationManager,
-  AiDocsManagementError: () => AiDocsManagementError,
-  AiDocsRequestError: () => AiDocsRequestError,
+  AiAppAssistantConfigurationConflictError: () => AiAppAssistantConfigurationConflictError,
+  AiAppAssistantConfigurationManager: () => AiAppAssistantConfigurationManager,
+  AiAppAssistantManagementError: () => AiAppAssistantManagementError,
+  AiAppAssistantRequestError: () => AiAppAssistantRequestError,
   AiModelDiscoveryError: () => AiModelDiscoveryError,
   AiSdkConfigurationError: () => AiSdkConfigurationError,
   AiSdkGenerationError: () => AiSdkGenerationError,
   PROTOCOL_VERSION: () => import_ai_app_assistant_contracts6.PROTOCOL_VERSION,
-  aiDocsAccessRuleSchema: () => import_ai_app_assistant_contracts6.aiDocsAccessRuleSchema,
-  aiDocsConfigurationInputSchema: () => import_ai_app_assistant_contracts6.aiDocsConfigurationInputSchema,
-  aiDocsConfigurationOptionsSchema: () => import_ai_app_assistant_contracts6.aiDocsConfigurationOptionsSchema,
-  aiDocsConfigurationSaveResultSchema: () => import_ai_app_assistant_contracts6.aiDocsConfigurationSaveResultSchema,
-  aiDocsConnectionResultSchema: () => import_ai_app_assistant_contracts6.aiDocsConnectionResultSchema,
-  aiDocsConnectionTestInputSchema: () => import_ai_app_assistant_contracts6.aiDocsConnectionTestInputSchema,
-  aiDocsCredentialsSchema: () => import_ai_app_assistant_contracts6.aiDocsCredentialsSchema,
-  aiDocsManagedConfigurationViewSchema: () => import_ai_app_assistant_contracts6.aiDocsManagedConfigurationViewSchema,
-  aiDocsModelInfoSchema: () => import_ai_app_assistant_contracts6.aiDocsModelInfoSchema,
-  aiDocsProviderInfoSchema: () => import_ai_app_assistant_contracts6.aiDocsProviderInfoSchema,
-  aiDocsProviderSchema: () => import_ai_app_assistant_contracts6.aiDocsProviderSchema,
-  askDocumentationRequestSchema: () => import_ai_app_assistant_contracts6.askDocumentationRequestSchema,
-  askDocumentationResponseSchema: () => import_ai_app_assistant_contracts6.askDocumentationResponseSchema,
-  askDocumentationStreamEventSchema: () => import_ai_app_assistant_contracts6.askDocumentationStreamEventSchema,
+  aiAppAssistantAccessRuleSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantAccessRuleSchema,
+  aiAppAssistantConfigurationInputSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantConfigurationInputSchema,
+  aiAppAssistantConfigurationOptionsSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantConfigurationOptionsSchema,
+  aiAppAssistantConfigurationSaveResultSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantConfigurationSaveResultSchema,
+  aiAppAssistantConnectionResultSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantConnectionResultSchema,
+  aiAppAssistantConnectionTestInputSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantConnectionTestInputSchema,
+  aiAppAssistantCredentialsSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantCredentialsSchema,
+  aiAppAssistantManagedConfigurationViewSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantManagedConfigurationViewSchema,
+  aiAppAssistantModelInfoSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantModelInfoSchema,
+  aiAppAssistantProviderInfoSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantProviderInfoSchema,
+  aiAppAssistantProviderSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantProviderSchema,
+  aiAppAssistantRequestSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantRequestSchema,
+  aiAppAssistantResponseSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantResponseSchema,
+  aiAppAssistantTransportEventSchema: () => import_ai_app_assistant_contracts6.aiAppAssistantTransportEventSchema,
   createAes256GcmSecretProtector: () => createAes256GcmSecretProtector,
-  createAiDocsConfigurationRepository: () => createAiDocsConfigurationRepository,
-  createAiDocsDeploymentDefaults: () => createAiDocsDeploymentDefaults,
-  createAiDocsFailureEvent: () => createAiDocsFailureEvent,
-  createAiDocsFetchHandlers: () => createAiDocsFetchHandlers,
-  createAiDocsNodeHttpListener: () => createAiDocsNodeHttpListener,
-  createAiDocsServer: () => createAiDocsServer,
+  createAiAppAssistant: () => createAiAppAssistant,
+  createAiAppAssistantConfigurationRepository: () => createAiAppAssistantConfigurationRepository,
+  createAiAppAssistantDeploymentDefaults: () => createAiAppAssistantDeploymentDefaults,
+  createAiAppAssistantFailureEvent: () => createAiAppAssistantFailureEvent,
+  createAiAppAssistantFetchHandlers: () => createAiAppAssistantFetchHandlers,
+  createAiAppAssistantNodeHttpListener: () => createAiAppAssistantNodeHttpListener,
+  createAiAppAssistantServer: () => createAiAppAssistantServer,
   createAiSdkGenerator: () => createAiSdkGenerator,
   createDisabledSecretProtector: () => createDisabledSecretProtector,
-  createDocsAssistant: () => createDocsAssistant,
-  createManagedAiDocsFetchHandlers: () => createManagedAiDocsFetchHandlers,
-  createManagedAiDocsRuntime: () => createManagedAiDocsRuntime,
-  createManagedAiDocsServer: () => createManagedAiDocsServer,
-  createMemoryAiDocsQuotaStore: () => createMemoryAiDocsQuotaStore,
-  createMemoryAiDocsStore: () => createMemoryAiDocsStore,
-  createMemoryAiDocsTelemetryStore: () => createMemoryAiDocsTelemetryStore,
+  createManagedAiAppAssistantFetchHandlers: () => createManagedAiAppAssistantFetchHandlers,
+  createManagedAiAppAssistantRuntime: () => createManagedAiAppAssistantRuntime,
+  createManagedAiAppAssistantServer: () => createManagedAiAppAssistantServer,
+  createMemoryAiAppAssistantQuotaStore: () => createMemoryAiAppAssistantQuotaStore,
+  createMemoryAiAppAssistantStore: () => createMemoryAiAppAssistantStore,
+  createMemoryAiAppAssistantTelemetryStore: () => createMemoryAiAppAssistantTelemetryStore,
   createOpenAiCompatibleGenerator: () => createOpenAiCompatibleGenerator,
-  createPollingAiDocsConfigurationSynchronizer: () => createPollingAiDocsConfigurationSynchronizer,
-  createRedisAiDocsQuotaStore: () => createRedisAiDocsQuotaStore,
-  createRedisAiDocsStore: () => createRedisAiDocsStore,
-  createRedisAiDocsTelemetryStore: () => createRedisAiDocsTelemetryStore,
+  createPollingAiAppAssistantConfigurationSynchronizer: () => createPollingAiAppAssistantConfigurationSynchronizer,
+  createRedisAiAppAssistantQuotaStore: () => createRedisAiAppAssistantQuotaStore,
+  createRedisAiAppAssistantStore: () => createRedisAiAppAssistantStore,
+  createRedisAiAppAssistantTelemetryStore: () => createRedisAiAppAssistantTelemetryStore,
   filterOpenApiContext: () => filterOpenApiContext,
   listAiModels: () => listAiModels,
   listAiProviders: () => listAiProviders,
   normalizeAiSdkGenerationError: () => normalizeAiSdkGenerationError,
   testAiSdkConnection: () => testAiSdkConnection,
-  validateAndSaveAiDocsConfiguration: () => validateAndSaveAiDocsConfiguration
+  validateAndSaveAiAppAssistantConfiguration: () => validateAndSaveAiAppAssistantConfiguration
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -139,7 +139,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,
@@ -147,7 +147,7 @@ function createDocsAssistant(options) {
   );
   const documents = prepareDocuments(options.documents ?? []);
   const prepare = (request) => {
-    const validated = import_ai_app_assistant_contracts.askDocumentationRequestSchema.parse(request);
+    const validated = import_ai_app_assistant_contracts.aiAppAssistantRequestSchema.parse(request);
     return { validated, bundle: prepareBundle(validated, documents, options) };
   };
   const finalize = (validated, bundle, generatedInput, startedAt) => {
@@ -291,7 +291,7 @@ function prepareBundle(request, documents, options) {
       content: boundEvidence(
         request.selectedElementHtml,
         selectedLimit,
-        "AI_DOCS_SELECTED_ELEMENT_TRUNCATED"
+        "AI_APP_ASSISTANT_SELECTED_ELEMENT_TRUNCATED"
       ),
       relevance: 1
     });
@@ -306,7 +306,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",
@@ -333,7 +333,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;
@@ -379,28 +379,28 @@ function insufficientResponse(requestId, model, durationMs) {
 // src/http.ts
 var import_ai_app_assistant_contracts2 = require("@123toto/ai-app-assistant-contracts");
 var import_zod = require("zod");
-var AiDocsRequestError = class extends Error {
+var AiAppAssistantRequestError = class extends Error {
   constructor(status, code, message) {
     super(message);
     this.status = status;
     this.code = code;
-    this.name = "AiDocsRequestError";
+    this.name = "AiAppAssistantRequestError";
   }
   status;
   code;
 };
-function createAiDocsFetchHandlers(options) {
+function createAiAppAssistantFetchHandlers(options) {
   const prepare = async (request) => {
     assertPost(request);
     const raw = await readJson(request, options.maxBodyBytes ?? 86e5);
-    const validated = import_ai_app_assistant_contracts2.askDocumentationRequestSchema.parse(raw);
+    const validated = import_ai_app_assistant_contracts2.aiAppAssistantRequestSchema.parse(raw);
     if (!options.resolveContext && !options.authorize && !options.allowAnonymous) {
-      throw new AiDocsRequestError(401, "unauthorized", "Authentication is required");
+      throw new AiAppAssistantRequestError(401, "unauthorized", "Authentication is required");
     }
     const context = options.resolveContext ? await options.resolveContext(request) : void 0;
     await options.authorize?.(context, request);
     const input = options.transformRequest ? await options.transformRequest(validated, context) : validated;
-    return { input: import_ai_app_assistant_contracts2.askDocumentationRequestSchema.parse(input), context };
+    return { input: import_ai_app_assistant_contracts2.aiAppAssistantRequestSchema.parse(input), context };
   };
   const present = async (response, context) => options.transformResponse ? options.transformResponse(response, context) : response;
   const ask = async (request) => {
@@ -463,27 +463,27 @@ function createAiDocsFetchHandlers(options) {
 }
 function assertPost(request) {
   if (request.method !== "POST") {
-    throw new AiDocsRequestError(405, "method_not_allowed", "Only POST is supported");
+    throw new AiAppAssistantRequestError(405, "method_not_allowed", "Only POST is supported");
   }
 }
 async function readJson(request, maxBodyBytes) {
   const contentLength = Number(request.headers.get("content-length"));
   if (Number.isFinite(contentLength) && contentLength > 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");
   }
   const text = await request.text();
   if (new TextEncoder().encode(text).byteLength > 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");
   }
   try {
     return JSON.parse(text);
   } catch {
-    throw new AiDocsRequestError(400, "invalid_json", "Request body must be valid JSON");
+    throw new AiAppAssistantRequestError(400, "invalid_json", "Request body must be valid JSON");
   }
 }
 async function mapError(error, request, customMapper) {
   if (customMapper) return customMapper(error, request);
-  if (error instanceof AiDocsRequestError) {
+  if (error instanceof AiAppAssistantRequestError) {
     return jsonResponse({ error: error.code, message: error.message }, error.status);
   }
   if (error instanceof import_zod.ZodError) {
@@ -506,15 +506,15 @@ function jsonResponse(value, status = 200) {
 }
 
 // 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 }));
@@ -544,7 +544,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);
   }
@@ -1097,22 +1097,22 @@ function serializeEvidence(bundle, kind) {
 }
 
 // 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,
@@ -1130,10 +1130,10 @@ var import_node_crypto3 = require("crypto");
 // src/configuration.ts
 var import_node_crypto = require("crypto");
 var import_zod3 = require("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 = import_zod3.z.discriminatedUnion("mode", [
@@ -1177,8 +1177,8 @@ var persistedConfigurationSchema = import_zod3.z.object({
   maxConversationTurns: import_zod3.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));
@@ -1236,14 +1236,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}`,
@@ -1263,7 +1263,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 = (0, import_node_crypto.randomBytes)(12);
@@ -1293,7 +1293,7 @@ function createDisabledSecretProtector() {
   };
   return { protect: unavailable2, unprotect: unavailable2 };
 }
-function createMemoryAiDocsStore() {
+function createMemoryAiAppAssistantStore() {
   const values = /* @__PURE__ */ new Map();
   return {
     async get(key) {
@@ -1313,8 +1313,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)),
@@ -1392,7 +1392,7 @@ function toConfigurationView(configuration) {
 
 // src/quota.ts
 var import_node_crypto2 = require("crypto");
-function createMemoryAiDocsQuotaStore() {
+function createMemoryAiAppAssistantQuotaStore() {
   const counters = /* @__PURE__ */ new Map();
   return {
     async consume(subject, policy) {
@@ -1409,8 +1409,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);
@@ -1581,19 +1581,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;
@@ -1607,7 +1607,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() {
@@ -1730,7 +1730,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"
@@ -1804,8 +1804,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;
     }
@@ -1836,7 +1836,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) {
@@ -1870,8 +1870,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;
     }
@@ -1991,7 +1991,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",
@@ -2116,8 +2116,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 {
@@ -2229,11 +2229,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 = [];
@@ -2259,8 +2259,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);
@@ -2320,7 +2320,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",
@@ -2388,7 +2388,7 @@ function redisPairs(value) {
 }
 
 // src/managed-runtime.ts
-function createManagedAiDocsRuntime(options) {
+function createManagedAiAppAssistantRuntime(options) {
   let assistant;
   let activeGenerator;
   let documents = [...options.documents ?? []];
@@ -2419,7 +2419,7 @@ function createManagedAiDocsRuntime(options) {
       ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}
     });
     activeGenerator = generator;
-    assistant = createDocsAssistant({
+    assistant = createAiAppAssistant({
       generator,
       documents,
       ...options.policies ? { policies: options.policies } : {}
@@ -2461,7 +2461,7 @@ function createManagedAiDocsRuntime(options) {
     async setDocuments(nextDocuments) {
       documents = [...nextDocuments];
       if (!activeGenerator) return;
-      assistant = createDocsAssistant({
+      assistant = createAiAppAssistant({
         generator: activeGenerator,
         documents,
         ...options.policies ? { policies: options.policies } : {}
@@ -2487,7 +2487,7 @@ function createManagedAiDocsRuntime(options) {
         }, identity);
         return response;
       } catch (error) {
-        await observe(createAiDocsFailureEvent({
+        await observe(createAiAppAssistantFailureEvent({
           error,
           requestId: input.requestId,
           operation: "answer",
@@ -2529,7 +2529,7 @@ function createManagedAiDocsRuntime(options) {
           yield event;
         }
       } catch (error) {
-        await observe(createAiDocsFailureEvent({
+        await observe(createAiAppAssistantFailureEvent({
           error,
           requestId: input.requestId,
           operation: "stream",
@@ -2543,7 +2543,7 @@ function createManagedAiDocsRuntime(options) {
   };
 }
 function unavailable() {
-  return new AiDocsManagementError(
+  return new AiAppAssistantManagementError(
     503,
     "not_configured",
     "AI assistant is not configured or connected"
@@ -2553,17 +2553,17 @@ function unavailable() {
 // src/managed-http.ts
 var import_ai_app_assistant_contracts4 = require("@123toto/ai-app-assistant-contracts");
 var import_zod4 = require("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);
   };
@@ -2577,13 +2577,13 @@ function createManagedAiDocsFetchHandlers(options) {
           return json(await options.runtime.configuration.getAccess(currentIdentity));
         }
         if (request.method === "POST" && path.endsWith("/ask/stream")) {
-          const input = import_ai_app_assistant_contracts4.askDocumentationRequestSchema.parse(await readJson2(request, options.maxBodyBytes));
+          const input = import_ai_app_assistant_contracts4.aiAppAssistantRequestSchema.parse(await readJson2(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 = import_ai_app_assistant_contracts4.askDocumentationRequestSchema.parse(await readJson2(request, options.maxBodyBytes));
+          const input = import_ai_app_assistant_contracts4.aiAppAssistantRequestSchema.parse(await readJson2(request, options.maxBodyBytes));
           return json(await options.runtime.answer(input, currentIdentity));
         }
         await admin(request, currentIdentity, nativeContext);
@@ -2617,22 +2617,22 @@ function createManagedAiDocsFetchHandlers(options) {
           return json({ roles, users });
         }
         if (request.method === "POST" && path.endsWith("/models")) {
-          const input = import_ai_app_assistant_contracts4.aiDocsCredentialsSchema.parse(await readJson2(request, options.maxBodyBytes));
+          const input = import_ai_app_assistant_contracts4.aiAppAssistantCredentialsSchema.parse(await readJson2(request, options.maxBodyBytes));
           return json(await options.runtime.configuration.listModels(input));
         }
         if (request.method === "POST" && path.endsWith("/configuration/test")) {
-          const input = import_ai_app_assistant_contracts4.aiDocsConnectionTestInputSchema.parse(await readJson2(request, options.maxBodyBytes));
+          const input = import_ai_app_assistant_contracts4.aiAppAssistantConnectionTestInputSchema.parse(await readJson2(request, options.maxBodyBytes));
           return json(await options.runtime.configuration.testConnection(input));
         }
         if (request.method === "PUT" && path.endsWith("/configuration")) {
-          const input = import_ai_app_assistant_contracts4.aiDocsConfigurationInputSchema.parse(await readJson2(request, options.maxBodyBytes));
+          const input = import_ai_app_assistant_contracts4.aiAppAssistantConfigurationInputSchema.parse(await readJson2(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 mapError2(error);
@@ -2643,11 +2643,11 @@ function createManagedAiDocsFetchHandlers(options) {
 async function readJson2(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);
 }
@@ -2668,9 +2668,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
           }
@@ -2690,7 +2690,7 @@ function streamResponse(generation, first, requestId) {
   });
 }
 function mapError2(error) {
-  if (error instanceof AiDocsManagementError) {
+  if (error instanceof AiAppAssistantManagementError) {
     return json({ error: error.code, message: error.message, ...error.details }, error.status);
   }
   if (error instanceof import_zod4.ZodError || error instanceof SyntaxError) {
@@ -2710,16 +2710,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
   });
@@ -2737,19 +2737,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,
@@ -2760,20 +2760,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
       })
@@ -2782,17 +2782,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 resolveApiKey2 = (provider2) => apiKeys[provider2];
   if (!options.enabled || !options.model?.trim()) return { resolveApiKey: resolveApiKey2 };
   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 = resolveApiKey2(provider);
   const baseURL = options.baseURLs?.[provider]?.trim() || void 0;
@@ -3010,54 +3010,54 @@ function clampInteger3(value, minimum, maximum) {
 var import_ai_app_assistant_contracts6 = require("@123toto/ai-app-assistant-contracts");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AiDocsConfigurationConflictError,
-  AiDocsConfigurationManager,
-  AiDocsManagementError,
-  AiDocsRequestError,
+  AiAppAssistantConfigurationConflictError,
+  AiAppAssistantConfigurationManager,
+  AiAppAssistantManagementError,
+  AiAppAssistantRequestError,
   AiModelDiscoveryError,
   AiSdkConfigurationError,
   AiSdkGenerationError,
   PROTOCOL_VERSION,
-  aiDocsAccessRuleSchema,
-  aiDocsConfigurationInputSchema,
-  aiDocsConfigurationOptionsSchema,
-  aiDocsConfigurationSaveResultSchema,
-  aiDocsConnectionResultSchema,
-  aiDocsConnectionTestInputSchema,
-  aiDocsCredentialsSchema,
-  aiDocsManagedConfigurationViewSchema,
-  aiDocsModelInfoSchema,
-  aiDocsProviderInfoSchema,
-  aiDocsProviderSchema,
-  askDocumentationRequestSchema,
-  askDocumentationResponseSchema,
-  askDocumentationStreamEventSchema,
+  aiAppAssistantAccessRuleSchema,
+  aiAppAssistantConfigurationInputSchema,
+  aiAppAssistantConfigurationOptionsSchema,
+  aiAppAssistantConfigurationSaveResultSchema,
+  aiAppAssistantConnectionResultSchema,
+  aiAppAssistantConnectionTestInputSchema,
+  aiAppAssistantCredentialsSchema,
+  aiAppAssistantManagedConfigurationViewSchema,
+  aiAppAssistantModelInfoSchema,
+  aiAppAssistantProviderInfoSchema,
+  aiAppAssistantProviderSchema,
+  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.cjs.map