@avakado.ai/schemas 1.0.0 → 1.1.1

package/src/models/Channels.js

@@ -0,0 +1,268 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const Capability = new Schema({
+    key: String,
+    enabled: { type: Boolean, default: false },
+    label: String,
+    description: String,
+}, { _id: false });
+
+export const ChannelCapabilityDefaults = {
+    whatsapp: [
+        {
+            key: "text",
+            enabled: true,
+            label: "Text",
+            description: "Plain text messages. Supports basic formatting like bold, italic, and emojis.",
+        },
+        {
+            key: "button",
+            enabled: true,
+            label: "Quick Reply Buttons",
+            description: "Up to 3 tappable reply buttons below a message. Best for simple yes/no or multi-choice responses."
+        },
+        {
+            key: "list",
+            enabled: false,
+            label: "List Menu",
+            description: "A scrollable menu with up to 10 rows grouped into sections. Best for support categories, product options, or multi-step flows."
+        },
+        {
+            key: "cta_url",
+            enabled: false,
+            label: "CTA URL Button",
+            description: "A button that opens a URL in the user's browser when tapped."
+        },
+        {
+            key: "voice_call",
+            enabled: false,
+            label: "Voice Call Button",
+            description: "A button that opens the user's phone app to make a voice call when tapped."
+        },
+        {
+            key: "location",
+            enabled: false,
+            label: "Location Request",
+            description: "A button that opens the user's phone app to send their location when tapped."
+        },
+        {
+            key: "image",
+            enabled: false,
+            label: "Image",
+            description: "Send images (JPEG/PNG) with an optional caption. Useful for product visuals, receipts, or guides."
+        },
+        {
+            key: "template",
+            enabled: false,
+            label: "Template",
+            description: "Pre-approved message templates required for first outbound messages or notifications outside the 24-hour window."
+        },
+        {
+            key: "document",
+            enabled: false,
+            label: "Document",
+            description: "Send files such as PDFs, invoices, or manuals. Supports most common document formats."
+        },
+        {
+            key: "video",
+            enabled: false,
+            label: "Video",
+            description: "Send MP4 video files with an optional caption. Useful for tutorials or product demos."
+        },
+        {
+            key: "audio",
+            enabled: false,
+            label: "Audio",
+            description: "Send voice notes or audio clips. Useful for spoken instructions or announcements."
+        },
+        {
+            key: "sticker",
+            enabled: false,
+            label: "Sticker",
+            description: "Send WhatsApp-compatible WebP stickers. Mostly used for casual or expressive interactions."
+        },
+    ],
+    telegram: [
+        {
+            key: "text",
+            enabled: true,
+            label: "Text",
+            description: "Plain or Markdown-formatted text messages. Supports bold, italic, code blocks, and links."
+        },
+        {
+            key: "interactive_button",
+            enabled: true,
+            label: "Inline Buttons",
+            description: "Inline keyboard buttons attached to a message. Each button carries a callback_data payload sent back on tap."
+        },
+        {
+            key: "image",
+            enabled: false,
+            label: "Image",
+            description: "Send photos with an optional caption. Supports JPEG and PNG formats."
+        },
+        {
+            key: "video",
+            enabled: false,
+            label: "Video",
+            description: "Send MP4 video files with an optional caption."
+        },
+        {
+            key: "audio",
+            enabled: false,
+            label: "Audio",
+            description: "Send audio files or voice messages. Displayed as a playable audio player in chat."
+        },
+        {
+            key: "document",
+            enabled: false,
+            label: "Document",
+            description: "Send any file type as a document. Useful for sharing PDFs, spreadsheets, or archives."
+        },
+        {
+            key: "sticker",
+            enabled: false,
+            label: "Sticker",
+            description: "Send Telegram-compatible WebP or TGS animated stickers."
+        },
+    ],
+    sms: [
+        {
+            key: "text",
+            enabled: true,
+            label: "Text",
+            description: "Plain text SMS. Maximum 160 characters per segment. No formatting, links, or media supported natively."
+        },
+    ],
+    email: [
+        {
+            key: "text",
+            enabled: true,
+            label: "Text / HTML",
+            description: "Plain text or HTML-formatted email body. Supports rich layout, headings, and styled content."
+        },
+        {
+            key: "image",
+            enabled: false,
+            label: "Inline Image",
+            description: "Embed images directly in the email body or include them as attachments."
+        },
+        {
+            key: "document",
+            enabled: false,
+            label: "Attachment",
+            description: "Attach files such as PDFs, invoices, or reports to the email."
+        },
+    ],
+    web: [
+        {
+            key: "text",
+            enabled: true,
+            label: "Text",
+            description: "Plain text chat bubble rendered in the web widget. Supports basic markdown."
+        },
+        {
+            key: "interactive_button",
+            enabled: true,
+            label: "Quick Reply Buttons",
+            description: "Clickable option buttons rendered below a message. Ideal for guided flows and FAQs."
+        },
+        {
+            key: "interactive_list",
+            enabled: false,
+            label: "List Menu",
+            description: "A dropdown or scrollable list of options. Best for longer option sets like categories or topics."
+        },
+        {
+            key: "image",
+            enabled: false,
+            label: "Image",
+            description: "Display images inside the chat widget with an optional caption."
+        },
+        {
+            key: "card",
+            enabled: false,
+            label: "Card",
+            description: "A rich card with a title, subtitle, image, and action buttons. Useful for product listings or recommendations."
+        },
+    ],
+    instagram: [
+        {
+            key: "text",
+            enabled: true,
+            label: "Text",
+            description: "Plain text DM. Supports emojis but no rich formatting."
+        },
+        {
+            key: "interactive_button",
+            enabled: true,
+            label: "Quick Reply Buttons",
+            description: "Predefined reply chips shown below a message. User taps one to send a reply. Limited to Instagram's supported button types."
+        },
+        {
+            key: "image",
+            enabled: false,
+            label: "Image",
+            description: "Send images directly in the DM. Useful for product previews or visual confirmations."
+        },
+        {
+            key: "sticker",
+            enabled: false,
+            label: "Sticker / Reaction",
+            description: "Send Instagram stickers or emoji reactions within the DM thread."
+        },
+    ],
+    phone: [
+        {
+            key: "voice",
+            enabled: true,
+            label: "Voice / TTS",
+            description: "Text-to-speech voice response read aloud to the caller. Supports plain text or SSML for tone and pacing control."
+        },
+    ],
+};
+
+const ChannelBaseSchema = new Schema(
+    {
+        name: { type: String, required: true, trim: true },
+        business: { type: Schema.Types.ObjectId, ref: 'Businesses', required: true },
+        provider: { type: Schema.Types.ObjectId, ref: 'Providers' },
+        apiAuthenticator: { type: Schema.Types.ObjectId, ref: 'ApiAuthenticators' },
+        type: { type: String, enum: ["whatsapp", "telegram", "website", "web", "phone", "instagram", "sms", "email"] },
+        runtime: { type: String, enum: ['TURN_BASED', 'REALTIME'], default: 'TURN_BASED' },
+        config: { type: Schema.Types.Mixed, default: {} },
+        externalId: String,
+        status: { type: String, default: 'disabled' },   // enabled | disabled | error
+        webhookUrl: String,
+        systemPrompt: String,
+        isPublic: { type: Boolean, default: false },
+        UIElements: Schema.Types.Mixed,
+        settings: {
+            // defaultTemplate for leades created using this channel
+            // snoozTime: Date,
+            // Notification:Schema.Types.Mixed,
+            // iceBreaker: template
+            responseFormatCapabilities: [Capability],
+        }
+
+    },
+    { timestamps: true }
+);
+ChannelBaseSchema.methods.updateStatus = function (status) {
+    this.status = status;
+    return this.save();
+};
+ChannelBaseSchema.pre("save", function (next) {
+    if (this.isNew && !this.settings?.responseFormatCapabilities?.length) {
+        const defaults = ChannelCapabilityDefaults[this.type] || [
+            { key: "text", enabled: true, label: "Text", description: "Plain text messages. Supports basic formatting like bold, italic, and emojis." }   // fallback
+        ];
+        this.settings = {
+            ...this.settings,
+            responseFormatCapabilities: defaults
+        };
+    }
+    next();
+});
+export const Channel = defineModel('Channel', ChannelBaseSchema, 'Channel');

