@exulu/backend 1.25.4 → 1.26.0

package/dist/index.d.ts

@@ -27,7 +27,7 @@ declare const STATISTICS_TYPE_ENUM: {
     AGENT_RUN: string;
 };
 
-type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown";
+type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown" | "file" | "date" | "uuid";
 
 interface Item {
     id?: string;
@@ -80,6 +80,7 @@ type ExuluConfig = {
         s3secret: string;
         s3Bucket: string;
         s3endpoint?: string;
+        s3prefix?: string;
     };
 };
 declare class ExuluApp {
@@ -144,6 +145,7 @@ type User = {
         id: string;
         name: string;
         agents: "read" | "write";
+        evals: "read" | "write";
         workflows: "read" | "write";
         variables: "read" | "write";
         users: "read" | "write";
@@ -179,13 +181,11 @@ type ExuluAgentConfig = {
         };
     };
 };
-type ExuluAgentEval = {
-    runner: ExuluEvalRunnerInstance;
-};
 type imageTypes = '.png' | '.jpg' | '.jpeg' | '.gif' | '.webp';
 type fileTypes = '.pdf' | '.docx' | '.xlsx' | '.xls' | '.csv' | '.pptx' | '.ppt' | '.txt' | '.md' | '.json';
 type audioTypes = '.mp3' | '.wav' | '.m4a' | '.mp4' | '.mpeg';
 type videoTypes = '.mp4' | '.m4a' | '.mp3' | '.mpeg' | '.wav';
+type allFileTypes = imageTypes | fileTypes | audioTypes | videoTypes;
 interface ExuluAgentParams {
     id: string;
     name: string;
@@ -200,9 +200,9 @@ interface ExuluAgentParams {
         audio: audioTypes[];
         video: videoTypes[];
     };
-    evals?: ExuluAgentEval[];
     outputSchema?: z.ZodType;
     rateLimit?: RateLimiterRule;
+    evals?: ExuluEval[];
 }
 interface ExuluAgentToolConfig {
     id: string;
@@ -213,6 +213,50 @@ interface ExuluAgentToolConfig {
         value?: any;
     }[];
 }
