agentlang 0.7.9 → 0.7.11

package/out/runtime/interpreter.js

@@ -10,13 +10,14 @@ import { AdminSession, AdminUserId } from './auth/defs.js';
 import { AgentInstance, AgentEntityName, AgentFqName, findAgentByName, trimGeneratedCode, } from './modules/ai.js';
 import { logger } from './logger.js';
 import { FlowSuspensionTag, ParentAttributeName, PathAttributeName, PathAttributeNameQuery, } from './defs.js';
-import { addCreateAudit, addDeleteAudit, addUpdateAudit, createSuspension, flushMonitoringData, maybeCancelTimer, setTimerRunning, } from './modules/core.js';
+import { addCreateAudit, addDeleteAudit, addUpdateAudit, createSuspension, flushMonitoringData, triggerTimer, } from './modules/core.js';
 import { invokeModuleFn } from './jsmodules.js';
 import { invokeOpenApiEvent, isOpenApiEventInstance } from './openapi.js';
 import { fetchDoc } from './docs.js';
 import { getAgentFlow } from './agents/flows.js';
 import { isMonitoringEnabled } from './state.js';
 import { Monitor, MonitorEntry } from './monitor.js';
+import { detailedDiff } from 'deep-object-diff';
 const EmptyResult = null;
 export function isEmptyResult(r) {
     return r == EmptyResult;
@@ -76,7 +77,7 @@ export class Environment extends Instance {
         }
         this.preGeneratedSuspensionId = crypto.randomUUID();
     }
