@exulu/backend 1.23.2 → 1.24.0

package/dist/index.d.cts

@@ -2,9 +2,9 @@ import * as _opentelemetry_sdk_node from '@opentelemetry/sdk-node';
 import * as bullmq from 'bullmq';
 import { Queue } from 'bullmq';
 import { RedisClientType } from 'redis';
-import { ZodSchema } from 'zod';
+import { z } from 'zod';
 import { Tool, LanguageModel, UIMessage } from 'ai';
-import { Response, Request, Express } from 'express';
+import { Express, Response, Request } from 'express';
 import { Knex } from 'knex';
 import { Tiktoken } from 'tiktoken/lite';
 import models from 'tiktoken/model_to_encoding.json';
@@ -26,7 +26,7 @@ declare const STATISTICS_TYPE_ENUM: {
     AGENT_RUN: string;
 };
 
-type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum";
+type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json" | "enum" | "markdown";
 
 interface Item {
     id?: string;
@@ -50,12 +50,92 @@ interface Item {
     [key: string]: any;
 }
 
-declare const VectorMethodEnum: {
-    readonly cosineDistance: "cosineDistance";
-    readonly hybridSearch: "hybridSearch";
-    readonly tsvector: "tsvector";
+type ExuluConfig = {
+    telemetry?: {
+        enabled: boolean;
+    };
+    workers: {
+        enabled: boolean;
+        logsDir?: string;
+        telemetry?: {
+            enabled: boolean;
+        };
+    };
+    MCP: {
+        enabled: boolean;
+    };
+    fileUploads: {
+        s3region: string;
+        s3key: string;
+        s3secret: string;
+        s3Bucket: string;
+        s3endpoint?: string;
+    };
+};
+declare class ExuluApp {
+    private _agents;
+    private _config?;
+    private _queues;
+    private _contexts?;
+    private _tools;
+    private _expressApp;
+    constructor();
+    create: ({ contexts, agents, config, tools }: {
+        contexts?: Record<string, ExuluContext>;
+        config: ExuluConfig;
+        agents?: ExuluAgent[];
+        tools?: ExuluTool[];
+    }) => Promise<Express>;
+    get expressApp(): Express;
+    tool(id: string): ExuluTool | undefined;
+    tools(): ExuluTool[];
+    context(id: string): ExuluContext | undefined;
+    agent(id: string): ExuluAgent | undefined;
+    get contexts(): ExuluContext[];
+    get agents(): ExuluAgent[];
+    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: () => Promise<bullmq.Worker<any, any, string>[]>;
+        };
+    };
+    private server;
+}
+
+type User = {
+    id: number;
+    email: string;
+    emailVerified?: string;
+    type?: "api" | "user";
+    anthropic_token?: string;
+    super_admin?: boolean;
+    favourite_agents?: string[];
+    role: {
+        id: string;
+        name: string;
+        agents: "read" | "write";
+        workflows: "read" | "write";
+        variables: "read" | "write";
+        users: "read" | "write";
+    };
 };
-type VectorMethod = (typeof VectorMethodEnum)[keyof typeof VectorMethodEnum];
 
 interface RateLimiterRule {
     name?: string;
@@ -72,7 +152,7 @@ type ExuluAgentConfig = {
             apiKey: string;
         }) => LanguageModel;
     };
