agentlang 0.9.0 → 0.9.2

package/src/language/syntax.ts

@@ -5,10 +5,11 @@ import {
   isDecisionDefinition,
   isFlowDefinition,
   ModuleDefinition,
+  Statement,
 } from './generated/ast.js';
 import { createAgentlangServices } from './agentlang-module.js';
 import { EmptyFileSystem } from 'langium';
-import { introspect, parseModule } from './parser.js';
+import { introspect, parseModule, parseStatement } from './parser.js';
 
 export class BasePattern {
   alias: string | undefined;
@@ -806,16 +807,31 @@ function patternsToString(body: BasePattern[], sep = ';\n'): string {
 
 export class FlowStepPattern extends BasePattern {
   first: string;
-  next: string;
+  next: Statement | undefined;
   condition?: string;
 
-  constructor(first: string, next: string, condition?: string) {
+  constructor(first: string, next?: Statement, condition?: string) {
     super();
     this.first = first;
     this.next = next;
     this.condition = condition ? trimQuotes(condition) : undefined;
   }
 
+  async setNextFromString(pattern: string): Promise<FlowStepPattern> {
+    this.next = await parseStatement(pattern);
+    return this;
+  }
+
+  setNext(next: Statement): FlowStepPattern {
+    this.next = next;
+    return this;
+  }
+
+  setCondition(condition: string): FlowStepPattern {
+    this.condition = condition;
+    return this;
+  }
+
   static async Parse(s: string): Promise<FlowStepPattern> {
     const p = await parseModule(`module Temp
       flow tempFlow {
@@ -826,9 +842,9 @@ export class FlowStepPattern extends BasePattern {
     if (isFlowDefinition(d)) {
       d.body?.entries.forEach((fe: FlowEntry) => {
         if (fe.cond) {
-          result = new FlowStepPattern(fe.root, fe.cond.next.$cstNode?.text || '', fe.cond.expr);
+          result = new FlowStepPattern(fe.root, fe.cond.next, fe.cond.expr);
         } else {
-          result = new FlowStepPattern(fe.root, fe.next?.$cstNode?.text || '');
+          result = new FlowStepPattern(fe.root, fe.next);
         }
       });
     }
@@ -839,10 +855,11 @@ export class FlowStepPattern extends BasePattern {
   }
 
   override toString(): string {
+    const nxt = this.next === undefined ? '' : this.next.$cstNode?.text;
     if (this.condition) {
-      return `${this.first} --> "${this.condition}" ${this.next}`;
+      return `${this.first} --> "${this.condition}" ${nxt}`;
     } else {
-      return `${this.first} --> ${this.next}`;
+      return `${this.first} --> ${nxt}`;
     }
   }
 }

package/src/runtime/agents/common.ts

@@ -275,8 +275,7 @@ acceptOrder --> sendPaymentLinkToCustomer
 rejectOrder --> sendRejectionEmailToCustomer
 
 Along with this flowchart, you'll be passed a "context", which contain the steps in the flowchart that was executed so far, along with
-their results. Based on the context, you need to return the name of the step that needs to execute next. If you have reached the end
-of the chart, return 'DONE'. 
+their results. Based on the context, you need to return the step that needs to execute next. If you have reached the end of the chart, return 'DONE'.
 
 At the beginning of the execution, the context will contain only the order information, say something like:
 
@@ -311,6 +310,11 @@ The 'sendPaymentLinkToCustomer' has returned the customer email. You look at the
 Generally a flowchart has the following two types of entries:
   1. a --> b, meaning after step 'a' do step 'b'.
   2. a --> "x" b - this means if 'a' returns the string "x", then do step 'b'.
+The node 'b' can be a simple name of the next step or a complex pattern like: \`{acme.core/createProduct {productNo 19089, name "X200"}}\` or
+\`{acme.core/createProduct {productNo 19089, name "X200"}} @as NewProductCreated\`. In all cases, you must return the complete step-specification
+when you are required to produce the next step to execute. That is, return the spec -- complete with the enclosing \`{\` and \`}\` and the \`@as <alias>\` specification,
+if that's provided.
+
 If you detect that you have reached the end of the chart, return 'DONE'. Otherwise, return only the name of the next step. Never return
 any additional description, direction or comments.
 

package/src/runtime/defs.ts

@@ -121,6 +121,7 @@ export const FlowSuspensionTag = `--`;
 export enum SubGraphType {
   EVENT,
   IF,
+  IF_WITH_ALIAS,
   FOR_EACH,
   DELETE,
   PURGE,
@@ -206,6 +207,10 @@ export class ExecGraph {
     return this.fetchSubGraphAt(this.subGraphs.length - 1);
   }
 
+  fetchIfWithAliasSubGraph(): ExecGraph {
+    return this.fetchSubGraphAt(this.subGraphs.length - 1);
+  }
+
   fetchIfConsequentSubGraph(): ExecGraph {
     if (this.subGraphs.length >= 2) {
       return this.fetchSubGraphAt(this.subGraphs.length - 2);

package/src/runtime/exec-graph.ts

@@ -5,6 +5,7 @@ import {
   ForEach,
   FullTextSearch,
   If,
+  IfWithAlias,
   isPattern,
   isStatement,
   isWorkflowDefinition,
@@ -12,6 +13,7 @@ import {
   Pattern,
   Purge,
   Return,
+  RuntimeHint,
   Statement,
   ThrowError,
 } from '../language/generated/ast.js';
@@ -24,7 +26,9 @@ import {
   evaluatePattern,
   evaluateStatement,
   handleAgentInvocation,
+  handleMcpEvent,
   handleOpenApiEvent,
+  isMcpEventInstance,
   maybeBindStatementResultToAlias,
   maybeDeleteQueriedInstances,
   PatternHandler,
@@ -135,6 +139,12 @@ class GraphGenerator extends PatternHandler {
     this.addSubGraph(SubGraphType.IF, cond, env);
   }
 
+  override async handleIfWithAlias(ifWithAlias: IfWithAlias, env: Environment) {
+    const handler = new GraphGenerator();
+    await handler.handleIf(ifWithAlias.if, env);
+    this.addSubGraph(SubGraphType.IF_WITH_ALIAS, handler.getGraph(), env);
+  }
+
   private async handleSubPattern(subGraphType: SubGraphType, pat: Pattern, env: Environment) {
     const newEnv = Environment.from(env).setActiveUserData(pat);
     const handler = new GraphGenerator();
@@ -256,6 +266,12 @@ export async function executeGraph(execGraph: ExecGraph, env: Environment): Prom
                 env.setLastResult(newEnv.getLastResult());
                 break;
               }
+              case SubGraphType.IF_WITH_ALIAS: {
+                const newEnv = new Environment(`${env.name}-if`, env);
+                await executeIfSubGraph(subg.fetchIfWithAliasSubGraph(), newEnv);
+                env.setLastResult(newEnv.getLastResult());
+                break;
+              }
               case SubGraphType.FOR_EACH: {
                 const newEnv = new Environment(`${env.name}-forEach`, env);
                 await executeForEachSubGraph(subg, node, newEnv);
@@ -278,7 +294,10 @@ export async function executeGraph(execGraph: ExecGraph, env: Environment): Prom
                 throw new Error(`Invalid sub-graph type: ${node.subGraphType}`);
             }
           }
-          maybeSetAlias(node, env);
+          const aliasHints = fetchAliasHints(node);
+          if (aliasHints) {
+            maybeBindStatementResultToAlias(aliasHints, env);
+          }
         }
       } catch (reason: any) {
         if (monitoringEnabled) env.setMonitorEntryError(reason);
@@ -437,6 +456,10 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
     env = env || new Environment();
     await handleOpenApiEvent(eventInstance, env);
     return env.getLastResult();
+  } else if (isMcpEventInstance(eventInstance)) {
+    env = env || new Environment();
+    await handleMcpEvent(eventInstance, env);
+    return env.getLastResult();
   }
   const fqn = eventInstance.getFqName();
   let isLocalEnv = false;
@@ -453,6 +476,7 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
   }
   const oldModuleName = env.switchActiveModuleName(eventInstance.moduleName);
   env.bind(eventInstance.name, eventInstance);
+  env.bind(eventInstance.getFqName(), eventInstance);
   try {
     if (g) {
       await executeGraph(g, env);
@@ -570,6 +594,17 @@ export async function parseAndExecuteStatement(
   }
 }
 
+function fetchAliasHints(node: ExecGraphNode): RuntimeHint[] | undefined {
+  const stmt = node.code as Statement;
+  const hints = stmt.hints;
+  if (hints && hints.length > 0) {
+    return hints.filter((rh: RuntimeHint) => {
+      return rh.aliasSpec;
+    });
+  }
+  return undefined;
+}
+
 function maybeSetAlias(node: ExecGraphNode, env: Environment) {
   const stmt = node.code as Statement;
   const hints = stmt.hints;

package/src/runtime/interpreter.ts

@@ -8,6 +8,7 @@ import {
   FullTextSearch,
   Handler,
   If,
+  IfWithAlias,
   isBinExpr,
   isGroup,
   isLiteral,
@@ -52,6 +53,8 @@ import {
   Relationship,
   Workflow,
   setMetaAttributes,
+  Event,
+  isOneToOneBetweenRelationship,
 } from './module.js';
 import { JoinInfo, Resolver, WhereClause } from './resolvers/interface.js';
 import { ResolverAuthInfo } from './resolvers/authinfo.js';
@@ -107,6 +110,7 @@ import { FlowSpec, FlowStep, getAgentFlow } from './agents/flows.js';
 import { isMonitoringEnabled } from './state.js';
 import { Monitor, MonitorEntry } from './monitor.js';
 import { detailedDiff } from 'deep-object-diff';
+import { callMcpTool, mcpClientNameFromToolEvent } from './mcpclient.js';
 
 export type Result = any;
 
@@ -1215,6 +1219,10 @@ export class PatternHandler {
     await evaluateIf(_if, env);
   }
 
+  async handleIfWithAlias(ifWithAlias: IfWithAlias, env: Environment) {
+    await evaluateIfWithAlias(ifWithAlias, env);
+  }
+
   async handleDelete(del: Delete, env: Environment) {
     await evaluateDelete(del, env);
   }
@@ -1251,6 +1259,8 @@ export async function evaluatePattern(
     await handler.handleForEach(pat.forEach, env);
   } else if (pat.if) {
     await handler.handleIf(pat.if, env);
+  } else if (pat.ifWithAlias) {
+    await handler.handleIfWithAlias(pat.ifWithAlias, env);
   } else if (pat.delete) {
     await handler.handleDelete(pat.delete, env);
   } else if (pat.purge) {
@@ -1414,7 +1424,9 @@ async function instanceFromSource(crud: CrudMap, env: Environment): Promise<Inst
     await evaluateLiteral(crud.source, env);
     const attrsSrc = env.getLastResult();
     if (attrsSrc && attrsSrc instanceof Object) {
-      const attrs: InstanceAttributes = new Map(Object.entries(attrsSrc));
+      const obj =
+        attrsSrc instanceof Instance ? (attrsSrc as Instance).userAttributesAsObject() : attrsSrc;
+      const attrs: InstanceAttributes = new Map(Object.entries(obj));
       const nparts = nameToPath(crud.name);
       const n = nparts.getEntryName();
       const m = nparts.hasModule() ? nparts.getModuleName() : env.getActiveModuleName();
@@ -1606,8 +1618,25 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           isReadForUpdate,
           env.isInDeleteMode()
         );
-        const insts: Instance[] = await res.queryInstances(inst, isQueryAll, distinct);
-        env.setLastResult(insts);
+        let oneToOne = false;
+        let rel: Relationship | undefined;
+        if (isBetRel && env.isInDeleteMode()) {
+          rel = getRelationship(inst.name, inst.moduleName);
+          oneToOne = rel.isOneToOne();
+        }
+        if (oneToOne && rel !== undefined) {
+          await res.handleInstancesLink(
+            inst.lookupQueryVal(rel.node1.alias),
+            inst.lookupQueryVal(rel.node2.alias),
+            rel,
+            false,
+            true
+          );
+          env.setLastResult(inst);
+        } else {
+          const insts: Instance[] = await res.queryInstances(inst, isQueryAll, distinct);
+          env.setLastResult(insts);
+        }
       }
       if (crud.relationships !== undefined) {
         const lastRes: Instance[] = env.getLastResult();
@@ -1674,6 +1703,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     if (isAgentEventInstance(inst)) await handleAgentInvocation(inst, env);
     else if (isOpenApiEventInstance(inst)) await handleOpenApiEvent(inst, env);
     else if (isDocEventInstance(inst)) await handleDocEvent(inst, env);
+    else if (isMcpEventInstance(inst)) await handleMcpEvent(inst, env);
     else {
       const eventExec = env.getEventExecutor();
       const newEnv = new Environment(`${inst.name}.env`, env);
@@ -1697,6 +1727,11 @@ function isDocEventInstance(inst: Instance): boolean {
   return isInstanceOfType(inst, DocEventName);
 }
 
+export function isMcpEventInstance(inst: Instance): boolean {
+  const event: Event = inst.record as Event;
+  return event.isMcpTool();
+}
+
 async function handleDocEvent(inst: Instance, env: Environment): Promise<void> {
   const s = await fetchDoc(inst.lookup('url'));
   if (s) {
@@ -1709,6 +1744,17 @@ async function handleDocEvent(inst: Instance, env: Environment): Promise<void> {
   }
 }
 
+export async function handleMcpEvent(inst: Instance, env: Environment): Promise<void> {
+  const mcpClientName = mcpClientNameFromToolEvent(inst);
+  const clientInsts: Instance[] = await parseAndEvaluateStatement(
+    `{agentlang.mcp/Client {name? "${mcpClientName}"}}`,
+    undefined,
+    env
+  );
+  const result = await callMcpTool(clientInsts[0], inst);
+  env.setLastResult(result);
+}
+
 async function computeExprAttributes(
   inst: Instance,
   origAttrs: SetAttribute[] | undefined,
@@ -2093,7 +2139,7 @@ async function iterateOnFlow(
   env.setFlowContext(initContext);
   await agentInvoke(rootAgent, s, env);
   const rootModuleName = rootAgent.moduleName;
-  let preprocResult = await preprocessStep(env.getLastResult().trim(), rootModuleName, env);
+  let preprocResult = await preprocessStep(env.getLastResult(), rootModuleName, env);
   let step = preprocResult.step;
   let needAgentProcessing = preprocResult.needAgentProcessing;
   let context = initContext;
@@ -2147,11 +2193,11 @@ async function iterateOnFlow(
       );
       context = `${context}\n${step} --> ${rs}\n`;
       if (isfxc) {
-        preprocResult = await preprocessStep(rs.trim(), rootModuleName, env);
+        preprocResult = await preprocessStep(rs, rootModuleName, env);
       } else {
         env.setFlowContext(context);
         await agentInvoke(rootAgent, `${s}\n${context}`, env);
-        preprocResult = await preprocessStep(env.getLastResult().trim(), rootModuleName, env);
+        preprocResult = await preprocessStep(env.getLastResult(), rootModuleName, env);
       }
       step = preprocResult.step;
       needAgentProcessing = preprocResult.needAgentProcessing;
@@ -2173,7 +2219,8 @@ async function preprocessStep(
   env: Environment
 ): Promise<PreprocStepResult> {
   let needAgentProcessing = true;
-  if (spec.startsWith('{')) {
+  spec = trimGeneratedCode(spec);
+  if (spec.startsWith('{') || spec.indexOf(' ') > 0) {
     const newEnv = Environment.from(env, env.name + '_flow_eval', false, true).setActiveModuleName(
       activeModuleName
     );
@@ -2229,6 +2276,10 @@ async function evaluateIf(ifStmt: If, env: Environment): Promise<void> {
   }
 }
 
+async function evaluateIfWithAlias(ifWithAlias: IfWithAlias, env: Environment): Promise<void> {
+  await evaluateIf(ifWithAlias.if, env);
+}
+
 async function evaluateDeleteHelper(
   pattern: Pattern,
   purge: boolean,
@@ -2248,6 +2299,11 @@ export async function maybeDeleteQueriedInstances(
   let resolver: Resolver = Resolver.Default;
   if (inst instanceof Array) {
     if (inst.length > 0) {
+      if (isOneToOneBetweenRelationship(inst[0].name, inst[0].moduleName)) {
+        // delete already handled in evaluateCrudMap
+        env.setLastResult(inst);
+        return;
+      }
       resolver = await getResolverForPath(inst[0].name, inst[0].moduleName, queryEnv);
       const finalResult: Array<any> = new Array<any>();
       for (let i = 0; i < inst.length; ++i) {
@@ -2261,6 +2317,11 @@ export async function maybeDeleteQueriedInstances(
       queryEnv.setLastResult(inst);
     }
   } else {
+    if (isOneToOneBetweenRelationship(inst.name, inst.moduleName)) {
+      // delete already handled in evaluateCrudMap
+      env.setLastResult([inst]);
+      return;
+    }
     resolver = await getResolverForPath(inst.name, inst.moduleName, queryEnv);
     await runPreDeleteEvents(inst, env);
     const r: Instance | null = await resolver.deleteInstance(inst, purge);