@exulu/backend 1.47.0 → 1.48.2

package/dist/index.d.cts

@@ -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,50 +349,148 @@ declare class ExuluEmbedder {
 
 type ExuluRightsMode = "private" | "users" | "roles" | "public";
 
-declare const VectorMethodEnum: {
-    readonly cosineDistance: "cosineDistance";
-    readonly hybridSearch: "hybridSearch";
-    readonly tsvector: "tsvector";
+/**
+ * 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;
 };
-type VectorMethod = (typeof VectorMethodEnum)[keyof typeof VectorMethodEnum];
-
-type ExuluContextFieldDefinition = {
-    name: string;
-    type: ExuluFieldTypes;
-    editable?: boolean;
-    unique?: boolean;
-    required?: boolean;
-    default?: any;
-    calculated?: boolean;
-    index?: boolean;
-    enumValues?: string[];
-    allowedFileTypes?: allFileTypes[];
+/**
+ * String field filter operators
+ */
+type StringOperator = BaseOperator<string> & {
+    /** Contains (case-insensitive substring match) */
+    contains?: string;
 };
-type ExuluContextSource = {
-    id: string;
-    name: string;
-    description: string;
-    config?: {
-        schedule?: string;
-        queue?: Promise<ExuluQueueConfig>;
-        retries?: number;
-        backoff?: {
-            type: "exponential" | "linear";
-            delay: number;
-        };
-        params?: {
-            name: string;
-            description: string;
-            default?: string;
-        }[];
-    };
-    execute: (inputs: {
-        exuluConfig: ExuluConfig;
-        [key: string]: any;
-    }) => Promise<Item[]>;
+/**
+ * Number field filter operators
+ */
+type NumberOperator = BaseOperator<number> & {
+    /** Less than or equal to */
+    lte?: number;
+    /** Greater than or equal to */
+    gte?: number;
 };
-declare class ExuluContext {
-    id: string;
+/**
+ * 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";
+    readonly tsvector: "tsvector";
+};
+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;
+    editable?: boolean;
+    unique?: boolean;
+    required?: boolean;
+    default?: any;
+    calculated?: boolean;
+    index?: boolean;
+    enumValues?: string[];
+    allowedFileTypes?: allFileTypes[];
+};
+type ExuluContextSource = {
+    id: string;
+    name: string;
+    description: string;
+    config?: {
+        schedule?: string;
+        queue?: Promise<ExuluQueueConfig>;
+        retries?: number;
+        backoff?: {
+            type: "exponential" | "linear";
+            delay: number;
+        };
+        params?: {
+            name: string;
+            description: string;
+            default?: string;
+        }[];
+    };
+    execute: (inputs: {
+        exuluConfig: ExuluConfig;
+        [key: string]: any;
+    }) => Promise<Item[]>;
+};
+declare class ExuluContext {
+    id: string;
     name: string;
     active: boolean;
     fields: ExuluContextFieldDefinition[];
@@ -636,28 +663,6 @@ declare class ExuluContext {
     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;
@@ -678,156 +683,6 @@ declare class ExuluReranker {
     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;
-            }) => 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 ExuluTool {
-    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, }: {
-        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 ExuluAgentToolConfig = {
     id: string;
     type: string;
@@ -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: {
@@ -2012,4 +2012,4 @@ declare const ExuluChunkers: {
     };
 };
 
-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, queues as ExuluQueues, ExuluReranker, ExuluTool, ExuluVariables };