agentlang 0.10.1 → 0.10.3

package/out/runtime/interpreter.js

@@ -1,13 +1,13 @@
 import { isBinExpr, isGroup, isLiteral, isNegExpr, isNotExpr, isReturn, } from '../language/generated/ast.js';
-import { Agent, defineAgentEvent, getOneOfRef, getRelationship, getWorkflow, Instance, isAgentEventInstance, isBetweenRelationship, isContainsRelationship, isEmptyWorkflow, isEntityInstance, isEventInstance, isInstanceOfType, isOneToOneBetweenRelationship, isTimer, makeInstance, maybeInstanceAsString, newInstanceAttributes, PlaceholderRecordEntry, setMetaAttributes, } from './module.js';
+import { Agent, defineAgentEvent, getOneOfRef, getRelationship, getWorkflow, Instance, isAgentEventInstance, isBetweenRelationship, isContainsRelationship, isEmptyWorkflow, isEntityInstance, isEventInstance, isInstanceOfType, getAllBetweenRelationshipsForEntity, isOneToOneBetweenRelationship, isTimer, makeInstance, maybeInstanceAsString, newInstanceAttributes, PlaceholderRecordEntry, setMetaAttributes, } from './module.js';
 import { Resolver } from './resolvers/interface.js';
 import { ResolverAuthInfo } from './resolvers/authinfo.js';
 import { SqlDbResolver } from './resolvers/sqldb/impl.js';
-import { CrudType, DefaultModuleName, escapeFqName, escapeQueryName, fqNameFromPath, isCoreModule, isFqName, isPath, isString, makeCoreModuleName, makeFqName, nameToPath, preprocessRawConfig, QuerySuffix, restoreSpecialChars, splitRefs, } from './util.js';
+import { CrudType, DefaultModuleName, escapeFqName, escapeQueryName, firstAliasSpec, fqNameFromPath, isCoreModule, isFqName, isPath, isString, makeCoreModuleName, makeFqName, nameToPath, preprocessRawConfig, QuerySuffix, restoreSpecialChars, splitFqName, splitRefs, } from './util.js';
 import { getResolver, getResolverNameForPath } from './resolvers/registry.js';
 import { extractQueryOptions, parseStatement, parseWorkflow, } from '../language/parser.js';
 import { AdminSession, AdminUserId } from './auth/defs.js';
-import { AgentEntityName, AgentFqName, AgentInstance, findAgentByName, normalizeGeneratedCode, saveFlowStepResult, } from './modules/ai.js';
+import { AgentCancelledException, AgentEntityName, AgentFqName, AgentInstance, checkCancelled, clearCancellation, findAgentByName, normalizeGeneratedCode, saveFlowStepResult, } from './modules/ai.js';
 import { logger } from './logger.js';
 import { FlowSuspensionTag, ParentAttributeName, PathAttributeName, PathAttributeNameQuery, } from './defs.js';
 import { addCreateAudit, addDeleteAudit, addUpdateAudit, createSuspension, flushMonitoringData, triggerTimer, } from './modules/core.js';
@@ -20,6 +20,7 @@ import { Monitor, MonitorEntry } from './monitor.js';
 import { detailedDiff } from 'deep-object-diff';
 import { callMcpTool, mcpClientNameFromToolEvent } from './mcpclient.js';
 import { isNodeEnv } from '../utils/runtime.js';
