@avakado.ai/schemas 1.1.17 → 1.1.19

package/package.json

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

package/src/enums/index.js

@@ -3,6 +3,12 @@
 // missing from a validator, a partial index filtering on a status list that had fallen behind.
 // Anything that validates or filters on these values must read them from here.
 
+export const LEAD_STATUS = ["new", "contacted", "qualified", "converted", "lost", "spam"];
+export const CONVERSATION_STATUS = ["open", "pending", "snoozed", "completed", "closed", "archived", "spam"];
+export const CAMPAIGN_STATUS = ["pending", "active", "completed", "failed", "partial"];
+export const TASK_STATUS = ["pending", "in-progress", "completed", "failed", "skipped"];
+export const WORKFLOW_TRIGGERS = [...LEAD_STATUS.map(status => `lead_${status}`), ...CONVERSATION_STATUS.map(status => `conversation_${status}`), ...CAMPAIGN_STATUS.map(status => `campaign_${status}`), ...TASK_STATUS.map(status => `task_${status}`)];
+export const CONVERSATION_PRIORITY = ["low", "normal", "high", "urgent"];
 export const SUBSCRIPTION_STATUS = [
     "created",
     "pending_payment",
@@ -55,11 +61,7 @@ export const LEDGER_CATEGORY = {
     THIRD_PARTY: "third_party",
 };
 
-export const CONVERSATION_STATUS = ["open", "pending", "snoozed", "completed", "closed", "archived", "spam"];
-export const CONVERSATION_PRIORITY = ["low", "normal", "high", "urgent"];
 
-export const CAMPAIGN_STATUS = ["pending", "active", "completed", "failed", "partial"];
-export const TASK_STATUS = ["pending", "in-progress", "completed", "failed", "skipped"];
 export const TASK_TYPES = ["quick", "webhook"];
 export const TASK_REFERENCE_TYPES = ["Message", "CallSession"];
 

package/src/media.js

@@ -41,6 +41,7 @@ export const CONVERTERS = new Set([
     "identity",
     "pcm16:8000->pcm16:16000",
     "pcm16:8000->pcm16:24000",
+    "pcm16:16000->pcm16:24000",
     "pcm16:24000->pcm16:8000",
     "pcm16:24000->pcm16:16000",
     "pcm16:24000->g711_ulaw:8000",
@@ -73,9 +74,8 @@ export const CHANNEL_CATALOGS = {
 export const PROVIDER_CARDS = {
     openai: {
         symmetric: true,
+        // audio/pcm is 24 kHz only. audio/pcmu and audio/pcma carry no rate.
         wires: [
-            wire("pcm16", 8000),
-            wire("pcm16", 16000),
             wire("pcm16", 24000),
             wire("g711_ulaw", 8000),
             wire("g711_alaw", 8000),

package/src/media.test.js

@@ -2,24 +2,25 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { MediaPlanError, negotiateCall, selectChannelMedia } from "./media.js";
 
-test("exotel default and openai share pcm16 8 kHz", () => {
+test("exotel 8 kHz pcm is resampled to openai 24 kHz", () => {
     const plan = negotiateCall({ channelName: "Exotel", provider: "openai" });
     assert.deepEqual(plan.channel, { encoding: "pcm16", rate: 8000 });
-    assert.deepEqual(plan.provider.input, plan.channel);
-    assert.deepEqual(plan.provider.output, plan.channel);
-    assert.equal(plan.uplink, "identity");
-    assert.equal(plan.downlink, "identity");
+    assert.deepEqual(plan.provider.input, { encoding: "pcm16", rate: 24000 });
+    assert.deepEqual(plan.provider.output, { encoding: "pcm16", rate: 24000 });
+    assert.equal(plan.uplink, "pcm16:8000->pcm16:24000");
+    assert.equal(plan.downlink, "pcm16:24000->pcm16:8000");
 });
 
-test("user can move exotel to 16 kHz and openai follows", () => {
+test("exotel 16 kHz pcm is resampled to openai 24 kHz", () => {
     const plan = negotiateCall({
         channelName: "exotel",
         channelConfig: { media: { encoding: "pcm16", rate: 16000 } },
         provider: "openai",
     });
     assert.equal(plan.channel.rate, 16000);
-    assert.equal(plan.uplink, "identity");
-    assert.equal(plan.downlink, "identity");
+    assert.equal(plan.provider.input.rate, 24000);
+    assert.equal(plan.uplink, "pcm16:16000->pcm16:24000");
+    assert.equal(plan.downlink, "pcm16:24000->pcm16:16000");
 });
 
 test("exotel 8 kHz and gemini bridge 16 kHz in and 24 kHz out", () => {

package/src/models/Campaign.js

@@ -1,6 +1,7 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
 import { CAMPAIGN_STATUS, TASK_REFERENCE_TYPES, TASK_STATUS, TASK_TYPES } from "../enums/index.js";
+import { attachStatusChangeTrigger } from "../statusTrigger.js";
 
 const TaskSchema = new Schema({
     business: { type: Schema.Types.ObjectId, ref: 'Businesses', required: true },
@@ -62,6 +63,9 @@ CampaignSchema.methods.updateTimeLine = async function (timeLine, currentStatus)
     return this.save();
 };
 
+attachStatusChangeTrigger(TaskSchema, "task");
+attachStatusChangeTrigger(CampaignSchema, "campaign");
+
 export { CampaignSchema, TaskSchema };
 export const Campaign = defineModel('Campaign', CampaignSchema, 'Campaign');
 export const Task = defineModel('Task', TaskSchema, 'Tasks');

package/src/models/Conversations.js

@@ -1,6 +1,7 @@
 import { Schema } from "mongoose";
 import { defineModel, requireDep } from "../runtime.js";
 import { CONVERSATION_PRIORITY, CONVERSATION_STATUS } from "../enums/index.js";
+import { attachStatusChangeTrigger } from "../statusTrigger.js";
 const ConversationSchema = new Schema({
     agent: { type: Schema.Types.ObjectId, ref: 'Agent' },  // the AI agent
     business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
@@ -76,20 +77,10 @@ ConversationSchema.methods.updateStatus = async function (status) {
             acks: -1
         });
     }
-
-    // if (businessId) {
-    //     const trigger = await Trigger.findOne({ business: businessId, name: "conversationStatusUpdated", type: status });
-    //     for (const workflow of trigger?.workflows ?? []) {
-    //         await sendKafkaMessage({
-    //             topic: 'workflow-execution-trigger',
-    //             message: { key: workflow.toString(), value: JSON.stringify({ conversationId }) },
-    //             acks: -1
-    //         });
-    //     }
-    // }
-
     return saved;
 };
 
+attachStatusChangeTrigger(ConversationSchema, "conversation");
+
 export { ConversationSchema };
 export const Conversation = defineModel('Conversation', ConversationSchema, "Conversations");

package/src/models/Leads.js

@@ -1,6 +1,7 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
-const leadStatusEnum = ["new", "contacted", "qualified", "converted", "lost"];
+import { LEAD_STATUS } from "../enums/index.js";
+import { attachStatusChangeTrigger } from "../statusTrigger.js";
 const platformEntrySchema = new Schema({
     platform: { type: String, required: true },   // Phone,'Twitter', 'Instagram', 'Whatsapp', etc.
     handle: { type: String, trim: true },
@@ -49,7 +50,7 @@ const LeadSchema = new Schema({
     tags: [String],
     //evaluation
     leadScore: { type: Number, default: 0 },
-    status: { type: String, enum: leadStatusEnum, default: 'new' },
+    status: { type: String, enum: LEAD_STATUS, default: 'new' },
     notes: { type: [String], trim: true },
     // operations
     lastInteractedAt: Date,
@@ -80,5 +81,7 @@ const LeadTemplateSchema = new Schema({
     isActive: { type: Boolean, default: true }
 }, { timestamps: true });
 
+attachStatusChangeTrigger(LeadSchema, "lead");
+
 export const Lead = defineModel('Lead', LeadSchema, 'Leads');
 export const LeadTemplate = defineModel('LeadTemplate', LeadTemplateSchema, 'LeadTemplates');

package/src/models/Workflow.js

@@ -1,9 +1,10 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
 import { Task_Tree } from "./Action.js";
+import { WORKFLOW_TRIGGERS } from "../enums/index.js";
 const WorkflowSchema = new Schema({
     name: { type: String, default: "Untitled Workflow" },
-    trigger: { type: String, required: true },
+    trigger: { type: String, required: true, enum: WORKFLOW_TRIGGERS },
     business: { type: Schema.Types.ObjectId, ref: "Businesses" },
     status: { type: String, enum: ["active", "disabled"], default: "active" },
     task: Task_Tree,
@@ -17,6 +18,12 @@ WorkflowSchema.methods.updateStatus = function (status) {
     this.status = status;
     return this.save();
 };
+WorkflowSchema.methods.execute = function (payload) {
+    let trigger = this.trigger;
+    let businessId = this.business;
+    
+    return { trigger, businessId, payload };
+};
 // WorkflowSchema.methods.getNextNode = function ({ currentNode = "", outputPortsOfCurentNode = [] } = {}) {
 //     const nextNodes = [];
 //     if (!currentNode) return [Object.keys(this.nodes).find((ele) => this.nodes[ele].type === "trigger")];

package/src/statusTrigger.js

@@ -0,0 +1,217 @@
+import { randomUUID } from "node:crypto";
+import { CAMPAIGN_STATUS, CONVERSATION_STATUS, LEAD_STATUS, TASK_STATUS } from "./enums/index.js";
+import { requireDep } from "./runtime.js";
+
+// Status is not written in one place. Conversations go through updateStatus, but also
+// findOneAndUpdate. Leads are created and patched with findOneAndUpdate / findByIdAndUpdate.
+// Campaigns and tasks change status inside updateTimeLine, and tasks are also insertMany'd
+// and updateMany'd to "skipped". These hooks run after the write, so a status that fails
+// validation never publishes a trigger for a change that did not persist.
+
+export const WORKFLOW_TRIGGER_TOPIC = "workflow-execution-trigger";
+
+const STATUS_BY_ENTITY = {
+    lead: new Set(LEAD_STATUS),
+    conversation: new Set(CONVERSATION_STATUS),
+    campaign: new Set(CAMPAIGN_STATUS),
+    task: new Set(TASK_STATUS),
+};
+
+const UPDATE_HOOKS = ["findOneAndUpdate", "updateOne", "updateMany", "replaceOne", "findOneAndReplace"];
+const pendingWrites = new WeakMap();
+const BATCH_SIZE = 50;
+
+function allowed(entity, status) {
+    return typeof status === "string" && STATUS_BY_ENTITY[entity]?.has(status);
+}
+
+function businessIdOf(doc) {
+    const business = doc?.business;
+    if (business == null || business === "") return "";
+    if (typeof business === "object" && business._id != null) return String(business._id);
+    return String(business);
+}
+
+function serializeDocument(doc) {
+    if (doc == null) return null;
+    try {
+        const plain = typeof doc.toObject === "function" ? doc.toObject({ virtuals: false }) : doc;
+        const seen = new WeakSet();
+        return JSON.parse(JSON.stringify(plain, (_key, value) => {
+            if (typeof value === "bigint") return value.toString();
+            if (typeof value === "object" && value !== null) {
+                if (seen.has(value)) return undefined;
+                seen.add(value);
+            }
+            return value;
+        }));
+    } catch {
+        return {
+            _id: doc._id != null ? String(doc._id) : null,
+            status: doc.status ?? null,
+            business: businessIdOf(doc) || null,
+        };
+    }
+}
+
+function readNextStatus(entity, update) {
+    if (update == null || typeof update !== "object") return null;
+    let status;
+    // Timestamps middleware adds `$set.updatedAt` without moving the caller's fields,
+    // so a plain update arrives as `{ status, $set: { updatedAt } }`.
+    if (Array.isArray(update)) {
+        for (const stage of update) {
+            if (typeof stage?.$set?.status === "string") status = stage.$set.status;
+        }
+    } else if (typeof update.$set?.status === "string") {
+        status = update.$set.status;
+    } else if (typeof update.status === "string") {
+        status = update.status;
+    }
+    return allowed(entity, status) ? status : null;
+}
+
+function statusTriggerMessage({ entity, status, previousStatus, businessId, document }) {
+    if (!allowed(entity, status) || previousStatus === status) return null;
+    const eventId = randomUUID();
+    const entityId = document?._id != null ? String(document._id) : "";
+    const resolvedBusinessId = businessId ? String(businessId) : businessIdOf(document);
+    const trigger = `${entity}_${status}`;
+    const body = {
+        eventId,
+        businessId: resolvedBusinessId,
+        trigger,
+        payload: {
+            entity,
+            entityId,
+            status,
+            previousStatus: previousStatus ?? null,
+            changedAt: new Date().toISOString(),
+            document: serializeDocument(document),
+        },
+    };
+    return {
+        key: resolvedBusinessId || entityId || eventId,
+        value: JSON.stringify(body),
+        headers: {
+            eventId,
+            businessId: resolvedBusinessId,
+            trigger,
+            entity,
+        },
+    };
+}
+
+async function publishStatusChanges(changes) {
+    const messages = changes.map(statusTriggerMessage).filter(Boolean);
+    if (!messages.length) return;
+    const sendKafkaMessage = requireDep("sendKafkaMessage", "workflow status trigger");
+    for (let i = 0; i < messages.length; i += BATCH_SIZE) {
+        const batch = messages.slice(i, i + BATCH_SIZE);
+        try {
+            await sendKafkaMessage({ topic: WORKFLOW_TRIGGER_TOPIC, messages: batch, acks: -1 });
+        } catch (error) {
+            console.error(
+                `@avakado.ai/schemas: failed to publish ${batch.length} workflow status trigger(s) on ${WORKFLOW_TRIGGER_TOPIC}`,
+                error?.message || error
+            );
+        }
+    }
+}
+
+function writeApplied(result) {
+    if (result == null || typeof result !== "object") return false;
+    if ("matchedCount" in result || "modifiedCount" in result || "upsertedCount" in result) {
+        return (result.matchedCount || 0) > 0 || (result.modifiedCount || 0) > 0 || (result.upsertedCount || 0) > 0;
+    }
+    return result._id != null;
+}
+
+export function attachStatusChangeTrigger(schema, entity) {
+    schema.post("init", function recordLoadedStatus() {
+        this.$locals.loadedStatus = this.status;
+    });
+
+    schema.pre("save", function captureStatusChange() {
+        const status = this.status;
+        if (this.isNew) {
+            this.$locals.statusEmit = allowed(entity, status) ? { status, previousStatus: null } : null;
+            return;
+        }
+        if (!this.isModified("status") || !allowed(entity, status)) {
+            this.$locals.statusEmit = null;
+            return;
+        }
+        const previousStatus = Object.prototype.hasOwnProperty.call(this.$locals, "loadedStatus")
+            ? this.$locals.loadedStatus
+            : null;
+        this.$locals.statusEmit = previousStatus === status ? null : { status, previousStatus };
+    });
+
+    schema.post("save", async function publishSavedStatus() {
+        const emit = this.$locals.statusEmit;
+        this.$locals.loadedStatus = this.status;
+        this.$locals.statusEmit = null;
+        if (!emit) return;
+        await publishStatusChanges([{
+            entity,
+            status: emit.status,
+            previousStatus: emit.previousStatus,
+            businessId: businessIdOf(this),
+            document: this,
+        }]);
+    });
+
+    schema.pre(UPDATE_HOOKS, async function captureQueryStatusChange() {
+        const status = readNextStatus(entity, this.getUpdate());
+        if (!status) return;
+        const session = this.getOptions()?.session;
+        let finder = this.model.find(this.getFilter()).select("_id status");
+        if (session) finder = finder.session(session);
+        const rows = await finder.lean();
+        const changed = rows.filter((row) => row.status !== status);
+        if (!changed.length) return;
+        pendingWrites.set(this, {
+            status,
+            previousById: new Map(changed.map((row) => [String(row._id), row.status ?? null])),
+        });
+    });
+
+    schema.post(UPDATE_HOOKS, async function publishQueryStatusChange(result) {
+        const pending = pendingWrites.get(this);
+        pendingWrites.delete(this);
+        if (!pending || !writeApplied(result)) return;
+
+        let docs = [];
+        if (result?._id && pending.previousById.has(String(result._id)) && result.status === pending.status) {
+            docs = [result];
+        } else {
+            const session = this.getOptions()?.session;
+            let finder = this.model.find({
+                _id: { $in: [...pending.previousById.keys()] },
+                status: pending.status,
+            });
+            if (session) finder = finder.session(session);
+            docs = await finder.lean();
+        }
+
+        await publishStatusChanges(docs.map((doc) => ({
+            entity,
+            status: doc.status,
+            previousStatus: pending.previousById.get(String(doc._id)) ?? null,
+            businessId: businessIdOf(doc),
+            document: doc,
+        })));
+    });
+
+    schema.post("insertMany", async function publishInsertedStatus(docs) {
+        if (!Array.isArray(docs) || !docs.length) return;
+        await publishStatusChanges(docs.map((doc) => ({
+            entity,
+            status: doc?.status,
+            previousStatus: null,
+            businessId: businessIdOf(doc),
+            document: doc,
+        })));
+    });
+}