-    static from(parent, name, isAsync = false) {
+    static from(parent, name, isAsync = false, mergeScratchPad = false) {
         const env = new Environment(name, parent);
         if (isAsync) {
             env.activeResolvers = new Map();
@@ -84,6 +85,11 @@ export class Environment extends Instance {
             env.activeCatchHandlers = new Array();
             env.preGeneratedSuspensionId = parent.preGeneratedSuspensionId;
         }
+        if (mergeScratchPad && parent.scratchPad) {
+            Object.keys(parent.scratchPad).forEach((k) => {
+                env.bind(k, parent.scratchPad[k]);
+            });
+        }
         return env;
     }
     static fromInstance(inst) {
@@ -359,6 +365,10 @@ export class Environment extends Instance {
     getActiveModuleName() {
         return this.activeModule;
     }
+    setActiveModuleName(n) {
+        this.activeModule = n;
+        return this;
+    }
     switchActiveModuleName(newModuleName) {
         const oldModuleName = this.activeModule;
         this.activeModule = newModuleName;
@@ -1082,6 +1092,7 @@ async function patternToInstance(entryName, attributes, env) {
     const attrs = newInstanceAttributes();
     let qattrs;
     let qattrVals;
+    let aggregates;
     const isQueryAll = entryName.endsWith(QuerySuffix);
     if (isQueryAll) {
         entryName = entryName.slice(0, entryName.length - 1);
@@ -1089,23 +1100,30 @@ async function patternToInstance(entryName, attributes, env) {
     if (attributes) {
         for (let i = 0; i < attributes.length; ++i) {
             const a = attributes[i];
-            await evaluateExpression(a.value, env);
-            const v = env.getLastResult();
-            let aname = a.name;
-            if (aname.endsWith(QuerySuffix)) {
-                if (isQueryAll) {
-                    throw new Error(`Cannot specifiy query attribute ${aname} here`);
+            if (a.value !== undefined) {
+                await evaluateExpression(a.value, env);
+                const v = env.getLastResult();
+                let aname = a.name;
+                if (aname.endsWith(QuerySuffix)) {
+                    if (isQueryAll) {
+                        throw new Error(`Cannot specifiy query attribute ${aname} here`);
+                    }
+                    if (qattrs === undefined)
+                        qattrs = newInstanceAttributes();
+                    if (qattrVals === undefined)
+                        qattrVals = newInstanceAttributes();
+                    aname = aname.slice(0, aname.length - 1);
+                    qattrs.set(aname, a.op === undefined ? '=' : a.op);
+                    qattrVals.set(aname, v);
+                }
+                else {
+                    attrs.set(aname, v);
                 }
-                if (qattrs === undefined)
-                    qattrs = newInstanceAttributes();
-                if (qattrVals === undefined)
-                    qattrVals = newInstanceAttributes();
-                aname = aname.slice(0, aname.length - 1);
-                qattrs.set(aname, a.op === undefined ? '=' : a.op);
-                qattrVals.set(aname, v);
             }
-            else {
-                attrs.set(aname, v);
+            else if (a.aggregate !== undefined) {
+                if (aggregates === undefined)
+                    aggregates = new Map();
+                aggregates.set(escapeQueryName(a.name), { name: a.aggregate.name, args: a.aggregate.args });
             }
         }
     }
@@ -1117,7 +1135,11 @@ async function patternToInstance(entryName, attributes, env) {
         if (p.hasEntry())
             entryName = p.getEntryName();
     }
-    return makeInstance(moduleName, entryName, attrs, qattrs, qattrVals, isQueryAll);
+    const inst = makeInstance(moduleName, entryName, attrs, qattrs, qattrVals, isQueryAll);
+    if (aggregates !== undefined) {
+        return inst.setAggregates(aggregates);
+    }
+    return inst;
 }
 async function instanceFromSource(crud, env) {
     if (crud.source) {
@@ -1168,6 +1190,14 @@ async function maybeValidateOneOfRefs(inst, env) {
         }
     }
 }
+function maybeSetQueryClauses(inst, crud) {
+    if (crud.groupByClause) {
+        inst.setGroupBy(crud.groupByClause.colNames);
+    }
+    if (crud.orderByClause) {
+        inst.setOrderBy(crud.orderByClause.colNames, crud.orderByClause.order === '@desc');
+    }
+}
 async function evaluateCrudMap(crud, env) {
     var _a, _b, _c;
     if (!env.isInUpsertMode() && crud.upsert.length > 0) {
@@ -1180,8 +1210,10 @@ async function evaluateCrudMap(crud, env) {
     const moduleName = inst.moduleName;
     const attrs = inst.attributes;
     const qattrs = inst.queryAttributes;
-    const isQueryAll = crud.name.endsWith(QuerySuffix);
+    const onlyAggregates = inst.aggregates !== undefined && qattrs === undefined;
+    const isQueryAll = onlyAggregates || crud.name.endsWith(QuerySuffix);
     const distinct = crud.distinct.length > 0;
+    maybeSetQueryClauses(inst, crud);
     if (attrs.size > 0) {
         await maybeValidateOneOfRefs(inst, env);
     }
@@ -1192,8 +1224,8 @@ async function evaluateCrudMap(crud, env) {
         if (qattrs === undefined && !isQueryAll) {
             throw new Error(`Pattern for ${entryName} with 'into' clause must be a query`);
         }
-        if (crud.join) {
-            await evaluateJoinQuery(crud.join, crud.into, inst, distinct, env);
+        if (crud.joins.length > 0) {
+            await evaluateJoinQuery(crud.joins, crud.into, crud.where, inst, distinct, env);
         }
         else {
             await evaluateJoinQueryWithRelationships(crud.into, inst, crud.relationships, distinct, env);
@@ -1211,7 +1243,7 @@ async function evaluateCrudMap(crud, env) {
             const res = await getResolverForPath(entryName, moduleName, env);
             let r;
             await computeExprAttributes(inst, undefined, undefined, env);
-            setMetaAttributes(inst.attributes, env);
+            await setMetaAttributes(inst.attributes, env);
             if (env.isInUpsertMode()) {
                 await runPreUpdateEvents(inst, env);
                 r = await res.upsertInstance(inst);
@@ -1323,7 +1355,7 @@ async function evaluateCrudMap(crud, env) {
                             await computeExprAttributes(lastRes[i], (_b = crud.body) === null || _b === void 0 ? void 0 : _b.attributes, attrs, env);
                             env.attributes.set('__patch', attrs);
                             await runPreUpdateEvents(lastRes[i], env);
-                            setMetaAttributes(attrs, env, true);
+                            await setMetaAttributes(attrs, env, true);
                             const finalInst = await resolver.updateInstance(lastRes[i], attrs);
                             await runPostUpdateEvents(finalInst, lastRes[i], env);
                             res.push(finalInst);
@@ -1381,47 +1413,6 @@ async function handleDocEvent(inst, env) {
         await parseAndEvaluateStatement(`{${CoreAIModuleName}/Document {title "${title}", content "${s}"}}`, undefined, env);
     }
 }
-function triggerTimer(timerInst) {
-    const dur = timerInst.lookup('duration');
-    const unit = timerInst.lookup('unit');
-    let millisecs = 0;
-    switch (unit) {
-        case 'millisecond': {
-            millisecs = dur;
-            break;
-        }
-        case 'second': {
-            millisecs = dur * 1000;
-            break;
-        }
-        case 'minute': {
-            millisecs = dur * 60 * 1000;
-            break;
-        }
-        case 'hour': {
-            millisecs = dur * 60 * 60 * 1000;
-            break;
-        }
-    }
-    const eventName = nameToPath(timerInst.lookup('trigger'));
-    const m = eventName.hasModule() ? eventName.getModuleName() : timerInst.moduleName;
-    const n = eventName.getEntryName();
-    const inst = makeInstance(m, n, newInstanceAttributes());
-    const name = timerInst.lookup('name');
-    const timer = setInterval(async () => {
-        const env = new Environment();
-        try {
-            await evaluate(inst, (result) => logger.debug(`Timer ${name} ran with result ${result}`), env);
-            await env.commitAllTransactions();
-            await maybeCancelTimer(name, timer, env);
-        }
-        catch (reason) {
-            logger.error(`Timer ${name} raised error: ${reason}`);
-        }
-    }, millisecs);
-    setTimerRunning(timerInst);
-    return timerInst;
-}
 async function computeExprAttributes(inst, origAttrs, updatedAttrs, env) {
     const exprAttrs = inst.getExprAttributes();
     if (exprAttrs || origAttrs) {
@@ -1452,7 +1443,7 @@ async function computeExprAttributes(inst, origAttrs, updatedAttrs, env) {
             for (let i = 0; i < origAttrs.length; ++i) {
                 const a = origAttrs[i];
                 const n = a.name;
-                if (!n.endsWith(QuerySuffix) && updatedAttrs.has(n)) {
+                if (!n.endsWith(QuerySuffix) && updatedAttrs.has(n) && a.value !== undefined) {
                     await evaluateExpression(a.value, newEnv);
                     const v = newEnv.getLastResult();
                     updatedAttrs.set(n, v);
@@ -1462,21 +1453,58 @@ async function computeExprAttributes(inst, origAttrs, updatedAttrs, env) {
         }
     }
 }
-async function evaluateJoinQuery(joinSpec, intoSpec, inst, distinct, env) {
+async function evalWhereClauses(whereSpec, env) {
+    const result = new Array();
+    const e = new Environment(undefined, env);
+    for (let i = 0; i < whereSpec.clauses.length; ++i) {
+        const c = whereSpec.clauses[i];
+        await evaluateExpression(c.rhs, e);
+        result.push({
+            attrName: escapeQueryName(c.lhs),
+            op: c.op === undefined ? '=' : c.op,
+            qval: e.getLastResult(),
+        });
+    }
+    return result;
+}
+async function evaluateJoinQuery(joinSpec, intoSpec, whereSpec, inst, distinct, env) {
     const normIntoSpec = new Map();
+    let aggregates;
     intoSpec.entries.forEach((entry) => {
-        normIntoSpec.set(entry.alias, entry.attribute);
+        if (entry.attribute !== undefined)
+            normIntoSpec.set(entry.alias, entry.attribute);
+        else {
+            if (aggregates === undefined)
+                aggregates = new Map();
+            if (entry.aggregate !== undefined)
+                aggregates === null || aggregates === void 0 ? void 0 : aggregates.set(entry.alias, entry.aggregate);
+        }
     });
+    if (aggregates !== undefined) {
+        inst.setAggregates(aggregates);
+    }
+    const clauses = whereSpec ? await evalWhereClauses(whereSpec, env) : undefined;
     const resolver = await getResolverForPath(inst.name, inst.moduleName, env);
-    const result = await resolver.queryByJoin(inst, [], normIntoSpec, distinct, joinSpec);
+    const result = await resolver.queryByJoin(inst, [], normIntoSpec, distinct, joinSpec, clauses);
     const transformedResult = transformDateFieldsInJoinResult(result);
     env.setLastResult(transformedResult);
 }
 async function evaluateJoinQueryWithRelationships(intoSpec, inst, relationships, distinct, env) {
     const normIntoSpec = new Map();
+    let aggregates;
     intoSpec.entries.forEach((entry) => {
-        normIntoSpec.set(entry.alias, entry.attribute);
+        if (entry.attribute !== undefined)
+            normIntoSpec.set(entry.alias, entry.attribute);
+        else {
+            if (aggregates === undefined)
+                aggregates = new Map();
+            if (entry.aggregate !== undefined)
+                aggregates === null || aggregates === void 0 ? void 0 : aggregates.set(entry.alias, entry.aggregate);
+        }
     });
+    if (aggregates !== undefined) {
+        inst.setAggregates(aggregates);
+    }
     const moduleName = inst.moduleName;
     let joinsSpec = new Array();
     for (let i = 0; i < relationships.length; ++i) {
@@ -1709,7 +1737,10 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
   Important: Return only the next flow-step or DONE. Do not return any additional description, like your thinking process.\n`;
     env.setFlowContext(initContext);
     await agentInvoke(rootAgent, s, env);
-    let step = await preprocessStep(env.getLastResult().trim(), env);
+    const rootModuleName = rootAgent.moduleName;
+    let preprocResult = await preprocessStep(env.getLastResult().trim(), rootModuleName, env);
+    let step = preprocResult.step;
+    let needAgentProcessing = preprocResult.needAgentProcessing;
     let context = initContext;
     let stepc = 0;
     const iterId = crypto.randomUUID();
@@ -1719,6 +1750,7 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
     if (monitoringEnabled) {
         env.flagMonitorEntryAsFlow().incrementMonitor();
     }
+    let isfxc = false;
     try {
         while (step != 'DONE' && !executedSteps.has(step)) {
             if (stepc > MaxFlowSteps) {
@@ -1726,20 +1758,27 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
             }
             executedSteps.add(step);
             ++stepc;
-            const agent = AgentInstance.FromFlowStep(step, rootAgent, context);
-            console.debug(`\n---------------------------------------------------\n`);
-            console.debug(`Starting to execute flow step ${step} with agent ${agent.name} with iteration ID ${iterId} and context: \n${context}`);
-            const isfxc = agent.isFlowExecutor();
-            const isdec = agent.isDecisionExecutor();
-            if (isfxc || isdec)
-                env.setFlowContext(context);
-            else
-                env.setFlowContext(initContext);
-            if (monitoringEnabled) {
-                env.appendEntryToMonitor(step);
+            const agent = needAgentProcessing
+                ? AgentInstance.FromFlowStep(step, rootAgent, context)
+                : undefined;
+            if (agent) {
+                console.debug(`\n---------------------------------------------------\n`);
+                console.debug(`Starting to execute flow step ${step} with agent ${agent.name} with iteration ID ${iterId} and context: \n${context}`);
+                isfxc = agent.isFlowExecutor();
+                const isdec = agent.isDecisionExecutor();
+                if (isfxc || isdec)
+                    env.setFlowContext(context);
+                else
+                    env.setFlowContext(initContext);
+                if (monitoringEnabled) {
+                    env.appendEntryToMonitor(step);
+                }
+                const inst = agent.swapInstruction('');
+                await agentInvoke(agent, inst, env);
+            }
+            else {
+                rootAgent.maybeAddScratchData(env);
             }
-            const inst = agent.swapInstruction('');
-            await agentInvoke(agent, inst, env);
             if (monitoringEnabled)
                 env.setMonitorEntryResult(env.getLastResult());
             if (env.isSuspended()) {
@@ -1753,13 +1792,15 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
             console.debug(`\n----> Completed execution of step ${step}, iteration id ${iterId} with result:\n${rs}`);
             context = `${context}\n${step} --> ${rs}\n`;
             if (isfxc) {
-                step = await preprocessStep(rs.trim(), env);
+                preprocResult = await preprocessStep(rs.trim(), rootModuleName, env);
             }
             else {
                 env.setFlowContext(context);
                 await agentInvoke(rootAgent, `${s}\n${context}`, env);
-                step = await preprocessStep(env.getLastResult().trim(), env);
+                preprocResult = await preprocessStep(env.getLastResult().trim(), rootModuleName, env);
             }
+            step = preprocResult.step;
+            needAgentProcessing = preprocResult.needAgentProcessing;
         }
     }
     finally {
@@ -1767,30 +1808,15 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
     }
     console.debug(`No more flow steps, completed iteration ${iterId} on flow:\n${flow}`);
 }
-async function preprocessStep(spec, env) {
+async function preprocessStep(spec, activeModuleName, env) {
+    let needAgentProcessing = true;
     if (spec.startsWith('{')) {
-        const stmt = await parseStatement(spec);
-        const crudMap = stmt.pattern.crudMap;
-        if (crudMap) {
-            env.resetTemplateMappings();
-            const step = crudMap.name;
-            if (crudMap.body) {
-                crudMap.body.attributes.forEach((sa) => {
-                    var _a;
-                    const v = (_a = sa.value.$cstNode) === null || _a === void 0 ? void 0 : _a.text;
-                    if (v)
-                        env.setTemplateMapping(sa.name, v);
-                });
-            }
-            return step;
-        }
-        else {
-            throw new Error(`Invalid step - ${spec}`);
-        }
-    }
-    else {
-        return spec;
+        const newEnv = Environment.from(env, env.name + '_flow_eval', false, true).setActiveModuleName(activeModuleName);
+        const r = await parseAndEvaluateStatement(spec, undefined, newEnv);
+        env.setLastResult(r);
+        needAgentProcessing = false;
     }
+    return { step: spec, needAgentProcessing };
 }
 export async function handleOpenApiEvent(eventInst, env) {
     const r = await invokeOpenApiEvent(eventInst.moduleName, eventInst.name, eventInst.attributesAsObject());
@@ -1841,7 +1867,7 @@ export async function maybeDeleteQueriedInstances(queryEnv, env, purge = false)
     const inst = queryEnv.getLastResult();
     let resolver = Resolver.Default;
     if (inst instanceof Array) {
-        if (inst.length > 0 && isEntityInstance(inst[0])) {
+        if (inst.length > 0) {
             resolver = await getResolverForPath(inst[0].name, inst[0].moduleName, queryEnv);
             const finalResult = new Array();
             for (let i = 0; i < inst.length; ++i) {
@@ -1856,7 +1882,7 @@ export async function maybeDeleteQueriedInstances(queryEnv, env, purge = false)
             queryEnv.setLastResult(inst);
         }
     }
-    else if (isEntityInstance(inst)) {
+    else {
         resolver = await getResolverForPath(inst.name, inst.moduleName, queryEnv);
         await runPreDeleteEvents(inst, env);
         const r = await resolver.deleteInstance(inst, purge);
@@ -2103,7 +2129,7 @@ async function runPreCreateEvents(inst, env) {
 }
 export async function runPostCreateEvents(inst, env) {
     if (inst.requireAudit()) {
-        await addCreateAudit(inst.getPath(), env);
+        await addCreateAudit(inst.getPath(), env, { original: inst.userAttributesAsObject() });
     }
     await runPrePostEvents(CrudType.CREATE, false, inst, env);
 }
@@ -2112,7 +2138,13 @@ async function runPreUpdateEvents(inst, env) {
 }
 export async function runPostUpdateEvents(inst, oldInst, env) {
     if (inst.requireAudit()) {
-        await addUpdateAudit(inst.getPath(), oldInst, env);
+        let diff;
+        if (oldInst !== undefined) {
+            const oldAttrs = oldInst.userAttributesAsObject();
+            const d = detailedDiff(oldAttrs, inst.userAttributesAsObject());
+            diff = { original: oldAttrs, updated: d.updated };
+        }
+        await addUpdateAudit(inst.getPath(), diff, env);
     }
     await runPrePostEvents(CrudType.UPDATE, false, inst, env);
 }
@@ -2121,7 +2153,7 @@ async function runPreDeleteEvents(inst, env) {
 }
 export async function runPostDeleteEvents(inst, env) {
     if (inst.requireAudit()) {
-        await addDeleteAudit(inst.getPath(), inst, env);
+        await addDeleteAudit(inst.getPath(), { deleted: inst.userAttributesAsObject() }, env);
     }
     await runPrePostEvents(CrudType.DELETE, false, inst, env);
 }