@avakado.ai/schemas 1.0.0 → 1.1.0

package/README.md

@@ -22,8 +22,18 @@ configureSchemas({ sendKafkaMessage });
 await mongoose.connect(process.env.MONGO_URI);
 ```
 
+SaaS and Chat also pass the OAuth host map used by `ApiAuthenticators.refreshToken`:
+
+```js
+configureSchemas({
+    sendKafkaMessage,
+    getAuthProvider: (name) => PROVIDER_MAP[name],
+    providerSupportsRefresh,
+});
+```
+
 ```js
-import { Business, Payment, Subscription, UsageLog, Conversation, Campaign, Task } from "@avakado.ai/schemas";
+import { Business, User, AgentModel, Channel, Workflow } from "@avakado.ai/schemas";
 import { SUBSCRIPTION_STATUS, CURRENT_SUBSCRIPTION_STATUSES } from "@avakado.ai/schemas/enums";
 import { Payment } from "@avakado.ai/schemas/models/Payments.js";   // narrower import, same registration
 ```
@@ -32,7 +42,10 @@ Every entry point returns the **same** registered model. Importing a model twice
 via a subpath, or from two places in a dependency tree — reuses the existing registration instead of
 throwing `OverwriteModelError`.
 
-## What is in v1
+## What is in v1.1
+
+Every mongoose model the four services used. Where copies differed, the package keeps the **union**
+of fields (and a superset of enums) so a save in any service still has a path to write.
 
 | Model | Collection | Notes |
 | --- | --- | --- |
@@ -43,15 +56,30 @@ throwing `OverwriteModelError`.
 | `Conversation` | `Conversations` | includes `updateStatus`, which needs `sendKafkaMessage` |
 | `Campaign` / `Task` | `Campaign` / `Tasks` | includes `updateTimeLine`; the task executor stays in socketio-server |
 | `Trigger` | `triggers` | read by `Conversation.updateStatus` |
-
-Only models that have been through a cross-service alignment pass are here. Extracting an unaligned
-model would freeze whichever copy happened to be picked — that is exactly how production ended up
-running a partial index whose filter matched zero documents.
-
-Still per-service, pending alignment: `Agent`, `Channels`, `Workflow`, `Messages`, `Leads`,
-`CallSessions`, `Plans`, `User`, `Collection`, `Action`, `Log`, `apiAuthenticator`, `market`,
-`InbuiltNodes`, `ExternalServiceProviders`, and the already-identical-but-not-yet-moved `BillingLogs`,
-`Data`, `Document`, `Integrations`, `Job`, `Tickets`, `notifications`.
+| `User` | `Users` | exports `ScopesEnum` / `RoleScopes` |
+| `AgentModel` | `Agent` | runtime discriminators `TURN_BASED` / `REALTIME` / `BACKGROUND` |
+| `Channel` | `Channel` | type enum includes both `website` and `web` |
+| `CallSession` | `CallSession` | includes AvaPhone's `usage` |
+| `Plan` | `Plans` | type enum includes `TEST` |
+| `Api` / `Providers` | `Api` / `Providers` | |
+| `Template` | `StandardProduct` | marketplace discriminator `agent` / `action` |
+| `Message` / `MessageSession` | `Messages` / `MessageSessions` | |
+| `Lead` / `LeadTemplate` | `Leads` / `LeadTemplates` | |
+| `Log` | `Logs` | includes Lambda `error` / `response` |
+| `BillingLog` | `BillingLogs` | |
+| `ApiAuthenticators` | `ApiAuthenticators` | token refresh needs `getAuthProvider` |
+| `DemonstrationModel` | `Demonstrations` | |
+| `Action` | `Action` | |
+| `Collection` | `Collection` | Lambda stage helpers are statics |
+| `Node` / `NodeModel` | `Nodes` | same registration, two export names |
+| `Integration` | `Integration` | |
+| `Job` | `Job` | discriminator `outboundCall` |
+| `Notification` | `Notification` | |
+| `Ticket` | `Ticket` | |
+| `Document` | `documents` | mongoose model name is `document` |
+| `Data` | `Data` | |
+| `Workflow` | `Workflow` | `updateStatus` / `getNextNode` live here; `execute` stays in socketio-server |
+| `WorkflowLogs` | `WorkflowLogs` | |
 
 ## Behaviour that needs the host service
 
@@ -61,9 +89,11 @@ A package cannot import a service's `utils/`, so anything a shared model needs i
 | Option | Used by | If missing |
 | --- | --- | --- |
 | `sendKafkaMessage` | `Conversation.updateStatus` | throws a named error telling you to call `configureSchemas` |
+| `getAuthProvider` | `ApiAuthenticators` token refresh | throws if `refreshToken` / `ensureValidToken` / `_resolveProvider` runs |
+| `providerSupportsRefresh` | `ApiAuthenticators` token refresh | same |
 
-Methods that need more than a function — socketio-server's `Task.trigger` needs its `RealtimeServer`
-plus the `Message` and `CallSession` models — stay in the service and attach to the shared model:
+Methods that need more than a function — socketio-server's `Task.trigger` needs its `RealtimeServer`,
+and `Workflow.execute` writes `WorkflowLogs` — stay in the service and attach to the shared model:
 
 ```js
 import { Task } from "@avakado.ai/schemas";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avakado.ai/schemas",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Canonical Mongo schemas, models, enums and index declarations shared by the Avakado services.",
   "license": "UNLICENSED",
   "type": "module",

