@dyrected/core 2.11.0 → 2.13.0

package/dist/server.d.ts

@@ -1,160 +1,17 @@
-import * as hono_types from 'hono/types';
+import { J as DyrectedContext, D as DyrectedConfig, C as CollectionConfig, G as GlobalConfig, bf as DatabaseAdapter, b as AuthenticatedUser, bt as DyrectedAIContext, al as AIThread, ah as AIMessage, ck as RAGSearchResult, ak as AIRateLimitStore, aj as AIRateLimitResult } from './app-D_ODsBWA.js';
+export { cV as DyrectedObservabilityRuntime, cW as RequestBodyCapture, cX as RequestTraceContext, cY as ResolvedObservabilityConfig, cZ as attachRequestMetrics, c_ as bindObservabilityRuntime, c$ as buildRequestLogger, d0 as captureRequestBody, d1 as createDyrectedApp, d2 as createObservabilityRuntime, d3 as createRequestSpan, d4 as endRequestSpan, d5 as getConfigLogger, d6 as getObservabilityRuntime, d7 as getRequestLogger, d8 as redactBody, d9 as redactHeaders, da as renderPrometheusMetrics, db as resolveObservabilityConfig, dc as shouldSampleRequest } from './app-D_ODsBWA.js';
 import * as hono from 'hono';
-import { Context, Hono } from 'hono';
-import { Logger } from 'pino';
-import { D as DyrectedConfig, b5 as DyrectedObservabilityConfig, C as CollectionConfig, G as GlobalConfig } from './app-config-6U_Kum-Z.js';
-import { JWTPayload } from 'jose';
-import { Tracer, Counter, Attributes, Histogram, Span } from '@opentelemetry/api';
-import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
+import { Hono, Context, Next } from 'hono';
 import * as hono_utils_types from 'hono/utils/types';
 import * as hono_utils_http_status from 'hono/utils/http-status';
+import { LanguageModel, EmbeddingModel } from 'ai';
+import 'hono/types';
+import 'pino';
 import 'lucide-react';
