@exulu/backend 1.48.1 → 1.49.0

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import * as _opentelemetry_sdk_node from '@opentelemetry/sdk-node';
 import * as knex from 'knex';
-import { LanguageModel, UIMessage, Tool, streamText } from 'ai';
-import { z } from 'zod';
+import { RedisClientType } from 'redis';
 import * as bullmq from 'bullmq';
 import { Queue } from 'bullmq';
-import { Express, Request } from 'express';
+import { Request, Express } from 'express';
 import { transport } from 'winston';
-import { RedisClientType } from 'redis';
+import { LanguageModel, Tool, UIMessage, streamText } from 'ai';
+import { z } from 'zod';
 import { Tiktoken } from 'tiktoken/lite';
 import models from 'tiktoken/model_to_encoding.json';
 
@@ -31,6 +31,10 @@ type User = {
     };
 };
 
+declare function redisClient(): Promise<{
+    client: RedisClientType | null;
+}>;
+
 type ExuluProviderConfig = {
     name: string;
     instructions: string;
@@ -153,19 +157,61 @@ interface Item {
     [key: string]: any;
 }
 
-interface TestCase {
+declare class ExuluTool {
     id: string;
     name: string;
-    description?: string;
-    inputs: UIMessage[];
-    expected_output: string;
-    expected_tools?: string[];
-    expected_knowledge_sources?: string[];
-    expected_agent_tools?: string[];
-    createdAt: string;
-    updatedAt: string;
+    description: string;
+    category: string;
+    inputSchema?: z.ZodType;
+    type: "context" | "function" | "agent" | "web_search";
+    tool: Tool;
+    config: {
+        name: string;
+        description: string;
+        type: "boolean" | "string" | "number" | "variable";
+        default?: string | boolean | number;
+    }[];
+    constructor({ id, name, description, category, inputSchema, type, execute, config, }: {
+        id: string;
+        name: string;
+        description: string;
+        category?: string;
+        inputSchema?: z.ZodType;
+        type: "context" | "function" | "agent" | "web_search";
+        config: {
+            name: string;
+            description: string;
+            type: "boolean" | "string" | "number" | "variable";
+            default?: string | boolean | number;
+        }[];
+        execute: (inputs: any) => Promise<{
+            result?: string;
+            job?: string;
+            items?: Item[];
+        }> | AsyncGenerator<{
+            result?: string;
+            job?: string;
+            items?: Item[];
+        }>;
+    });
+    execute: ({ agent: agentId, config, user, inputs, project, items, }: {
+        agent: string;
+        config: ExuluConfig;
+        user?: User;
+        inputs: any;
+        project?: string;
+        items?: string[];
+    }) => Promise<any>;
 }
 
+type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown" | "file" | "date" | "uuid";
+
+type allFileTypes = imageTypes | fileTypes | audioTypes | videoTypes;
+type audioTypes = ".mp3" | ".wav" | ".m4a" | ".mp4" | ".mpeg";
+type videoTypes = ".mp4" | ".m4a" | ".mp3" | ".mpeg" | ".wav";
+type imageTypes = ".png" | ".jpg" | ".jpeg" | ".gif" | ".webp";
+type fileTypes = ".pdf" | ".docx" | ".doc" | ".xlsx" | ".xls" | ".csv" | ".pptx" | ".ppt" | ".txt" | ".md" | ".json" | ".srt" | ".html";
+
 type ExuluQueueConfig = {
     queue: Queue;
     ratelimit: number;
@@ -181,123 +227,6 @@ type ExuluQueueConfig = {
     };
 };
 
-interface ExuluEvalParams {
-    id: string;
-    name: string;
-    description: string;
-    llm: boolean;
-    execute: (params: {
-        agent: ExuluAgent;
-        provider: ExuluProvider;
-        messages: UIMessage[];
-        testCase: TestCase;
-        config?: Record<string, any>;
-    }) => Promise<number>;
-    config?: {
-        name: string;
-        description: string;
-    }[];
-    queue: Promise<ExuluQueueConfig>;
-}
-declare class ExuluEval {
-    id: string;
-    name: string;
-    description: string;
-    llm: boolean;
-    private execute;
-    config?: {
-        name: string;
-        description: string;
-    }[];
-    queue?: Promise<ExuluQueueConfig>;
-    constructor({ id, name, description, execute, config, queue, llm }: ExuluEvalParams);
-    run(agent: ExuluAgent, provider: ExuluProvider, testCase: TestCase, messages: UIMessage[], config?: Record<string, any>): Promise<number>;
-}
-
-/**
- * Base operator type with comparison operations
- */
-type BaseOperator<T> = {
-    /** Equals */
-    eq?: T;
-    /** Not equals */
-    ne?: T;
-    /** In array */
-    in?: T[];
-    /** AND conditions */
-    and?: BaseOperator<T>[];
-    /** OR conditions */
-    or?: BaseOperator<T>[];
-    /** Contains (case-insensitive substring match) */
-    contains?: string;
-};
-/**
- * String field filter operators
- */
-type StringOperator = BaseOperator<string> & {
-    /** Contains (case-insensitive substring match) */
-    contains?: string;
-};
-/**
- * Number field filter operators
- */
-type NumberOperator = BaseOperator<number> & {
-    /** Less than or equal to */
-    lte?: number;
-    /** Greater than or equal to */
-    gte?: number;
-};
-/**
- * Date field filter operators
- */
-type DateOperator = BaseOperator<Date | string> & {
-    /** Less than or equal to */
-    lte?: Date | string;
-    /** Greater than or equal to */
-    gte?: Date | string;
-};
-/**
- * Boolean field filter operators
- */
-type BooleanOperator = BaseOperator<boolean>;
-/**
- * JSON field filter operators
- */
-type JsonOperator = BaseOperator<any> & {
-    /** Contains (PostgreSQL @> operator for JSON containment) */
-    contains?: any;
-};
-/**
- * Filter operator type based on field type
- */
-type FilterOperator = BaseOperator<any> | StringOperator | NumberOperator | DateOperator | BooleanOperator | JsonOperator;
-/**
- * Single filter object - a record of field names to their filter operators
- */
-type Filter = Record<string, FilterOperator>;
-/**
- * Type for the filters parameter used throughout the codebase
- * Filters is an array of filter objects, where each object contains field names mapped to their operators
- *
- * @example
- * ```typescript
- * const filters: Filters = [
- *   { name: { contains: "test" } },
- *   { age: { gte: 18, lte: 65 } },
- *   { status: { in: ["active", "pending"] } }
- * ];
- * ```
- */
-type SearchFilters = Filter[];
-
-type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown" | "file" | "date" | "uuid";
-
-type allFileTypes = imageTypes | fileTypes | audioTypes | videoTypes;
-type audioTypes = ".mp3" | ".wav" | ".m4a" | ".mp4" | ".mpeg";
-type videoTypes = ".mp4" | ".m4a" | ".mp3" | ".mpeg" | ".wav";
-type imageTypes = ".png" | ".jpg" | ".jpeg" | ".gif" | ".webp";
-type fileTypes = ".pdf" | ".docx" | ".doc" | ".xlsx" | ".xls" | ".csv" | ".pptx" | ".ppt" | ".txt" | ".md" | ".json" | ".srt" | ".html";
-
 declare class ExuluStorage {
     private config;
     constructor({ config }: {
@@ -420,6 +349,82 @@ declare class ExuluEmbedder {
 
 type ExuluRightsMode = "private" | "users" | "roles" | "public";
 
+/**
+ * Base operator type with comparison operations
+ */
+type BaseOperator<T> = {
+    /** Equals */
+    eq?: T;
+    /** Not equals */
+    ne?: T;
+    /** In array */
+    in?: T[];
+    /** AND conditions */
+    and?: BaseOperator<T>[];
+    /** OR conditions */
+    or?: BaseOperator<T>[];
+    /** Contains (case-insensitive substring match) */
+    contains?: string;
+};
+/**
+ * String field filter operators
+ */
+type StringOperator = BaseOperator<string> & {
+    /** Contains (case-insensitive substring match) */
+    contains?: string;
+};
+/**
+ * Number field filter operators
+ */
+type NumberOperator = BaseOperator<number> & {
+    /** Less than or equal to */
+    lte?: number;
+    /** Greater than or equal to */
+    gte?: number;
+};
+/**
+ * Date field filter operators
+ */
+type DateOperator = BaseOperator<Date | string> & {
+    /** Less than or equal to */
+    lte?: Date | string;
+    /** Greater than or equal to */
+    gte?: Date | string;
+};
+/**
+ * Boolean field filter operators
+ */
+type BooleanOperator = BaseOperator<boolean>;
+/**
+ * JSON field filter operators
+ */
+type JsonOperator = BaseOperator<any> & {
+    /** Contains (PostgreSQL @> operator for JSON containment) */
+    contains?: any;
+};
+/**
+ * Filter operator type based on field type
+ */
+type FilterOperator = BaseOperator<any> | StringOperator | NumberOperator | DateOperator | BooleanOperator | JsonOperator;
+/**
+ * Single filter object - a record of field names to their filter operators
+ */
+type Filter = Record<string, FilterOperator>;
+/**
+ * Type for the filters parameter used throughout the codebase
+ * Filters is an array of filter objects, where each object contains field names mapped to their operators
+ *
+ * @example
+ * ```typescript
+ * const filters: Filters = [
+ *   { name: { contains: "test" } },
+ *   { age: { gte: 18, lte: 65 } },
+ *   { status: { in: ["active", "pending"] } }
+ * ];
+ * ```
+ */
+type SearchFilters = Filter[];
+
 declare const VectorMethodEnum: {
     readonly cosineDistance: "cosineDistance";
     readonly hybridSearch: "hybridSearch";
@@ -427,6 +432,28 @@ declare const VectorMethodEnum: {
 };
 type VectorMethod = (typeof VectorMethodEnum)[keyof typeof VectorMethodEnum];
 
+type VectorSearchChunkResult = {
+    chunk_content: string;
+    chunk_index: number;
+    chunk_id: string;
+    chunk_source: string;
+    chunk_metadata: Record<string, string>;
+    chunk_created_at: string;
+    chunk_updated_at: string;
+    item_id: string;
+    item_external_id: string;
+    item_name: string;
+    item_updated_at: string;
+    item_created_at: string;
+    chunk_cosine_distance?: number;
+    chunk_fts_rank?: number;
+    chunk_hybrid_score?: number;
+    context?: {
+        name: string;
+        id: string;
+    };
+};
+
 type ExuluContextFieldDefinition = {
     name: string;
     type: ExuluFieldTypes;
@@ -614,218 +641,46 @@ declare class ExuluContext {
     }) => Promise<Item[]>;
     embeddings: {
         generate: {
-            one: ({ item, user, role, trigger, config, }: {
-                item: Item;
-                user?: number;
-                role?: string;
-                trigger: STATISTICS_LABELS;
-                config: ExuluConfig;
-            }) => Promise<{
-                id: string;
-                job?: string;
-                chunks?: number;
-            }>;
-            all: (config: ExuluConfig, userId?: number, roleId?: string, limit?: number) => Promise<{
-                jobs: string[];
-                items: number;
-            }>;
-        };
-    };
-    createItemsTable: () => Promise<void>;
-    createChunksTable: () => Promise<void>;
-    tool: () => ExuluTool | null;
-}
-
-type VectorSearchChunkResult = {
-    chunk_content: string;
-    chunk_index: number;
-    chunk_id: string;
-    chunk_source: string;
-    chunk_metadata: Record<string, string>;
-    chunk_created_at: string;
-    chunk_updated_at: string;
-    item_id: string;
-    item_external_id: string;
-    item_name: string;
-    item_updated_at: string;
-    item_created_at: string;
-    chunk_cosine_distance?: number;
-    chunk_fts_rank?: number;
-    chunk_hybrid_score?: number;
-    context?: {
-        name: string;
-        id: string;
-    };
-};
-
-declare class ExuluReranker {
-    id: string;
-    name: string;
-    description: string;
-    execute: (params: {
-        query: string;
-        chunks: VectorSearchChunkResult[];
-    }) => Promise<VectorSearchChunkResult[]>;
-    constructor({ id, name, description, execute, }: {
-        id: string;
-        name: string;
-        description: string;
-        execute: (params: {
-            query: string;
-            chunks: VectorSearchChunkResult[];
-        }) => Promise<VectorSearchChunkResult[]>;
-    });
-    run(query: string, chunks: VectorSearchChunkResult[]): Promise<VectorSearchChunkResult[]>;
-}
-
-type ExuluConfig = {
-    telemetry?: {
-        enabled: boolean;
-    };
-    logger?: {
-        winston: {
-            transports: transport[];
-        };
-    };
-    workers: {
-        enabled: boolean;
-        logger?: {
-            winston: {
-                transports: transport[];
-            };
-        };
-        telemetry?: {
-            enabled: boolean;
-        };
-    };
-    MCP: {
-        enabled: boolean;
-    };
-    fileUploads?: {
-        s3region: string;
-        s3key: string;
-        s3secret: string;
-        s3Bucket: string;
-        s3endpoint?: string;
-        s3prefix?: string;
-    };
-    privacy?: {
-        systemPromptPersonalization?: boolean;
-    };
-};
-declare class ExuluApp {
-    private _providers;
-    private _agents;
-    private _config?;
-    private _evals;
-    private _queues;
-    private _rerankers;
-    private _contexts?;
-    private _tools;
-    private _expressApp;
-    constructor();
-    create: ({ contexts, providers, config, agents, tools, evals, rerankers, }: {
-        contexts?: Record<string, ExuluContext>;
-        config: ExuluConfig;
-        agents?: ExuluAgent[];
-        providers?: ExuluProvider[];
-        rerankers?: ExuluReranker[];
-        evals?: ExuluEval[];
-        tools?: ExuluTool[];
-    }) => Promise<ExuluApp>;
-    express: {
-        init: () => Promise<Express>;
-    };
-    get expressApp(): Express;
-    tool(id: string): ExuluTool | undefined;
-    tools(): ExuluTool[];
-    agent(id: string, include?: {
-        source: {
-            code: boolean;
-            database: boolean;
-        };
-    }): Promise<ExuluAgent | undefined>;
-    agents(include?: {
-        source: {
-            code: boolean;
-            database: boolean;
-        };
-    }): Promise<ExuluAgent[]>;
-    context(id: string): ExuluContext | undefined;
-    provider(id: string): ExuluProvider | undefined;
-    get contexts(): ExuluContext[];
-    get providers(): ExuluProvider[];
-    embeddings: {
-        generate: {
-            one: ({ context: contextId, item: itemId }: {
-                context: string;
-                item: string;
+            one: ({ item, user, role, trigger, config, }: {
+                item: Item;
+                user?: number;
+                role?: string;
+                trigger: STATISTICS_LABELS;
+                config: ExuluConfig;
             }) => Promise<{
                 id: string;
                 job?: string;
                 chunks?: number;
             }>;
-            all: ({ context: contextId }: {
-                context: string;
-            }) => Promise<{
+            all: (config: ExuluConfig, userId?: number, roleId?: string, limit?: number) => Promise<{
                 jobs: string[];
                 items: number;
             }>;
         };
     };
-    bullmq: {
-        workers: {
-            create: (queues?: string[]) => Promise<bullmq.Worker<any, any, string>[]>;
-        };
-    };
-    private server;
+    createItemsTable: () => Promise<void>;
+    createChunksTable: () => Promise<void>;
+    tool: () => ExuluTool | null;
 }
 
-declare class ExuluTool {
+declare class ExuluReranker {
     id: string;
     name: string;
     description: string;
-    category: string;
-    inputSchema?: z.ZodType;
-    type: "context" | "function" | "agent" | "web_search";
-    tool: Tool;
-    config: {
-        name: string;
-        description: string;
-        type: "boolean" | "string" | "number" | "variable";
-        default?: string | boolean | number;
-    }[];
-    constructor({ id, name, description, category, inputSchema, type, execute, config, }: {
+    execute: (params: {
+        query: string;
+        chunks: VectorSearchChunkResult[];
+    }) => Promise<VectorSearchChunkResult[]>;
+    constructor({ id, name, description, execute, }: {
         id: string;
         name: string;
         description: string;
-        category?: string;
-        inputSchema?: z.ZodType;
-        type: "context" | "function" | "agent" | "web_search";
-        config: {
-            name: string;
-            description: string;
-            type: "boolean" | "string" | "number" | "variable";
-            default?: string | boolean | number;
-        }[];
-        execute: (inputs: any) => Promise<{
-            result?: string;
-            job?: string;
-            items?: Item[];
-        }> | AsyncGenerator<{
-            result?: string;
-            job?: string;
-            items?: Item[];
-        }>;
+        execute: (params: {
+            query: string;
+            chunks: VectorSearchChunkResult[];
+        }) => Promise<VectorSearchChunkResult[]>;
     });
-    execute: ({ agent: agentId, config, user, inputs, project, items, }: {
-        agent: string;
-        config: ExuluConfig;
-        user?: User;
-        inputs: any;
-        project?: string;
-        items?: string[];
-    }) => Promise<any>;
+    run(query: string, chunks: VectorSearchChunkResult[]): Promise<VectorSearchChunkResult[]>;
 }
 
 type ExuluAgentToolConfig = {
@@ -944,9 +799,154 @@ declare class ExuluProvider {
     }>;
 }
 
-declare function redisClient(): Promise<{
-    client: RedisClientType | null;
-}>;
+interface TestCase {
+    id: string;
+    name: string;
+    description?: string;
+    inputs: UIMessage[];
+    expected_output: string;
+    expected_tools?: string[];
+    expected_knowledge_sources?: string[];
+    expected_agent_tools?: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+
+interface ExuluEvalParams {
+    id: string;
+    name: string;
+    description: string;
+    llm: boolean;
+    execute: (params: {
+        agent: ExuluAgent;
+        provider: ExuluProvider;
+        messages: UIMessage[];
+        testCase: TestCase;
+        config?: Record<string, any>;
+    }) => Promise<number>;
+    config?: {
+        name: string;
+        description: string;
+    }[];
+    queue: Promise<ExuluQueueConfig>;
+}
+declare class ExuluEval {
+    id: string;
+    name: string;
+    description: string;
+    llm: boolean;
+    private execute;
+    config?: {
+        name: string;
+        description: string;
+    }[];
+    queue?: Promise<ExuluQueueConfig>;
+    constructor({ id, name, description, execute, config, queue, llm }: ExuluEvalParams);
+    run(agent: ExuluAgent, provider: ExuluProvider, testCase: TestCase, messages: UIMessage[], config?: Record<string, any>): Promise<number>;
+}
+
+type ExuluConfig = {
+    telemetry?: {
+        enabled: boolean;
+    };
+    logger?: {
+        winston: {
+            transports: transport[];
+        };
+    };
+    workers: {
+        enabled: boolean;
+        logger?: {
+            winston: {
+                transports: transport[];
+            };
+        };
+        telemetry?: {
+            enabled: boolean;
+        };
+    };
+    MCP: {
+        enabled: boolean;
+    };
+    fileUploads?: {
+        s3region: string;
+        s3key: string;
+        s3secret: string;
+        s3Bucket: string;
+        s3endpoint?: string;
+        s3prefix?: string;
+    };
+    privacy?: {
+        systemPromptPersonalization?: boolean;
+    };
+};
+declare class ExuluApp {
+    private _providers;
+    private _agents;
+    private _config?;
+    private _evals;
+    private _queues;
+    private _rerankers;
+    private _contexts?;
+    private _tools;
+    private _expressApp;
+    constructor();
+    create: ({ contexts, providers, config, agents, tools, evals, rerankers, }: {
+        contexts?: Record<string, ExuluContext>;
+        config: ExuluConfig;
+        agents?: ExuluAgent[];
+        providers?: ExuluProvider[];
+        rerankers?: ExuluReranker[];
+        evals?: ExuluEval[];
+        tools?: ExuluTool[];
+    }) => Promise<ExuluApp>;
+    express: {
+        init: () => Promise<Express>;
+    };
+    get expressApp(): Express;
+    tool(id: string): ExuluTool | undefined;
+    tools(): ExuluTool[];
+    agent(id: string, include?: {
+        source: {
+            code: boolean;
+            database: boolean;
+        };
+    }): Promise<ExuluAgent | undefined>;
+    agents(include?: {
+        source: {
+            code: boolean;
+            database: boolean;
+        };
+    }): Promise<ExuluAgent[]>;
+    context(id: string): ExuluContext | undefined;
+    provider(id: string): ExuluProvider | undefined;
+    get contexts(): ExuluContext[];
+    get providers(): ExuluProvider[];
+    embeddings: {
+        generate: {
+            one: ({ context: contextId, item: itemId }: {
+                context: string;
+                item: string;
+            }) => Promise<{
+                id: string;
+                job?: string;
+                chunks?: number;
+            }>;
+            all: ({ context: contextId }: {
+                context: string;
+            }) => Promise<{
+                jobs: string[];
+                items: number;
+            }>;
+        };
+    };
+    bullmq: {
+        workers: {
+            create: (queues?: string[]) => Promise<bullmq.Worker<any, any, string>[]>;
+        };
+    };
+    private server;
+}
 
 declare class ExuluQueues {
     queues: {
@@ -1897,6 +1897,95 @@ declare class MarkdownChunker {
     }[]>;
 }
 
+/**
+ * Python Environment Setup Utility
+ *
+ * Provides functions to set up and validate the Python environment for Exulu backend.
+ * This can be called manually by package consumers or run automatically on install.
+ */
+/**
+ * Options for Python environment setup
+ */
+interface PythonSetupOptions {
+    /**
+     * Package root directory (where @exulu/backend is installed)
+     * @default Auto-detected from package location
+     */
+    packageRoot?: string;
+    /**
+     * Whether to force reinstall even if environment exists
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * Whether to show verbose output
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Timeout for setup process in milliseconds
+     * @default 600000 (10 minutes)
+     */
+    timeout?: number;
+}
+/**
+ * Result of Python environment setup
+ */
+interface PythonSetupResult {
+    /** Whether setup was successful */
+    success: boolean;
+    /** Message describing the result */
+    message: string;
+    /** Whether the environment already existed */
+    alreadyExists: boolean;
+    /** Python version installed */
+    pythonVersion?: string;
+    /** Full output from setup script */
+    output?: string;
+}
+/**
+ * Check if Python environment is already set up
+ */
+declare function isPythonEnvironmentSetup(packageRoot?: string): boolean;
+/**
+ * Set up the Python environment by running the setup script
+ *
+ * @param options - Setup configuration options
+ * @returns Result of the setup operation
+ *
+ * @example
+ * ```typescript
+ * import { setupPythonEnvironment } from '@exulu/backend';
+ *
+ * // Basic usage
+ * const result = await setupPythonEnvironment();
+ * if (result.success) {
+ *   console.log('Python environment ready!');
+ * }
+ *
+ * // With options
+ * const result = await setupPythonEnvironment({
+ *   force: true,
+ *   verbose: true
+ * });
+ * ```
+ */
+declare function setupPythonEnvironment(options?: PythonSetupOptions): Promise<PythonSetupResult>;
+/**
+ * Get helpful setup instructions for users
+ */
+declare function getPythonSetupInstructions(): string;
+/**
+ * Validate Python environment and provide helpful error messages
+ *
+ * @param packageRoot - Package root directory
+ * @returns Object with validation status and message
+ */
+declare function validatePythonEnvironment(packageRoot?: string): Promise<{
+    valid: boolean;
+    message: string;
+}>;
+
 type DocumentProcessorConfig = {
     vlm?: {
         model: LanguageModel;
@@ -2011,5 +2100,11 @@ declare const ExuluChunkers: {
         rules: typeof RecursiveRules;
     };
 };
+declare const ExuluPython: {
+    setup: typeof setupPythonEnvironment;
+    check: typeof isPythonEnvironmentSetup;
+    validate: typeof validatePythonEnvironment;
+    instructions: typeof getPythonSetupInstructions;
+};
 
-export { type JOB_STATUS as EXULU_JOB_STATUS, JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM, type STATISTICS_TYPE as EXULU_STATISTICS_TYPE, STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM, ExuluApp, ExuluAuthentication, ExuluChunkers, ExuluContext, ExuluDatabase, ExuluDefaultProviders, ExuluDocumentProcessor, ExuluEmbedder, ExuluEval, type Item as ExuluItem, ExuluJobs, ExuluOtel, queues as ExuluQueues, ExuluReranker, ExuluTool, ExuluVariables };
+export { type JOB_STATUS as EXULU_JOB_STATUS, JOB_STATUS_ENUM as EXULU_JOB_STATUS_ENUM, type STATISTICS_TYPE as EXULU_STATISTICS_TYPE, STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM, type ExuluAgent, ExuluApp, ExuluAuthentication, ExuluChunkers, ExuluContext, ExuluDatabase, ExuluDefaultProviders, ExuluDocumentProcessor, ExuluEmbedder, ExuluEval, type Item as ExuluItem, ExuluJobs, ExuluOtel, ExuluProvider, ExuluPython, queues as ExuluQueues, ExuluReranker, ExuluTool, ExuluVariables };