@123toto/ai-app-assistant-server 0.1.0

package/dist/managed-server-7iurKxF1.d.cts

@@ -0,0 +1,533 @@
+import { a as DocsAssistantOptions, d as AiSdkConnectionTestResult, e as AiSdkFailureCode, D as DocumentationSource, A as AnswerGenerator } from './ai-sdk-QImICd56.cjs';
+import { AskDocumentationResponse, AskDocumentationRequest, AiDocsConnectionTestInput, AiDocsConnectionResult, AiDocsCredentials, AiDocsConfigurationInput, AiDocsManagedConfigurationView, TokenUsage } from '@123toto/ai-app-assistant-contracts';
+
+type DocsAssistantStreamEvent = {
+    type: "status";
+    phase: "preparing" | "generating";
+} | {
+    type: "partial";
+    text: string;
+} | {
+    type: "retry";
+    attempt: number;
+    maxRetries: number;
+    delayMs: number;
+} | {
+    type: "complete";
+    response: AskDocumentationResponse;
+};
+/** Stateful facade whose static documentation is prepared only once. */
+interface DocsAssistant {
+    answer(request: AskDocumentationRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<AskDocumentationResponse>;
+    /** Streams provider-neutral progress and always ends with a complete event. */
+    stream(request: AskDocumentationRequest, options?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<DocsAssistantStreamEvent, AskDocumentationResponse>;
+}
+/**
+ * Creates a provider-neutral documentation assistant.
+ *
+ * Documents are serialized, bounded and deduplicated during this call. Each
+ * subsequent question only adds the current page HTML, an optional selected
+ * 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;
+
+/** Providers available without installing an additional AI SDK package. */
+type BuiltInProvider = "anthropic" | "google" | "mistral" | "ollama" | "openai";
+/** Stable provider metadata suitable for a settings interface. */
+interface AiProviderInfo {
+    id: BuiltInProvider;
+    label: string;
+    requiresApiKey: boolean;
+    supportsModelDiscovery: boolean;
+}
+/** Provider-neutral model metadata returned by discovery endpoints. */
+interface AiModelInfo {
+    id: string;
+    provider: BuiltInProvider;
+    label?: string;
+    createdAt?: string;
+}
+/** Credentials and transport options used only by the host backend. */
+interface ListAiModelsOptions {
+    provider: BuiltInProvider;
+    apiKey?: string;
+    baseURL?: string;
+    signal?: AbortSignal;
+    fetch?: typeof fetch;
+}
+/** Returns a copy so consumers cannot mutate the library's provider registry. */
+declare function listAiProviders(): AiProviderInfo[];
+/**
+ * Discovers models with the provider's own API.
+ *
+ * The API key is used only for this backend request. It is never included in
+ * the returned metadata or in an error message.
+ */
+declare function listAiModels(options: ListAiModelsOptions): Promise<AiModelInfo[]>;
+/** Safe discovery error that deliberately excludes provider response bodies. */
+declare class AiModelDiscoveryError extends Error {
+    readonly provider: BuiltInProvider;
+    readonly status: number;
+    constructor(provider: BuiltInProvider, status: number);
+}
+
+/** Generic access rule; host applications map their own roles and user IDs. */
+type AiDocsAccessRule = {
+    mode: "all";
+} | {
+    mode: "roles";
+    roles: string[];
+} | {
+    mode: "users";
+    userIds: string[];
+};
+/** Stable identity used for ownership and audit without coupling the library to a user directory. */
+interface AiDocsConfigurationActor {
+    id: string;
+    label: string;
+}
+type AiDocsConfigurationAuditField = "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;
+    from?: string;
+    to?: string;
+}
+interface AiDocsConfigurationAuditEntry {
+    id: string;
+    actor: AiDocsConfigurationActor;
+    changedAt: string;
+    changes: AiDocsConfigurationAuditChange[];
+}
+/** Ownership and persisted audit metadata managed by the host application's authenticated backend. */
+interface AiDocsConfigurationAdministration {
+    keyCreatedBy?: AiDocsConfigurationActor;
+    keyCreatedAt?: string;
+    modelUpdatedBy?: AiDocsConfigurationActor;
+    modelUpdatedAt?: string;
+    allowModelChangesByOthers: boolean;
+    history: AiDocsConfigurationAuditEntry[];
+}
+/** Provider configuration owned by the library and persisted by an adapter. */
+interface AiDocsConfiguration {
+    provider: BuiltInProvider;
+    model: string;
+    /** Whether provider fields override deployment defaults or merely accompany stored policies. */
+    connectionSource?: "environment" | "override";
+    apiKey?: string;
+    baseURL?: string;
+    access: AiDocsAccessRule;
+    quota?: {
+        maxRequests: number;
+        windowSeconds: number;
+    };
+    /** Maximum number of user questions kept in one assistant conversation. */
+    maxConversationTurns?: number;
+    administration?: AiDocsConfigurationAdministration;
+}
+/** Safe representation returned to a frontend; it never contains the secret. */
+type AiDocsConfigurationView = Omit<AiDocsConfiguration, "apiKey"> & {
+    apiKeyConfigured: boolean;
+};
+/** Minimal persistence contract supported by Redis, databases or secret stores. */
+interface AiDocsKeyValueStore {
+    get(key: string): Promise<string | null | undefined>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    /** Optional atomic compare-and-set used to prevent lost concurrent updates. */
+    compareAndSet?(key: string, expected: string | null, value: string): Promise<boolean>;
+}
+/** Secret protection is explicit so plaintext keys can never be persisted. */
+interface AiDocsSecretProtector {
+    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>;
+    /** Atomic when the underlying key/value store supports compare-and-set. */
+    mutate?(update: (current: AiDocsConfiguration | undefined) => AiDocsConfiguration | Promise<AiDocsConfiguration>): Promise<AiDocsConfigurationView>;
+    clear(): Promise<void>;
+}
+interface CreateAiDocsConfigurationRepositoryOptions {
+    store: AiDocsKeyValueStore;
+    secretProtector: AiDocsSecretProtector;
+    /** Allows several applications or environments to share one storage system. */
+    key?: string;
+}
+declare class AiDocsConfigurationConflictError extends Error {
+    constructor();
+}
+/** Creates a repository that validates and encrypts configuration data. */
+declare function createAiDocsConfigurationRepository(options: CreateAiDocsConfigurationRepositoryOptions): AiDocsConfigurationRepository;
+/**
+ * Tests the exact model configuration and persists it only after a successful
+ * structured-output response.
+ */
+declare function validateAndSaveAiDocsConfiguration(repository: AiDocsConfigurationRepository, configuration: AiDocsConfiguration, options?: {
+    timeoutMs?: number;
+}): Promise<{
+    saved: boolean;
+    connection: AiSdkConnectionTestResult;
+    configuration?: AiDocsConfigurationView;
+}>;
+/**
+ * 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;
+/**
+ * Allows environment-only configurations while failing closed if a caller
+ * attempts to persist a secret without configuring encryption.
+ */
+declare function createDisabledSecretProtector(): AiDocsSecretProtector;
+/** Lightweight local store useful for tests and single-process prototypes. */
+declare function createMemoryAiDocsStore(): AiDocsKeyValueStore;
+/** Minimal Redis shape; consumers can pass an existing ioredis-like client. */
+interface AiDocsRedisClient {
+    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?: {
+    prefix?: string;
+}): AiDocsKeyValueStore;
+
+interface AiDocsQuotaPolicy {
+    maxRequests: number;
+    windowSeconds: number;
+}
+interface AiDocsQuotaResult {
+    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>;
+}
+/** Single-process implementation intended for tests and local development. */
+declare function createMemoryAiDocsQuotaStore(): AiDocsQuotaStore;
+/** Minimal ioredis-compatible shape needed for one atomic Lua operation. */
+interface AiDocsRedisQuotaClient {
+    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?: {
+    prefix?: string;
+}): AiDocsQuotaStore;
+
+/** Minimal identity understood by the generic access and audit policies. */
+interface AiDocsRuntimeIdentity extends AiDocsConfigurationActor {
+    roles?: readonly string[];
+}
+interface AiDocsConfigurationChangeEvent {
+    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 AiDocsConfigurationManagerOptions {
+    repository: AiDocsConfigurationRepository;
+    /** Defaults to the local in-memory quota implementation. */
+    quotaStore?: AiDocsQuotaStore;
+    /** Environment or deployment defaults. They are never persisted automatically. */
+    defaultConfiguration?: AiDocsConfiguration | (() => AiDocsConfiguration | undefined);
+    /** Resolves a secret supplied by the host environment or secret manager. */
+    resolveDefaultApiKey?: (provider: AiDocsConfiguration["provider"]) => string | undefined;
+    apiKeyStorageAvailable?: boolean;
+    defaultQuota?: AiDocsQuotaPolicy;
+    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[]>;
+    now?: () => Date;
+    createId?: () => string;
+    logger?: Pick<Console, "info" | "warn">;
+}
+interface AiDocsConfigurationSaveResult {
+    saved: boolean;
+    connection: AiDocsConnectionResult;
+    configuration?: AiDocsManagedConfigurationView;
+    reloadRequired: boolean;
+}
+type AiDocsManagementErrorCode = "unauthorized" | "forbidden" | "conflict" | "invalid_request" | "not_configured" | "quota_reached" | "secret_storage_unavailable";
+/** Framework-neutral policy error that HTTP adapters can map safely. */
+declare class AiDocsManagementError extends Error {
+    readonly status: number;
+    readonly code: AiDocsManagementErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(status: number, code: AiDocsManagementErrorCode, 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 {
+    #private;
+    constructor(options: AiDocsConfigurationManagerOptions);
+    /** 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[]>;
+    /** Notifies the runtime when a provider-affecting setting changes. */
+    subscribe(listener: (event: AiDocsConfigurationChangeEvent) => 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>;
+    /** 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>;
+    /** Removes only the manual key, records the revocation and falls back to defaults. */
+    revokeApiKey(actor: AiDocsRuntimeIdentity): Promise<AiDocsManagedConfigurationView>;
+    /** Resolves persisted policy against deployment defaults, including the secret. */
+    getRuntimeConfiguration(): Promise<AiDocsConfiguration | undefined>;
+    /** Returns the frontend-safe view: secret presence and permissions, never the key. */
+    getView(identity?: AiDocsRuntimeIdentity): Promise<AiDocsManagedConfigurationView>;
+    /** Minimal launcher state used by clients before rendering the assistant. */
+    getAccess(identity: AiDocsRuntimeIdentity): Promise<{
+        available: boolean;
+        maxConversationTurns: number;
+    }>;
+    /** Combines configuration, provider health and application access rules. */
+    canUse(identity: AiDocsRuntimeIdentity): Promise<boolean>;
+    /** Atomically consumes one request from the user's active quota window. */
+    consumeQuota(identity: AiDocsRuntimeIdentity): Promise<AiDocsQuotaResult>;
+    /** Enforces access and quota immediately before any model call. */
+    assertCanAsk(identity: AiDocsRuntimeIdentity): Promise<void>;
+    /** Retries a failed provider lazily, with a shared backoff across requests. */
+    ensureRuntimeConnection(): Promise<boolean>;
+    private applyTestResultToActiveConfiguration;
+    private resolveApiKey;
+    private resolveDefaultApiKey;
+    private defaultConfiguration;
+    /** Resolves stored policy-only data against the current deployment connection. */
+    private effectiveConfiguration;
+    private validateConnectionForSave;
+    private connectionSignature;
+    private lastKnownConnection;
+    private now;
+    private publishAndEmit;
+    private emit;
+}
+/**
+ * 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?: {
+    key?: string;
+    intervalMs?: number;
+}): AiDocsConfigurationSynchronizer;
+
+type AiDocsGenerationOperation = "answer" | "stream";
+interface AiDocsGenerationEventBase {
+    requestId: string;
+    operation: AiDocsGenerationOperation;
+    model: string;
+    durationMs: number;
+    occurredAt: string;
+}
+/** Safe operational event. It deliberately excludes prompts, HTML, users and credentials. */
+type AiDocsGenerationEvent = (AiDocsGenerationEventBase & {
+    outcome: "success";
+    usage?: TokenUsage;
+}) | (AiDocsGenerationEventBase & {
+    outcome: "failure";
+    error: {
+        code: AiSdkFailureCode;
+        message: string;
+        retryable: boolean;
+        attempts: number;
+        providerStatus?: number;
+    };
+});
+interface AiDocsTelemetrySummary {
+    requests: number;
+    succeeded: number;
+    failed: number;
+    durationMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    failuresByCode: Partial<Record<AiSdkFailureCode, number>>;
+}
+type AiDocsRecentFailure = Extract<AiDocsGenerationEvent, {
+    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[]>;
+}
+/** Single-process telemetry intended for tests and local development. */
+declare function createMemoryAiDocsTelemetryStore(options?: {
+    recentFailureLimit?: number;
+}): AiDocsTelemetryStore;
+/** Minimal Redis shape; compatible with ioredis without adding it as a dependency. */
+interface AiDocsRedisTelemetryClient {
+    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?: {
+    prefix?: string;
+    recentFailureLimit?: number;
+}): AiDocsTelemetryStore;
+/** Converts any generator error to the same safe public diagnostic. */
+declare function createAiDocsFailureEvent(input: {
+    error: unknown;
+    requestId: string;
+    operation: AiDocsGenerationOperation;
+    model: string;
+    durationMs: number;
+}): AiDocsRecentFailure;
+
+type AssistantPolicies = NonNullable<DocsAssistantOptions["policies"]>;
+interface CreateManagedAiDocsRuntimeOptions<TIdentity extends AiDocsRuntimeIdentity> {
+    configuration: AiDocsConfigurationManager;
+    documents?: DocumentationSource[];
+    policies?: AssistantPolicies;
+    /** Overrides the built-in `provider:model` AI SDK generator. */
+    createGenerator?: (configuration: {
+        model: string;
+        apiKey?: string;
+        baseURL?: string;
+    }) => 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>;
+    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;
+    /** Optional persistence used by the batteries-included managed server. */
+    telemetryStore?: AiDocsTelemetryStore;
+}
+interface ManagedAiDocsRuntime<TIdentity extends AiDocsRuntimeIdentity> {
+    readonly configuration: AiDocsConfigurationManager;
+    readonly telemetry?: AiDocsTelemetryStore;
+    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>;
+}
+/**
+ * Optional batteries-included runtime. The minimal `createDocsAssistant` API
+ * remains available for applications that want to own the lifecycle.
+ */
+declare function createManagedAiDocsRuntime<TIdentity extends AiDocsRuntimeIdentity>(options: CreateManagedAiDocsRuntimeOptions<TIdentity>): ManagedAiDocsRuntime<TIdentity>;
+
+interface ManagedAiDocsFetchHandlerOptions<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined> {
+    runtime: ManagedAiDocsRuntime<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. */
+    allowAnonymous?: boolean;
+    /** Admin endpoints fail closed when this hook is omitted. */
+    authorizeAdministration?: (identity: TIdentity, request: Request, nativeContext: TNativeContext | undefined) => Promise<void> | void;
+    /** Optional application directory exposed to the generic settings UI. */
+    listUsers?: (identity: TIdentity, nativeContext: TNativeContext | undefined) => Promise<Array<{
+        id: string;
+        label: string;
+    }>>;
+    /** Optional application roles exposed to the generic settings UI. */
+    listRoles?: (identity: TIdentity, nativeContext: TNativeContext | undefined) => Promise<Array<{
+        id: string;
+        label: string;
+    }>> | Array<{
+        id: string;
+        label: string;
+    }>;
+    maxBodyBytes?: number;
+    onError?: (error: unknown, request: Request, nativeContext: TNativeContext | undefined) => Response | Promise<Response>;
+}
+interface ManagedAiDocsFetchHandlers<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>;
+
+type AiDocsManagedStorage = {
+    type: "memory";
+} | {
+    type: "redis";
+    client: AiDocsRedisClient & AiDocsRedisQuotaClient;
+    /** Shared namespace. Defaults to `ai-docs:`. */
+    prefix?: string;
+    synchronizationIntervalMs?: number;
+};
+interface AiDocsManagedConfigurationSetup extends Omit<AiDocsConfigurationManagerOptions, "apiKeyStorageAvailable" | "quotaStore" | "repository" | "synchronizer"> {
+    /** Creates configuration, quota and synchronization adapters automatically. */
+    storage?: AiDocsManagedStorage;
+    /** AES-256-GCM key used to persist administrator-supplied API keys. */
+    encryptionKey?: string;
+    /** Alternative secret manager; takes precedence over encryptionKey. */
+    secretProtector?: AiDocsSecretProtector;
+    repositoryKey?: string;
+    quotaStore?: AiDocsQuotaStore;
+    synchronizer?: AiDocsConfigurationManagerOptions["synchronizer"];
+    apiKeyStorageAvailable?: boolean;
+}
+interface CreateManagedAiDocsServerOptions<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined> {
+    /** Pass an existing manager, or its construction options for the common case. */
+    configuration: AiDocsConfigurationManager | AiDocsConfigurationManagerOptions | AiDocsManagedConfigurationSetup;
+    /** 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">;
+    /** Enabled by default; Redis configuration automatically makes it persistent. */
+    telemetry?: false | {
+        store?: AiDocsTelemetryStore;
+        recentFailureLimit?: number;
+    };
+}
+interface ManagedAiDocsServer<TIdentity extends AiDocsRuntimeIdentity, TNativeContext = undefined> {
+    readonly configuration: AiDocsConfigurationManager;
+    readonly runtime: ManagedAiDocsRuntime<TIdentity>;
+    readonly fetch: ManagedAiDocsFetchHandlers<TNativeContext>;
+    readonly telemetry?: AiDocsTelemetryStore;
+    initialize(): Promise<void>;
+    setDocuments(documents: DocumentationSource[]): Promise<void>;
+    dispose(): void;
+}
+/**
+ * Creates the complete managed assistant: configuration, provider lifecycle,
+ * access, quotas, HTTP routes and late-bound documentation.
+ *
+ * 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>;
+
+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 };