-
-interface CollectionTokenPayload extends JWTPayload {
-    sub: string;
-    email: string;
-    collection: string;
-    sid?: string;
-    purpose?: 'invite' | 'reset';
-    providerId?: string;
-    authSource?: 'local' | 'external';
-}
-
-type RequestVars = DyrectedContext["Variables"];
-interface ResolvedObservabilityConfig {
-    requestLogging: {
-        enabled: boolean;
-        logBodies: boolean;
-        maxBodyBytes: number;
-        redactPaths: string[];
-        includeHeaders: string[];
-        redactHeaders: string[];
-    };
-    sampling: {
-        successRate: number;
-        traceSuccessRate: number;
-        bodySuccessRate: number;
-        alwaysKeep4xx: boolean;
-        alwaysKeep5xx: boolean;
-    };
-    tracing: {
-        enabled: boolean;
-        serviceName: string;
-        exporter: "otlp" | "console" | "none";
-        headers: Record<string, string>;
-        endpoint?: string;
-    };
-    metrics: {
-        enabled: boolean;
-        exporter: "otlp" | "prometheus" | "none";
-        endpoint?: string;
-        path: string;
-    };
-    transports: {
-        targets: Array<{
-            type: "stdout";
-        } | {
-            type: "stderr";
-        } | {
-            type: "file";
-            path: string;
-        } | {
-            type: "otlp";
-            endpoint: string;
-            headers?: Record<string, string>;
-        }>;
-    };
-}
-interface RequestTraceContext {
-    span: Span;
-    traceId: string;
-    spanId: string;
-    sampled: boolean;
-}
-interface RequestBodyCapture {
-    attempted: boolean;
-    contentType?: string;
-    contentLength?: number;
-    truncated?: boolean;
-    parseFailed?: boolean;
-    body?: unknown;
-}
-interface MetricsRuntime {
-    requestCount: Counter<Attributes>;
-    authFailureCount: Counter<Attributes>;
-    uncaughtErrorCount: Counter<Attributes>;
-    auditWriteFailureCount: Counter<Attributes>;
-    emailSendFailureCount: Counter<Attributes>;
-    workflowHookFailureCount: Counter<Attributes>;
-    requestDuration: Histogram<Attributes>;
-}
-interface DyrectedObservabilityRuntime {
-    logger: Logger;
-    config: ResolvedObservabilityConfig;
-    tracer?: Tracer;
-    metrics?: MetricsRuntime;
-    prometheusExporter?: PrometheusExporter;
-    shutdown: () => Promise<void>;
-    recordAuthFailure: (attributes?: Attributes) => void;
-    recordUncaughtError: (attributes?: Attributes) => void;
-    recordAuditWriteFailure: (attributes?: Attributes) => void;
-    recordEmailSendFailure: (attributes?: Attributes) => void;
-    recordWorkflowHookFailure: (attributes?: Attributes) => void;
-}
-declare function resolveObservabilityConfig(config?: DyrectedObservabilityConfig): ResolvedObservabilityConfig;
-declare function createObservabilityRuntime(config: DyrectedConfig): DyrectedObservabilityRuntime;
-declare function bindObservabilityRuntime(config: DyrectedConfig, runtime: DyrectedObservabilityRuntime): void;
-declare function getObservabilityRuntime(config: Pick<DyrectedConfig, "logger"> | undefined): DyrectedObservabilityRuntime | undefined;
-declare function getConfigLogger(config: Pick<DyrectedConfig, "logger"> | undefined, component: string): Logger;
-declare function getRequestLogger(c: Context<DyrectedContext>, component?: string): Logger;
-declare function buildRequestLogger(runtime: DyrectedObservabilityRuntime, vars: RequestVars, requestId?: string): Logger;
-declare function shouldSampleRequest(requestId: string | undefined, statusCode: number, sampling: ResolvedObservabilityConfig["sampling"], kind: "log" | "trace" | "body"): boolean;
-declare function redactHeaders(headers: Record<string, string>, observability: ResolvedObservabilityConfig): Record<string, string>;
-declare function captureRequestBody(request: Request, observability: ResolvedObservabilityConfig): Promise<RequestBodyCapture>;
-declare function redactBody(value: unknown, redactPaths: string[]): unknown;
-declare function createRequestSpan(runtime: DyrectedObservabilityRuntime, name: string, attributes: Attributes): RequestTraceContext | undefined;
-declare function endRequestSpan(requestTrace: RequestTraceContext | undefined, statusCode: number, error?: unknown): void;
-declare function attachRequestMetrics(runtime: DyrectedObservabilityRuntime, args: {
-    method: string;
-    route: string;
-    statusCode: number;
-    durationMs: number;
-}): void;
-declare function renderPrometheusMetrics(exporter: PrometheusExporter): Promise<{
-    body: string;
-    headers: Record<string, string>;
-    statusCode: number;
-}>;
-
-interface DyrectedContext {
-    Variables: {
-        config: DyrectedConfig;
-        logger?: Logger;
-        observability?: DyrectedObservabilityRuntime;
-        siteId?: string;
-        workspaceId?: string;
-        requestBodyCapture?: RequestBodyCapture;
-        requestTrace?: RequestTraceContext;
-        /**
-         * The authenticated user set by requireAuth() or optionalAuth() middleware.
-         * Hydrated from the full user record (minus password) when a db adapter is
-         * configured, so collection fields like `roles` are available; falls back to
-         * the token's identity claims otherwise.
-         */
-        user?: {
-            sub: string;
-            email?: string;
-            collection: string;
-            [key: string]: any;
-        };
-        clientIp?: string;
-        authTokenPayload?: CollectionTokenPayload;
-    };
-}
-/**
- * Create the main Dyrected Hono application.
- */
-declare function createDyrectedApp(rawConfig: DyrectedConfig | any): Promise<Hono<DyrectedContext, hono_types.BlankSchema, "/">>;
+import 'zod';
+import 'jose';
+import '@opentelemetry/api';
+import '@opentelemetry/exporter-prometheus';
 
 declare function serializeDetailForApi(detail?: any): any;
 /**
@@ -311,76 +168,16 @@ declare class AuthController {
 declare class CollectionController {
     private collection;
     constructor(collection: CollectionConfig);
+    private checkTenantAccess;
     private getDelegatedProvider;
     private toHookRequestContext;
     private sanitizeDoc;
     private evaluateAccess;
-    find(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        docs: {
-            id: string;
-            externalSubject: string;
-            email: string;
-            name?: string | undefined;
-            roles: string[];
-            siteAccess?: string[] | undefined;
-            status?: "active" | "pending" | undefined;
-        }[];
-        totalDocs: number;
-        limit: number;
-        page: number;
-        totalPages: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">) | (Response & hono.TypedResponse<{
-        docs: {
-            [x: string]: any;
-        }[];
-        total: number;
-        limit: number;
-        page: number;
-        totalPages: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
-    findOne(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<any, hono_utils_http_status.ContentfulStatusCode, "json">>;
-    create(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 413 | 415, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">) | (Response & hono.TypedResponse<{
-        [x: string]: hono_utils_types.JSONValue;
-    }, 201, "json">) | (Response & hono.TypedResponse<{
-        id: string;
-        externalSubject: string;
-        email: string;
-        name?: string | undefined;
-        roles: string[];
-        siteAccess?: string[] | undefined;
-        status?: "active" | "pending" | undefined;
-    }, 201, "json">)>;
-    upload(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 413 | 415, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">) | (Response & hono.TypedResponse<{
-        [x: string]: hono_utils_types.JSONValue;
-    }, 201, "json">)>;
-    update(c: Context<DyrectedContext>): Promise<Response>;
+    find(c: Context<DyrectedContext>): Promise<any>;
+    findOne(c: Context<DyrectedContext>): Promise<any>;
+    create(c: Context<DyrectedContext>): Promise<any>;
+    upload(c: Context<DyrectedContext>): Promise<any>;
+    update(c: Context<DyrectedContext>): Promise<any>;
     /**
      * Core update pipeline shared by PATCH requests and operational actions:
      * auth-field stripping, timestamps, access enforcement, field write access,
@@ -394,59 +191,9 @@ declare class CollectionController {
      * and every write flows through the standard update pipeline so the
      * collection's lifecycle hooks and audit trail still apply.
      */