package/src/models/Collection.js

@@ -0,0 +1,189 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const metaData = new Schema({
+    webcrawler: {
+        options: Object,
+        jobId: String,
+        lastUpdate: Schema.Types.Mixed,
+        urls: [String]
+    },
+    chunkingDetails: {
+        strategy: { type: String, enum: ["recursiveStructural", "recursiveSemantic"], default: 'recursiveStructural' },
+        tunables: {
+            MIN_TOKENS: { type: Number, default: 30 },
+            MAX_TOKENS: { type: Number, default: 512 },
+            OVERLAP_TOKENS: { type: Number, default: 50 },
+        }
+    },
+    parserDetails: {
+        tier: { type: String, enum: ['fast', 'cost_effective', 'agentic', "agentic_plus"], default: 'cost_effective' },
+        expand: { type: [String], enum: ['text', 'items', "markdown", 'metadata', 'images_content_metadata', 'xlsx_content_metadata', 'output_pdf_content_metadata'], default: ['items', "markdown", 'metadata', 'images_content_metadata'] },
+        version: { type: String, enum: ['latest'], default: 'latest' },
+        source_url: String,
+        advancedOptions: {
+            page_ranges: {
+                target_pages: String,
+                max_pages: Number,
+            },
+            disable_cache: Boolean,
+            agentic_options: {
+                custom_prompt: String
+            },
+            output_options: {
+                extract_printed_page_number: Boolean,
+                images_to_save: { type: [String], enum: ["screenshot", "embedded", "layout"] },
+                markdown: {
+                    annotate_links: Boolean,
+                    inline_images: Boolean,
+                    tables: {
+                        compact_markdown_tables: Boolean,
+                        markdown_table_multiline_separator: String,
+                        merge_continued_tables: Boolean,
+                        output_tables_as_markdown: Boolean,
+                    },
+                    spatial_text: {
+                        do_not_unroll_columns: Boolean,
+                        preserve_layout_alignment_across_pages: Boolean,
+                        preserve_very_small_text: Boolean,
+                    },
+                    tables_as_spreadsheet: {
+                        enable: Boolean,
+                        guess_sheet_name: Boolean,
+                    },
+                }
+            },
+            input_options: {
+                html: {
+                    make_all_elements_visible: Boolean,
+                    remove_fixed_elements: Boolean,
+                    remove_navigation_elements: Boolean,
+                },
+                presentation: {
+                    out_of_bounds_content: Boolean,
+                    skip_embedded_data: Boolean,
+                },
+                spreadsheet: {
+                    detect_sub_tables_in_sheets: Boolean,
+                    force_formula_computation_in_sheets: Boolean,
+                    include_hidden_sheets: Boolean,
+                },
+            },
+            processing_options: {
+                aggressive_table_extraction: Boolean,
+                cost_optimizer: {
+                    enable: Boolean,
+                },
+                disable_heuristics: Boolean,
+                ignore: {
+                    ignore_diagonal_text: Boolean,
+                    ignore_text_in_image: Boolean,
+                    ignore_hidden_text: Boolean,
+                },
+                ocr_parameters: {
+                    languages: { type: [String], enum: ["en", "fr", "de", "es", "it", "pt", "ru", "zh"] },
+                },
+                specialized_chart_parsing: { type: String, enum: ["agentic_plus", "agentic", "efficient"] }
+            },
+            // webhook_configurations: {
+            //     webhook_events: { type: [String], enum: ["parsing_completed", "parsing_failed", "parsing_progress"] },
+            //     webhook_headers: { type: Object },
+            //     webhook_url: { type: String },
+            // },
+            processing_control: {
+                job_failure_conditions: {
+                    allowed_page_failure_ratio: Number,
+                    fail_on_buggy_font: Boolean,
+                    fail_on_image_extraction_error: Boolean,
+                    fail_on_image_ocr_error: Boolean,
+                    fail_on_markdown_reconstruction_error: Boolean,
+                },
+                timeouts: {
+                    base_in_seconds: Number,
+                    extra_time_per_page_in_seconds: Number,
+                },
+            }
+        },
+        jobId: String,
+        lastUpdate: Schema.Types.Mixed,
+    },
+    progressStages: [{
+        name: { type: String, enum: ['webcrawler', 'embed and upsert', 'Chunking', 'Parsing'] },
+        accomplished: { type: Boolean, default: false },
+        status: { type: String, default: "PENDING", enum: ["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED"] },
+        error: { type: String },
+        startedAt: { type: Date, default: Date.now },
+        completedAt: { type: Date },
+        failedAt: { type: Date },
+        moreInfo: { type: Schema.Types.Mixed }
+    }],
+}, { _id: false });
+const CollectionSchema = new Schema({
+    name: { type: String, required: true, },
+    source: { type: String, enum: ['website', 'youtube', 'file', 'text'] },
+    status: { type: String, default: "loading", enum: ["active", "loading", "failed", "cancelled"] },
+    error: { type: String },
+    metaData: metaData,
+    description: { type: String },
+    tags: [String],
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+    createdBy: { type: Schema.Types.ObjectId, ref: 'Users' },
+    isPublic: { type: Boolean, default: false },
+    isFeatured: { type: Boolean, default: false }
+}, {
+    timestamps: true
+});
+
+CollectionSchema.statics.updateStage = async function (collectionId, stageName, updates) {
+    return this.findOneAndUpdate({ _id: collectionId, 'metaData.progressStages.name': stageName }, { $set: updates }, { new: true });
+};
+CollectionSchema.statics.startStage = function (collectionId, stageName, moreInfo) {
+    return this.updateStage(collectionId, stageName, {
+        'metaData.progressStages.$.status': 'RUNNING',
+        'metaData.progressStages.$.startedAt': new Date(),
+        'metaData.progressStages.$.error': null,
+        'metaData.progressStages.$.moreInfo': moreInfo
+    });
+};
+CollectionSchema.statics.cancelStage = function (collectionId, stageName, moreInfo) {
+    return this.updateStage(collectionId, stageName, {
+        'metaData.progressStages.$.status': 'CANCELLED',
+        'metaData.progressStages.$.completedAt': new Date(),
+        'metaData.progressStages.$.error': 'Cancelled by user',
+        'metaData.progressStages.$.moreInfo': moreInfo
+    });
+};
+CollectionSchema.statics.pendingStage = function (collectionId, stageName, moreInfo) {
+    return this.updateStage(collectionId, stageName, {
+        'metaData.progressStages.$.status': 'PENDING',
+        'metaData.progressStages.$.startedAt': null,
+        'metaData.progressStages.$.completedAt': null,
+        'metaData.progressStages.$.failedAt': null,
+        'metaData.progressStages.$.error': null,
+        'metaData.progressStages.$.moreInfo': moreInfo
+    });
+};
+CollectionSchema.statics.completeStage = function (collectionId, stageName, moreInfo) {
+    return this.updateStage(collectionId, stageName, {
+        'metaData.progressStages.$.accomplished': true,
+        'metaData.progressStages.$.status': 'COMPLETED',
+        'metaData.progressStages.$.completedAt': new Date(),
+        'metaData.progressStages.$.error': null,
+        'metaData.progressStages.$.moreInfo': moreInfo
+    });
+};
+CollectionSchema.statics.failStage = function (collectionId, stageName, error, moreInfo) {
+    return this.updateStage(collectionId, stageName, {
+        'metaData.progressStages.$.accomplished': false,
+        'metaData.progressStages.$.status': 'FAILED',
+        'metaData.progressStages.$.failedAt': new Date(),
+        'metaData.progressStages.$.error': error?.message || error,
+        'metaData.progressStages.$.moreInfo': moreInfo
+    });
+};
+CollectionSchema.statics.updateMetadata = async function (collectionId, updates) {
+    return await this.findOneAndUpdate({ _id: collectionId, 'metaData': { $exists: true } }, { $set: updates }, { new: true });
+};
+CollectionSchema.statics.updateStatus = async function (collectionId, status, error) {
+    return await this.findOneAndUpdate({ _id: collectionId }, { $set: { status, error: error?.message || error } }, { new: true });
+};
+export const Collection = defineModel('Collection', CollectionSchema, "Collection");

