agentlang 0.10.0 → 0.10.2

package/src/runtime/interpreter.ts

@@ -80,7 +80,12 @@ import {
   splitRefs,
 } from './util.js';
 import { getResolver, getResolverNameForPath } from './resolvers/registry.js';
-import { parseStatement, parseWorkflow } from '../language/parser.js';
+import {
+  ExtractedQueryOptions,
+  extractQueryOptions,
+  parseStatement,
+  parseWorkflow,
+} from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession, AdminUserId } from './auth/defs.js';
 import {
   AgentEntityName,
@@ -114,6 +119,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';
 
 export type Result = any;
 
@@ -126,6 +132,7 @@ export function isEmptyResult(r: Result): boolean {
 type BetweenRelInfo = {
   relationship: Relationship;
   connectedInstance: Instance;
+  connectedAlias?: string;
 };
 
 function mkEnvName(name: string | undefined, parent: Environment | undefined): string {
@@ -150,6 +157,7 @@ export class Environment extends Instance {
   private activeUserSet: boolean = false;
   private lastResult: Result;
   private trashedResult: Result = undefined;
+  private lastPattern: string | undefined;
   private returnFlag: boolean = false;
   private parentPath: string | undefined;
   private normalizedParentPath: string | undefined;
@@ -169,6 +177,7 @@ export class Environment extends Instance {
   private agentChatId: string | undefined = undefined;
   private monitor: Monitor | undefined = undefined;
   private escalatedRole: string | undefined;
+  private activeChatId: string | undefined;
 
   private activeUserData: any = undefined;
 
@@ -196,6 +205,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;
       this.activeResolvers = new Map<string, Resolver>();
@@ -322,6 +332,15 @@ export class Environment extends Instance {
     return this.attributes.get(Environment.FlowContextTag);
   }
 
+  setActiveChatId(chatId: string): Environment {
+    this.activeChatId = chatId;
+    return this;
+  }
+
+  getActiveChatId(): string | undefined {
+    return this.activeChatId;
+  }
+
   addToScratchPad(k: string, data: any): Environment {
     if (this.scratchPad === undefined) {
       this.scratchPad = {};
@@ -392,6 +411,11 @@ export class Environment extends Instance {
     return this;
   }
 
+  maybeRewriteTemplatePatterns(instruction: string, scratchPad?: any): string {
+    const templ = Handlebars.compile(this.rewriteTemplateMappings(instruction));
+    return templ(scratchPad);
+  }
+
   static SuspensionUserData = '^';
 
   bindSuspensionUserData(userData: string): Environment {
@@ -549,6 +573,15 @@ export class Environment extends Instance {
     return this.lastResult;
   }
 
+  setLastPattern(pattern: string | undefined): Environment {
+    this.lastPattern = pattern;
+    return this;
+  }
+
+  getLastPattern(): string | undefined {
+    return this.lastPattern;
+  }
+
   getActiveModuleName(): string {
     return this.activeModule;
   }
@@ -886,6 +919,13 @@ export class Environment extends Instance {
     return this;
   }
 
+  setMonitorEntryLlmTokenUsage(input: number, output: number, total: number): Environment {
+    if (this.monitor !== undefined) {
+      this.monitor.setEntryLlmTokenUsage(input, output, total);
+    }
+    return this;
+  }
+
   incrementMonitor(): Environment {
     if (this.monitor !== undefined) {
       this.monitor = this.monitor.increment();
@@ -934,7 +974,13 @@ export let evaluate = async function (
       } 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);
         await handleOpenApiEvent(eventInstance, env);
@@ -1087,6 +1133,9 @@ export async function evaluateStatement(stmt: Statement, env: Environment): Prom
       handlersPushed = env.pushHandlers(handlers);
     }
     await evaluatePattern(stmt.pattern, env);
+    if (hasHints) {
+      await maybeHandleEmpty(hints, env);
+    }
     if (hasHints) {
       maybeBindStatementResultToAlias(hints, env);
     }
@@ -1116,6 +1165,24 @@ async function maybeHandleNotFound(handlers: CatchHandlers | undefined, env: Env
   }
 }
 
+async function maybeHandleEmpty(hints: RuntimeHint[], env: Environment) {
+  const lastResult: Result = 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: CatchHandlers | undefined,
   reason: any,
@@ -1497,17 +1564,18 @@ async function maybeValidateOneOfRefs(inst: Instance, env: Environment) {
   }
 }
 
-function maybeSetQueryClauses(inst: Instance, crud: CrudMap) {
-  if (crud.groupByClause) {
-    inst.setGroupBy(crud.groupByClause.colNames);
+function maybeSetQueryClauses(inst: Instance, qopts: ExtractedQueryOptions) {
+  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: CrudMap, env: Environment): Promise<void> {
-  if (!env.isInUpsertMode() && crud.upsert.length > 0) {
+  const qopts = extractQueryOptions(crud);
+  if (!env.isInUpsertMode() && qopts.upsert !== undefined) {
     return await evaluateUpsert(crud, env);
   }
   const inst: Instance = crud.source
@@ -1519,12 +1587,12 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   const qattrs = inst.queryAttributes;
   const onlyAggregates = inst.aggregates !== undefined && qattrs === undefined;
   const isQueryAll = onlyAggregates || crud.name.endsWith(QuerySuffix);
-  const distinct: boolean = crud.distinct.length > 0;
-  maybeSetQueryClauses(inst, crud);
+  const distinct: boolean = 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`
@@ -1533,10 +1601,16 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     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;
   }
@@ -1634,7 +1708,8 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
         const insts: Instance[] = await res.queryConnectedInstances(
           betRelInfo.relationship,
           betRelInfo.connectedInstance,
-          inst
+          inst,
+          betRelInfo.connectedAlias
         );
         env.setLastResult(insts);
       } else {
@@ -1659,7 +1734,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
             false,
             true
           );
-          env.setLastResult(inst);
+          env.setLastResult([inst]);
         } else {
           const insts: Instance[] = await res.queryInstances(inst, isQueryAll, distinct);
           env.setLastResult(insts);
@@ -1686,7 +1761,12 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
               await evaluatePattern(rel.pattern, newEnv);
               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());
             }
@@ -1722,7 +1802,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           await runPreUpdateEvents(lastRes, env);
           const finalInst: Instance = await res.updateInstance(lastRes, attrs);
           await runPostUpdateEvents(finalInst, lastRes, env);
-          env.setLastResult(finalInst);
+          env.setLastResult([finalInst]);
         }
       }
     }
@@ -2023,6 +2103,11 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
       while (true) {
         try {
           let rs: string = 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);
@@ -2116,6 +2201,10 @@ export async function handleAgentInvocation(
   env: Environment
 ): Promise<void> {
   const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
+  const chatId = agentEventInst.lookup('chatId');
+  if (chatId) {
+    env.setActiveChatId(chatId);
+  }
   const origMsg: any =
     agentEventInst.lookup('message') || JSON.stringify(agentEventInst.asObject());
   const msg: string = isString(origMsg) ? origMsg : maybeInstanceAsString(origMsg);
@@ -2125,7 +2214,6 @@ export async function handleAgentInvocation(
   } else {
     const mode = agentEventInst.lookup('mode');
     let activeEnv = env;
-    const chatId = agentEventInst.lookup('chatId');
     if (chatId !== undefined) {
       activeEnv.setAgentChatId(chatId);
     }

package/src/runtime/module.ts

@@ -1409,6 +1409,10 @@ export class Relationship extends Record {
     return this.relType == RelType.BETWEEN;
   }
 
+  isSelfReferencing(): boolean {
+    return this.node1.path.asFqName() === this.node2.path.asFqName();
+  }
+
   parentNode(): RelationshipNode {
     return this.node1;
   }
@@ -1502,6 +1506,28 @@ export class Relationship extends Record {
     }
   }
 
+  /**
+   * For self-referencing relationships, resolve the alias for the connected instance
+   * based on an explicit connectedAlias. Falls back to fqName-based lookup for
+   * non-self-referencing relationships.
+   */
+  getAliasForConnected(inst: Instance, connectedAlias?: string): string {
+    if (connectedAlias && this.isSelfReferencing()) {
+      return connectedAlias;
+    }
+    return this.getAliasFor(inst);
+  }
+
+  getInverseAliasForConnected(inst: Instance, connectedAlias?: string): string {
+    if (connectedAlias && this.isSelfReferencing()) {
+      if (connectedAlias === this.node1.alias) {
+        return this.node2.alias;
+      }
+      return this.node1.alias;
+    }
+    return this.getInverseAliasFor(inst);
+  }
+
   isParent(inst: Instance): boolean {
     return inst.getFqName() == this.node1.path.asFqName();
   }

package/src/runtime/modules/ai.ts

@@ -1,6 +1,10 @@
 import {
   DefaultModuleName,
   escapeSpecialChars,
+  extractAndRemoveAllXmlTaggedText,
+  ExtractedCode,
+  ExtractedText,
+  extractFencedCodeBlocks,
   isFqName,
   isString,
   makeCoreModuleName,
@@ -66,7 +70,6 @@ import {
 } from '../agents/common.js';
 import { logger } from '../logger.js';
 import { FlowStep } from '../agents/flows.js';
-import Handlebars from 'handlebars';
 import { Statement } from '../../language/generated/ast.js';
 import { isMonitoringEnabled, TtlCache } from '../state.js';
 import { isNodeEnv } from '../../utils/runtime.js';
@@ -103,6 +106,7 @@ entity ${AgentEntityName} {
     flows String @optional,
     validate String @optional,
     retry String @optional,
+    saveResponseAs String @optional,
     llm String
 }
 
@@ -319,6 +323,7 @@ export class AgentInstance {
   flows: string | undefined;
   validate: string | undefined;
   retry: string | undefined;
+  saveResponseAs: string | undefined;
   stateless: boolean = false;
   private toolsArray: string[] | undefined = undefined;
   private hasModuleTools = false;
@@ -580,7 +585,7 @@ export class AgentInstance {
     }
   }
 
-  private async getFullInstructions(
+  private async getFullInstructionsHelper(
     env: Environment,
     activator: AgentInstructionActivator
   ): Promise<string> {
@@ -641,7 +646,7 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     const spad = env.getScratchPad();
     if (spad !== undefined && Object.keys(spad).length > 0) {
       if (finalInstruction.indexOf('{{') > 0) {
-        return AgentInstance.maybeRewriteTemplatePatterns(spad, finalInstruction, env);
+        return env.maybeRewriteTemplatePatterns(finalInstruction, spad);
       } else {
         const ctx = JSON.stringify(spad);
         return `${finalInstruction}\nSome additional context:\n${ctx}`;
@@ -652,13 +657,36 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     }
   }
 
-  private static maybeRewriteTemplatePatterns(
-    scratchPad: any,
-    instruction: string,
-    env: Environment
-  ): string {
-    const templ = Handlebars.compile(env.rewriteTemplateMappings(instruction));
-    return templ(scratchPad);
+  private static UserTag = 'user';
+  private static FileTag = 'file';
+
+  private async getFullInstructions(
+    env: Environment,
+    activator: AgentInstructionActivator
+  ): Promise<ExtractedText> {
+    const finalInstruction = await this.getFullInstructionsHelper(env, activator);
+    if (finalInstruction.indexOf(`<${AgentInstance.UserTag}>`) > 0) {
+      return extractAndRemoveAllXmlTaggedText(finalInstruction, AgentInstance.UserTag);
+    } else {
+      return { extracted: undefined, updatedText: finalInstruction };
+    }
+  }
+
+  private async maybeFillInFileContents(instructions: string, env: Environment): Promise<string> {
+    const chatId = env.getActiveChatId();
+    const FC = '$FC';
+    if (chatId && instructions.indexOf(`<${AgentInstance.FileTag}>`) > 0) {
+      const ext = extractAndRemoveAllXmlTaggedText(instructions, AgentInstance.FileTag, FC);
+      if (ext.extracted) {
+        instructions = ext.updatedText;
+        for (let i = 0; i < ext.extracted.length; ++i) {
+          const fileName = ext.extracted[i];
+          const contents = await loadLocalAgentResult(chatId, fileName);
+          if (contents) instructions = instructions.replace(FC, contents);
+        }
+      }
+    }
+    return instructions;
   }
 
   maybeValidateJsonResponse(response: string | undefined): object | undefined {
@@ -820,6 +848,7 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     const sess: Instance | null = this.withSession ? await findAgentChatSession(chatId, env) : null;
     let msgs: BaseMessage[] | undefined;
     let cachedMsg: string | undefined = undefined;
+    let extractedText: ExtractedText | undefined;
     const activator: AgentInstructionActivator = {
       provider: p,
       userMessage: message,
@@ -829,7 +858,8 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     if (sess) {
       msgs = sess.lookup('messages');
     } else {
-      cachedMsg = await this.getFullInstructions(env, activator);
+      extractedText = await this.getFullInstructions(env, activator);
+      cachedMsg = extractedText.updatedText;
       msgs = [systemMessage(cachedMsg || '')];
     }
     if (msgs) {
@@ -844,12 +874,22 @@ Only return a pure JSON object with no extra text, annotations etc.`;
                 ? EvalInstructions
                 : LearnerAgentInstructions;
           const ts = this.toolsAsString();
-          const msg = `${s}\n${ts}\n${cachedMsg || (await this.getFullInstructions(env, activator))}`;
+          let tmpMsg = cachedMsg;
+          if (!tmpMsg) {
+            extractedText = await this.getFullInstructions(env, activator);
+            tmpMsg = extractedText.updatedText;
+          }
+          const msg = `${s}\n${ts}\n${tmpMsg}`;
           const newSysMsg = systemMessage(msg);
           msgs[0] = newSysMsg;
         }
+        let tmpMsg = message;
+        if (extractedText?.extracted) {
+          const s = await this.maybeFillInFileContents(extractedText.extracted.join('\n'), env);
+          tmpMsg = `${tmpMsg}\n${s}`;
+        }
         const hmsg = await this.maybeAddRelevantDocuments(
-          this.maybeAddFlowContext(message, env),
+          this.maybeAddFlowContext(tmpMsg, env),
           env
         );
         if (hmsg.length > 0) {
@@ -898,6 +938,13 @@ Only return a pure JSON object with no extra text, annotations etc.`;
           await saveAgentChatSession(chatId, msgs, env);
         }
         if (monitoringEnabled) env.setMonitorEntryLlmResponse(response.content);
+        if (monitoringEnabled && response.sysMsg.usage_metadata) {
+          const u = response.sysMsg.usage_metadata;
+          env.setMonitorEntryLlmTokenUsage(u.input_tokens, u.output_tokens, u.total_tokens);
+        }
+        if (this.saveResponseAs) {
+          await saveAgentResponse(this.saveResponseAs, response.content, env);
+        }
         env.setLastResult(response.content);
       } catch (err: any) {
         logger.error(`Error while invoking ${agentName} - ${err}`);
@@ -1299,26 +1346,6 @@ function processScenarioResponse(resp: string): string {
   return resp;
 }
 
-type ExtractedCode = {
-  language: string | null;
-  code: string;
-};
-
-export function extractFencedCodeBlocks(markdown: string): ExtractedCode[] {
-  const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
-  const blocks: ExtractedCode[] = [];
-  let match;
-
-  while ((match = codeBlockRegex.exec(markdown)) !== null) {
-    blocks.push({
-      language: match[1] || null,
-      code: match[2],
-    });
-  }
-
-  return blocks;
-}
-
 export function normalizeGeneratedCode(code: string | undefined): string {
   if (code !== undefined) {
     const blocks = extractFencedCodeBlocks(code);
@@ -1439,15 +1466,9 @@ export async function saveFlowStepResultLocally(
   chatId: string,
   step: string,
   result: string,
-  suspensionId: string
-): Promise<Instance | undefined> {
+  suspensionId?: string | undefined
+): Promise<string> {
   const fs = await getFileSystem();
-  const attrs = newInstanceAttributes()
-    .set('chatId', chatId)
-    .set('step', step)
-    .set('result', result)
-    .set('suspensionId', suspensionId);
-  const inst = makeInstance(CoreAIModuleName, AgentFlowStep, attrs);
   const rootDirName = LocalFlowStepsRootDirName;
   if (!(await fs.exists(rootDirName))) {
     await fs.mkdir(rootDirName);
@@ -1460,8 +1481,18 @@ export async function saveFlowStepResultLocally(
   if (await fs.exists(fileName)) {
     await fs.unlink(fileName);
   }
-  await fs.writeFile(fileName, JSON.stringify(inst.attributesAsObject(true)));
-  return inst;
+  let s = result;
+  if (suspensionId) {
+    const attrs = newInstanceAttributes()
+      .set('chatId', chatId)
+      .set('step', step)
+      .set('result', result)
+      .set('suspensionId', suspensionId);
+    const inst = makeInstance(CoreAIModuleName, AgentFlowStep, attrs);
+    s = JSON.stringify(inst.attributesAsObject(true));
+  }
+  await fs.writeFile(fileName, s);
+  return s;
 }
 
 export async function saveFlowStepResult(
@@ -1470,9 +1501,10 @@ export async function saveFlowStepResult(
   result: string,
   suspensionId: string,
   env: Environment
-): Promise<Instance | undefined> {
+): Promise<boolean> {
   if (LocalAgentgFlow) {
-    return await saveFlowStepResultLocally(chatId, step, result, suspensionId);
+    await saveFlowStepResultLocally(chatId, step, result, suspensionId);
+    return true;
   } else {
     const t = `${CoreAIModuleName}/${AgentFlowStep}`;
     try {
@@ -1486,11 +1518,11 @@ export async function saveFlowStepResult(
         undefined,
         env
       );
-      if (isInstanceOfType(inst, t)) return inst;
-      else return undefined;
+      if (isInstanceOfType(inst, t)) return true;
+      else return false;
     } catch (reason: any) {
       logger.error(`failed to save flow result for step ${step} - ${reason}`);
-      return undefined;
+      return false;
     }
   }
 }
@@ -1528,10 +1560,10 @@ export async function loadFlowStepResults(chatId: string): Promise<Instance[]> {
   }
 }
 
-export async function loadLocalFlowStep(
+export async function loadLocalAgentResult(
   chatId: string,
   step: string
-): Promise<Instance | undefined> {
+): Promise<string | undefined> {
   const fs = await getFileSystem();
   const dirName = `${LocalFlowStepsRootDirName}/${chatId}`;
   if (await fs.exists(dirName)) {
@@ -1539,10 +1571,7 @@ export async function loadLocalFlowStep(
     for (let i = 0; i < fileNames.length; ++i) {
       const fileName = fileNames[i];
       if (fileName === step) {
-        const attrs = objectToInstanceAttributes(
-          JSON.parse(await fs.readFile(`${dirName}/${fileName}`))
-        );
-        return makeInstance(CoreAIModuleName, AgentFlowStep, attrs);
+        return await fs.readFile(`${dirName}/${fileName}`);
       }
     }
     return undefined;
@@ -1551,6 +1580,19 @@ export async function loadLocalFlowStep(
   }
 }
 
+export async function loadLocalFlowStep(
+  chatId: string,
+  step: string
+): Promise<Instance | undefined> {
+  const contents = await loadLocalAgentResult(chatId, step);
+  if (contents) {
+    const attrs = objectToInstanceAttributes(JSON.parse(contents));
+    return makeInstance(CoreAIModuleName, AgentFlowStep, attrs);
+  } else {
+    return undefined;
+  }
+}
+
 export async function loadFlowStep(chatId: string, step: string): Promise<Instance | undefined> {
   if (LocalAgentgFlow) {
     return await loadLocalFlowStep(chatId, step);
@@ -1630,3 +1672,17 @@ export async function fetchAndCreateDocument(
     throw new Error(`Failed to fetch document: ${title} from ${url}`);
   }
 }
+
+export async function saveAgentResponse(
+  fileName: string,
+  response: string,
+  env: Environment
+): Promise<string> {
+  const chatId = env.getActiveChatId();
+  if (chatId) {
+    await saveFlowStepResultLocally(chatId, fileName, response);
+  } else {
+    logger.warn(`No chatId set, ${fileName} was not saved.`);
+  }
+  return response;
+}

package/src/runtime/modules/core.ts

@@ -749,5 +749,9 @@ export function migrationDowns(inst: Instance): string[] | undefined {
 
 export async function doRawQuery(q: any): Promise<any> {
   const qs = objectToQueryPattern(q);
-  return await parseAndEvaluateStatement(qs);
+  const result = await parseAndEvaluateStatement(qs);
+  return {
+    query: qs,
+    result: result.map((res: any) => (res.attributes ? Object.fromEntries(res.attributes) : res)),
+  };
 }