-    runViewAction(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 404, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">) | (Response & hono.TypedResponse<never, any, "json">) | (Response & hono.TypedResponse<hono_utils_types.JSONValue, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-        updated: number;
-        failed: number;
-        results: {
-            id: string;
-            ok: boolean;
-            status?: number | undefined;
-            doc?: hono_utils_types.JSONValue | undefined;
-            error?: hono_utils_types.JSONValue | undefined;
-        }[];
-    }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
-    transition(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 404, "json">) | (Response & hono.TypedResponse<{
-        [x: string]: any;
-        id: string;
-    } | null, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 400, "json">)>;
-    workflowHistory(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        docs: {
-            [x: string]: any;
-        }[];
-        total: number;
-        limit: number;
-        page: number;
-        totalPages: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 404, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">)>;
+    runViewAction(c: Context<DyrectedContext>): Promise<any>;
+    transition(c: Context<DyrectedContext>): Promise<any>;
+    workflowHistory(c: Context<DyrectedContext>): Promise<any>;
     /**
      * POST /api/collections/:slug/:id/change-password
      *
@@ -458,69 +205,21 @@ declare class CollectionController {
      *  - Non-admin callers MUST provide a valid oldPassword.
      *  - newPassword and confirmPassword must match.
      */
-    changePassword(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 401, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 403, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 404, "json">) | (Response & hono.TypedResponse<{
-        success: true;
-        message: string;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
-    delete(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
-        message: string;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
-    deleteMany(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        failed?: {
-            id: string;
-            error: string;
-        }[] | undefined;
-        message: string;
-        deleted: string[];
-    }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
+    changePassword(c: Context<DyrectedContext>): Promise<any>;
+    delete(c: Context<DyrectedContext>): Promise<any>;
+    deleteMany(c: Context<DyrectedContext>): Promise<any>;
     seed(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
         message: string;
     }, hono_utils_http_status.ContentfulStatusCode, "json">>;
-    aggregate(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<{
-        [x: string]: any;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
+    aggregate(c: Context<DyrectedContext>): Promise<any>;
 }
 
 declare class GlobalController {
     private global;
     constructor(global: GlobalConfig);
-    get(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        [x: string]: hono_utils_types.JSONValue;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">)>;
-    update(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
-        [x: string]: hono_utils_types.JSONValue;
-    }, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
-        message: string;
-    }, 500, "json">) | (Response & hono.TypedResponse<{
-        error: true;
-        message: string;
-    }, 403, "json">)>;
+    private checkTenantAccess;
+    get(c: Context<DyrectedContext>): Promise<any>;
+    update(c: Context<DyrectedContext>): Promise<any>;
     seed(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
         message: string;
     }, hono_utils_http_status.ContentfulStatusCode, "json">>;
@@ -540,6 +239,18 @@ declare class MediaController {
         [x: string]: any;
         id: string;
     }, 201, "json">)>;
+    replace(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
+        message: string;
+    }, 500, "json">) | (Response & hono.TypedResponse<{
+        message: string;
+    }, 400, "json">) | (Response & hono.TypedResponse<{
+        message: string;
+    }, 404, "json">) | (Response & hono.TypedResponse<{
+        message: string;
+    }, 413 | 415, "json">) | (Response & hono.TypedResponse<{
+        [x: string]: any;
+        id: string;
+    }, 200, "json">)>;
     find(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
         docs: {
             [x: string]: any;
@@ -560,7 +271,7 @@ declare class MediaController {
         message: string;
     }, 404, "json">) | (Response & hono.TypedResponse<{
         message: string;
-    }, 400, "json">) | (Response & hono.TypedResponse<any, hono_utils_http_status.ContentfulStatusCode, "body">)>;
+    }, 400, "json">) | (Response & hono.TypedResponse<undefined, 302, "redirect">) | (Response & hono.TypedResponse<any, hono_utils_http_status.ContentfulStatusCode, "body">)>;
 }
 
 declare class PreviewController {
@@ -598,4 +309,335 @@ declare class PreviewController {
     }, 401, "json">)>;
 }
 
