agentlang 0.10.0 → 0.10.2

package/out/runtime/interpreter.js

@@ -5,7 +5,7 @@ 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 { getResolver, getResolverNameForPath } from './resolvers/registry.js';
-import { parseStatement, parseWorkflow } from '../language/parser.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 { logger } from './logger.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,6 +865,9 @@ export async function evaluateStatement(stmt, env) {
             handlersPushed = env.pushHandlers(handlers);
         }
         await evaluatePattern(stmt.pattern, env);
+        if (hasHints) {
+            await maybeHandleEmpty(hints, env);
+        }
         if (hasHints) {
             maybeBindStatementResultToAlias(hints, env);
         }
@@ -860,6 +895,21 @@ 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());
+                break;
+            }
+        }
+    }
+}
 async function maybeHandleError(handlers, reason, env) {
     const handler = handlers ? handlers.get('error') : undefined;
     if (handler) {
@@ -1219,17 +1269,18 @@ async function maybeValidateOneOfRefs(inst, env) {
         }
     }
 }
-function maybeSetQueryClauses(inst, crud) {
-    if (crud.groupByClause) {
-        inst.setGroupBy(crud.groupByClause.colNames);
+function maybeSetQueryClauses(inst, qopts) {
+    if (qopts.groupByClause) {
+        inst.setGroupBy(qopts.groupByClause.colNames);
     }
-    if (crud.orderByClause) {
-        inst.setOrderBy(crud.orderByClause.colNames, crud.orderByClause.order === '@desc');
+    if (qopts.orderByClause) {
+        inst.setOrderBy(qopts.orderByClause.colNames, qopts.orderByClause.order === '@desc');
     }
 }
 async function evaluateCrudMap(crud, env) {
     var _a, _b, _c;
-    if (!env.isInUpsertMode() && crud.upsert.length > 0) {
+    const qopts = extractQueryOptions(crud);
+    if (!env.isInUpsertMode() && qopts.upsert !== undefined) {
         return await evaluateUpsert(crud, env);
     }
     const inst = crud.source
@@ -1241,23 +1292,23 @@ async function evaluateCrudMap(crud, env) {
     const qattrs = inst.queryAttributes;
     const onlyAggregates = inst.aggregates !== undefined && qattrs === undefined;
     const isQueryAll = onlyAggregates || crud.name.endsWith(QuerySuffix);
-    const distinct = crud.distinct.length > 0;
-    maybeSetQueryClauses(inst, crud);
+    const distinct = qopts.distinct !== undefined;
+    maybeSetQueryClauses(inst, qopts);
     if (attrs.size > 0) {
         await maybeValidateOneOfRefs(inst, env);
     }
-    if (crud.into) {
+    if (qopts.into) {
         if (attrs.size > 0) {
             throw new Error(`Query pattern for ${entryName} with 'into' clause cannot be used to update attributes`);
         }
         if (qattrs === undefined && !isQueryAll) {
             throw new Error(`Pattern for ${entryName} with 'into' clause must be a query`);
         }
-        if (crud.joins.length > 0) {
-            await evaluateJoinQuery(crud.joins, crud.into, crud.where, inst, distinct, env);
+        if (qopts.joins && qopts.joins.length > 0) {
+            await evaluateJoinQuery(qopts.joins, qopts.into, qopts.where, inst, distinct, env);
         }
         else {
-            await evaluateJoinQueryWithRelationships(crud.into, inst, crud.relationships, distinct, env);
+            await evaluateJoinQueryWithRelationships(qopts.into, inst, crud.relationships || [], distinct, env);
         }
         return;
     }
@@ -1336,7 +1387,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 {
@@ -1349,7 +1400,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);
@@ -1379,7 +1430,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());
                         }
@@ -1413,7 +1469,7 @@ async function evaluateCrudMap(crud, env) {
                     await runPreUpdateEvents(lastRes, env);
                     const finalInst = await res.updateInstance(lastRes, attrs);
                     await runPostUpdateEvents(finalInst, lastRes, env);
-                    env.setLastResult(finalInst);
+                    env.setLastResult([finalInst]);
                 }
             }
         }
@@ -1670,6 +1726,12 @@ async function agentInvoke(agent, msg, env) {
             while (true) {
                 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);
@@ -1764,6 +1826,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);
@@ -1773,7 +1839,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);
         }