package/src/models/Data.js

@@ -0,0 +1,35 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const DataSchema = new Schema({
+    collection: { type: Schema.Types.ObjectId, ref: "Collection" },
+    content: String,
+    chunkNumber: Number,
+    summary: String,
+    embeddingVector: [Number],
+    newTopics: [String],
+    metadata: {
+        tokensUsed: Number,
+        chunkSize: Number, // length of content
+        createdAt: { type: Date, default: Date.now },  // time of creation
+        url: String,
+        tokenUsage: {
+            embeddingTokens: Number,
+            embeddingModel: String,
+            summarizationInputTokens: Number,
+            summarizationOutputTokens: Number,
+            summarizationTotalTokens: Number,
+            summarizationModel: String
+        }
+    }
+}, {
+    timestamps: true,
+    suppressReservedKeysWarning: true,
+});
+DataSchema.pre('save', function (next) {
+    if (this.content) {
+        this.metadata.chunkSize = this.content.length;
+    }
+    next();
+});
+export const Data = defineModel('Data', DataSchema, "Data");

package/src/models/Demonstarations.js

@@ -0,0 +1,23 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const DemonstrationSchema = new Schema({
+    lead: {
+        name: String,
+        email: String,
+        phone: String,
+        department: String,
+        source: String,
+    },
+    organization: {
+        id: String,
+        name: String,
+        industry: String,
+    },
+    transcripts: Schema.Types.Mixed,
+    miscellaneous: Schema.Types.Mixed,
+    kind: String,
+    demoEndedAt: Date,
+}, { timestamps: true });
+
+export const DemonstrationModel = defineModel('Demonstrations', DemonstrationSchema, "Demonstrations");

