@exulu/backend 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,450 @@
+import * as bullmq from 'bullmq';
+import { Queue } from 'bullmq';
+import * as redis from 'redis';
+import * as _mastra_core from '@mastra/core';
+import { ToolAction, Workflow, Agent } from '@mastra/core';
+import { ZodSchema, z } from 'zod';
+import { LanguageModelV1 } from 'ai';
+import { Express } from 'express';
+import { Knex } from 'knex';
+
+type STATISTICS_TYPE = "context.retrieve" | "source.update" | "embedder.upsert" | "embedder.delete" | "workflow.run" | "context.upsert" | "tool.call" | "agent.run";
+declare const STATISTICS_TYPE_ENUM: {
+    CONTEXT_RETRIEVE: string;
+    SOURCE_UPDATE: string;
+    EMBEDDER_UPSERT: string;
+    EMBEDDER_GENERATE: string;
+    EMBEDDER_DELETE: string;
+    WORKFLOW_RUN: string;
+    CONTEXT_UPSERT: string;
+    TOOL_CALL: string;
+    AGENT_RUN: string;
+};
+
+type ExuluFieldTypes = "text" | "longText" | "shortText" | "number" | "boolean" | "code" | "json";
+
+interface Item {
+    id?: string;
+    name?: string;
+    description?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    external_id?: string;
+    source?: string;
+    tags?: string[];
+    textLength?: number;
+    chunks?: {
+        id: string;
+        index: number;
+        content: string;
+        source: string;
+        embedding: number;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    [key: string]: any;
+}
+
+declare const VectorMethodEnum: {
+    readonly cosineDistance: "cosineDistance";
+    readonly l1Distance: "l1Distance";
+    readonly l2Distance: "l2Distance";
+    readonly hammingDistance: "hammingDistance";
+    readonly jaccardDistance: "jaccardDistance";
+    readonly maxInnerProduct: "maxInnerProduct";
+};
+type VectorMethod = (typeof VectorMethodEnum)[keyof typeof VectorMethodEnum];
+
+interface RateLimiterRule {
+    name?: string;
+    rate_limit: {
+        time: number;
+        limit: number;
+    };
+}
+declare const ExuluZodFileType: ({ name, label, description, allowedFileTypes }: {
+    name: string;
+    label: string;
+    description: string;
+    allowedFileTypes: (".mp4" | ".m4a" | ".mp3" | ".pdf" | ".jpeg" | ".png" | ".plain" | ".mpeg" | ".wav" | ".docx" | ".xlsx" | ".xls" | ".csv" | ".pptx" | ".ppt")[];
+}) => z.ZodObject<{
+    [x: string]: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    [x: string]: string;
+}, {
+    [x: string]: string;
+}>;
+type ExuluAgentConfig = {
+    name: string;
+    instructions: string;
+    model: LanguageModelV1;
+    memory?: {
+        lastMessages: number;
+        vector: boolean;
+        semanticRecall: {
+            topK: number;
+            messageRange: number;
+        };
+    };
+};
+declare class ExuluAgent {
+    id: string;
+    name: string;
+    description: string;
+    slug: string;
+    streaming: boolean;
+    type: "agent" | "workflow";
+    outputSchema?: ZodSchema;
+    rateLimit?: RateLimiterRule;
+    config: ExuluAgentConfig;
+    private memory;
+    tools?: ExuluTool[];
+    capabilities: {
+        tools: boolean;
+        images: string[];
+        files: string[];
+        audio: string[];
+        video: string[];
+    };
+    constructor({ id, name, description, outputSchema, config, rateLimit, type, capabilities, tools }: {
+        id: string;
+        name: string;
+        type: "agent" | "workflow";
+        description: string;
+        config: ExuluAgentConfig;
+        outputSchema?: ZodSchema;
+        rateLimit?: RateLimiterRule;
+        capabilities: {
+            tools: boolean;
+            images: string[];
+            files: string[];
+            audio: string[];
+            video: string[];
+        };
+        tools?: ExuluTool[];
+    });
+    chat: (id: string) => Promise<Agent<string, {}, Record<string, _mastra_core.Metric>>>;
+}
+type VectorOperationResponse = Promise<{
+    count: number;
+    results: any;
+    errors?: string[];
+}>;
+type VectorGenerateOperation = (inputs: ChunkerResponse) => VectorGenerationResponse;
+type ChunkerOperation = (item: Item & {
+    id: string;
+}, maxChunkSize: number) => Promise<ChunkerResponse>;
+type ChunkerResponse = {
+    item: Item & {
+        id: string;
+    };
+    chunks: {
+        content: string;
+        index: number;
+    }[];
+};
+type VectorGenerationResponse = Promise<{
+    id: string;
+    chunks: {
+        content: string;
+        index: number;
+        vector: number[];
+    }[];
+}>;
+declare class ExuluEmbedder {
+    id: string;
+    name: string;
+    slug: string;
+    queue?: Queue;
+    private generateEmbeddings;
+    vectorDimensions: number;
+    maxChunkSize: number;
+    chunker: ChunkerOperation;
+    constructor({ id, name, description, generateEmbeddings, queue, vectorDimensions, maxChunkSize, chunker }: {
+        id: string;
+        name: string;
+        description: string;
+        generateEmbeddings: VectorGenerateOperation;
+        chunker: ChunkerOperation;
+        queue?: Queue;
+        vectorDimensions: number;
+        maxChunkSize: number;
+    });
+    generateFromQuery(query: string, statistics?: {
+        label: string;
+        trigger: string;
+    }): VectorGenerationResponse;
+    generateFromDocument(input: Item, statistics?: {
+        label: string;
+        trigger: string;
+    }): VectorGenerationResponse;
+}
+declare class ExuluWorkflow {
+    id: string;
+    name: string;
+    description: string;
+    enable_batch: boolean;
+    slug: string;
+    queue: Queue | undefined;
+    workflow: Workflow;
+    inputSchema?: ZodSchema;
+    constructor({ id, name, description, workflow, queue, enable_batch, inputSchema }: {
+        id: string;
+        name: string;
+        description: string;
+        workflow: Workflow;
+        queue?: Queue;
+        inputSchema?: ZodSchema;
+        enable_batch: boolean;
+    });
+}
+type AddSourceArgs = Omit<ExuluSourceConstructorArgs, "context">;
+declare class ExuluTool {
+    id: string;
+    name: string;
+    description: string;
+    inputSchema?: ZodSchema;
+    outputSchema?: ZodSchema;
+    type: "context" | "function";
+    private _execute;
+    constructor({ id, name, description, inputSchema, outputSchema, type, execute }: {
+        id: string;
+        name: string;
+        description: string;
+        inputSchema?: ZodSchema;
+        outputSchema?: ZodSchema;
+        type: "context" | "function";
+        execute: ToolAction['execute'];
+    });
+    execute: (inputs: any) => Promise<unknown>;
+}
+type ExuluContextFieldDefinition = {
+    name: string;
+    type: ExuluFieldTypes;
+};
+declare class ExuluContext {
+    id: string;
+    name: string;
+    active: boolean;
+    fields: ExuluContextFieldDefinition[];
+    rateLimit?: RateLimiterRule;
+    description: string;
+    embedder: ExuluEmbedder;
+    queryRewriter?: (query: string) => Promise<string>;
+    resultReranker?: (results: any[]) => Promise<any[]>;
+    private _sources;
+    private configuration;
+    constructor({ id, name, description, embedder, active, rateLimit, fields, queryRewriter, resultReranker, configuration }: {
+        id: string;
+        name: string;
+        fields: ExuluContextFieldDefinition[];
+        description: string;
+        embedder: ExuluEmbedder;
+        active: boolean;
+        rateLimit?: RateLimiterRule;
+        queryRewriter?: (query: string) => Promise<string>;
+        resultReranker?: (results: any[]) => Promise<any[]>;
+        configuration?: {
+            calculateVectors: "manual" | "onUpdate" | "onInsert" | "always";
+        };
+    });
+    deleteOne: (id: string) => VectorOperationResponse;
+    deleteAll: () => VectorOperationResponse;
+    getTableName: () => string;
+    getChunksTableName: () => string;
+    tableExists: () => Promise<boolean>;
+    updateItem(user: string, id: string, item: Item): Promise<{
+        id: string;
+        job?: string;
+    }>;
+    insertItem(user: string, item: Item, upsert?: boolean): Promise<{
+        id: string;
+        job?: string;
+    }>;
+    getItems: ({ statistics, limit, page, name, archived, query, method }: {
+        statistics?: {
+            label: string;
+            trigger: string;
+        };
+        page: number;
+        limit: number;
+        name?: 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;
+        };
+        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;
+    sources: {
+        add: (inputs: AddSourceArgs) => ExuluSource;
+        get: (id?: string) => ExuluSource[] | (ExuluSource | undefined);
+    };
+}
+/**
+ * @param updaters - Defines how this source decides when and which data to send to the embedder for updating vectors
+ * @param updaters.type - The type of update mechanism:
+ *   - "manual": Will be shown in the Exulu frontend UI via a Button for manual triggering
+ *   - "cron": Will automatically update on a schedule
+ *   - "webhook": Will update when triggered by an external webhook
+ * @param updaters.fn - The function that handles the update logic
+ * @param configuration - Defines fields shown in the UI that admins can set for each instance of the Source
+ *   This allows reusing logic while exposing configurable variables (e.g. a "query" field)
+ *   that admins can set differently for different instances in the UI
+ */
+type ExuluSourceConstructorArgs = {
+    id: string;
+    name: string;
+    description: string;
+    updaters: ExuluSourceUpdaterArgs[];
+    context: string;
+};
+type SourceDocument = {
+    id: string;
+    content: string;
+    metadata?: Record<string, any>;
+};
+type ExuluSourceUpdaterArgs = {
+    id: string;
+    type: "manual" | "cron" | "webhook";
+    fn: (configuration: Record<string, any>) => Promise<SourceDocument[]>;
+    configuration: Record<string, {
+        type: "string" | "number" | "query";
+        example: string;
+    }>;
+};
+type ExuluSourceUpdater = ExuluSourceUpdaterArgs & {
+    slug?: string;
+};
+declare class ExuluSource {
+    id: string;
+    name: string;
+    description: string;
+    updaters: ExuluSourceUpdater[];
+    context: string;
+    constructor({ id, name, description, updaters, context }: ExuluSourceConstructorArgs);
+}
+
+type ExuluConfig = {
+    workers: {
+        enabled: boolean;
+        logsDir?: string;
+    };
+};
+declare class ExuluApp {
+    private _agents;
+    private _workflows;
+    private _config;
+    private _embedders;
+    private _queues;
+    private _contexts?;
+    private _tools;
+    constructor({ contexts, embedders, agents, workflows, config, tools }: {
+        contexts?: Record<string, ExuluContext>;
+        config: ExuluConfig;
+        embedders?: ExuluEmbedder[];
+        agents?: ExuluAgent[];
+        workflows?: ExuluWorkflow[];
+        tools?: ExuluTool[];
+    });
+    embedder(id: string): ExuluEmbedder | undefined;
+    tool(id: string): ExuluTool | undefined;
+    tools(): ExuluTool[];
+    context(id: string): ExuluContext | undefined;
+    agent(id: string): ExuluAgent | undefined;
+    workflow(id: string): ExuluWorkflow | undefined;
+    get embedders(): ExuluEmbedder[];
+    get contexts(): ExuluContext[];
+    get workflows(): ExuluWorkflow[];
+    get agents(): ExuluAgent[];
+    bullmq: {
+        workers: {
+            create: () => Promise<bullmq.Worker<any, any, string>[]>;
+        };
+    };
+    server: {
+        express: {
+            init: (app: Express) => Promise<void>;
+        };
+    };
+}
+
+type User = {
+    id: string;
+    email: string;
+    emailVerified?: string;
+    type?: "api" | "user";
+    roles?: {
+        id: string;
+        role: string;
+    }[];
+};
+
+declare const authentication: ({ apikey, authtoken, internalkey, db, }: {
+    authtoken?: any;
+    apikey?: string;
+    internalkey?: string;
+    db: Knex;
+}) => Promise<{
+    error: boolean;
+    message?: string;
+    code?: number;
+    user?: User;
+}>;
+
+declare class ExuluQueues {
+    queues: Queue[];
+    constructor();
+    queue(name: string): Queue | undefined;
+    use(name: string): Queue;
+}
+declare const queues: ExuluQueues;
+
+declare const ExuluJobs: {
+    redis: redis.RedisClientType | null;
+    jobs: {
+        validate: (job: bullmq.Job) => bullmq.Job<any, any, string>;
+    };
+};
+
+declare const ExuluDatabase: {
+    init: () => Promise<void>;
+};
+
+export { type STATISTICS_TYPE as EXULU_STATISTICS_TYPE, STATISTICS_TYPE_ENUM as EXULU_STATISTICS_TYPE_ENUM, ExuluAgent, ExuluApp, authentication as ExuluAuthentication, ExuluContext, ExuluDatabase, ExuluEmbedder, ExuluJobs, queues as ExuluQueues, ExuluSource, ExuluTool, ExuluWorkflow, ExuluZodFileType };