package/src/index.js

@@ -1,3 +1,4 @@
+import "./models/index.js";
 export * from "./models/index.js";
 export * from "./enums/index.js";
 export { configureSchemas, defineModel, getSchemaConfig } from "./runtime.js";

package/src/models/Action.js

@@ -0,0 +1,19 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+const ActionSchema = new Schema({
+    name: String,
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+    async: { type: Boolean, default: true },
+    description: String,
+    needsApproval: Boolean, // Knowledge fetching doesn't need approval
+    parameters: Schema.Types.Mixed,
+    config: Schema.Types.Mixed,
+    functionString: String,
+    errorFunction: String,
+    UI: Schema.Types.Mixed,
+    isPublic: { type: Boolean, default: false },
+}, {
+    timestamps: true
+});
+export const Action = defineModel('Action', ActionSchema, "Action");
+

package/src/models/Agent.js

@@ -0,0 +1,219 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const ProviderConfig = {
+    openai: {
+        TURN_BASED: {
+            models: ['gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'],
+        },
+        REALTIME: {
+            models: ['gpt-realtime', 'gpt-realtime-mini', 'gpt-realtime-2.1', 'gpt-realtime-2.1-mini', 'gpt-realtime-2.0', 'gpt-realtime-1.5'],
+            voices: ['alloy', 'ash', 'ballad', 'coral', 'echo', 'sage', 'shimmer', 'verse', 'marin', 'cedar'],
+            modalities: ['audio', 'text'],
+            wssUrl: 'wss://api.openai.com/v1/realtime',
+        },
+    },
+    gemini: {
+        TURN_BASED: {
+            models: ['gemini-2.5-flash', 'gemini-2.5-flash-lite', 'gemini-3.5-flash', 'gemini-3.1-flash-lite', 'gemini-2.5-pro'],
+        },
+        REALTIME: {
+            models: ['gemini-2.5-flash-native-audio-latest'],
+            voices: ['Zephyr', 'Puck', 'Charon', 'Kore', 'Fenrir', 'Leda', 'Orus', 'Aoede', 'Callirrhoe', 'Autonoe', 'Enceladus', 'Iapetus', 'Umbriel', 'Algieba', 'Despina', 'Erinome', 'Algenib', 'Rasalgethi', 'Laomedeia', 'Achernar', 'Alnilam', 'Schedar', 'Gacrux', 'Pulcherrima', 'Achird', 'Zubenelgenubi', 'Vindemiatrix', 'Sadachbia', 'Sadaltager', 'Sulafat'],
+            modalities: ['AUDIO', 'TEXT'],
+            wssUrl: 'wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent',
+        },
+    },
+    anthropic: {
+        TURN_BASED: { models: ['claude-opus-4-8', 'claude-sonnet-5', 'claude-haiku-4-5-20251001'] },
+        REALTIME: null
+    }
+};
+
+
+// --- AGENT SCHEMA ---
+const ModelConfigSchema = new Schema({
+    provider: { type: String, enum: [...Object.keys(ProviderConfig), 'custom'], required: true, default: 'openai' },
+    customProviderRef: { type: String, required: function () { return this.provider === 'custom' } },
+    providerData: Schema.Types.Mixed,
+    model: {
+        type: String, required: true, validate: {
+            validator: function (value) {
+                if (this.provider === 'custom') return true;
+                return ProviderConfig[this.provider]?.[this._doc?.runtime]?.models.includes(value);
+            }, message: props => `Model "${props.value}" is not valid for provider "${this.provider}"`
+        }
+    },
+    modelSettings: {
+        temperature: { type: Number, default: 0.3 },
+        toolChoice: { type: String, default: 'auto' },
+        topP: Number,
+        frequencyPenalty: Number,
+        presencePenalty: Number,
+        parallelToolCalls: Boolean,
+        truncation: { type: String, enum: ['auto', 'disabled'] },
+        maxTokens: Number,
+        store: Boolean,
+        reasoning: {
+            effort: { type: String, enum: ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] },
+            mode: String,
+            context: { type: String, enum: ['auto', 'current_turn', 'all_turns', null] },
+            summary: { type: String, enum: ['auto', 'concise', 'detailed'] },
+        },
+        text: { verbosity: { type: String, enum: ['low', 'medium', 'high'] } },
+        promptCacheOptions: {
+            mode: { type: String, enum: ['implicit', 'explicit'] },
+            ttl: { type: String, enum: ['30m'] },
+        },
+        promptCacheRetention: { type: String, enum: ['in-memory', '24h', null] },
+        // retry: {
+        //     maxRetries: Number,
+        //     backoff: {
+        //         initialDelayMs: Number,
+        //         maxDelayMs: Number,
+        //         multiplier: Number,
+        //         jitter: Boolean,
+        //     },
+        //     policy: { type: String, enum: ['providerSuggested', 'networkError', 'retryAfter', 'never'] },
+        // },
+    },
+},
+    { _id: false }
+);
+const ResponseConfigSchema = new Schema({
+    provider: { type: String, enum: [...Object.keys(ProviderConfig), 'elevenlabs', 'custom'], required: true },
+}, { _id: false, discriminatorKey: 'provider' });
+const RealtimeConfigSchema = new Schema({
+    modality: {
+        type: String, required: true,
+        validate: {
+            validator(value) {
+                const provider = this._doc?.modelConfig?.provider;
+                const runtime = this._doc?.runtime;
+                return ProviderConfig[provider]?.[runtime]?.modalities?.includes(value);
+            },
+            message: props => `Invalid modality "${props.value}" for this provider`,
+        }
+    },
+    responseConfig: ResponseConfigSchema
+}, { _id: false });
+const responseConfigPath = RealtimeConfigSchema.path('responseConfig');
+responseConfigPath.discriminator('openai', new Schema({
+    wssUrl: { type: String, default: ProviderConfig.openai?.REALTIME?.wssUrl },
+    audio: {
+        input: {
+            noise_reduction: { type: String, enum: ['near_field', 'far_field'], default: 'near_field' },
+            transcription: { model: { type: String, default: "whisper-1" }, prompt: String, language: String },
+            turn_detection: {
+                type: { type: String, enum: ['server_vad', 'semantic_vad'], default: 'server_vad' },
+                // shared
+                create_response: { type: Boolean, default: true },
+                interrupt_response: { type: Boolean, default: true },
+                // server_vad only
+                prefix_padding_ms: {
+                    type: Number,
+                    default: function () { return this._doc.audio.input.turn_detection.type === 'server_vad' ? 300 : undefined; },
+                    validate: {
+                        validator(value) {
+                            if (value == null) return true;
+                            return this._doc.audio.input.turn_detection.type === 'server_vad';
+                        },
+                        message: 'prefix_padding_ms is only valid for server_vad',
+                    },
+                },
+                silence_duration_ms: {
+                    type: Number,
+                    default: function () { return this._doc.audio.input.turn_detection.type === 'server_vad' ? 500 : undefined; },
+                    validate: {
+                        validator(value) {
+                            if (value == null) return true;
+                            return this._doc.audio.input.turn_detection.type === 'server_vad';
+                        },
+                        message: 'silence_duration_ms is only valid for server_vad',
+                    },
+                },
+                threshold: {
+                    type: Number,
+                    min: 0,
+                    max: 1,
+                    default: function () { return this._doc.audio.input.turn_detection.type === 'server_vad' ? 0.5 : undefined; },
+                    validate: {
+                        validator(value) {
+                            if (value == null) return true;
+                            return this._doc.audio.input.turn_detection.type === 'server_vad';
+                        },
+                        message: 'threshold is only valid for server_vad',
+                    },
+                },
+                // semantic_vad only
+                eagerness: {
+                    type: String,
+                    enum: ['low', 'medium', 'high', 'auto'],
+                    default: function () { return this._doc.audio.input.turn_detection.type === 'semantic_vad' ? 'auto' : undefined; },
+                    validate: {
+                        validator(value) {
+                            if (value == null) return true;
+                            return this._doc.audio.input.turn_detection.type === 'semantic_vad';
+                        },
+                        message: 'eagerness is only valid for semantic_vad',
+                    },
+                },
+            }
+        },
+        output: {
+            speed: { type: Number, min: 0.25, max: 2.0, default: 1.0 },
+            voice: { type: String, validate: { validator: function (value) { return ProviderConfig.openai?.REALTIME?.voices.includes(value); }, message: props => `Invalid voice for openai` } },
+        }
+    }
+}, { _id: false }));
+responseConfigPath.discriminator('gemini', new Schema({
+    wssUrl: { type: String, default: ProviderConfig.gemini?.REALTIME?.wssUrl },
+    proactivity: { proactiveAudio: { type: Boolean, default: true } },
+    enableAffectiveDialog: { type: Boolean, default: true },
+    realtimeInputConfig: {
+        automaticActivityDetection: {
+            disabled: { type: Boolean, default: false },
+            startOfSpeechSensitivity: { type: String, enum: ['START_SENSITIVITY_LOW', 'START_SENSITIVITY_HIGH'], default: 'START_SENSITIVITY_HIGH' }, // gemini
+            endOfSpeechSensitivity: { type: String, enum: ['END_SENSITIVITY_LOW', 'END_SENSITIVITY_HIGH'], default: 'END_SENSITIVITY_LOW' }, // gemini
+            prefixPaddingMs: { type: Number, default: 300 },
+            silenceDurationMs: { type: Number, default: 1000 },
+        }
+    },
+    realtimeOutputConfig: {
+        speed: { type: Number, min: 0.25, max: 2.0, default: 1.0 },
+        voice: { type: String, validate: { validator: function (value) { return ProviderConfig.gemini?.REALTIME?.voices.includes(value); }, message: props => `Invalid voice for openai` } },
+    },
+    inputAudioTranscription: Schema.Types.Mixed,
+    outputAudioTranscription: Schema.Types.Mixed,
+}, { _id: false }));
+const AgentSchema = new Schema({
+    personalInfo: {
+        name: String,
+        description: String,
+        avatar: String,
+        systemPrompt: {
+            role: String,
+            objective: String,
+            instructionsAndWorkflow: String,
+            constraintsAndRules: String
+        }
+    },
+    runtime: { type: String, enum: ['TURN_BASED', 'REALTIME', 'BACKGROUND'], default: 'TURN_BASED' },
+    modelConfig: ModelConfigSchema,
+    workflow: { type: Schema.Types.ObjectId, ref: 'Workflow' },
+    collections: [{ type: Schema.Types.ObjectId, ref: 'Collection' }],
+    channels: [{ type: Schema.Types.ObjectId, ref: 'Channel' }],
+    actions: [{ type: Schema.Types.ObjectId, ref: 'Action' }],
+    tool_choice: { type: String, enum: ['auto', 'none', 'required'], default: "auto" },
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+    createdBy: { type: Schema.Types.ObjectId, ref: 'Users' },
+    isPublic: { type: Boolean, default: false },
+    isFeatured: { type: Boolean, default: false },
+}, {
+    discriminatorKey: 'runtime',
+    timestamps: true
+});
+AgentSchema.discriminator('TURN_BASED', new Schema({}, { _id: false }))
+AgentSchema.discriminator('REALTIME', RealtimeConfigSchema)
+AgentSchema.discriminator('BACKGROUND', new Schema({}, { _id: false }))
+export const AgentModel = defineModel('Agent', AgentSchema, "Agent");