+import Handlebars from 'handlebars';
 const EmptyResult = null;
 export function isEmptyResult(r) {
     return r == EmptyResult;
@@ -70,6 +71,7 @@ export class Environment extends Instance {
             this.agentChatId = parent.agentChatId;
             this.monitor = parent.monitor;
             this.escalatedRole = parent.escalatedRole;
+            this.activeChatId = parent.activeChatId;
         }
         else {
             this.activeModule = DefaultModuleName;
@@ -180,6 +182,13 @@ export class Environment extends Instance {
     getFlowContext() {
         return this.attributes.get(Environment.FlowContextTag);
     }
+    setActiveChatId(chatId) {
+        this.activeChatId = chatId;
+        return this;
+    }
+    getActiveChatId() {
+        return this.activeChatId;
+    }
     addToScratchPad(k, data) {
         if (this.scratchPad === undefined) {
             this.scratchPad = {};
@@ -244,6 +253,10 @@ export class Environment extends Instance {
         (_a = this.templateMappings) === null || _a === void 0 ? void 0 : _a.clear();
         return this;
     }
+    maybeRewriteTemplatePatterns(instruction, scratchPad) {
+        const templ = Handlebars.compile(this.rewriteTemplateMappings(instruction));
+        return templ(scratchPad);
+    }
     bindSuspensionUserData(userData) {
         this.bind(Environment.SuspensionUserData, userData);
         return this;
@@ -380,6 +393,13 @@ export class Environment extends Instance {
     getLastResult() {
         return this.lastResult;
     }
+    setLastPattern(pattern) {
+        this.lastPattern = pattern;
+        return this;
+    }
+    getLastPattern() {
+        return this.lastPattern;
+    }
     getActiveModuleName() {
         return this.activeModule;
     }
@@ -666,6 +686,12 @@ export class Environment extends Instance {
         }
         return this;
     }
+    setMonitorEntryLlmTokenUsage(input, output, total) {
+        if (this.monitor !== undefined) {
+            this.monitor.setEntryLlmTokenUsage(input, output, total);
+        }
+        return this;
+    }
     incrementMonitor() {
         if (this.monitor !== undefined) {
             this.monitor = this.monitor.increment();
@@ -709,8 +735,14 @@ export let evaluate = async function (eventInstance, continuation, activeEnv, ke
             else if (isAgentEventInstance(eventInstance)) {
                 env = new Environment(eventInstance.name + '.env', activeEnv);
                 await handleAgentInvocation(eventInstance, env);
-                if (continuation)
-                    continuation(env.getLastResult());
+                if (continuation) {
+                    if (env.getLastPattern()) {
+                        continuation({ result: env.getLastResult(), pattern: env.getLastPattern() });
+                    }
+                    else {
+                        continuation(env.getLastResult());
+                    }
+                }
             }
             else if (isOpenApiEventInstance(eventInstance)) {
                 env = new Environment(eventInstance.name + '.env', activeEnv);
@@ -833,7 +865,11 @@ export async function evaluateStatement(stmt, env) {
             handlersPushed = env.pushHandlers(handlers);
         }
         await evaluatePattern(stmt.pattern, env);
+        let skipOuterAlias = false;
         if (hasHints) {
+            skipOuterAlias = await maybeHandleEmpty(hints, env);
+        }
+        if (hasHints && !skipOuterAlias) {
             maybeBindStatementResultToAlias(hints, env);
         }
         await maybeHandleNotFound(handlers, env);
@@ -860,6 +896,28 @@ async function maybeHandleNotFound(handlers, env) {
         }
     }
 }
+async function maybeHandleEmpty(hints, env) {
+    const lastResult = env.getLastResult();
+    if (lastResult === null ||
+        lastResult === undefined ||
+        (lastResult instanceof Array && lastResult.length == 0)) {
+        for (const rh of hints) {
+            if (rh.emptySpec) {
+                const newEnv = new Environment('empty-env', env).unsetEventExecutor();
+                await evaluateStatement(rh.emptySpec.stmt, newEnv);
+                env.setLastResult(newEnv.getLastResult());
+                // If inner statement has its own @as, propagate binding to parent env
+                const innerAlias = firstAliasSpec(rh.emptySpec.stmt);
+                if (innerAlias) {
+                    maybeBindStatementResultToAlias(rh.emptySpec.stmt.hints, env);
+                    return true; // signal: skip outer @as
+                }
+                break;
+            }
+        }
+    }
+    return false;
+}
 async function maybeHandleError(handlers, reason, env) {
     const handler = handlers ? handlers.get('error') : undefined;
     if (handler) {
@@ -1226,9 +1284,15 @@ function maybeSetQueryClauses(inst, qopts) {
     if (qopts.orderByClause) {
         inst.setOrderBy(qopts.orderByClause.colNames, qopts.orderByClause.order === '@desc');
     }
+    if (qopts.limitClause) {
+        inst.setLimit(qopts.limitClause.value);
+    }
+    if (qopts.offsetClause) {
+        inst.setOffset(qopts.offsetClause.value);
+    }
 }
 async function evaluateCrudMap(crud, env) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const qopts = extractQueryOptions(crud);
     if (!env.isInUpsertMode() && qopts.upsert !== undefined) {
         return await evaluateUpsert(crud, env);
@@ -1272,7 +1336,7 @@ async function evaluateCrudMap(crud, env) {
             }
             const res = await getResolverForPath(entryName, moduleName, env);
             let r;
-            await computeExprAttributes(inst, undefined, undefined, env);
+            await computeExprAttributes(inst, (_b = crud.body) === null || _b === void 0 ? void 0 : _b.attributes, inst.attributes, env);
             await setMetaAttributes(inst.attributes, env);
             if (env.isInUpsertMode()) {
                 await runPreUpdateEvents(inst, env);
@@ -1337,7 +1401,7 @@ async function evaluateCrudMap(crud, env) {
             }
             else if (betRelInfo !== undefined) {
                 res = await getResolverForPath(betRelInfo.relationship.name, betRelInfo.relationship.moduleName, env);
-                const insts = await res.queryConnectedInstances(betRelInfo.relationship, betRelInfo.connectedInstance, inst);
+                const insts = await res.queryConnectedInstances(betRelInfo.relationship, betRelInfo.connectedInstance, inst, betRelInfo.connectedAlias);
                 env.setLastResult(insts);
             }
             else {
@@ -1350,7 +1414,7 @@ async function evaluateCrudMap(crud, env) {
                 }
                 if (oneToOne && rel !== undefined) {
                     await res.handleInstancesLink(inst.lookupQueryVal(rel.node1.alias), inst.lookupQueryVal(rel.node2.alias), rel, false, true);
-                    env.setLastResult(inst);
+                    env.setLastResult([inst]);
                 }
                 else {
                     const insts = await res.queryInstances(inst, isQueryAll, distinct);
@@ -1380,7 +1444,12 @@ async function evaluateCrudMap(crud, env) {
                             lastRes[j].attachRelatedInstances(rel.name, newEnv.getLastResult());
                         }
                         else if (isBetweenRelationship(rel.name, moduleName)) {
-                            newEnv.setBetweenRelInfo({ relationship: relEntry, connectedInstance: lastRes[j] });
+                            const connAlias = relEntry.isSelfReferencing() ? relEntry.node1.alias : undefined;
+                            newEnv.setBetweenRelInfo({
+                                relationship: relEntry,
+                                connectedInstance: lastRes[j],
+                                connectedAlias: connAlias,
+                            });
                             await evaluatePattern(rel.pattern, newEnv);
                             lastRes[j].attachRelatedInstances(rel.name, newEnv.getLastResult());
                         }
@@ -1394,7 +1463,7 @@ async function evaluateCrudMap(crud, env) {
                         const resolver = await getResolverForPath(lastRes[0].name, lastRes[0].moduleName, env);
                         const res = new Array();
                         for (let i = 0; i < lastRes.length; ++i) {
-                            await computeExprAttributes(lastRes[i], (_b = crud.body) === null || _b === void 0 ? void 0 : _b.attributes, attrs, env);
+                            await computeExprAttributes(lastRes[i], (_c = crud.body) === null || _c === void 0 ? void 0 : _c.attributes, attrs, env);
                             env.attributes.set('__patch', attrs);
                             await runPreUpdateEvents(lastRes[i], env);
                             await setMetaAttributes(attrs, env, true);
@@ -1410,11 +1479,11 @@ async function evaluateCrudMap(crud, env) {
                 }
                 else {
                     const res = await getResolverForPath(lastRes.name, lastRes.moduleName, env);
-                    await computeExprAttributes(lastRes, (_c = crud.body) === null || _c === void 0 ? void 0 : _c.attributes, attrs, env);
+                    await computeExprAttributes(lastRes, (_d = crud.body) === null || _d === void 0 ? void 0 : _d.attributes, attrs, env);
                     await runPreUpdateEvents(lastRes, env);
                     const finalInst = await res.updateInstance(lastRes, attrs);
                     await runPostUpdateEvents(finalInst, lastRes, env);
-                    env.setLastResult(finalInst);
+                    env.setLastResult([finalInst]);
                 }
             }
         }
@@ -1513,24 +1582,103 @@ async function computeExprAttributes(inst, origAttrs, updatedAttrs, env) {
             if (v !== undefined)
                 newEnv.bind(k, v);
         });
+        // Bind related instances from between-relationships so that @expr references
+        // like DeptEmployee.Department.BudgetMultiplier can be resolved via followReference.
+        const entityFqName = inst.getFqName();
+        const fqParts = splitFqName(entityFqName);
+        const rels = getAllBetweenRelationshipsForEntity(fqParts[0], fqParts[1]);
+        for (const rel of rels) {
+            const isFirst = rel.isFirstNodeName(entityFqName);
+            // Only bind if this entity is on a valid side for single-entity resolution
+            if (rel.isManyToMany())
+                continue;
+            if (rel.isOneToMany() && isFirst)
+                continue;
+            // Determine the target entity on the other side
+            const targetNode = isFirst ? rel.node2 : rel.node1;
+            const targetAlias = targetNode.alias;
+            let connectedInst;
+            // Fast path: check if the environment carries between-rel info for this relationship
+            const betRelInfo = env.getBetweenRelInfo();
+            if (betRelInfo && betRelInfo.relationship.name === rel.name) {
+                connectedInst = betRelInfo.connectedInstance;
+            }
+            else if (inst.lookup(PathAttributeName)) {
+                // Slow path: query the connected instance through the resolver.
+                // Only possible if the current instance has been persisted (has a __path__).
+                try {
+                    const targetFqName = targetNode.path.asFqName();
+                    const targetParts = splitFqName(targetFqName);
+                    const res = await getResolverForPath(targetParts[1], targetParts[0], env);
+                    const queryInst = Instance.EmptyInstance(targetParts[1], targetParts[0]);
+                    const connected = await res.queryConnectedInstances(rel, inst, queryInst);
+                    if (connected && connected.length > 0) {
+                        connectedInst = connected[0];
+                    }
+                }
+                catch (reason) {
+                    logger.debug(`Relationship query failed (e.g. not yet linked) - skip binding - ${reason}`);
+                }
+            }
+            if (connectedInst) {
+                const relMap = new Map();
+                relMap.set(targetAlias, connectedInst);
+                newEnv.bind(rel.name, relMap);
+            }
+        }
+        // Build a map of user-provided values for @expr attributes so that
+        // overrides are applied inline during expression evaluation, allowing
+        // dependent expressions to see the user's value immediately.
+        let userExprOverrides;
+        if (exprAttrs && origAttrs) {
+            for (let i = 0; i < origAttrs.length; ++i) {
+                const a = origAttrs[i];
+                const n = a.name;
+                if (exprAttrs.has(n) && !n.endsWith(QuerySuffix) && a.value !== undefined) {
+                    if (userExprOverrides === undefined) {
+                        userExprOverrides = new Map();
+                    }
+                    userExprOverrides.set(n, a.value);
+                }
+            }
+        }
         if (exprAttrs) {
             const ks = [...exprAttrs.keys()];
             for (let i = 0; i < ks.length; ++i) {
                 const n = ks[i];
-                const expr = exprAttrs.get(n);
-                if (expr) {
-                    await evaluateExpression(expr, newEnv);
-                    const v = newEnv.getLastResult();
-                    newEnv.bind(n, v);
-                    inst.attributes.set(n, v);
-                    updatedAttrs === null || updatedAttrs === void 0 ? void 0 : updatedAttrs.set(n, v);
+                const userValue = userExprOverrides === null || userExprOverrides === void 0 ? void 0 : userExprOverrides.get(n);
+                if (userValue !== undefined) {
+                    // User explicitly provided a value for this @expr attribute - use it
+                    await evaluateExpression(userValue, newEnv);
+                }
+                else {
+                    // No user override - evaluate the @expr expression
+                    const expr = exprAttrs.get(n);
+                    if (expr) {
+                        await evaluateExpression(expr, newEnv);
+                    }
+                    else {
+                        continue;
+                    }
                 }
+                const v = newEnv.getLastResult();
+                newEnv.bind(n, v);
+                inst.attributes.set(n, v);
+                updatedAttrs === null || updatedAttrs === void 0 ? void 0 : updatedAttrs.set(n, v);
             }
         }
-        if (origAttrs && updatedAttrs) {
+        // Re-evaluate non-@expr attribute expressions from origAttrs in the context
+        // of the queried instance. This handles workflow update expressions like
+        // `balance balance + (balance * interestRate) + makeDeposit.amount` where
+        // the local attribute references must resolve from the existing instance.
+        // Only runs on the update path (where updatedAttrs is a separate map from
+        // inst.attributes) to avoid double-evaluating expressions on create.
+        if (origAttrs && updatedAttrs && updatedAttrs !== inst.attributes) {
             for (let i = 0; i < origAttrs.length; ++i) {
                 const a = origAttrs[i];
                 const n = a.name;
+                if (exprAttrs === null || exprAttrs === void 0 ? void 0 : exprAttrs.has(n))
+                    continue;
                 if (!n.endsWith(QuerySuffix) && updatedAttrs.has(n) && a.value !== undefined) {
                     await evaluateExpression(a.value, newEnv);
                     const v = newEnv.getLastResult();
@@ -1655,6 +1803,8 @@ async function agentInvoke(agent, msg, env) {
     invokeDebugMsg = `\nMessage=${msg}`;
     console.debug(invokeDebugMsg);
     //
+    const agentChatId = env.getAgentChatId() || env.getActiveChatId() || '';
+    await clearCancellation(agentChatId);
     const monitoringEnabled = isMonitoringEnabled();
     await agent.invoke(msg, env);
     let result = env.getLastResult();
@@ -1669,8 +1819,15 @@ async function agentInvoke(agent, msg, env) {
             }
             let retries = 0;
             while (true) {
+                await checkCancelled(agentChatId);
                 try {
                     let rs = result ? normalizeGeneratedCode(result) : '';
+                    if (agent.tools) {
+                        env.setLastPattern(rs);
+                    }
+                    else {
+                        env.setLastPattern(undefined);
+                    }
                     let isWf = rs.startsWith('workflow');
                     if (isWf && !agent.runWorkflows) {
                         await parseWorkflow(rs);
@@ -1729,6 +1886,7 @@ async function agentInvoke(agent, msg, env) {
         else {
             let retries = 0;
             while (true) {
+                await checkCancelled(agentChatId);
                 try {
                     result = normalizeGeneratedCode(result);
                     const obj = agent.maybeValidateJsonResponse(result);
@@ -1765,6 +1923,10 @@ async function agentInvoke(agent, msg, env) {
 }
 export async function handleAgentInvocation(agentEventInst, env) {
     const agent = await findAgentByName(agentEventInst.name, env);
+    const chatId = agentEventInst.lookup('chatId');
+    if (chatId) {
+        env.setActiveChatId(chatId);
+    }
     const origMsg = agentEventInst.lookup('message') || JSON.stringify(agentEventInst.asObject());
     const msg = isString(origMsg) ? origMsg : maybeInstanceAsString(origMsg);
     const flow = getAgentFlow(agent.name, agent.moduleName);
@@ -1774,7 +1936,6 @@ export async function handleAgentInvocation(agentEventInst, env) {
     else {
         const mode = agentEventInst.lookup('mode');
         let activeEnv = env;
-        const chatId = agentEventInst.lookup('chatId');
         if (chatId !== undefined) {
             activeEnv.setAgentChatId(chatId);
         }
@@ -1822,9 +1983,11 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
     rootAgent.disableSession();
     const chatId = (_a = env.getActiveEventInstance()) === null || _a === void 0 ? void 0 : _a.lookup('chatId');
     const iterId = chatId || crypto.randomUUID();
+    await clearCancellation(iterId);
     let step = '';
     let fullFlowRetries = 0;
     while (true) {
+        await checkCancelled(iterId);
         try {
             const initContext = msg;
             const s = `Now consider the following flowchart and return the next step:\n${flow}\n
@@ -1847,6 +2010,7 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
                 env.flagMonitorEntryAsFlow().incrementMonitor();
             }
             while (step != 'DONE' && !executedSteps.has(step)) {
+                await checkCancelled(iterId);
                 if (stepc > MaxFlowSteps) {
                     throw new Error(`Flow execution exceeded maximum steps limit`);
                 }
@@ -1903,6 +2067,9 @@ async function iterateOnFlow(flow, rootAgent, msg, env) {
             }
         }
         catch (reason) {
+            if (reason instanceof AgentCancelledException) {
+                throw reason;
+            }
             if (fullFlowRetries < MaxFlowRetries) {
                 msg = `The previous attempt failed at step ${step} with the error ${reason}. Restart the flow the appropriate step
 (maybe even from the first step) and try to fix the issue.`;
@@ -2114,6 +2281,38 @@ export async function evaluateExpression(expr, env) {
     }
     env.setLastResult(result);
 }
+export function extractRefsFromExpr(expr) {
+    const refs = [];
+    function walk(e) {
+        if (isBinExpr(e)) {
+            walk(e.e1);
+            walk(e.e2);
+        }
+        else if (isLiteral(e)) {
+            if (e.ref)
+                refs.push(e.ref);
+            if (e.fnCall) {
+                for (const arg of e.fnCall.args)
+                    walk(arg);
+            }
+            if (e.asyncFnCall) {
+                for (const arg of e.asyncFnCall.fnCall.args)
+                    walk(arg);
+            }
+        }
+        else if (isGroup(e)) {
+            walk(e.ge);
+        }
+        else if (isNegExpr(e)) {
+            walk(e.ne);
+        }
+        else if (isNotExpr(e)) {
+            walk(e.ne);
+        }
+    }
+    walk(expr);
+    return refs;
+}
 async function getRef(r, src, env) {
     if (Instance.IsInstance(src))
         return src.lookup(r);