+type ExuluQueueConfig = {
+    queue: Queue;
+    ratelimit: number;
+    concurrency: number;
+};
+type ExuluEvalTokenMetadata = {
+    totalTokens?: number;
+    reasoningTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+};
+type ExuluEvalMetadata = {
+    tokens?: ExuluEvalTokenMetadata;
+    duration?: number;
+};
+interface ExuluEvalParams {
+    id: string;
+    name: string;
+    description: string;
+    execute: (params: {
+        messages: UIMessage[];
+        metadata: ExuluEvalMetadata;
+        config?: Record<string, any>;
+    }) => Promise<number>;
+    config?: {
+        name: string;
+        description: string;
+    }[];
+    queue: ExuluQueueConfig;
+}
+declare class ExuluEval {
+    id: string;
+    name: string;
+    description: string;
+    private execute;
+    config?: {
+        name: string;
+        description: string;
+    }[];
+    queue: ExuluQueueConfig;
+    constructor({ id, name, description, execute, config, queue }: ExuluEvalParams);
+    run(messages: UIMessage[], metadata: ExuluEvalMetadata, config?: Record<string, any>): Promise<number>;
+}
 declare class ExuluAgent {
     id: string;
     name: string;
@@ -223,7 +267,7 @@ declare class ExuluAgent {
     maxContextLength?: number;
     rateLimit?: RateLimiterRule;
     config?: ExuluAgentConfig | undefined;
-    evals?: ExuluAgentEval[];
+    evals?: ExuluEval[];
     model?: {
         create: ({ apiKey }: {
             apiKey: string;
@@ -236,11 +280,11 @@ declare class ExuluAgent {
         audio: string[];
         video: string[];
     };
-    constructor({ id, name, description, config, rateLimit, capabilities, type, evals, maxContextLength }: ExuluAgentParams);
+    constructor({ id, name, description, config, rateLimit, capabilities, type, maxContextLength, evals }: ExuluAgentParams);
     get providerName(): string;
     get modelName(): string;
     tool: (instance: string, agents: ExuluAgent[]) => Promise<ExuluTool | null>;
-    generateSync: ({ prompt, user, session, message, currentTools, allExuluTools, statistics, toolConfigs, providerapikey, contexts, exuluConfig, filesContext, outputSchema, instructions }: {
+    generateSync: ({ prompt, user, session, message, currentTools, allExuluTools, statistics, toolConfigs, providerapikey, contexts, exuluConfig, outputSchema, instructions }: {
         prompt?: string;
         user?: User;
         session?: string;
@@ -252,11 +296,10 @@ declare class ExuluAgent {
         providerapikey: string;
         contexts?: ExuluContext[] | undefined;
         exuluConfig?: ExuluConfig;
-        filesContext?: ExuluContext;
         instructions?: string;
         outputSchema?: z.ZodType;
     }) => Promise<string | any>;
-    generateStream: ({ express, user, session, message, currentTools, allExuluTools, statistics, toolConfigs, providerapikey, contexts, exuluConfig, filesContext, instructions, }: {
+    generateStream: ({ express, user, session, message, currentTools, allExuluTools, statistics, toolConfigs, providerapikey, contexts, exuluConfig, instructions, }: {
         express: {
             res: Response;
             req: Request;
@@ -271,7 +314,6 @@ declare class ExuluAgent {
         providerapikey: string;
         contexts?: ExuluContext[] | undefined;
         exuluConfig?: ExuluConfig;
-        filesContext?: ExuluContext;
         instructions?: string;
     }) => Promise<void>;
 }
@@ -283,7 +325,9 @@ type VectorOperationResponse = Promise<{
 type VectorGenerateOperation = (inputs: ChunkerResponse) => VectorGenerationResponse;
 type ChunkerOperation = (item: Item & {
     id: string;
-}, maxChunkSize: number) => Promise<ChunkerResponse>;
+}, maxChunkSize: number, utils: {
+    storage: ExuluStorage;
+}) => Promise<ChunkerResponse>;
 type ChunkerResponse = {
     item: Item & {
         id: string;
@@ -305,106 +349,27 @@ declare class ExuluEmbedder {
     id: string;
     name: string;
     slug: string;
-    queue?: Queue;
+    queue?: Promise<ExuluQueueConfig>;
     private generateEmbeddings;
+    description: string;
     vectorDimensions: number;
     maxChunkSize: number;
-    chunker: ChunkerOperation;
+    _chunker: ChunkerOperation;
     constructor({ id, name, description, generateEmbeddings, queue, vectorDimensions, maxChunkSize, chunker }: {
         id: string;
         name: string;
         description: string;
         generateEmbeddings: VectorGenerateOperation;
         chunker: ChunkerOperation;
-        queue?: Queue;
+        queue?: Promise<ExuluQueueConfig>;
         vectorDimensions: number;
         maxChunkSize: number;
     });
-    generateFromQuery(query: string, statistics?: ExuluStatisticParams, user?: number, role?: string): VectorGenerationResponse;
-    generateFromDocument(input: Item, statistics?: ExuluStatisticParams, user?: number, role?: string): VectorGenerationResponse;
-}
-interface WorkflowVariable {
-    name: string;
-    description?: string;
-    type: 'string';
-    required: boolean;
-    defaultValue?: string;
-}
-interface WorkflowStep {
-    id: string;
-    type: 'user' | 'assistant' | 'tool';
-    content?: string;
-    contentExample?: string;
-    toolName?: string;
-    variablesUsed?: string[];
-}
-interface ExuluWorkflow {
-    id: string;
-    name: string;
-    description?: string;
-    rights_mode?: ExuluRightsMode;
-    RBAC?: ExuluRBAC;
-    variables?: WorkflowVariable[];
-    steps_json?: WorkflowStep[];
-}
-interface ExuluRBAC {
-    users?: Array<{
+    chunker: (item: Item & {
         id: string;
-        rights: 'read' | 'write';
-    }>;
-    roles?: Array<{
-        id: string;
-        rights: 'read' | 'write';
-    }>;
-}
-type ExuluEvalRunnerInstance = {
-    name: string;
-    description: string;
-    testcases: ExuluEvalInput[];
-    run: ExuluEvalRunner;
-};
-type ExuluEvalRunner = ({ data, runner }: {
-    data: ExuluEvalInput;
-    runner: {
-        agent?: ExuluAgent & {
-            providerapikey: string;
-        };
-        workflow?: ExuluWorkflow;
-    };
-}) => Promise<{
-    score: number;
-    comment: string;
-}>;
-type ExuluEvalInput = {
-    prompt?: string;
-    inputs?: any;
-    result?: string;
-    category?: string;
-    metadata?: Record<string, any>;
-    duration?: number;
-    reference?: string;
-};
-declare class ExuluEval {
-    name: string;
-    description: string;
-    constructor({ name, description }: {
-        name: string;
-        description: string;
-    });
-    create: {
-        LlmAsAJudge: {
-            niah: ({ label, model, needles, testDocument, contextlengths }: {
-                label: string;
-                model: LanguageModel;
-                needles: {
-                    question: string;
-                    answer: string;
-                }[];
-                testDocument: string;
-                contextlengths: (5000 | 30000 | 50000 | 128000)[];
-            }) => ExuluEvalRunnerInstance;
-        };
-    };
+    }, maxChunkSize: number, config: ExuluConfig) => Promise<ChunkerResponse>;
+    generateFromQuery(query: string, statistics?: ExuluStatisticParams, user?: number, role?: string): VectorGenerationResponse;
+    generateFromDocument(input: Item, config: ExuluConfig, statistics?: ExuluStatisticParams, user?: number, role?: string): VectorGenerationResponse;
 }
 declare class ExuluTool {
     id: string;
@@ -438,12 +403,50 @@ declare class ExuluTool {
         }>;
     });
 }
+type ExuluContextFieldProcessor = {
+    description: string;
+    execute: ({ item, user, role, utils, config }: {
+        item: Item & {
+            field: string;
+        };
+        user: number;
+        role: string;
+        utils: {
+            storage: ExuluStorage;
+            items: {
+                update: ExuluContext['updateItem'];
+                create: ExuluContext['createItem'];
+                delete: ExuluContext['deleteItem'];
+            };
+        };
+        config: ExuluConfig;
+    }) => Promise<string>;
+    config?: {
+        queue?: Promise<ExuluQueueConfig>;
+        trigger: "manual" | "onUpdate" | "onCreate" | "always";
+    };
+};
 type ExuluContextFieldDefinition = {
     name: string;
     type: ExuluFieldTypes;
     unique?: boolean;
+    required?: boolean;
+    default?: any;
+    calculated?: boolean;
+    index?: boolean;
+    enumValues?: string[];
+    allowedFileTypes?: allFileTypes[];
+    processor?: ExuluContextFieldProcessor;
 };
 type ExuluRightsMode = "private" | "users" | "roles" | "public" | "projects";
+declare class ExuluStorage {
+    private config;
+    constructor({ config }: {
+        config: ExuluConfig;
+    });
+    getPresignedUrl: (key: string) => Promise<string>;
+    uploadFile: (user: number, file: Buffer | Uint8Array, key: string, type: string, metadata?: Record<string, string>) => Promise<string>;
+}
 declare class ExuluContext {
     id: string;
     name: string;
@@ -475,39 +478,37 @@ declare class ExuluContext {
             language?: "german" | "english";
         };
     });
+    process: (trigger: STATISTICS_LABELS, user: number, role: string, item: Item & {
+        field: string;
+    }, config: ExuluConfig) => Promise<{
+        result: string;
+        job?: string;
+    }>;
     deleteAll: () => Promise<VectorOperationResponse>;
     tableExists: () => Promise<boolean>;
     chunksTableExists: () => Promise<boolean>;
-    createAndUpsertEmbeddings: (item: Item, user?: number, statistics?: ExuluStatisticParams, role?: string, job?: string) => Promise<{
+    createAndUpsertEmbeddings: (item: Item, config: ExuluConfig, user?: number, statistics?: ExuluStatisticParams, role?: string, job?: string) => Promise<{
         id: string;
         chunks?: number;
         job?: string;
     }>;
-    createItem: (item: Item, user?: number, role?: string, upsert?: boolean) => Promise<{
-        item: Item;
-        job?: string;
-    }>;
-    updateItem: (item: Item, user?: number, role?: string) => Promise<{
-        item: Item;
-        job?: string;
-    }>;
-    deleteItem: (item: Item, user?: number, role?: string) => Promise<{
-        id: string;
-        job?: string;
-    }>;
+    private createItem;
+    private updateItem;
+    private deleteItem;
     embeddings: {
         generate: {
-            one: ({ item, user, role, trigger }: {
+            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: (userId?: number, roleId?: string) => Promise<{
+            all: (config: ExuluConfig, userId?: number, roleId?: string) => Promise<{
                 jobs: string[];
                 items: number;
             }>;
@@ -540,10 +541,18 @@ declare const authentication: ({ apikey, authtoken, internalkey, db, }: {
 }>;
 
 declare class ExuluQueues {
-    queues: Queue[];
+    queues: {
+        queue: Queue;
+        ratelimit: number;
+        concurrency: number;
+    }[];
     constructor();
-    queue(name: string): Queue | undefined;
-    use(name: string): Queue;
+    queue(name: string): {
+        queue: Queue;
+        ratelimit: number;
+        concurrency: number;
+    } | undefined;
+    use: (name: string, concurrency?: number, ratelimit?: number) => Promise<ExuluQueueConfig>;
 }
 declare const queues: ExuluQueues;
 
@@ -1420,7 +1429,6 @@ declare const ExuluJobs: {
     };
 };
 declare const ExuluDefaultContexts: {
-    files: ExuluContext;
     codeStandards: ExuluContext;
     outputs: ExuluContext;
 };
@@ -1482,4 +1490,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, ExuluAgent, ExuluApp, authentication as ExuluAuthentication, ExuluChunkers, ExuluContext, ExuluDefaultAgents, ExuluDefaultContexts, ExuluEmbedder, ExuluEval, ExuluJobs, ExuluOtel, queues as ExuluQueues, ExuluTool, ExuluUtils, ExuluVariables, db };
+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, ExuluAgent, ExuluApp, authentication as ExuluAuthentication, ExuluChunkers, ExuluContext, ExuluDefaultAgents, ExuluDefaultContexts, ExuluEmbedder, ExuluEval, type ExuluEvalMetadata, type ExuluEvalTokenMetadata, ExuluJobs, ExuluOtel, type ExuluQueueConfig, queues as ExuluQueues, ExuluTool, ExuluUtils, ExuluVariables, db };