package/src/models/BillingLogs.js

@@ -0,0 +1,131 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+// ─── Enums ────────────────────────────────────────────────────────────────────
+
+const BILLING_CATEGORY = [
+    // AI
+    "ai.conversation",        // agent replying to a lead
+    "ai.analysis",            // post-conversation analysis
+    "ai.summarization",       // conversation summarization
+    "ai.transcription",       // voice/audio → text (Whisper)
+    "ai.embedding",           // vector embeddings
+    // Messaging
+    "messaging.outbound",     // outbound message sent via WhatsApp/Telegram/SMS
+    "messaging.inbound",      // inbound (if your provider charges per inbound)
+    "messaging.template",     // WhatsApp template message (meta charges separately)
+    // Workflow
+    "workflow.execution",     // workflow triggered and ran
+    "workflow.step",          // individual step within a workflow
+    // Platform
+    "platform.api_call",      // external API call made on behalf of business
+    "platform.storage",       // file/media storage
+    "platform.export",        // data export
+];
+
+const BILLING_STATUS = ["success", "failed", "refunded", "pending"];
+
+const CHANNEL_TYPE = ["Whatsapp", "Telegram", "SMS", "Email", "Web", "Phone"];
+
+// ─── Sub-schemas ──────────────────────────────────────────────────────────────
+
+// AI-specific usage — only populated for ai.* categories
+const aiUsageSchema = new Schema({
+    model:          { type: String },                    // "gpt-4o-mini", "whisper-1"
+    inputTokens:    { type: Number, default: 0 },
+    cachedTokens:   { type: Number, default: 0 },        // prompt cache hits (cheaper)
+    outputTokens:   { type: Number, default: 0 },
+    totalTokens:    { type: Number, default: 0 },
+    turns:          { type: Number, default: 1 },        // how many agent turns ran
+    toolCallCount:  { type: Number, default: 0 },        // number of tool calls made
+}, { _id: false });
+
+// Messaging-specific — only for messaging.* categories
+const messagingUsageSchema = new Schema({
+    channel:        { type: String, enum: CHANNEL_TYPE },
+    provider:       { type: String },                    // "meta", "twilio", "vonage"
+    messageType:    { type: String },                    // "text", "template", "media"
+    segmentCount:   { type: Number, default: 1 },        // SMS segments
+    templateName:   { type: String },                    // WhatsApp template name
+    direction:      { type: String, enum: ["inbound", "outbound"] },
+}, { _id: false });
+
+// Workflow-specific
+const workflowUsageSchema = new Schema({
+    stepsExecuted:  { type: Number, default: 0 },
+    stepsFailed:    { type: Number, default: 0 },
+    durationMs:     { type: Number },                    // total execution time
+}, { _id: false });
+
+// Cost breakdown — always populated
+const costSchema = new Schema({
+    // Raw provider cost
+    providerCostUsd:    { type: Number, default: 0 },   // what YOU pay provider
+    // What you charge the business
+    creditRate:         { type: Number },               // your spendRatio at time of billing
+    creditsCharged:     { type: Number, default: 0 },   // credits deducted from business
+    // For reconciliation
+    currency:           { type: String, default: "USD" },
+}, { _id: false });
+
+// References — what triggered this log entry
+const sourceSchema = new Schema({
+    conversation:   { type: Schema.Types.ObjectId, ref: "Conversation" },
+    message:        { type: Schema.Types.ObjectId, ref: "Message" },
+    campaign:       { type: Schema.Types.ObjectId, ref: "Campaign" },
+    workflow:       { type: Schema.Types.ObjectId, ref: "Workflow" },
+    channel:        { type: Schema.Types.ObjectId, ref: "Channel" },
+    agent:          { type: Schema.Types.ObjectId, ref: "Agent" },
+    lead:           { type: Schema.Types.ObjectId, ref: "Lead" },
+    // The external ID from the provider (wamid, etc.)
+    externalId:     { type: String },
+}, { _id: false });
+
+// ─── Main Schema ──────────────────────────────────────────────────────────────
+
+const BillingLogSchema = new Schema({
+    // ── Who ───────────────────────────────────────────────────────────
+    business:       { type: Schema.Types.ObjectId, ref: 'Businesses', required: true },
+
+    // ── What ──────────────────────────────────────────────────────────
+    category:       { type: String, enum: BILLING_CATEGORY, required: true },
+    status:         { type: String, enum: BILLING_STATUS, default: "success" },
+
+    // ── Why / Where ───────────────────────────────────────────────────
+    source:         { type: sourceSchema, default: () => ({}) },
+
+    // ── Usage detail (only relevant sub-schema will be populated) ─────
+    ai:             { type: aiUsageSchema },
+    messaging:      { type: messagingUsageSchema },
+    workflow:       { type: workflowUsageSchema },
+
+    // ── Cost ──────────────────────────────────────────────────────────
+    cost:           { type: costSchema, required: true },
+
+    // ── Failure detail (if status = failed) ───────────────────────────
+    error:          { type: String },
+
+    // ── Catch-all for provider-specific raw data ───────────────────────
+    // e.g. WhatsApp pricing object, raw OpenAI usage response
+    raw:            { type: Schema.Types.Mixed },
+
+}, { timestamps: true });
+
+// ─── Indexes ──────────────────────────────────────────────────────────────────
+
+// Dashboard: "show me all logs for business X in date range"
+BillingLogSchema.index({ business: 1, createdAt: -1 });
+
+// Category breakdown: "show me all AI usage for business X"
+BillingLogSchema.index({ business: 1, category: 1, createdAt: -1 });
+
+// Conversation drill-down: "how much did this conversation cost?"
+BillingLogSchema.index({ "source.conversation": 1 });
+
+// Campaign cost totals
+BillingLogSchema.index({ "source.campaign": 1 });
+
+// Failed billing reconciliation
+BillingLogSchema.index({ business: 1, status: 1 });
+
+export const BillingLog = defineModel('BillingLog', BillingLogSchema, 'BillingLogs');