-export { AuthController, CollectionController, type DyrectedContext, type DyrectedObservabilityRuntime, GlobalController, MediaController, PreviewController, type RequestBodyCapture, type RequestTraceContext, type ResolvedObservabilityConfig, attachRequestMetrics, bindObservabilityRuntime, buildRequestLogger, captureRequestBody, createDyrectedApp, createObservabilityRuntime, createRequestSpan, endRequestSpan, getConfigLogger, getObservabilityRuntime, getRequestLogger, redactBody, redactHeaders, registerRoutes, renderPrometheusMetrics, resolveObservabilityConfig, serializeDetailForApi, serializeViewForApi, shouldSampleRequest };
+declare class AIController {
+    private config;
+    constructor(config: DyrectedConfig);
+    private getAgent;
+    chat(c: Context<DyrectedContext>): Promise<Response>;
+    createThread(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        thread: {
+            [x: string]: hono_utils_types.JSONValue;
+            id: string;
+            projectId: string;
+            userId: string;
+            title?: string | undefined;
+            summary?: string | undefined;
+            createdAt: string;
+            updatedAt: string;
+        };
+    }, 201, "json">>;
+    listThreads(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        threads: {
+            [x: string]: hono_utils_types.JSONValue;
+            id: string;
+            projectId: string;
+            userId: string;
+            title?: string | undefined;
+            summary?: string | undefined;
+            createdAt: string;
+            updatedAt: string;
+        }[];
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    getThread(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        thread: {
+            [x: string]: hono_utils_types.JSONValue;
+            id: string;
+            projectId: string;
+            userId: string;
+            title?: string | undefined;
+            summary?: string | undefined;
+            createdAt: string;
+            updatedAt: string;
+        };
+        messages: {
+            [x: string]: hono_utils_types.JSONValue;
+            id: string;
+            threadId: string;
+            role: "user" | "assistant" | "system";
+            content: string;
+            parts?: any[] | undefined;
+            createdAt: string;
+            metadata?: {
+                [x: string]: hono_utils_types.JSONValue;
+            } | undefined;
+        }[];
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    postMessage(c: Context<DyrectedContext>): Promise<Response>;
+    deleteThread(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        success: true;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    clearThreads(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        success: true;
+        count: number;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    reindex(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        success: true;
+        collections: {
+            collection: string;
+            totalDocs: number;
+            indexedChunks: number;
+        }[];
+        totalChunks: number;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    searchRAG(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        query: string;
+        resultsCount: number;
+        sources: {
+            id: string;
+            collection: string;
+            documentId: string;
+            title: string;
+            field: string;
+            score: number;
+            text: string;
+            url: string;
+            metadata?: {
+                [x: string]: hono_utils_types.JSONValue;
+            } | undefined;
+        }[];
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    getAction(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        action: {
+            [x: string]: any;
+            id: string;
+        };
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+    executeAction(c: Context<DyrectedContext>): Promise<(Response & hono.TypedResponse<{
+        success: true;
+        message: string;
+        action: {
+            [x: string]: any;
+            id: string;
+        };
+    }, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
+        success: true;
+        action: {
+            [x: string]: any;
+            id: string;
+        };
+        result: any;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
+    rejectAction(c: Context<DyrectedContext>): Promise<Response & hono.TypedResponse<{
+        success: true;
+        action: {
+            [x: string]: any;
+            id: string;
+        };
+    }, hono_utils_http_status.ContentfulStatusCode, "json">>;
+}
+
+declare function getAIModel(config?: DyrectedConfig): LanguageModel;
+declare function formatAIErrorMessage(error: any): string;
+declare function buildDyrectedSystemPrompt(context: DyrectedAIContext): string;
+interface AIAgentOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    projectId: string;
+    userId: string;
+    userName?: string;
+    userRole?: string;
+    user?: AuthenticatedUser;
+}
+declare class AIAgent {
+    private db;
+    private config;
+    private projectId;
+    private userId;
+    private userName?;
+    private userRole?;
+    private user?;
+    private contextCache;
+    constructor(options: AIAgentOptions);
+    getContext(): Promise<DyrectedAIContext>;
+    getThread(threadId: string): Promise<AIThread | null>;
+    updateThreadTitle(threadId: string, title: string): Promise<void>;
+    createThread(title?: string, id?: string): Promise<AIThread>;
+    getOrCreateThread(threadId?: string, title?: string): Promise<AIThread>;
+    listThreads(limit?: number): Promise<AIThread[]>;
+    deleteThread(threadId: string): Promise<boolean>;
+    clearAllThreads(): Promise<number>;
+    getMessages(threadId: string): Promise<AIMessage[]>;
+    persistUserMessage(threadId: string, content: string): Promise<AIMessage>;
+    persistAssistantMessage(threadId: string, content: string, metadata?: Record<string, unknown>, parts?: any[]): Promise<AIMessage>;
+    generateTitle(userMessage: string): Promise<string>;
+    compactMessages(messages: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>): Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>;
+    streamReply(threadId: string, userMessage: string): AsyncGenerator<string, {
+        text: string;
+        usage?: any;
+        finishReason: string;
+    }, void>;
+    createStreamResponse(threadId: string, userMessage: string, clientMessages?: any[], abortSignal?: AbortSignal, requestId?: string): Promise<Response>;
+}
+
+declare function validatePayloadAgainstFields(fields: Array<{
+    name: string;
+    type: string;
+    required?: boolean;
+}>, data: Record<string, unknown>, isPartial?: boolean): {
+    valid: boolean;
+    error?: string;
+};
+declare function createDyrectedAITools({ db, config, user, projectId, }: {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    user?: AuthenticatedUser;
+    projectId: string;
+}): Record<string, any>;
+
+interface IndexDocumentOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    collection: string;
+    doc: Record<string, unknown>;
+    projectId: string;
+    force?: boolean;
+}
+interface DeleteDocumentChunksOptions {
+    db: DatabaseAdapter;
+    collection: string;
+    documentId: string;
+    projectId: string;
+}
+interface ReindexCollectionOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    collection: string;
+    projectId: string;
+    force?: boolean;
+}
+interface ReindexAllOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    projectId: string;
+    force?: boolean;
+}
+interface RAGSearchOptions {
+    db: DatabaseAdapter;
+    config: DyrectedConfig;
+    query: string;
+    projectId: string;
+    collections?: string[];
+    limit?: number;
+    minScore?: number;
+    user?: AuthenticatedUser;
+}
+declare class RAGService {
+    private static embeddingServiceCache;
+    private static getEmbeddingService;
+    /**
+     * Determines whether RAG indexing is enabled for a given collection.
+     */
+    static isCollectionRAGEnabled(config: DyrectedConfig, col: CollectionConfig): boolean;
+    /**
+     * Indexes a single document's text fields into `_dyrected_ai_chunks`.
+     */
+    static indexDocument(options: IndexDocumentOptions): Promise<{
+        indexed: number;
+        skipped: number;
+    }>;
+    /**
+     * Deletes all vector chunks associated with a specific document.
+     */
+    static deleteDocumentChunks(options: DeleteDocumentChunksOptions): Promise<number>;
+    /**
+     * Reindexes all documents in a specific collection.
+     */
+    static reindexCollection(options: ReindexCollectionOptions): Promise<{
+        collection: string;
+        totalDocs: number;
+        indexedChunks: number;
+    }>;
+    /**
+     * Reindexes all RAG-enabled collections across the project.
+     */
+    static reindexAll(options: ReindexAllOptions): Promise<{
+        collections: Array<{
+            collection: string;
+            totalDocs: number;
+            indexedChunks: number;
+        }>;
+        totalChunks: number;
+    }>;
+    /**
+     * Performs semantic vector search over project chunks with access filtering.
+     */
+    static search(options: RAGSearchOptions): Promise<{
+        query: string;
+        resultsCount: number;
+        sources: RAGSearchResult[];
+    }>;
+}
+
+/**
+ * Content normalizer for Dyrected CMS fields before chunking and embedding.
+ * Converts raw rich-text ASTs (Lexical, Slate, TipTap, custom blocks), HTML,
+ * JSON objects, and arrays into clean, structured Markdown.
+ */
+/**
+ * Normalizes an unknown field value into clean Markdown/text.
+ */
+declare function normalizeFieldValue(value: unknown, _fieldType?: string): string;
+/**
+ * Extracts searchable text from target fields of a document.
+ */
+declare function extractTextFromDoc(doc: Record<string, unknown>, targetFields?: string[]): Array<{
+    field: string;
+    text: string;
+}>;
+
+interface ChunkOptions {
+    /** Maximum target characters per chunk. Defaults to 1500 (~375-500 tokens). */
+    maxChunkSize?: number;
+    /** Overlap in characters between consecutive chunks. Defaults to 150. */
+    chunkOverlap?: number;
+    /** Hierarchy of string separators for recursive splitting. */
+    separators?: string[];
+}
+interface ChunkResult {
+    text: string;
+    tokenCount: number;
+    index: number;
+}
+/**
+ * Computes a fast, collision-resistant 53-bit hex hash of a string.
+ * 100% isomorphic and pure JavaScript (safe across Node.js, Vite, Nuxt, and browsers).
+ */
+declare function hashContent(content: string, seed?: number): string;
+/**
+ * Estimates token count based on standard ~4 characters per token heuristic.
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Recursively splits a text into coherent chunks with overlap.
+ */
+declare function chunkText(text: string, options?: ChunkOptions): ChunkResult[];
+
+declare function getEmbeddingModel(config?: DyrectedConfig): EmbeddingModel;
+declare class EmbeddingService {
+    private config?;
+    private model;
+    constructor(config?: DyrectedConfig);
+    embedText(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+/**
+ * Computes cosine similarity between two float vector arrays.
+ * Returns a value between -1.0 and 1.0 (typically 0.0 to 1.0 for normalized text embeddings).
+ */
+declare function cosineSimilarity(a: number[], b: number[]): number;
+
+declare class InMemoryRateLimitStore implements AIRateLimitStore {
+    private windows;
+    constructor();
+    consume(key: string, limit: number, windowMs: number): Promise<AIRateLimitResult>;
+    clear(): void;
+}
+declare function aiRateLimit(config?: DyrectedConfig): (c: Context<DyrectedContext>, next: Next) => Promise<void>;
+
+export { AIAgent, type AIAgentOptions, AIController, AuthController, type ChunkOptions, type ChunkResult, CollectionController, type DeleteDocumentChunksOptions, DyrectedContext, EmbeddingService, GlobalController, InMemoryRateLimitStore, type IndexDocumentOptions, MediaController, PreviewController, type RAGSearchOptions, RAGService, type ReindexAllOptions, type ReindexCollectionOptions, aiRateLimit, buildDyrectedSystemPrompt, chunkText, cosineSimilarity, createDyrectedAITools, estimateTokens, extractTextFromDoc, formatAIErrorMessage, getAIModel, getEmbeddingModel, hashContent, normalizeFieldValue, registerRoutes, serializeDetailForApi, serializeViewForApi, validatePayloadAgainstFields };