agentlang 0.3.7 → 0.3.8

package/src/language/parser.ts

@@ -381,7 +381,7 @@ function introspectForEach(forEach: ForEach): ForEachPattern {
   return fp;
 }
 
-function introspectIf(ifpat: If): IfPattern {
+export function introspectIf(ifpat: If): IfPattern {
   const ifp: IfPattern = new IfPattern(introspectExpression(ifpat.cond));
   ifpat.statements.forEach((stmt: Statement) => {
     ifp.addPattern(introspectStatement(stmt));

package/src/language/syntax.ts

@@ -670,6 +670,27 @@ export function isIfPattern(p: BasePattern): boolean {
   return p instanceof IfPattern;
 }
 
+export class CasePattern extends BasePattern {
+  condition: BasePattern;
+  body: BasePattern;
+
+  constructor(condition: BasePattern, body: BasePattern) {
+    super();
+    this.condition = condition;
+    this.body = body;
+  }
+
+  override toString(): string {
+    return `case (${this.condition.toString()}) {
+    ${this.body.toString()}
+  }`;
+  }
+}
+
+export function isCasePattern(p: BasePattern): boolean {
+  return p instanceof CasePattern;
+}
+
 export function newCreatePattern(recName: string): CrudPattern {
   const cp: CrudPattern = new CrudPattern(recName);
   cp.isCreate = true;

package/src/runtime/agents/common.ts

@@ -1,3 +1,6 @@
+import { IfPattern } from '../../language/syntax.js';
+import { trimQuotes } from '../util.js';
+
 export const PlannerInstructions = `Agentlang is a very-high-level declarative language that makes it easy to define business applications as 'models'.
 The model of a business application consists of entity definitions and workflows defined in "modules". 
 A module is be encoded in a syntax inspired by JavaScript and JSON. Example of a simple module follows:
@@ -357,16 +360,22 @@ export type AgentCondition = {
   if: string;
   then: string;
   internal: boolean;
+  ifPattern: IfPattern | undefined;
 };
 
 const AgentDirectives = new Map<string, AgentCondition[]>();
 
 export function newAgentDirective(
   cond: string,
-  then: string,
-  internal: boolean = false
+  then: string = '',
+  internal: boolean = false,
+  ifPattern: IfPattern | undefined = undefined
 ): AgentCondition {
-  return { if: cond, then, internal };
+  return { if: cond, then, internal, ifPattern };
+}
+
+export function newAgentDirectiveFromIf(ifPattern: IfPattern): AgentCondition {
+  return newAgentDirective(ifPattern.toString(), '', false, ifPattern);
 }
 
 export function registerAgentDirectives(agentFqName: string, conds: AgentCondition[]) {
@@ -385,9 +394,13 @@ export function getAgentDirectivesInternal(agentFqName: string): AgentCondition[
 
 export function getAgentDirectivesJson(agentFqName: string): string | undefined {
   const conds = getAgentDirectivesInternal(agentFqName);
-  if (conds) {
+  if (conds && conds.length > 0) {
     const fmted = conds.map((c: AgentCondition) => {
-      return { if: c.if, then: c.then };
+      if (c.ifPattern) {
+        return c.ifPattern.toString();
+      } else {
+        return { if: c.if, then: c.then };
+      }
     });
     return JSON.stringify(fmted);
   }
@@ -408,14 +421,22 @@ export type AgentScenario = {
   user: string;
   ai: string;
   internal: boolean;
+  ifPattern: IfPattern | undefined;
 };
 
 export function newAgentScenario(
   user: string,
   ai: string,
-  internal: boolean = false
+  internal: boolean = false,
+  ifPattern: IfPattern | undefined = undefined
 ): AgentScenario {
-  return { user, ai, internal };
+  return { user, ai, internal, ifPattern };
+}
+
+export function newAgentScenarioFromIf(ifPattern: IfPattern): AgentScenario {
+  const user = trimQuotes(ifPattern.condition.toString());
+  const ai = trimQuotes(ifPattern.body[0].toString());
+  return newAgentScenario(user, ai, false, ifPattern);
 }
 
 const AgentScenarios = new Map<string, AgentScenario[]>();
@@ -430,7 +451,7 @@ export function getAgentScenarios(agentFqName: string): AgentScenario[] | undefi
 
 export function getAgentScenariosJson(agentFqName: string): string | undefined {
   const scns = getAgentScenariosInternal(agentFqName);
-  if (scns) {
+  if (scns && scns.length > 0) {
     const fmtd = scns.map((scn: AgentScenario) => {
       return {
         user: scn.user,
@@ -492,7 +513,7 @@ export function getAgentGlossaryInternal(agentFqName: string): AgentGlossaryEntr
 
 export function getAgentGlossaryJson(agentFqName: string): string | undefined {
   const gls = getAgentGlossaryInternal(agentFqName);
-  if (gls) {
+  if (gls && gls.length > 0) {
     const fmtd = gls.map((ge: AgentGlossaryEntry) => {
       return {
         name: ge.name,

package/src/runtime/loader.ts

@@ -42,6 +42,8 @@ import {
   isPublicWorkflowDefinition,
   isPublicAgentDefinition,
   isPublicEventDefinition,
+  AgentXtraAttribute,
+  If,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -80,6 +82,7 @@ import { AstNode, LangiumCoreServices, LangiumDocument } from 'langium';
 import { isNodeEnv, path } from '../utils/runtime.js';
 import { CoreModules, registerCoreModules } from './modules/core.js';
 import {
+  introspectIf,
   maybeGetValidationErrors,
   maybeRaiseParserErrors,
   parse,
@@ -528,8 +531,7 @@ function processAgentDirectives(agentName: string, value: Literal): AgentConditi
           }
         });
         if (cond && then) {
-          const internal = true;
-          conds?.push({ if: cond, then, internal });
+          conds?.push({ if: cond, then, internal: true, ifPattern: undefined });
         } else {
           throw new Error(`Invalid condition spec in agent ${agentName}`);
         }
@@ -560,7 +562,7 @@ function processAgentScenarios(agentName: string, value: Literal): AgentScenario
         });
         if (user && ai) {
           const internal = true;
-          scenarios.push({ user, ai, internal });
+          scenarios.push({ user, ai, internal, ifPattern: undefined });
         } else {
           throw new Error(`Invalid glossary spec in agent ${agentName}`);
         }
@@ -812,17 +814,47 @@ function addDecisionDefinition(def: DecisionDefinition, moduleName: string) {
   }
 }
 
+function agentXtraAttributesAsMap(xtras: AgentXtraAttribute[] | undefined): Map<string, string> {
+  const result = new Map<string, string>();
+  xtras?.forEach((v: AgentXtraAttribute) => {
+    result.set(v.name, v.value);
+  });
+  return result;
+}
+
+function scenarioConditionAsMap(cond: If | undefined) {
+  const result = new Map<string, any>();
+  if (cond) {
+    if (isLiteral(cond.cond)) {
+      const s = cond.cond.str;
+      if (s === undefined) {
+        throw new Error(`scenario condition must be a string - ${cond.cond.$cstNode?.text}`);
+      }
+      const stmt = cond.statements[0];
+      const v = stmt.pattern.$cstNode?.text;
+      if (v === undefined) {
+        throw new Error(
+          `scenario consequent must be a string or name - ${cond.cond.$cstNode?.text}`
+        );
+      }
+      result.set('user', s).set('ai', v).set('if', introspectIf(cond));
+    }
+  }
+  return result;
+}
+
 function addScenarioDefintion(def: ScenarioDefinition, moduleName: string) {
-  if (def.body) {
+  if (def.body || def.scn) {
     let n = rootRef(def.name);
     if (!isFqName(n)) {
       n = makeFqName(moduleName, n);
     }
-    const m = asStringLiteralsMap(def.body);
+    const m = def.body ? asStringLiteralsMap(def.body) : scenarioConditionAsMap(def.scn);
     const user = m.get('user');
     const ai = m.get('ai');
+    const ifPattern = m.get('if');
     if (user && ai) {
-      const scn = { user: user, ai: ai, internal: false };
+      const scn = { user: user, ai: ai, internal: false, ifPattern };
       addAgentScenario(n, scn);
       fetchModule(moduleName).addScenario(def.name, scn);
     } else throw new Error(`scenario ${def.name} requires both user and ai entries`);
@@ -830,30 +862,44 @@ function addScenarioDefintion(def: ScenarioDefinition, moduleName: string) {
 }
 
 function addDirectiveDefintion(def: DirectiveDefinition, moduleName: string) {
-  if (def.body) {
+  if (def.body || def.dir) {
     let n = rootRef(def.name);
     if (!isFqName(n)) {
       n = makeFqName(moduleName, n);
     }
-    const m = asStringLiteralsMap(def.body);
-    const cond = m.get('if');
-    const then = m.get('then');
-    if (cond && then) {
-      const dir = { if: cond, then: then, internal: false };
-      addAgentDirective(n, dir);
-      fetchModule(moduleName).addDirective(def.name, dir);
-    } else throw new Error(`directive ${def.name} requires both if and then entries`);
+    if (def.body) {
+      const m = asStringLiteralsMap(def.body);
+      const cond = m.get('if');
+      const then = m.get('then');
+      if (cond && then) {
+        const dir = { if: cond, then: then, internal: false, ifPattern: undefined };
+        addAgentDirective(n, dir);
+        fetchModule(moduleName).addDirective(def.name, dir);
+      } else throw new Error(`directive ${def.name} requires both if and then entries`);
+    } else if (def.dir) {
+      const cond = def.dir.$cstNode?.text;
+      if (cond) {
+        const ifPattern = introspectIf(def.dir);
+        const dir = { if: cond, then: '', internal: false, ifPattern };
+        addAgentDirective(n, dir);
+        fetchModule(moduleName).addDirective(def.name, dir);
+      } else {
+        throw new Error(`directive ${def.name} requires a valid if expression`);
+      }
+    }
   }
 }
 
 function addGlossaryEntryDefintion(def: GlossaryEntryDefinition, moduleName: string) {
-  if (def.body) {
+  if (def.body || def.glos) {
     let n = rootRef(def.name);
     if (!isFqName(n)) {
       n = makeFqName(moduleName, n);
     }
-    const m = asStringLiteralsMap(def.body);
-    const name = m.get('name');
+    const m = def.body
+      ? asStringLiteralsMap(def.body)
+      : agentXtraAttributesAsMap(def.glos?.attributes);
+    const name = m.get('name') || m.get('word');
     const meaning = m.get('meaning');
     const syn = m.get('synonyms');
     if (name && meaning) {

package/src/runtime/module.ts

@@ -1602,11 +1602,13 @@ export class Scenario extends ModuleEntry {
   }
 
   override toString(): string {
-    const obj: any = {
-      user: this.def.user,
-      ai: this.def.ai,
-    };
-    return `scenario ${this.name} ${JSON.stringify(obj)}`;
+    if (this.def.ifPattern) {
+      return `scenario ${this.name} {\n    ${this.def.ifPattern.toString()}\n}\n`;
+    }
+    const s = `if ("${this.def.user}") {
+      ${this.def.ai}
+    }`;
+    return `scenario ${this.name} {\n    ${s}\n}\n`;
   }
 }
 
@@ -1619,11 +1621,17 @@ export class Directive extends ModuleEntry {
   }
 
   override toString(): string {
-    const obj: any = {
-      if: this.def.if,
-      then: this.def.then,
-    };
-    return `directive ${this.name} ${JSON.stringify(obj)}`;
+    if (this.def.ifPattern) {
+      return `directive ${this.name} {
+        ${this.def.if}
+      }`;
+    } else {
+      const obj: any = {
+        if: this.def.if,
+        then: this.def.then,
+      };
+      return `directive ${this.name} ${JSON.stringify(obj)}`;
+    }
   }
 }
 
@@ -1636,12 +1644,13 @@ export class GlossaryEntry extends ModuleEntry {
   }
 
   override toString(): string {
-    const obj: any = {
-      name: this.def.name,
-      meaning: this.def.meaning,
-      synonyms: this.def.synonyms,
-    };
-    return `glossaryEntry ${this.name} ${JSON.stringify(obj)}`;
+    const ss = new Array<string>();
+    ss.push(`    name "${this.def.name}"`);
+    ss.push(`    meaning "${this.def.meaning}"`);
+    if (this.def.synonyms) {
+      ss.push(`    synonyms "${this.def.synonyms}"`);
+    }
+    return `glossaryEntry ${this.name} \n{\n${ss.join(',\n')}\n}`;
   }
 }
 

package/src/runtime/modules/ai.ts

@@ -229,7 +229,11 @@ export class AgentInstance {
         '\nUse the following guidelines to take more accurate decisions in relevant scenarios.\n'
       );
       conds.forEach((ac: AgentCondition) => {
-        ss.push(`if ${ac.if}, then ${ac.then}`);
+        if (ac.ifPattern) {
+          ss.push(ac.if);
+        } else {
+          ss.push(`if ${ac.if}, then ${ac.then}`);
+        }
       });
       return `${ss.join('\n')}\n`;
     }