package/src/models/CallSessions.js

@@ -0,0 +1,34 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const TranscriptSchema = new Schema({
+    speaker: { type: String, enum: ["Lead", "agent", "user", "system"] },
+    transcript: String,
+    startMs: Number,                 // offset from call start
+    endMs: Number,
+    confidence: Number,
+    source: String,                  // provider | whisper | deepgram | …
+    usage: Schema.Types.Mixed,
+}, { _id: false });
+const CallSessionSchema = new Schema({
+    lead: { type: Schema.Types.ObjectId, ref: 'Lead' },
+    conversation: { type: Schema.Types.ObjectId, ref: 'Conversation' },
+    campaign: Schema.Types.ObjectId, // participant of the campaign(bulk messaging)
+    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
+    channel: { type: Schema.Types.ObjectId, ref: "Channel" },
+    agent: { type: Schema.Types.ObjectId, ref: 'Agent' },
+    externalCallSessionId: String,
+    direction: String,
+    statusTimeline: {
+        scheduledAt: Date, initiatedAt: Date, ringingAt: Date, in_progressAt: Date, completedAt: Date, failedAt: Date, busyAt: Date, no_answerAt: Date, canceledAt: Date, rejectedAt: Date, durationSec: { type: Number, default: 0 },
+    },
+    recording: { status: { type: String, enum: ["none", "pending", "stored", "failed"], default: "none" }, key: String, url: String },
+    transcripts: { type: [TranscriptSchema], default: [] }, // see note in chat re: very long calls
+    callDetails: Schema.Types.Mixed,
+    usage: { type: Schema.Types.Mixed, default: {} },
+    sequenceOfEvents: [Schema.Types.Mixed],
+    isSummarized: { type: Boolean, default: false }
+}, {
+    timestamps: true
+});
+export const CallSession = defineModel('CallSession', CallSessionSchema, 'CallSession');