@avakado.ai/schemas 1.1.19 → 1.1.20

package/package.json

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

package/src/models/Workflow.js

@@ -1,7 +1,10 @@
+import { randomUUID } from "node:crypto";
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
 import { Task_Tree } from "./Action.js";
 import { WORKFLOW_TRIGGERS } from "../enums/index.js";
+import { WorkflowLogs } from "./WorkflowLogs.js";
+import { runTaskTree, stored } from "../workflowRunner.js";
 const WorkflowSchema = new Schema({
     name: { type: String, default: "Untitled Workflow" },
     trigger: { type: String, required: true, enum: WORKFLOW_TRIGGERS },
@@ -18,11 +21,54 @@ 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.execute = async function (payload, meta = {}) {
+    if (this.status === "disabled") return { skipped: true };
+    const businessId = String(this.business?._id ?? this.business ?? "");
+    const executionId = randomUUID();
+    const startedAt = new Date();
+    const log = await WorkflowLogs.create({
+        workflow: this._id,
+        business: this.business?._id ?? this.business,
+        executionId,
+        eventId: meta.eventId,
+        name: this.name,
+        trigger: this.trigger,
+        status: "running",
+        summary: `Workflow "${this.name}" started for ${this.trigger}.`,
+        input: stored(payload),
+        steps: [],
+        startedAt,
+    });
+
+    const record = async (step) => {
+        log.steps.push(step);
+        log.summary = [`Workflow "${this.name}" ran for ${this.trigger}.`, ...log.steps.map((item) => item.summary)].join("\n");
+        await log.save();
+    };
+
+    try {
+        const outputs = await runTaskTree(this.task, {
+            runtime: payload ?? {},
+            trigger: this.trigger,
+            businessId,
+            onStep: record,
+        });
+        log.status = "completed";
+        log.outputs = stored(outputs);
+        log.finishedAt = new Date();
+        log.summary = [`Workflow "${this.name}" completed for ${this.trigger}.`, ...log.steps.map((item) => item.summary)].join("\n");
+        await log.save();
+        return { executionId, outputs };
+    } catch (error) {
+        log.status = "failed";
+        log.error = { message: error?.message || String(error), stack: error?.stack };
+        log.outputs = stored(error.workflowOutputs ?? []);
+        log.finishedAt = new Date();
+        log.summary = [`Workflow "${this.name}" failed for ${this.trigger}.`, ...log.steps.map((item) => item.summary)].filter(Boolean).join("\n");
+        if (!log.steps.some((step) => step.status === "failed")) log.summary += `\n${error?.message || error}`;
+        await log.save();
+        throw error;
+    }
 };
 // WorkflowSchema.methods.getNextNode = function ({ currentNode = "", outputPortsOfCurentNode = [] } = {}) {
 //     const nextNodes = [];

package/src/models/WorkflowLogs.js

@@ -1,22 +1,45 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
 
-const WorkflowLogsSchema = new Schema({
-    workflowId: String,
-    trigger: {
-        conversationId: String,
-    },
-    executionId: String,
+// One document per workflow run. `steps` is the order the task tree actually ran,
+// including the input and output of each step, so a person can read what happened.
+const workflowStepSchema = new Schema({
     nodeId: String,
-    lable: String,
-    nodeInput: Schema.Types.Mixed,
-    nodeInputError: Schema.Types.Mixed,
-    nodeOutput: Schema.Types.Mixed,
-    nodeError: Schema.Types.Mixed,
-    nodeStatus: { type: String, enum: ["pending", "in-progress", "completed", "failed", "skipped"], default: "pending" },
+    label: String,
+    type: { type: String, enum: ["task", "conditional"] },
+    status: { type: String, enum: ["completed", "failed"], required: true },
+    summary: String,
+    input: Schema.Types.Mixed,
+    output: Schema.Types.Mixed,
+    error: { message: String, stack: String },
+    startedAt: Date,
+    finishedAt: Date,
+}, { _id: false });
+
+const WorkflowLogsSchema = new Schema({
+    workflow: { type: Schema.Types.ObjectId, ref: "Workflow", required: true },
+    business: { type: Schema.Types.ObjectId, ref: "Businesses" },
+    executionId: { type: String, required: true },
+    eventId: String,
+    name: String,
+    trigger: String,
+    status: { type: String, enum: ["running", "completed", "failed"], default: "running" },
+    summary: String,
+    input: Schema.Types.Mixed,
+    outputs: Schema.Types.Mixed,
+    error: { message: String, stack: String },
+    steps: [workflowStepSchema],
+    startedAt: Date,
+    finishedAt: Date,
 }, {
-    timestamps: true
-}
-);
+    timestamps: true,
+});
+
+WorkflowLogsSchema.index({ executionId: 1 }, { unique: true });
+WorkflowLogsSchema.index({ workflow: 1, createdAt: -1 });
+WorkflowLogsSchema.index({ business: 1, createdAt: -1 });
+WorkflowLogsSchema.index({ trigger: 1, createdAt: -1 });
+WorkflowLogsSchema.index({ status: 1, createdAt: -1 });
 
-export const WorkflowLogs = defineModel('WorkflowLogs', WorkflowLogsSchema, 'WorkflowLogs');
+export { WorkflowLogsSchema };
+export const WorkflowLogs = defineModel("WorkflowLogs", WorkflowLogsSchema, "WorkflowLogs");

package/src/workflowRunner.js

@@ -0,0 +1,190 @@
+// Walks a workflow task the same way tool_utils.executeTool does: each node reads
+// `context.runtime`, `context.preset`, and `context.outputs`, then a task runs its
+// compiled instructions. Conditionals take the first child when the mapped value is
+// truthy and the second child otherwise.
+
+const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+
+export function plainValue(value) {
+    if (value == null) return value;
+    if (typeof value.toObject === "function") return value.toObject({ virtuals: false });
+    return value;
+}
+
+export function getTreeMap(tree) {
+    const plain = plainValue(tree) ?? {};
+    const nodes = new Map((plain.nodes ?? []).map((node) => [node.id, node]));
+    return { rootId: plain.rootId, rootKey: plain.rootKey, nodes };
+}
+
+function evaluateExpression(expression, context) {
+    return new Function("context", `return (${expression});`)(context);
+}
+
+// tool_utils.evaluateToolInput
+export function evaluateMapper(mapper, context) {
+    const treeMap = getTreeMap(mapper);
+    const evaluate = (node) => {
+        if (!node) return undefined;
+        const expression = node.core?.mapper?.expression;
+        if (expression) return evaluateExpression(expression, context);
+        switch (node.core?.flattenedSchema?.type) {
+            case "object":
+                return Object.fromEntries((node.children ?? []).map((child) => {
+                    const childNode = treeMap.nodes.get(child.id);
+                    return [child.key, childNode ? evaluate(childNode) : undefined];
+                }));
+            case "array":
+                return (node.children ?? []).map((child) => {
+                    const childNode = treeMap.nodes.get(child.id);
+                    return childNode ? evaluate(childNode) : undefined;
+                });
+            default:
+                return undefined;
+        }
+    };
+    const root = treeMap.nodes.get(treeMap.rootId);
+    return root ? evaluate(root) : undefined;
+}
+
+export function nodeInput(node, context) {
+    const compiled = node.core?.input?.compiledMapper;
+    if (typeof compiled === "string" && compiled.trim()) return evaluateExpression(compiled, context);
+    if (node.core?.input?.mapper) return evaluateMapper(node.core.input.mapper, context);
+    return undefined;
+}
+
+export function nodeLabel(node) {
+    return node?.meta?.label || node?.core?.meta?.label || node?.id || "Untitled step";
+}
+
+export async function runInstructions(node, input) {
+    const instructions = node.core?.coreExecution?.compiledInstructions;
+    if (typeof instructions !== "string" || !instructions.trim()) return undefined;
+    return new AsyncFunction("input", instructions)(input);
+}
+
+export function stored(value) {
+    if (value instanceof Error) return { message: value.message, stack: value.stack };
+    const seen = new WeakSet();
+    try {
+        return JSON.parse(JSON.stringify(value, (_key, item) => {
+            if (typeof item === "bigint") return item.toString();
+            if (typeof item === "object" && item !== null) {
+                if (seen.has(item)) return undefined;
+                seen.add(item);
+            }
+            return item;
+        }));
+    } catch {
+        return undefined;
+    }
+}
+
+function childNode(treeMap, child) {
+    if (!child?.id) return undefined;
+    const node = treeMap.nodes.get(child.id);
+    if (!node) throw new Error(`Invalid tree: referenced node "${child.id}" does not exist`);
+    return node;
+}
+
+/**
+ * Runs the task tree from its root. `onStep` is awaited with each step once that
+ * step has finished (completed or failed) so the caller can persist it.
+ * A failed step rejects after `onStep` returns.
+ */
+export async function runTaskTree(task, { runtime, trigger, businessId, onStep }) {
+    const treeMap = getTreeMap(task);
+    const outputs = [];
+    const root = treeMap.nodes.get(treeMap.rootId);
+    if (!root) throw new Error("Workflow task has no root node");
+
+    const execute = async (node) => {
+        const startedAt = new Date();
+        const label = nodeLabel(node);
+        const context = {
+            runtime: runtime ?? {},
+            preset: node.core?.input?.preset ?? {},
+            outputs,
+            trigger,
+            businessId,
+            payload: runtime ?? {},
+        };
+        let completed;
+        try {
+            if (node.core?.type === "task") {
+                if ((node.children ?? []).length > 1) {
+                    throw new Error(`Task "${label}" has multiple outgoing edges`);
+                }
+                const input = nodeInput(node, context);
+                const output = await runInstructions(node, input);
+                outputs.push(output);
+                const next = (node.children ?? []).length ? childNode(treeMap, node.children[0]) : undefined;
+                completed = {
+                    step: {
+                        nodeId: node.id,
+                        label,
+                        type: "task",
+                        status: "completed",
+                        input: stored(input),
+                        output: stored(output),
+                        summary: `Completed "${label}".`,
+                        startedAt,
+                        finishedAt: new Date(),
+                    },
+                    next,
+                };
+            } else if (node.core?.type === "conditional") {
+                if ((node.children ?? []).length > 2) {
+                    throw new Error(`Condition "${label}" cannot have more than 2 outgoing edges`);
+                }
+                const condition = nodeInput(node, context);
+                outputs.push(condition);
+                const nextChild = condition ? node.children?.[0] : node.children?.[1];
+                const next = nextChild ? childNode(treeMap, nextChild) : undefined;
+                const nextLabel = next ? nodeLabel(next) : "";
+                const summary = condition
+                    ? `Condition "${label}" was true${nextLabel ? `, continued to "${nextLabel}"` : ""}.`
+                    : `Condition "${label}" was false${nextLabel ? `, continued to "${nextLabel}"` : ", so the workflow stopped"}.`;
+                completed = {
+                    step: {
+                        nodeId: node.id,
+                        label,
+                        type: "conditional",
+                        status: "completed",
+                        input: stored(condition),
+                        output: stored({ condition: Boolean(condition), nextNodeId: next?.id ?? null }),
+                        summary,
+                        startedAt,
+                        finishedAt: new Date(),
+                    },
+                    next,
+                };
+            } else {
+                throw new Error(`Unknown step type on "${label}"`);
+            }
+        } catch (error) {
+            try {
+                await onStep?.({
+                    nodeId: node.id,
+                    label,
+                    ...(node.core?.type === "task" || node.core?.type === "conditional" ? { type: node.core.type } : {}),
+                    status: "failed",
+                    error: { message: error?.message || String(error), stack: error?.stack },
+                    summary: `Failed at "${label}": ${error?.message || error}`,
+                    startedAt,
+                    finishedAt: new Date(),
+                });
+            } catch (logError) {
+                console.error("@avakado.ai/schemas: failed to record workflow step", logError?.message || logError);
+            }
+            error.workflowOutputs = outputs;
+            throw error;
+        }
+        await onStep?.(completed.step);
+        if (completed.next) await execute(completed.next);
+    };
+
+    await execute(root);
+    return outputs;
+}