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

package/dist/{managed-server-CrZumvVU.d.ts → managed-server-CQb-RK-i.d.cts}

@@ -1,7 +1,7 @@
-import { a as DocsAssistantOptions, d as AiSdkConnectionTestResult, e as AiSdkFailureCode, D as DocumentationSource, A as AnswerGenerator } from './ai-sdk-QImICd56.js';
-import { AskDocumentationResponse, AskDocumentationRequest, AiDocsConnectionTestInput, AiDocsConnectionResult, AiDocsCredentials, AiDocsConfigurationInput, AiDocsManagedConfigurationView, TokenUsage } from '@123toto/ai-app-assistant-contracts';
+import { a as AiAppAssistantOptions, d as AiSdkConnectionTestResult, e as AiSdkFailureCode, D as DocumentationSource, A as AnswerGenerator } from './ai-sdk-qU3KgNu-.cjs';
+import { AiAppAssistantResponse, AiAppAssistantRequest, AiAppAssistantConnectionTestInput, AiAppAssistantConnectionResult, AiAppAssistantCredentials, AiAppAssistantConfigurationInput, AiAppAssistantManagedConfigurationView, TokenUsage } from '@123toto/ai-app-assistant-contracts';
 
-type DocsAssistantStreamEvent = {
+type AiAppAssistantStreamEvent = {
     type: "status";
     phase: "preparing" | "generating";
 } | {
@@ -14,17 +14,17 @@ type DocsAssistantStreamEvent = {
     delayMs: number;
 } | {
     type: "complete";
-    response: AskDocumentationResponse;
+    response: AiAppAssistantResponse;
 };
 /** Stateful facade whose static documentation is prepared only once. */
-interface DocsAssistant {
-    answer(request: AskDocumentationRequest, options?: {
+interface AiAppAssistant {
+    answer(request: AiAppAssistantRequest, options?: {
         signal?: AbortSignal;
-    }): Promise<AskDocumentationResponse>;
+    }): Promise<AiAppAssistantResponse>;
     /** Streams provider-neutral progress and always ends with a complete event. */
-    stream(request: AskDocumentationRequest, options?: {
+    stream(request: AiAppAssistantRequest, options?: {
         signal?: AbortSignal;
-    }): AsyncGenerator<DocsAssistantStreamEvent, AskDocumentationResponse>;
+    }): AsyncGenerator<AiAppAssistantStreamEvent, AiAppAssistantResponse>;
 }
 /**
  * Creates a provider-neutral documentation assistant.
@@ -34,7 +34,7 @@ interface DocsAssistant {
  * element and the user's prompt. This keeps the public integration small and
  * lets provider-side prompt caching reuse the stable document prefix.
  */
-declare function createDocsAssistant(options: DocsAssistantOptions): DocsAssistant;
+declare function createAiAppAssistant(options: AiAppAssistantOptions): AiAppAssistant;
 
 /** Providers available without installing an additional AI SDK package. */
 type BuiltInProvider = "anthropic" | "google" | "mistral" | "ollama" | "openai";
@@ -77,7 +77,7 @@ declare class AiModelDiscoveryError extends Error {
 }
 
 /** Generic access rule; host applications map their own roles and user IDs. */
-type AiDocsAccessRule = {
+type AiAppAssistantAccessRule = {
     mode: "all";
 } | {
     mode: "roles";
@@ -87,55 +87,55 @@ type AiDocsAccessRule = {
     userIds: string[];
 };
 /** Stable identity used for ownership and audit without coupling the library to a user directory. */
-interface AiDocsConfigurationActor {
+interface AiAppAssistantConfigurationActor {
     id: string;
     label: string;
 }
-type AiDocsConfigurationAuditField = "provider" | "apiKey" | "model" | "access" | "quota" | "conversation" | "modelChangePolicy";
+type AiAppAssistantConfigurationAuditField = "provider" | "apiKey" | "model" | "access" | "quota" | "conversation" | "modelChangePolicy";
 /** One safe configuration change. API key values must never be placed in from/to. */
-interface AiDocsConfigurationAuditChange {
-    field: AiDocsConfigurationAuditField;
+interface AiAppAssistantConfigurationAuditChange {
+    field: AiAppAssistantConfigurationAuditField;
     from?: string;
     to?: string;
 }
-interface AiDocsConfigurationAuditEntry {
+interface AiAppAssistantConfigurationAuditEntry {
     id: string;
-    actor: AiDocsConfigurationActor;
+    actor: AiAppAssistantConfigurationActor;
     changedAt: string;
-    changes: AiDocsConfigurationAuditChange[];
+    changes: AiAppAssistantConfigurationAuditChange[];
 }
 /** Ownership and persisted audit metadata managed by the host application's authenticated backend. */
-interface AiDocsConfigurationAdministration {
-    keyCreatedBy?: AiDocsConfigurationActor;
+interface AiAppAssistantConfigurationAdministration {
+    keyCreatedBy?: AiAppAssistantConfigurationActor;
     keyCreatedAt?: string;
-    modelUpdatedBy?: AiDocsConfigurationActor;
+    modelUpdatedBy?: AiAppAssistantConfigurationActor;
     modelUpdatedAt?: string;
     allowModelChangesByOthers: boolean;
-    history: AiDocsConfigurationAuditEntry[];
+    history: AiAppAssistantConfigurationAuditEntry[];
 }
 /** Provider configuration owned by the library and persisted by an adapter. */
-interface AiDocsConfiguration {
+interface AiAppAssistantConfiguration {
     provider: BuiltInProvider;
     model: string;
     /** Whether provider fields override deployment defaults or merely accompany stored policies. */
     connectionSource?: "environment" | "override";
     apiKey?: string;
     baseURL?: string;
-    access: AiDocsAccessRule;
+    access: AiAppAssistantAccessRule;
     quota?: {
         maxRequests: number;
         windowSeconds: number;
     };
     /** Maximum number of user questions kept in one assistant conversation. */
     maxConversationTurns?: number;
-    administration?: AiDocsConfigurationAdministration;
+    administration?: AiAppAssistantConfigurationAdministration;
 }
 /** Safe representation returned to a frontend; it never contains the secret. */
-type AiDocsConfigurationView = Omit<AiDocsConfiguration, "apiKey"> & {
+type AiAppAssistantConfigurationView = Omit<AiAppAssistantConfiguration, "apiKey"> & {
     apiKeyConfigured: boolean;
 };
 /** Minimal persistence contract supported by Redis, databases or secret stores. */
-interface AiDocsKeyValueStore {
+interface AiAppAssistantKeyValueStore {
     get(key: string): Promise<string | null | undefined>;
     set(key: string, value: string): Promise<void>;
     delete(key: string): Promise<void>;
@@ -143,180 +143,184 @@ interface AiDocsKeyValueStore {
     compareAndSet?(key: string, expected: string | null, value: string): Promise<boolean>;
 }
 /** Secret protection is explicit so plaintext keys can never be persisted. */
-interface AiDocsSecretProtector {
+interface AiAppAssistantSecretProtector {
     protect(secret: string): Promise<string> | string;
     unprotect(protectedSecret: string): Promise<string> | string;
 }
-interface AiDocsConfigurationRepository {
-    load(): Promise<AiDocsConfiguration | undefined>;
-    loadView(): Promise<AiDocsConfigurationView | undefined>;
-    save(configuration: AiDocsConfiguration): Promise<AiDocsConfigurationView>;
+interface AiAppAssistantConfigurationRepository {
+    load(): Promise<AiAppAssistantConfiguration | undefined>;
+    loadView(): Promise<AiAppAssistantConfigurationView | undefined>;
+    save(configuration: AiAppAssistantConfiguration): Promise<AiAppAssistantConfigurationView>;
     /** Atomic when the underlying key/value store supports compare-and-set. */
-    mutate?(update: (current: AiDocsConfiguration | undefined) => AiDocsConfiguration | Promise<AiDocsConfiguration>): Promise<AiDocsConfigurationView>;
+    mutate?(update: (current: AiAppAssistantConfiguration | undefined) => AiAppAssistantConfiguration | Promise<AiAppAssistantConfiguration>): Promise<AiAppAssistantConfigurationView>;
     clear(): Promise<void>;
 }
-interface CreateAiDocsConfigurationRepositoryOptions {
-    store: AiDocsKeyValueStore;
-    secretProtector: AiDocsSecretProtector;
+interface CreateAiAppAssistantConfigurationRepositoryOptions {
+    store: AiAppAssistantKeyValueStore;
+    secretProtector: AiAppAssistantSecretProtector;
     /** Allows several applications or environments to share one storage system. */
     key?: string;
 }
-declare class AiDocsConfigurationConflictError extends Error {
+declare class AiAppAssistantConfigurationConflictError extends Error {
     constructor();
 }
 /** Creates a repository that validates and encrypts configuration data. */
-declare function createAiDocsConfigurationRepository(options: CreateAiDocsConfigurationRepositoryOptions): AiDocsConfigurationRepository;
+declare function createAiAppAssistantConfigurationRepository(options: CreateAiAppAssistantConfigurationRepositoryOptions): AiAppAssistantConfigurationRepository;
 /**
  * Tests the exact model configuration and persists it only after a successful
  * structured-output response.
  */
-declare function validateAndSaveAiDocsConfiguration(repository: AiDocsConfigurationRepository, configuration: AiDocsConfiguration, options?: {
+declare function validateAndSaveAiAppAssistantConfiguration(repository: AiAppAssistantConfigurationRepository, configuration: AiAppAssistantConfiguration, options?: {
     timeoutMs?: number;
 }): Promise<{
     saved: boolean;
     connection: AiSdkConnectionTestResult;
-    configuration?: AiDocsConfigurationView;
+    configuration?: AiAppAssistantConfigurationView;
 }>;
 /**
  * AES-256-GCM protector for applications that keep configuration outside a
  * dedicated secret manager. The key must be a random 32-byte base64 value.
  */
-declare function createAes256GcmSecretProtector(base64Key: string): AiDocsSecretProtector;
+declare function createAes256GcmSecretProtector(base64Key: string): AiAppAssistantSecretProtector;
 /**
  * Allows environment-only configurations while failing closed if a caller
  * attempts to persist a secret without configuring encryption.
  */
-declare function createDisabledSecretProtector(): AiDocsSecretProtector;
+declare function createDisabledSecretProtector(): AiAppAssistantSecretProtector;
 /** Lightweight local store useful for tests and single-process prototypes. */
-declare function createMemoryAiDocsStore(): AiDocsKeyValueStore;
+declare function createMemoryAiAppAssistantStore(): AiAppAssistantKeyValueStore;
 /** Minimal Redis shape; consumers can pass an existing ioredis-like client. */
-interface AiDocsRedisClient {
+interface AiAppAssistantRedisClient {
     get(key: string): Promise<string | null>;
     set(key: string, value: string): Promise<unknown>;
     del(key: string): Promise<number>;
     eval?(script: string, numberOfKeys: number, ...args: string[]): Promise<unknown>;
 }
 /** Reuses the host application's Redis connection without adding a dependency. */
-declare function createRedisAiDocsStore(client: AiDocsRedisClient, options?: {
+declare function createRedisAiAppAssistantStore(client: AiAppAssistantRedisClient, options?: {
     prefix?: string;
-}): AiDocsKeyValueStore;
+}): AiAppAssistantKeyValueStore;
 
-interface AiDocsQuotaPolicy {
+interface AiAppAssistantQuotaPolicy {
     maxRequests: number;
     windowSeconds: number;
 }
-interface AiDocsQuotaResult {
+interface AiAppAssistantQuotaResult {
     allowed: boolean;
     remaining: number;
     retryAfterSeconds: number;
     resetAt: Date;
 }
 /** Atomic quota contract implemented by shared or local stores. */
-interface AiDocsQuotaStore {
-    consume(subject: string, policy: AiDocsQuotaPolicy): Promise<AiDocsQuotaResult>;
+interface AiAppAssistantQuotaStore {
+    consume(subject: string, policy: AiAppAssistantQuotaPolicy): Promise<AiAppAssistantQuotaResult>;
 }
 /** Single-process implementation intended for tests and local development. */
-declare function createMemoryAiDocsQuotaStore(): AiDocsQuotaStore;
+declare function createMemoryAiAppAssistantQuotaStore(): AiAppAssistantQuotaStore;
 /** Minimal ioredis-compatible shape needed for one atomic Lua operation. */
-interface AiDocsRedisQuotaClient {
+interface AiAppAssistantRedisQuotaClient {
     eval(script: string, numberOfKeys: number, ...args: Array<string | number>): Promise<unknown>;
 }
 /**
  * Redis quota with one atomic increment/expiry operation. Subject identifiers
  * are SHA-256 fingerprints, never readable user IDs.
  */
-declare function createRedisAiDocsQuotaStore(client: AiDocsRedisQuotaClient, options?: {
+declare function createRedisAiAppAssistantQuotaStore(client: AiAppAssistantRedisQuotaClient, options?: {
     prefix?: string;
-}): AiDocsQuotaStore;
+}): AiAppAssistantQuotaStore;
 
 /** Minimal identity understood by the generic access and audit policies. */
-interface AiDocsRuntimeIdentity extends AiDocsConfigurationActor {
+interface AiAppAssistantRuntimeIdentity extends AiAppAssistantConfigurationActor {
     roles?: readonly string[];
 }
-interface AiDocsConfigurationChangeEvent {
+interface AiAppAssistantConfigurationChangeEvent {
     reason: "saved" | "revoked" | "connection-tested" | "remote-change";
     reloadRequired: boolean;
     /** A successful provider call already validated the current configuration. */
     connectionValidated: boolean;
     remote: boolean;
 }
-interface AiDocsConfigurationSynchronizer {
-    start(onChange: (event: AiDocsConfigurationChangeEvent) => Promise<void> | void): Promise<() => void> | (() => void);
-    publish(event: AiDocsConfigurationChangeEvent): Promise<void>;
+interface AiAppAssistantConfigurationSynchronizer {
+    start(onChange: (event: AiAppAssistantConfigurationChangeEvent) => Promise<void> | void): Promise<() => void> | (() => void);
+    publish(event: AiAppAssistantConfigurationChangeEvent): Promise<void>;
 }
-interface AiDocsConfigurationManagerOptions {
-    repository: AiDocsConfigurationRepository;
+interface AiAppAssistantConfigurationManagerOptions {
+    repository: AiAppAssistantConfigurationRepository;
+    /** Global kill switch. When false, no provider operation is allowed. */
+    enabled?: boolean | (() => boolean);
     /** Defaults to the local in-memory quota implementation. */
-    quotaStore?: AiDocsQuotaStore;
+    quotaStore?: AiAppAssistantQuotaStore;
     /** Environment or deployment defaults. They are never persisted automatically. */
-    defaultConfiguration?: AiDocsConfiguration | (() => AiDocsConfiguration | undefined);
+    defaultConfiguration?: AiAppAssistantConfiguration | (() => AiAppAssistantConfiguration | undefined);
     /** Resolves a secret supplied by the host environment or secret manager. */
-    resolveDefaultApiKey?: (provider: AiDocsConfiguration["provider"]) => string | undefined;
+    resolveDefaultApiKey?: (provider: AiAppAssistantConfiguration["provider"]) => string | undefined;
     apiKeyStorageAvailable?: boolean;
-    defaultQuota?: AiDocsQuotaPolicy;
+    defaultQuota?: AiAppAssistantQuotaPolicy;
     connectionTimeoutMs?: number;
     /** Minimum delay before retrying a disconnected provider on demand. */
     reconnectIntervalMs?: number;
-    synchronizer?: AiDocsConfigurationSynchronizer;
-    testConnection?: (input: AiDocsConnectionTestInput) => Promise<AiDocsConnectionResult>;
-    listModels?: (input: AiDocsCredentials) => Promise<AiModelInfo[]>;
+    synchronizer?: AiAppAssistantConfigurationSynchronizer;
+    testConnection?: (input: AiAppAssistantConnectionTestInput) => Promise<AiAppAssistantConnectionResult>;
+    listModels?: (input: AiAppAssistantCredentials) => Promise<AiModelInfo[]>;
     now?: () => Date;
     createId?: () => string;
     logger?: Pick<Console, "info" | "warn">;
 }
-interface AiDocsConfigurationSaveResult {
+interface AiAppAssistantConfigurationSaveResult {
     saved: boolean;
-    connection: AiDocsConnectionResult;
-    configuration?: AiDocsManagedConfigurationView;
+    connection: AiAppAssistantConnectionResult;
+    configuration?: AiAppAssistantManagedConfigurationView;
     reloadRequired: boolean;
 }
-type AiDocsManagementErrorCode = "unauthorized" | "forbidden" | "conflict" | "invalid_request" | "not_configured" | "quota_reached" | "secret_storage_unavailable";
+type AiAppAssistantManagementErrorCode = "unauthorized" | "forbidden" | "conflict" | "invalid_request" | "not_configured" | "assistant_disabled" | "quota_reached" | "secret_storage_unavailable";
 /** Framework-neutral policy error that HTTP adapters can map safely. */
-declare class AiDocsManagementError extends Error {
+declare class AiAppAssistantManagementError extends Error {
     readonly status: number;
-    readonly code: AiDocsManagementErrorCode;
+    readonly code: AiAppAssistantManagementErrorCode;
     readonly details?: Record<string, unknown> | undefined;
-    constructor(status: number, code: AiDocsManagementErrorCode, message: string, details?: Record<string, unknown> | undefined);
+    constructor(status: number, code: AiAppAssistantManagementErrorCode, message: string, details?: Record<string, unknown> | undefined);
 }
 /**
  * Owns provider configuration, access, quota, audit and runtime connection
  * state. Hosts only supply identity mapping, storage and optional defaults.
  */
-declare class AiDocsConfigurationManager {
+declare class AiAppAssistantConfigurationManager {
     #private;
-    constructor(options: AiDocsConfigurationManagerOptions);
+    constructor(options: AiAppAssistantConfigurationManagerOptions);
+    /** Returns the current state of the host-controlled global kill switch. */
+    isEnabled(): boolean;
     /** Returns the built-in provider catalogue; no credentials are exposed. */
     listProviders(): AiProviderInfo[];
     /** Discovers models with an explicit key or the currently configured secret. */
-    listModels(input: AiDocsCredentials): Promise<AiModelInfo[]>;
+    listModels(input: AiAppAssistantCredentials): Promise<AiModelInfo[]>;
     /** Notifies the runtime when a provider-affecting setting changes. */
-    subscribe(listener: (event: AiDocsConfigurationChangeEvent) => Promise<void> | void): () => void;
+    subscribe(listener: (event: AiAppAssistantConfigurationChangeEvent) => Promise<void> | void): () => void;
     /** Starts optional cross-instance invalidation. Calling it repeatedly is safe. */
     startSynchronization(): Promise<void>;
     dispose(): void;
     /** Tests credentials and briefly caches a successful result for the next save. */
-    testConnection(input: AiDocsConnectionTestInput): Promise<AiDocsConnectionResult>;
+    testConnection(input: AiAppAssistantConnectionTestInput): Promise<AiAppAssistantConnectionResult>;
     /** Checks the effective stored/deployment connection used by live questions. */
     validateRuntimeConnection(): Promise<boolean>;
     /** Validates sensitive connection changes, persists safely and records their author. */
-    save(rawInput: AiDocsConfigurationInput, actor: AiDocsRuntimeIdentity): Promise<AiDocsConfigurationSaveResult>;
+    save(rawInput: AiAppAssistantConfigurationInput, actor: AiAppAssistantRuntimeIdentity): Promise<AiAppAssistantConfigurationSaveResult>;
     /** Removes only the manual key, records the revocation and falls back to defaults. */
-    revokeApiKey(actor: AiDocsRuntimeIdentity): Promise<AiDocsManagedConfigurationView>;
+    revokeApiKey(actor: AiAppAssistantRuntimeIdentity): Promise<AiAppAssistantManagedConfigurationView>;
     /** Resolves persisted policy against deployment defaults, including the secret. */
-    getRuntimeConfiguration(): Promise<AiDocsConfiguration | undefined>;
+    getRuntimeConfiguration(): Promise<AiAppAssistantConfiguration | undefined>;
     /** Returns the frontend-safe view: secret presence and permissions, never the key. */
-    getView(identity?: AiDocsRuntimeIdentity): Promise<AiDocsManagedConfigurationView>;
+    getView(identity?: AiAppAssistantRuntimeIdentity): Promise<AiAppAssistantManagedConfigurationView>;
     /** Minimal launcher state used by clients before rendering the assistant. */
-    getAccess(identity: AiDocsRuntimeIdentity): Promise<{
+    getAccess(identity: AiAppAssistantRuntimeIdentity): Promise<{
         available: boolean;
         maxConversationTurns: number;
     }>;
     /** Combines configuration, provider health and application access rules. */
-    canUse(identity: AiDocsRuntimeIdentity): Promise<boolean>;
+    canUse(identity: AiAppAssistantRuntimeIdentity): Promise<boolean>;
     /** Atomically consumes one request from the user's active quota window. */
-    consumeQuota(identity: AiDocsRuntimeIdentity): Promise<AiDocsQuotaResult>;
+    consumeQuota(identity: AiAppAssistantRuntimeIdentity): Promise<AiAppAssistantQuotaResult>;
     /** Enforces access and quota immediately before any model call. */
-    assertCanAsk(identity: AiDocsRuntimeIdentity): Promise<void>;
+    assertCanAsk(identity: AiAppAssistantRuntimeIdentity): Promise<void>;
     /** Retries a failed provider lazily, with a shared backoff across requests. */
     ensureRuntimeConnection(): Promise<boolean>;
     private applyTestResultToActiveConfiguration;
@@ -329,6 +333,7 @@ declare class AiDocsConfigurationManager {
     private connectionSignature;
     private lastKnownConnection;
     private now;
+    private assertEnabled;
     private publishAndEmit;
     private emit;
 }
@@ -336,24 +341,24 @@ declare class AiDocsConfigurationManager {
  * Portable cross-instance invalidation using any key/value store. It avoids a
  * Redis-specific dependency and gives every process an eventual reload.
  */
-declare function createPollingAiDocsConfigurationSynchronizer(store: AiDocsKeyValueStore, options?: {
+declare function createPollingAiAppAssistantConfigurationSynchronizer(store: AiAppAssistantKeyValueStore, options?: {
     key?: string;
     intervalMs?: number;
-}): AiDocsConfigurationSynchronizer;
+}): AiAppAssistantConfigurationSynchronizer;
 
-type AiDocsGenerationOperation = "answer" | "stream";
-interface AiDocsGenerationEventBase {
+type AiAppAssistantGenerationOperation = "answer" | "stream";
+interface AiAppAssistantGenerationEventBase {
     requestId: string;
-    operation: AiDocsGenerationOperation;
+    operation: AiAppAssistantGenerationOperation;
     model: string;
     durationMs: number;
     occurredAt: string;
 }
 /** Safe operational event. It deliberately excludes prompts, HTML, users and credentials. */
-type AiDocsGenerationEvent = (AiDocsGenerationEventBase & {
+type AiAppAssistantGenerationEvent = (AiAppAssistantGenerationEventBase & {
     outcome: "success";
     usage?: TokenUsage;
-}) | (AiDocsGenerationEventBase & {
+}) | (AiAppAssistantGenerationEventBase & {
     outcome: "failure";
     error: {
         code: AiSdkFailureCode;
@@ -363,7 +368,7 @@ type AiDocsGenerationEvent = (AiDocsGenerationEventBase & {
         providerStatus?: number;
     };
 });
-interface AiDocsTelemetrySummary {
+interface AiAppAssistantTelemetrySummary {
     requests: number;
     succeeded: number;
     failed: number;
@@ -373,43 +378,43 @@ interface AiDocsTelemetrySummary {
     totalTokens: number;
     failuresByCode: Partial<Record<AiSdkFailureCode, number>>;
 }
-type AiDocsRecentFailure = Extract<AiDocsGenerationEvent, {
+type AiAppAssistantRecentFailure = Extract<AiAppAssistantGenerationEvent, {
     outcome: "failure";
 }>;
 /** Persistence contract used by the managed server and reusable by any host. */
-interface AiDocsTelemetryStore {
-    record(event: AiDocsGenerationEvent): Promise<void>;
-    summary(): Promise<AiDocsTelemetrySummary>;
-    recentFailures(limit?: number): Promise<AiDocsRecentFailure[]>;
+interface AiAppAssistantTelemetryStore {
+    record(event: AiAppAssistantGenerationEvent): Promise<void>;
+    summary(): Promise<AiAppAssistantTelemetrySummary>;
+    recentFailures(limit?: number): Promise<AiAppAssistantRecentFailure[]>;
 }
 /** Single-process telemetry intended for tests and local development. */
-declare function createMemoryAiDocsTelemetryStore(options?: {
+declare function createMemoryAiAppAssistantTelemetryStore(options?: {
     recentFailureLimit?: number;
-}): AiDocsTelemetryStore;
+}): AiAppAssistantTelemetryStore;
 /** Minimal Redis shape; compatible with ioredis without adding it as a dependency. */
-interface AiDocsRedisTelemetryClient {
+interface AiAppAssistantRedisTelemetryClient {
     eval(script: string, numberOfKeys: number, ...args: Array<string | number>): Promise<unknown>;
 }
 /**
  * Shared Redis telemetry. One Lua call atomically updates counters and keeps a
  * bounded failure list, so several application instances can safely share it.
  */
-declare function createRedisAiDocsTelemetryStore(client: AiDocsRedisTelemetryClient, options?: {
+declare function createRedisAiAppAssistantTelemetryStore(client: AiAppAssistantRedisTelemetryClient, options?: {
     prefix?: string;
     recentFailureLimit?: number;
-}): AiDocsTelemetryStore;
+}): AiAppAssistantTelemetryStore;
 /** Converts any generator error to the same safe public diagnostic. */
-declare function createAiDocsFailureEvent(input: {
+declare function createAiAppAssistantFailureEvent(input: {
     error: unknown;
     requestId: string;
-    operation: AiDocsGenerationOperation;
+    operation: AiAppAssistantGenerationOperation;
     model: string;
     durationMs: number;
-}): AiDocsRecentFailure;
+}): AiAppAssistantRecentFailure;
 
-type AssistantPolicies = NonNullable<DocsAssistantOptions["policies"]>;
-interface CreateManagedAiDocsRuntimeOptions<TIdentity extends AiDocsRuntimeIdentity> {
-    configuration: AiDocsConfigurationManager;
+type AssistantPolicies = NonNullable<AiAppAssistantOptions["policies"]>;
+interface CreateManagedAiAppAssistantRuntimeOptions<TIdentity extends AiAppAssistantRuntimeIdentity> {
+    configuration: AiAppAssistantConfigurationManager;
     documents?: DocumentationSource[];
     policies?: AssistantPolicies;
     /** Overrides the built-in `provider:model` AI SDK generator. */
@@ -420,36 +425,36 @@ interface CreateManagedAiDocsRuntimeOptions<TIdentity extends AiDocsRuntimeIdent
     }) => AnswerGenerator | Promise<AnswerGenerator>;
     timeoutMs?: number;
     maxRetries?: number;
-    transformRequest?: (input: AskDocumentationRequest, identity: TIdentity) => AskDocumentationRequest | Promise<AskDocumentationRequest>;
-    transformResponse?: (output: AskDocumentationResponse, identity: TIdentity) => AskDocumentationResponse | Promise<AskDocumentationResponse>;
-    transformStreamEvent?: (event: DocsAssistantStreamEvent, identity: TIdentity) => DocsAssistantStreamEvent | Promise<DocsAssistantStreamEvent>;
+    transformRequest?: (input: AiAppAssistantRequest, identity: TIdentity) => AiAppAssistantRequest | Promise<AiAppAssistantRequest>;
+    transformResponse?: (output: AiAppAssistantResponse, identity: TIdentity) => AiAppAssistantResponse | Promise<AiAppAssistantResponse>;
+    transformStreamEvent?: (event: AiAppAssistantStreamEvent, identity: TIdentity) => AiAppAssistantStreamEvent | Promise<AiAppAssistantStreamEvent>;
     authorize?: (identity: TIdentity) => Promise<void> | void;
     /** Receives provider/runtime failures without exposing prompts or credentials. */
     onGenerationError?: (error: unknown, operation: "answer" | "stream", identity: TIdentity) => Promise<void> | void;
     /** Receives one safe success/failure event per user request. */
-    onGenerationEvent?: (event: AiDocsGenerationEvent, identity: TIdentity) => Promise<void> | void;
+    onGenerationEvent?: (event: AiAppAssistantGenerationEvent, identity: TIdentity) => Promise<void> | void;
     /** Optional persistence used by the batteries-included managed server. */
-    telemetryStore?: AiDocsTelemetryStore;
+    telemetryStore?: AiAppAssistantTelemetryStore;
 }
-interface ManagedAiDocsRuntime<TIdentity extends AiDocsRuntimeIdentity> {
-    readonly configuration: AiDocsConfigurationManager;
-    readonly telemetry?: AiDocsTelemetryStore;
+interface ManagedAiAppAssistantRuntime<TIdentity extends AiAppAssistantRuntimeIdentity> {
+    readonly configuration: AiAppAssistantConfigurationManager;
+    readonly telemetry?: AiAppAssistantTelemetryStore;
     initialize(): Promise<void>;
     dispose(): void;
     reload(connectionAlreadyValidated?: boolean): Promise<void>;
     /** Replaces the stable documentation without recreating the configuration manager. */
     setDocuments(documents: DocumentationSource[]): Promise<void>;
-    answer(input: AskDocumentationRequest, identity: TIdentity): Promise<AskDocumentationResponse>;
-    stream(input: AskDocumentationRequest, identity: TIdentity, signal?: AbortSignal): AsyncGenerator<DocsAssistantStreamEvent, AskDocumentationResponse>;
+    answer(input: AiAppAssistantRequest, identity: TIdentity): Promise<AiAppAssistantResponse>;
+    stream(input: AiAppAssistantRequest, identity: TIdentity, signal?: AbortSignal): AsyncGenerator<AiAppAssistantStreamEvent, AiAppAssistantResponse>;
 }
 /**
- * Optional batteries-included runtime. The minimal `createDocsAssistant` API
+ * Optional batteries-included runtime. The minimal `createAiAppAssistant` API
  * remains available for applications that want to own the lifecycle.
  */
-declare function createManagedAiDocsRuntime<TIdentity extends AiDocsRuntimeIdentity>(options: CreateManagedAiDocsRuntimeOptions<TIdentity>): ManagedAiDocsRuntime<TIdentity>;
+declare function createManagedAiAppAssistantRuntime<TIdentity extends AiAppAssistantRuntimeIdentity>(options: CreateManagedAiAppAssistantRuntimeOptions<TIdentity>): ManagedAiAppAssistantRuntime<TIdentity>;
 
-interface ManagedAiDocsFetchHandlerOptions<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined> {
-    runtime: ManagedAiDocsRuntime<TIdentity>;
+interface ManagedAiAppAssistantFetchHandlerOptions<TIdentity extends AiAppAssistantRuntimeIdentity, TNativeContext = undefined> {
+    runtime: ManagedAiAppAssistantRuntime<TIdentity>;
     /** Required by default so application endpoints fail closed. */
     resolveIdentity?: (request: Request, nativeContext: TNativeContext | undefined) => TIdentity | Promise<TIdentity>;
     /** Explicit opt-in for public prototypes. Never enable it on authenticated applications. */
@@ -472,51 +477,51 @@ interface ManagedAiDocsFetchHandlerOptions<TIdentity extends AiDocsRuntimeIdenti
     maxBodyBytes?: number;
     onError?: (error: unknown, request: Request, nativeContext: TNativeContext | undefined) => Response | Promise<Response>;
 }
-interface ManagedAiDocsFetchHandlers<TNativeContext = undefined> {
+interface ManagedAiAppAssistantFetchHandlers<TNativeContext = undefined> {
     handle(request: Request, nativeContext?: TNativeContext): Promise<Response>;
 }
 /** Complete framework-neutral chat and administration API. */
-declare function createManagedAiDocsFetchHandlers<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined>(options: ManagedAiDocsFetchHandlerOptions<TIdentity, TNativeContext>): ManagedAiDocsFetchHandlers<TNativeContext>;
+declare function createManagedAiAppAssistantFetchHandlers<TIdentity extends AiAppAssistantRuntimeIdentity, TNativeContext = undefined>(options: ManagedAiAppAssistantFetchHandlerOptions<TIdentity, TNativeContext>): ManagedAiAppAssistantFetchHandlers<TNativeContext>;
 
-type AiDocsManagedStorage = {
+type AiAppAssistantManagedStorage = {
     type: "memory";
 } | {
     type: "redis";
-    client: AiDocsRedisClient & AiDocsRedisQuotaClient;
-    /** Shared namespace. Defaults to `ai-docs:`. */
+    client: AiAppAssistantRedisClient & AiAppAssistantRedisQuotaClient;
+    /** Shared namespace. Defaults to `ai-app-assistant:`. */
     prefix?: string;
     synchronizationIntervalMs?: number;
 };
-interface AiDocsManagedConfigurationSetup extends Omit<AiDocsConfigurationManagerOptions, "apiKeyStorageAvailable" | "quotaStore" | "repository" | "synchronizer"> {
+interface AiAppAssistantManagedConfigurationSetup extends Omit<AiAppAssistantConfigurationManagerOptions, "apiKeyStorageAvailable" | "quotaStore" | "repository" | "synchronizer"> {
     /** Creates configuration, quota and synchronization adapters automatically. */
-    storage?: AiDocsManagedStorage;
+    storage?: AiAppAssistantManagedStorage;
     /** AES-256-GCM key used to persist administrator-supplied API keys. */
     encryptionKey?: string;
     /** Alternative secret manager; takes precedence over encryptionKey. */
-    secretProtector?: AiDocsSecretProtector;
+    secretProtector?: AiAppAssistantSecretProtector;
     repositoryKey?: string;
-    quotaStore?: AiDocsQuotaStore;
-    synchronizer?: AiDocsConfigurationManagerOptions["synchronizer"];
+    quotaStore?: AiAppAssistantQuotaStore;
+    synchronizer?: AiAppAssistantConfigurationManagerOptions["synchronizer"];
     apiKeyStorageAvailable?: boolean;
 }
-interface CreateManagedAiDocsServerOptions<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined> {
+interface CreateManagedAiAppAssistantServerOptions<TIdentity extends AiAppAssistantRuntimeIdentity, TNativeContext = undefined> {
     /** Pass an existing manager, or its construction options for the common case. */
-    configuration: AiDocsConfigurationManager | AiDocsConfigurationManagerOptions | AiDocsManagedConfigurationSetup;
+    configuration: AiAppAssistantConfigurationManager | AiAppAssistantConfigurationManagerOptions | AiAppAssistantManagedConfigurationSetup;
     /** Stable application documentation. It can also be supplied later with setDocuments(). */
     documents?: DocumentationSource[];
-    runtime?: Omit<CreateManagedAiDocsRuntimeOptions<TIdentity>, "configuration" | "documents">;
-    http?: Omit<ManagedAiDocsFetchHandlerOptions<TIdentity, TNativeContext>, "runtime">;
+    runtime?: Omit<CreateManagedAiAppAssistantRuntimeOptions<TIdentity>, "configuration" | "documents">;
+    http?: Omit<ManagedAiAppAssistantFetchHandlerOptions<TIdentity, TNativeContext>, "runtime">;
     /** Enabled by default; Redis configuration automatically makes it persistent. */
     telemetry?: false | {
-        store?: AiDocsTelemetryStore;
+        store?: AiAppAssistantTelemetryStore;
         recentFailureLimit?: number;
     };
 }
-interface ManagedAiDocsServer<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined> {
-    readonly configuration: AiDocsConfigurationManager;
-    readonly runtime: ManagedAiDocsRuntime<TIdentity>;
-    readonly fetch: ManagedAiDocsFetchHandlers<TNativeContext>;
-    readonly telemetry?: AiDocsTelemetryStore;
+interface ManagedAiAppAssistantServer<TIdentity extends AiAppAssistantRuntimeIdentity, TNativeContext = undefined> {
+    readonly configuration: AiAppAssistantConfigurationManager;
+    readonly runtime: ManagedAiAppAssistantRuntime<TIdentity>;
+    readonly fetch: ManagedAiAppAssistantFetchHandlers<TNativeContext>;
+    readonly telemetry?: AiAppAssistantTelemetryStore;
     initialize(): Promise<void>;
     setDocuments(documents: DocumentationSource[]): Promise<void>;
     dispose(): void;
@@ -528,6 +533,6 @@ interface ManagedAiDocsServer<TIdentity extends AiDocsRuntimeIdentity, TNativeCo
  * Framework integrations only need to adapt their native request/response and
  * pass the authenticated application identity through `http.resolveIdentity`.
  */
-declare function createManagedAiDocsServer<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined>(options: CreateManagedAiDocsServerOptions<TIdentity, TNativeContext>): ManagedAiDocsServer<TIdentity, TNativeContext>;
+declare function createManagedAiAppAssistantServer<TIdentity extends AiAppAssistantRuntimeIdentity, TNativeContext = undefined>(options: CreateManagedAiAppAssistantServerOptions<TIdentity, TNativeContext>): ManagedAiAppAssistantServer<TIdentity, TNativeContext>;
 
-export { createManagedAiDocsRuntime as $, type AiDocsConfiguration as A, type BuiltInProvider as B, type AiDocsRedisClient as C, type DocsAssistant as D, type AiDocsRedisQuotaClient as E, type AiDocsRedisTelemetryClient as F, type AiDocsRuntimeIdentity as G, type AiDocsSecretProtector as H, type AiDocsTelemetryStore as I, type AiDocsTelemetrySummary as J, AiModelDiscoveryError as K, type AiModelInfo as L, type ManagedAiDocsServer as M, type AiProviderInfo as N, type CreateAiDocsConfigurationRepositoryOptions as O, type CreateManagedAiDocsRuntimeOptions as P, type CreateManagedAiDocsServerOptions as Q, type ListAiModelsOptions as R, type ManagedAiDocsFetchHandlerOptions as S, type ManagedAiDocsFetchHandlers as T, type ManagedAiDocsRuntime as U, createAes256GcmSecretProtector as V, createAiDocsConfigurationRepository as W, createAiDocsFailureEvent as X, createDisabledSecretProtector as Y, createDocsAssistant as Z, createManagedAiDocsFetchHandlers as _, type DocsAssistantStreamEvent as a, createManagedAiDocsServer as a0, createMemoryAiDocsQuotaStore as a1, createMemoryAiDocsStore as a2, createMemoryAiDocsTelemetryStore as a3, createPollingAiDocsConfigurationSynchronizer as a4, createRedisAiDocsQuotaStore as a5, createRedisAiDocsStore as a6, createRedisAiDocsTelemetryStore as a7, listAiModels as a8, listAiProviders as a9, validateAndSaveAiDocsConfiguration as aa, type AiDocsAccessRule as b, type AiDocsConfigurationActor as c, type AiDocsConfigurationAdministration as d, type AiDocsConfigurationAuditChange as e, type AiDocsConfigurationAuditEntry as f, type AiDocsConfigurationAuditField as g, type AiDocsConfigurationChangeEvent as h, AiDocsConfigurationConflictError as i, AiDocsConfigurationManager as j, type AiDocsConfigurationManagerOptions as k, type AiDocsConfigurationRepository as l, type AiDocsConfigurationSaveResult as m, type AiDocsConfigurationSynchronizer as n, type AiDocsConfigurationView as o, type AiDocsGenerationEvent as p, type AiDocsGenerationOperation as q, type AiDocsKeyValueStore as r, type AiDocsManagedConfigurationSetup as s, type AiDocsManagedStorage as t, AiDocsManagementError as u, type AiDocsManagementErrorCode as v, type AiDocsQuotaPolicy as w, type AiDocsQuotaResult as x, type AiDocsQuotaStore as y, type AiDocsRecentFailure as z };
+export { createManagedAiAppAssistantRuntime as $, type AiAppAssistant as A, type BuiltInProvider as B, type AiAppAssistantRecentFailure as C, type AiAppAssistantRedisClient as D, type AiAppAssistantRedisQuotaClient as E, type AiAppAssistantRedisTelemetryClient as F, type AiAppAssistantRuntimeIdentity as G, type AiAppAssistantSecretProtector as H, type AiAppAssistantTelemetryStore as I, type AiAppAssistantTelemetrySummary as J, AiModelDiscoveryError as K, type AiModelInfo as L, type ManagedAiAppAssistantServer as M, type AiProviderInfo as N, type CreateAiAppAssistantConfigurationRepositoryOptions as O, type CreateManagedAiAppAssistantRuntimeOptions as P, type CreateManagedAiAppAssistantServerOptions as Q, type ListAiModelsOptions as R, type ManagedAiAppAssistantFetchHandlerOptions as S, type ManagedAiAppAssistantFetchHandlers as T, type ManagedAiAppAssistantRuntime as U, createAes256GcmSecretProtector as V, createAiAppAssistant as W, createAiAppAssistantConfigurationRepository as X, createAiAppAssistantFailureEvent as Y, createDisabledSecretProtector as Z, createManagedAiAppAssistantFetchHandlers as _, type AiAppAssistantStreamEvent as a, createManagedAiAppAssistantServer as a0, createMemoryAiAppAssistantQuotaStore as a1, createMemoryAiAppAssistantStore as a2, createMemoryAiAppAssistantTelemetryStore as a3, createPollingAiAppAssistantConfigurationSynchronizer as a4, createRedisAiAppAssistantQuotaStore as a5, createRedisAiAppAssistantStore as a6, createRedisAiAppAssistantTelemetryStore as a7, listAiModels as a8, listAiProviders as a9, validateAndSaveAiAppAssistantConfiguration as aa, type AiAppAssistantConfiguration as b, type AiAppAssistantAccessRule as c, type AiAppAssistantConfigurationActor as d, type AiAppAssistantConfigurationAdministration as e, type AiAppAssistantConfigurationAuditChange as f, type AiAppAssistantConfigurationAuditEntry as g, type AiAppAssistantConfigurationAuditField as h, type AiAppAssistantConfigurationChangeEvent as i, AiAppAssistantConfigurationConflictError as j, AiAppAssistantConfigurationManager as k, type AiAppAssistantConfigurationManagerOptions as l, type AiAppAssistantConfigurationRepository as m, type AiAppAssistantConfigurationSaveResult as n, type AiAppAssistantConfigurationSynchronizer as o, type AiAppAssistantConfigurationView as p, type AiAppAssistantGenerationEvent as q, type AiAppAssistantGenerationOperation as r, type AiAppAssistantKeyValueStore as s, type AiAppAssistantManagedConfigurationSetup as t, type AiAppAssistantManagedStorage as u, AiAppAssistantManagementError as v, type AiAppAssistantManagementErrorCode as w, type AiAppAssistantQuotaPolicy as x, type AiAppAssistantQuotaResult as y, type AiAppAssistantQuotaStore as z };