package/src/models/Document.js

@@ -0,0 +1,15 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+
+const documentSchema = Schema({
+    name: String,
+    data: { FileName: String, resource_id: String, mimetype: String, originalname: String, fileIdentifier: String, preview_url: String, download_url: String },
+    contentType: String,
+    user: { type: Schema.Types.ObjectId, ref: "Users" },
+    viewers: [{ type: Schema.Types.ObjectId, ref: "Users" }],
+    type: String
+}, { timestamps: true });
+const Document = defineModel('document', documentSchema);
+export { Document };
+export default Document

package/src/models/ExternalServiceProviders.js

@@ -0,0 +1,104 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const ApiSchema = new Schema({
+    provider: { type: Schema.Types.ObjectId, ref: 'Providers' },
+    title: String, // <Provider>.<Resource>.<Action> excel.table.list  excel.range.update
+    description: String, // description of the api in human readable format
+    version: String, // version of the api
+    schemas: {
+        input: Schema.Types.Mixed, // JSON schema for the input
+        config: Schema.Types.Mixed, // JSON schema for the config
+        output: Schema.Types.Mixed, // JSON schema for the output
+        error: Schema.Types.Mixed, // JSON schema for the error
+        auth: { type: String, enum: ['oauth2', 'apiKey', 'basic', 'bearer', 'jwt', 'hmac', 'customHeader', 'mtls', 'cookie', 'none'] } // auth type for now only oauth2 is supported
+    },
+    requestTemplate: {
+        method: String, // GET, POST, PUT, DELETE, PATCH, etc.
+        url: {
+            base: String, // base url of the api
+            path: String, // path of the api
+            params: Schema.Types.Mixed // query params of the api 
+        },
+        headers: Schema.Types.Mixed, // headers of the api
+        body: Schema.Types.Mixed // body of the api
+    },
+    requiredScopes: [String], // scopes required for the api
+    metadata: {
+        category: String,
+        feature: String
+    }
+}, { timestamps: true });
+
+ApiSchema.methods.evaluateExpressions = function (context = { input, config, auth }) {
+    const EXPR_REGEX = /\{\{\{([\s\S]*?)\}\}\}|\{\{([\s\S]*?)\}\}/g;
+    function evalExpression(expr) {
+        try {
+            const fn = new Function(
+                "input",
+                "config",
+                "auth",
+                "context",
+                `return (${expr})`
+            );
+            return fn(context.input, context.config, context.auth, context);
+        } catch (err) {
+            console.error("Expression error:", expr, err);
+            return undefined;
+        }
+    }
+
+    function process(value) {
+        if (typeof value === "string") {
+            const matches = [...value.matchAll(EXPR_REGEX)];
+            //entire string is a single expression → return real type
+            if (
+                matches.length === 1 &&
+                matches[0][0].length === value.length
+            ) {
+                const expr = matches[0][1] || matches[0][2];
+                return evalExpression(expr);
+            }
+
+            //string with mixed content → interpolate
+            return value.replace(EXPR_REGEX, (_, expr1, expr2) => {
+                const result = evalExpression(expr1 || expr2);
+
+                if (result === undefined || result === null) return "";
+                if (typeof result === "object") return JSON.stringify(result);
+
+                return String(result);
+            });
+        }
+
+        //Array
+        if (Array.isArray(value)) {
+            return value.map(process);
+        }
+
+        // Object
+        if (typeof value === "object" && value !== null) {
+            const result = {};
+            for (const key in value) {
+                result[key] = process(value[key]);
+            }
+            return result;
+        }
+        // Pimitive (number, boolean, etc.)
+        return value;
+    }
+    return process(this.requestTemplate);
+};
+
+// { method: String, url: { base: String, path: String, params: object }, headers: object, body: object }
+const ProvidersSchema = new Schema({
+    name: String,
+    description: String,
+    icon: String, // url
+    color: String,
+    basicScopes: [String],
+    apiFilters: Schema.Types.Mixed,
+    createdBy: { type: Schema.Types.ObjectId, ref: 'Users' }
+}, { timestamps: true });
+
+export const Api = defineModel('Api', ApiSchema, 'Api');
+export const Providers = defineModel('Providers', ProvidersSchema, 'Providers');

package/src/models/InbuiltNodes.js

@@ -0,0 +1,19 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const NodeSchema = new Schema(
+    {
+        type: { type: String, required: true, enum: ['trigger', 'task', 'conditional'] },
+        core: {
+            inputMapper: String,
+            inputSchema: Schema.Types.Mixed,
+            outputSchema: Schema.Types.Mixed,
+            configSchema: Schema.Types.Mixed,
+            handlerFunction: { type: String, required: true },
+            errorFunction: { type: String }
+        },
+        meta: { label: String }
+    },
+    { timestamps: true }
+);
+export const NodeModel = defineModel('Node', NodeSchema, 'Nodes');
+export const Node = NodeModel;