agentlang 0.2.0 → 0.2.2

package/src/language/parser.ts

@@ -132,34 +132,35 @@ export function maybeGetValidationErrors(document: LangiumDocument): string[] |
   }
 }
 
-function maybeRaiseParserErrors(document: LangiumDocument) {
-  const errs = maybeGetValidationErrors(document);
-  if (errs) {
-    throw new Error(errs.join('\n'));
-  }
-}
-
-export async function introspect(s: string): Promise<BasePattern[]> {
-  let result: BasePattern[] = [];
-  const v: LangiumDocument<ModuleDefinition> = await parse(`module Temp workflow Test {${s}}`);
-  if (v.parseResult.lexerErrors.length > 0) {
+export function maybeRaiseParserErrors(document: LangiumDocument) {
+  if (document.parseResult.lexerErrors.length > 0) {
     throw new Error(
-      `Lexer errors: ${v.parseResult.lexerErrors
+      `Lexer errors: ${document.parseResult.lexerErrors
         .map((err: any) => {
           return err.message;
         })
         .join('\n')}`
     );
   }
-  if (v.parseResult.parserErrors.length > 0) {
+  if (document.parseResult.parserErrors.length > 0) {
     throw new Error(
-      `Parser errors: ${v.parseResult.parserErrors
+      `Parser errors: ${document.parseResult.parserErrors
         .map((err: any) => {
           return err.message;
         })
         .join('\n')}`
     );
   }
+  const errs = maybeGetValidationErrors(document);
+  if (errs) {
+    throw new Error(errs.join('\n'));
+  }
+}
+
+export async function introspect(s: string): Promise<BasePattern[]> {
+  let result: BasePattern[] = [];
+  const v: LangiumDocument<ModuleDefinition> = await parse(`module Temp workflow Test {${s}}`);
+  maybeRaiseParserErrors(v);
   if (isWorkflowDefinition(v.parseResult.value.defs[0])) {
     result = introspectHelper(v.parseResult.value.defs[0].statements);
   } else {

package/src/runtime/agents/common.ts

@@ -62,11 +62,10 @@ Other than the create-pattern for entities and events, some of the most useful p
    instance, if the instance does not already exist.
 4. Delete - e.g: 'delete {Erp/Employee {employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"}}'
 
-The default query operator is '=' (equals). So an expression like 'employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"' means,
+The default query operator is equals. So an expression like 'employeeId? "56392e13-0d9a-42f7-b556-0d7cd9468a24"' means,
 'where employeeId equals "56392e13-0d9a-42f7-b556-0d7cd9468a24"'. Other comparison operators has to be specified explicitly, as in
 '{age?< 50}' - which means 'where age less-than 50'. The comparison operators supported by a query pattern are:
 
-=         - equals
 !=        - not-equals
 <         - less-than
 <=        - less-than or equals
@@ -95,7 +94,7 @@ Another example of the 'if' pattern:
 
 workflow validateLicense {
     {checkLicenseNumber {number validateLicense.number}} @as response;
-    if (response = "ok") {
+    if (response == "ok") {
         {license {number? validateLicense.number, status "active"}}
     } else {
         {license {number? validateLicense.number, status "canceled"}}
@@ -313,6 +312,47 @@ If you detect that you have reached the end of the chart, return 'DONE'. Otherwi
 any additional description, direction or comments.
 `;
 
+export const DecisionAgentInstructions = `Analyse a decision table with multiple cases along with the context to return one or more values.
+A decision table will be a sequence of case-conditions as in,
+
+case (condition1) {
+  value1
+}
+
+case (condition2) {
+  value2
+}
+
+The context will be some additional instructions and JSON-like data based on which you can evaluate the conditions and decide which values to return.
+Let's consider an example:
+
+
+analyseSalesReport --> {"Acme/salesReport": {"employeeId": 101, "employeeGrade": "A", "totalSalesAmount": 14000}}
+
+case (totalSalesAmount > 10000) {
+  giveIncrementToEmployee
+}
+
+case (totalSalesAmount > 15000) {
+  promoteEmployee
+}
+
+case (totalSalesAmount < 10000 and employeeGrade == "A") {
+  demoteEmployee
+}
+
+
+Given the above context and cases, you must return giveIncrementToEmployee - because the data in the context satisfies only the first case.
+If the context is,
+
+analyseSalesReport --> {"Acme/salesReport": {"employeeId": 101, "employeeGrade": "A", "totalSalesAmount": 16000}}
+
+you must return giveIncrementToEmployee,promoteEmployee because the data satisfies the first two cases. You must return only the value of the 
+case or cases you selected and no additional text or comments. If you decide to select more than one case, return the values separated by commas.
+Also select the case that is the best match for the given context, no need to look for a perfect match for all values specified in the context.
+Now apply the same analysis to the following context and cases provided by the user.
+`;
+
 export type AgentCondition = {
   cond: string;
   then: string;
@@ -339,6 +379,10 @@ export function getAgentDirectivesJson(agentFqName: string): string | undefined
   return undefined;
 }
 
+export function removeAgentDirectives(agentFqName: string) {
+  AgentDirectives.delete(agentFqName);
+}
+
 export type AgentScenario = {
   user: string;
   ai: string;
@@ -354,6 +398,10 @@ export function getAgentScenarios(agentFqName: string): AgentScenario[] | undefi
   return AgentScenarios.get(agentFqName);
 }
 
+export function removeAgentScenarios(agentFqName: string) {
+  AgentScenarios.delete(agentFqName);
+}
+
 export type AgentGlossaryEntry = {
   name: string;
   meaning: string;
@@ -370,6 +418,10 @@ export function getAgentGlossary(agentFqName: string): AgentGlossaryEntry[] | un
   return AgentGlossary.get(agentFqName);
 }
 
+export function removeAgentGlossary(agentFqName: string) {
+  AgentGlossary.delete(agentFqName);
+}
+
 const AgentResponseSchema = new Map<string, string>();
 
 export function registerAgentResponseSchema(agentFqName: string, responseSchema: string) {
@@ -380,6 +432,10 @@ export function getAgentResponseSchema(agentFqName: string): string | undefined
   return AgentResponseSchema.get(agentFqName);
 }
 
+export function removeAgentResponseSchema(agentFqName: string) {
+  AgentResponseSchema.delete(agentFqName);
+}
+
 const AgentScratchNames = new Map<string, Set<string>>();
 
 export function registerAgentScratchNames(agentFqName: string, scratch: string[]) {
@@ -389,3 +445,7 @@ export function registerAgentScratchNames(agentFqName: string, scratch: string[]
 export function getAgentScratchNames(agentFqName: string): Set<string> | undefined {
   return AgentScratchNames.get(agentFqName);
 }
+
+export function removeAgentScratchNames(agentFqName: string) {
+  AgentScratchNames.delete(agentFqName);
+}

package/src/runtime/exec-graph.ts

@@ -39,7 +39,7 @@ import {
   RecordType,
 } from './module.js';
 import { isOpenApiEventInstance, isOpenApiModule } from './openapi.js';
-import { escapeQueryName, makeFqName, splitFqName } from './util.js';
+import { escapeQueryName, makeFqName, nameToPath } from './util.js';
 
 const GraphCache = new Map<string, ExecGraph>();
 
@@ -47,7 +47,7 @@ export async function generateExecutionGraph(eventName: string): Promise<ExecGra
   const cg = GraphCache.get(eventName);
   if (cg) return cg;
   const wf = getWorkflowForEvent(eventName);
-  const parts = splitFqName(eventName);
+  const parts = nameToPath(eventName);
   const moduleName = parts.hasModule() ? parts.getModuleName() : undefined;
   if (!isEmptyWorkflow(wf)) {
     const g = await graphFromStatements(wf.statements, moduleName);
@@ -69,7 +69,7 @@ class GraphGenerator extends PatternHandler {
   }
 
   override async handleCrudMap(crudMap: CrudMap, env: Environment) {
-    const parts = splitFqName(crudMap.name);
+    const parts = nameToPath(crudMap.name);
     const moduleName = parts.hasModule() ? parts.getModuleName() : env.getActiveModuleName();
     const crudName = makeFqName(moduleName, parts.getEntryName());
     if (crudName == DocEventName) {
@@ -381,14 +381,21 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
     env = new Environment(`${fqn}-env`);
     isLocalEnv = true;
   }
-  const g = await generateExecutionGraph(fqn);
-  if (!g) {
-    throw new Error(`Failed to generate graph for event ${fqn}`);
+  let g: ExecGraph | undefined;
+  if (!isAgentEventInstance(eventInstance)) {
+    g = await generateExecutionGraph(fqn);
+    if (!g) {
+      throw new Error(`Failed to generate graph for event ${fqn}`);
+    }
   }
   const oldModuleName = env.switchActiveModuleName(eventInstance.moduleName);
   env.bind(eventInstance.name, eventInstance);
   try {
-    await executeGraph(g, env);
+    if (g) {
+      await executeGraph(g, env);
+    } else {
+      await handleAgentInvocation(eventInstance, env);
+    }
     if (isLocalEnv) {
       await env.commitAllTransactions();
     }

package/src/runtime/interpreter.ts

@@ -65,7 +65,7 @@ import {
   Path,
   QuerySuffix,
   restoreSpecialChars,
-  splitFqName,
+  nameToPath,
   splitRefs,
 } from './util.js';
 import { getResolver, getResolverNameForPath } from './resolvers/registry.js';
@@ -276,7 +276,7 @@ export class Environment extends Instance {
       this.scratchPad = {};
     }
     if (isFqName(k)) {
-      const parts = splitFqName(k);
+      const parts = nameToPath(k);
       this.scratchPad[parts.getEntryName()] = data;
     }
     this.scratchPad[k] = data;
@@ -1064,7 +1064,7 @@ async function evaluateFullTextSearch(fts: FullTextSearch, env: Environment): Pr
       throw new Error(`Fully qualified name required for full-text-search in ${n}`);
     }
   }
-  const path = splitFqName(n);
+  const path = nameToPath(n);
   const entryName = path.getEntryName();
   const moduleName = path.getModuleName();
   const resolver = await getResolverForPath(entryName, moduleName, env);
@@ -1171,7 +1171,7 @@ async function patternToInstance(
   }
   let moduleName = env.getActiveModuleName();
   if (isFqName(entryName)) {
-    const p: Path = splitFqName(entryName);
+    const p: Path = nameToPath(entryName);
     if (p.hasModule()) moduleName = p.getModuleName();
     if (p.hasEntry()) entryName = p.getEntryName();
   }
@@ -1184,7 +1184,7 @@ async function instanceFromSource(crud: CrudMap, env: Environment): Promise<Inst
     const attrsSrc = env.getLastResult();
     if (attrsSrc && attrsSrc instanceof Object) {
       const attrs: InstanceAttributes = new Map(Object.entries(attrsSrc));
-      const nparts = splitFqName(crud.name);
+      const nparts = nameToPath(crud.name);
       const n = nparts.getEntryName();
       const m = nparts.hasModule() ? nparts.getModuleName() : env.getActiveModuleName();
       return makeInstance(m, n, attrs);
@@ -1462,7 +1462,7 @@ function triggerTimer(timerInst: Instance): Instance {
       break;
     }
   }
-  const eventName = splitFqName(timerInst.lookup('trigger'));
+  const eventName = nameToPath(timerInst.lookup('trigger'));
   const m = eventName.hasModule() ? eventName.getModuleName() : timerInst.moduleName;
   const n = eventName.getEntryName();
   const inst = makeInstance(m, n, newInstanceAttributes());
@@ -1524,7 +1524,31 @@ async function evaluateJoinQuery(
   }
   const resolver = await getResolverForPath(inst.name, moduleName, env);
   const result: Result = await resolver.queryByJoin(inst, joinsSpec, normIntoSpec, distinct);
-  env.setLastResult(result);
+
+  const transformedResult = transformDateFieldsInJoinResult(result);
+
+  env.setLastResult(transformedResult);
+}
+
+function transformDateFieldsInJoinResult(result: any): any {
+  if (!result || !Array.isArray(result)) {
+    return result;
+  }
+  return result.map((row: any) => {
+    if (typeof row !== 'object' || row === null) {
+      return row;
+    }
+
+    for (const [key, value] of Object.entries(row)) {
+      if (value && value instanceof Date) {
+        if (value instanceof Date) {
+          row[key] = value.toLocaleDateString('en-CA');
+        }
+      }
+    }
+
+    return row;
+  });
 }
 
 async function walkJoinQueryPattern(
@@ -1743,12 +1767,14 @@ async function iterateOnFlow(
     }
     executedSteps.add(step);
     ++stepc;
-    const agent = AgentInstance.FromFlowStep(step, rootAgent);
+    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}`
     );
-    env.setFlowContext(initContext);
+    const isfxc = agent.isFlowExecutor();
+    if (isfxc || agent.isDecisionExecutor()) env.setFlowContext(context);
+    else env.setFlowContext(initContext);
     await agentInvoke(agent, '', env);
     if (env.isSuspended()) {
       console.debug(`${iterId} suspending iteration on step ${step}`);
@@ -1762,9 +1788,13 @@ async function iterateOnFlow(
       `\n----> Completed execution of step ${step}, iteration id ${iterId} with result:\n${rs}`
     );
     context = `${context}\n${step} --> ${rs}\n`;
-    env.setFlowContext(context);
-    await agentInvoke(rootAgent, `${s}\n${context}`, env);
-    step = env.getLastResult().trim();
+    if (isfxc) {
+      step = rs.trim();
+    } else {
+      env.setFlowContext(context);
+      await agentInvoke(rootAgent, `${s}\n${context}`, env);
+      step = env.getLastResult().trim();
+    }
   }
   console.debug(`No more flow steps, completed iteration ${iterId} on flow:\n${flow}`);
 }
@@ -1912,7 +1942,7 @@ export async function evaluateExpression(expr: Expr, env: Environment): Promise<
         result = v1 / v2;
         break;
       // comparison operators
-      case '=':
+      case '==':
         result = v1 == v2;
         break;
       case '<':
@@ -2060,7 +2090,7 @@ async function runPrePostEvents(
     ? inst.record.getPreTriggerInfo(crudType)
     : inst.record.getPostTriggerInfo(crudType);
   if (trigInfo) {
-    const p = splitFqName(trigInfo.eventName);
+    const p = nameToPath(trigInfo.eventName);
     const moduleName = p.hasModule() ? p.getModuleName() : inst.record.moduleName;
     const eventInst: Instance = makeInstance(
       moduleName,
@@ -2081,20 +2111,22 @@ async function runPrePostEvents(
       }
     };
     if (trigInfo.async) {
-      const newEnv = new Environment('async.prepost.env');
-      evaluate(eventInst, callback, bindAliasesForPrePost(newEnv, inst)).catch(catchHandler);
+      evaluate(eventInst, callback, bindAliasesForPrePost(env, inst, prefix)).catch(catchHandler);
     } else {
-      env.bind('this', inst);
-      await evaluate(eventInst, callback, bindAliasesForPrePost(env, inst)).catch(catchHandler);
+      await evaluate(eventInst, callback, bindAliasesForPrePost(env, inst, prefix)).catch(
+        catchHandler
+      );
     }
   }
 }
 
-function bindAliasesForPrePost(env: Environment, inst: Instance): Environment {
+function bindAliasesForPrePost(env: Environment, inst: Instance, prefix: string): Environment {
+  const newEnv = new Environment(`${prefix}.env`, env);
   const fullAlias = inst.getFqName();
-  env.bind('this', inst);
-  env.bind(fullAlias, inst);
-  return env;
+  newEnv.bind('this', inst);
+  newEnv.bind(fullAlias, inst);
+  newEnv.bind(inst.name, inst);
+  return newEnv;
 }
 
 async function runPreCreateEvents(inst: Instance, env: Environment) {

package/src/runtime/loader.ts

@@ -30,6 +30,9 @@ import {
   FlowDefinition,
   isFlowDefinition,
   Literal,
+  isDecisionDefinition,
+  DecisionDefinition,
+  CaseEntry,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -65,7 +68,13 @@ import { URI } from 'vscode-uri';
 import { AstNode, LangiumCoreServices, LangiumDocument } from 'langium';
 import { isNodeEnv, path } from '../utils/runtime.js';
 import { CoreModules, registerCoreModules } from './modules/core.js';
-import { maybeGetValidationErrors, parse, parseModule, parseWorkflow } from '../language/parser.js';
+import {
+  maybeGetValidationErrors,
+  maybeRaiseParserErrors,
+  parse,
+  parseModule,
+  parseWorkflow,
+} from '../language/parser.js';
 import { logger } from './logger.js';
 import { Environment, evaluateStatements, GlobalEnvironment } from './interpreter.js';
 import { createPermission, createRole } from './modules/auth.js';
@@ -621,7 +630,7 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
     } else if (apdef.name == 'glossary') {
       glossary = processAgentGlossary(name, apdef.value);
     } else if (apdef.name == 'responseSchema') {
-      const s = apdef.value.id || apdef.value.str || apdef.value.id;
+      const s = apdef.value.id || apdef.value.ref || apdef.value.str;
       if (s) {
         if (isFqName(s)) {
           responseSchema = s;
@@ -755,6 +764,16 @@ function addFlowDefinition(def: FlowDefinition, moduleName: string) {
   }
 }
 
+function addDecisionDefinition(def: DecisionDefinition, moduleName: string) {
+  if (def.body) {
+    const m = fetchModule(moduleName);
+    const cases = def.body.cases.map((ce: CaseEntry) => {
+      return ce.$cstNode?.text;
+    });
+    m.addDecision(def.name, cases as string[]);
+  }
+}
+
 function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
   const resolverName = `${moduleName}/${def.name}`;
   const paths = def.paths;
@@ -814,6 +833,7 @@ export async function addFromDef(def: Definition, moduleName: string) {
   else if (isStandaloneStatement(def)) addStandaloneStatement(def.stmt, moduleName);
   else if (isResolverDefinition(def)) addResolverDefinition(def, moduleName);
   else if (isFlowDefinition(def)) addFlowDefinition(def, moduleName);
+  else if (isDecisionDefinition(def)) addDecisionDefinition(def, moduleName);
 }
 
 export async function parseAndIntern(code: string, moduleName?: string) {
@@ -821,12 +841,7 @@ export async function parseAndIntern(code: string, moduleName?: string) {
     throw new Error(`Module not found - ${moduleName}`);
   }
   const r = await parse(moduleName ? `module ${moduleName} ${code}` : code);
-  if (r.parseResult.lexerErrors.length > 0) {
-    throw new Error(`Lexer errors: ${r.parseResult.lexerErrors.join('\n')}`);
-  }
-  if (r.parseResult.parserErrors.length > 0) {
-    throw new Error(`Parser errors: ${r.parseResult.parserErrors.join('\n')}`);
-  }
+  maybeRaiseParserErrors(r);
   await internModule(r.parseResult.value);
 }