-    outputSchema?: ZodSchema;
+    outputSchema?: z.ZodType;
     custom?: {
         name: string;
         description: string;
@@ -89,25 +169,31 @@ 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';
 interface ExuluAgentParams {
     id: string;
     name: string;
-    type: "agent" | "custom";
+    type: "agent";
     description: string;
     config?: ExuluAgentConfig | undefined;
+    maxContextLength?: number;
     capabilities?: {
         text: boolean;
-        images: ('.png' | '.jpg' | '.jpeg' | '.gif' | '.webp')[];
-        files: ('.pdf' | '.docx' | '.xlsx' | '.xls' | '.csv' | '.pptx' | '.ppt')[];
-        audio: ('.mp3' | '.wav' | '.m4a' | '.mp4' | '.mpeg')[];
-        video: ('.mp4' | '.m4a' | '.mp3' | '.mpeg' | '.wav')[];
+        images: imageTypes[];
+        files: fileTypes[];
+        audio: audioTypes[];
+        video: videoTypes[];
     };
     evals?: ExuluAgentEval[];
-    outputSchema?: ZodSchema;
+    outputSchema?: z.ZodType;
     rateLimit?: RateLimiterRule;
 }
 interface ExuluAgentToolConfig {
-    toolId: string;
+    id: string;
+    type: string;
     config: {
         name: string;
         variable: string;
@@ -119,8 +205,9 @@ declare class ExuluAgent {
     name: string;
     description: string;
     slug: string;
-    type: "agent" | "custom";
+    type: "agent";
     streaming: boolean;
+    maxContextLength?: number;
     rateLimit?: RateLimiterRule;
     config?: ExuluAgentConfig | undefined;
     evals?: ExuluAgentEval[];
@@ -136,34 +223,43 @@ declare class ExuluAgent {
         audio: string[];
         video: string[];
     };
-    constructor({ id, name, description, config, rateLimit, capabilities, type, evals }: ExuluAgentParams);
+    constructor({ id, name, description, config, rateLimit, capabilities, type, evals, maxContextLength }: ExuluAgentParams);
     get providerName(): string;
     get modelName(): string;
-    tool: () => ExuluTool;
-    generateSync: ({ prompt, user, role, session, message, tools, statistics, toolConfigs, providerApiKey }: {
+    tool: (instance: string, agents: ExuluAgent[]) => Promise<ExuluTool | null>;
+    generateSync: ({ prompt, user, session, message, currentTools, allExuluTools, statistics, toolConfigs, providerapikey, contexts, exuluConfig, filesContext, outputSchema, instructions }: {
         prompt?: string;
-        user?: string;
-        role?: string;
+        user?: User;
         session?: string;
         message?: UIMessage;
-        tools?: ExuluTool[];
+        currentTools?: ExuluTool[];
+        allExuluTools?: ExuluTool[];
         statistics?: ExuluStatisticParams;
         toolConfigs?: ExuluAgentToolConfig[];
-        providerApiKey: string;
-    }) => Promise<string | undefined>;
-    generateStream: ({ express, user, role, session, message, tools, statistics, toolConfigs, providerApiKey }: {
+        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, }: {
         express: {
             res: Response;
             req: Request;
         };
-        user: string;
-        role: string;
+        user: User;
         session: string;
         message?: UIMessage;
-        tools?: ExuluTool[];
+        currentTools?: ExuluTool[];
+        allExuluTools?: ExuluTool[];
         statistics?: ExuluStatisticParams;
         toolConfigs?: ExuluAgentToolConfig[];
-        providerApiKey: string;
+        providerapikey: string;
+        contexts?: ExuluContext[] | undefined;
+        exuluConfig?: ExuluConfig;
+        filesContext?: ExuluContext;
+        instructions?: string;
     }) => Promise<void>;
 }
 type VectorOperationResponse = Promise<{
@@ -211,8 +307,8 @@ declare class ExuluEmbedder {
         vectorDimensions: number;
         maxChunkSize: number;
     });
-    generateFromQuery(query: string, statistics?: ExuluStatisticParams, user?: string, role?: string): VectorGenerationResponse;
-    generateFromDocument(input: Item, statistics?: ExuluStatisticParams, user?: string, role?: string): VectorGenerationResponse;
+    generateFromQuery(query: string, statistics?: ExuluStatisticParams, user?: number, role?: string): VectorGenerationResponse;
+    generateFromDocument(input: Item, statistics?: ExuluStatisticParams, user?: number, role?: string): VectorGenerationResponse;
 }
 interface WorkflowVariable {
     name: string;
@@ -258,7 +354,7 @@ type ExuluEvalRunner = ({ data, runner }: {
     data: ExuluEvalInput;
     runner: {
         agent?: ExuluAgent & {
-            providerApiKey: string;
+            providerapikey: string;
         };
         workflow?: ExuluWorkflow;
     };
@@ -301,7 +397,7 @@ declare class ExuluTool {
     id: string;
     name: string;
     description: string;
-    inputSchema?: ZodSchema;
+    inputSchema?: z.ZodType;
     type: "context" | "function" | "agent";
     tool: Tool;
     config: {
@@ -312,13 +408,21 @@ declare class ExuluTool {
         id: string;
         name: string;
         description: string;
-        inputSchema?: ZodSchema;
+        inputSchema?: z.ZodType;
         type: "context" | "function" | "agent";
         config: {
             name: string;
             description: string;
         }[];
-        execute: (inputs: any) => Promise<any>;
+        execute: (inputs: any) => Promise<{
+            result?: string;
+            job?: string;
+            items?: Item[];
+        }> | AsyncGenerator<{
+            result?: string;
+            job?: string;
+            items?: Item[];
+        }>;
     });
 }
 type ExuluContextFieldDefinition = {
@@ -361,16 +465,28 @@ declare class ExuluContext {
     deleteAll: () => Promise<VectorOperationResponse>;
     tableExists: () => Promise<boolean>;
     chunksTableExists: () => Promise<boolean>;
-    createAndUpsertEmbeddings: (item: Item, user?: string, statistics?: ExuluStatisticParams, role?: string, job?: string) => Promise<{
+    createAndUpsertEmbeddings: (item: Item, 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;
+    }>;
     embeddings: {
         generate: {
             one: ({ item, user, role, trigger }: {
                 item: Item;
-                user?: string;
+                user?: number;
                 role?: string;
                 trigger: STATISTICS_LABELS;
             }) => Promise<{
@@ -378,61 +494,12 @@ declare class ExuluContext {
                 job?: string;
                 chunks?: number;
             }>;
-            all: (userId?: string, roleId?: string) => Promise<{
+            all: (userId?: number, roleId?: string) => Promise<{
                 jobs: string[];
                 items: number;
             }>;
         };
     };
-    getItems: ({ statistics, limit, sort, order, page, name, user, role, archived, query, method }: {
-        statistics?: ExuluStatisticParams;
-        page: number;
-        sort?: "created_at" | "embeddings_updated_at";
-        order?: "desc" | "asc";
-        limit: number;
-        name?: string;
-        user?: string;
-        role?: string;
-        archived?: boolean;
-        query?: string;
-        method?: VectorMethod;
-    }) => Promise<{
-        pagination: {
-            totalCount: number;
-            currentPage: number;
-            limit: number;
-            from: number;
-            pageCount: number;
-            to: number;
-            lastPage: number;
-            nextPage: number | null;
-            previousPage: number | null;
-        };
-        filters: {
-            archived: boolean | undefined;
-            name: string | undefined;
-            query: string | undefined;
-        };
-        context: {
-            name: string;
-            id: string;
-            embedder: string | undefined;
-        };
-        items: any[];
-    } | {
-        filters: {
-            archived: boolean | undefined;
-            name: string | undefined;
-            query: string;
-        };
-        context: {
-            name: string;
-            id: string;
-            embedder: string;
-        };
-        items: any[];
-        pagination?: undefined;
-    } | undefined>;
     createItemsTable: () => Promise<void>;
     createChunksTable: () => Promise<void>;
     tool: () => ExuluTool;
@@ -447,93 +514,6 @@ type ExuluStatistic = {
 };
 type ExuluStatisticParams = Omit<ExuluStatistic, "total" | "name" | "type">;
 
-type ExuluConfig = {
-    telemetry?: {
-        enabled: boolean;
-    };
-    workers: {
-        enabled: boolean;
-        logsDir?: string;
-        telemetry?: {
-            enabled: boolean;
-        };
-    };
-    MCP: {
-        enabled: boolean;
-    };
-    fileUploads: {
-        s3region: string;
-        s3key: string;
-        s3secret: string;
-        s3Bucket: string;
-        s3endpoint?: string;
-    };
-};
-declare class ExuluApp {
-    private _agents;
-    private _config?;
-    private _queues;
-    private _contexts?;
-    private _tools;
-    private _expressApp;
-    constructor();
-    create: ({ contexts, agents, config, tools }: {
-        contexts?: Record<string, ExuluContext>;
-        config: ExuluConfig;
-        agents?: ExuluAgent[];
-        tools?: ExuluTool[];
-    }) => Promise<Express>;
-    get expressApp(): Express;
-    tool(id: string): ExuluTool | undefined;
-    tools(): ExuluTool[];
-    context(id: string): ExuluContext | undefined;
-    agent(id: string): ExuluAgent | undefined;
-    get contexts(): ExuluContext[];
-    get agents(): ExuluAgent[];
-    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: () => Promise<bullmq.Worker<any, any, string>[]>;
-        };
-    };
-    private server;
-}
-
-type User = {
-    id: string;
-    email: string;
-    emailVerified?: string;
-    type?: "api" | "user";
-    anthropic_token?: string;
-    super_admin?: boolean;
-    favourite_agents?: string[];
-    role: {
-        id: string;
-        name: string;
-        agents: "read" | "write";
-        workflows: "read" | "write";
-        variables: "read" | "write";
-        users: "read" | "write";
-    };
-};
-
 declare const authentication: ({ apikey, authtoken, internalkey, db, }: {
     authtoken?: any;
     apikey?: string;
@@ -1426,6 +1406,41 @@ declare const ExuluJobs: {
         validate: (job: bullmq.Job) => bullmq.Job<any, any, string>;
     };
 };
+declare const ExuluDefaultContexts: {
+    files: ExuluContext;
+    codeStandards: ExuluContext;
+    outputs: ExuluContext;
+};
+declare const ExuluDefaultAgents: {
+    anthropic: {
+        opus4: ExuluAgent;
+        sonnet4: ExuluAgent;
+    };
+    openai: {
+        gpt5Mini: ExuluAgent;
+        gpt5: ExuluAgent;
+    };
+};
+declare const ExuluVariables: {
+    get: (name: string) => Promise<string>;
+};
+declare const ExuluUtils: {
+    batch: ({ fn, size, inputs, delay, retries }: {
+        fn: (data: any) => Promise<any>;
+        size: number;
+        inputs: any[];
+        delay: number;
+        retries: {
+            max: number;
+            delays: number[];
+        };
+    }) => Promise<any[]>;
+    retry: ({ fn, retries, delays }: {
+        fn: () => Promise<any>;
+        retries?: number;
+        delays?: number[];
+    }) => Promise<any>;
+};
 declare const ExuluOtel: {
     create: ({ SIGNOZ_ACCESS_TOKEN, SIGNOZ_TRACES_URL, SIGNOZ_LOGS_URL }: {
         SIGNOZ_ACCESS_TOKEN: string;
@@ -1454,4 +1469,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, ExuluEmbedder, ExuluEval, ExuluJobs, ExuluOtel, queues as ExuluQueues, ExuluTool, 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, ExuluJobs, ExuluOtel, queues as ExuluQueues, ExuluTool, ExuluUtils, ExuluVariables, db };