agentlang 0.0.67 → 0.1.0

package/src/runtime/interpreter.ts

@@ -20,6 +20,7 @@ import {
   Pattern,
   Purge,
   RelationshipPattern,
+  Return,
   RuntimeHint,
   SelectIntoEntry,
   SelectIntoSpec,
@@ -55,7 +56,6 @@ import {
   DefaultModuleName,
   escapeFqName,
   escapeQueryName,
-  escapeSpecialChars,
   fqNameFromPath,
   isFqName,
   isPath,
@@ -90,7 +90,7 @@ import {
 import { invokeModuleFn } from './jsmodules.js';
 import { invokeOpenApiEvent, isOpenApiEventInstance } from './openapi.js';
 import { fetchDoc } from './docs.js';
-import { FlowSpec, FlowStep, getAgentFlow } from './agents/common.js';
+import { FlowSpec, FlowStep, getAgentFlow } from './agents/flows.js';
 
 export type Result = any;
 
@@ -136,7 +136,12 @@ export class Environment extends Instance {
   private inDeleteMode: boolean = false;
   private inKernelMode: boolean = false;
   private suspensionId: string | undefined;
+  private preGeneratedSuspensionId: string;
   private activeCatchHandlers: Array<CatchHandlers>;
+  private eventExecutor: Function | undefined = undefined;
+  private statementsExecutor: Function | undefined = undefined;
+
+  private activeUserData: any = undefined;
 
   constructor(name?: string, parent?: Environment) {
     super(
@@ -158,6 +163,7 @@ export class Environment extends Instance {
       this.inKernelMode = parent.inKernelMode;
       this.activeCatchHandlers = parent.activeCatchHandlers;
       this.suspensionId = parent.suspensionId;
+      this.eventExecutor = parent.eventExecutor;
     } else {
       this.activeModule = DefaultModuleName;
       this.activeResolvers = new Map<string, Resolver>();
@@ -165,6 +171,7 @@ export class Environment extends Instance {
       this.activeCatchHandlers = new Array<CatchHandlers>();
       this.attributes.set('process', process);
     }
+    this.preGeneratedSuspensionId = crypto.randomUUID();
   }
 
   static from(
@@ -177,6 +184,7 @@ export class Environment extends Instance {
       env.activeResolvers = new Map<string, Resolver>();
       env.activeTransactions = new Map<string, string>();
       env.activeCatchHandlers = new Array<CatchHandlers>();
+      env.preGeneratedSuspensionId = parent.preGeneratedSuspensionId;
     }
     return env;
   }
@@ -306,7 +314,7 @@ export class Environment extends Instance {
 
   suspend(): string {
     if (this.suspensionId == undefined) {
-      const id = crypto.randomUUID();
+      const id = this.preGeneratedSuspensionId;
       this.propagateSuspension(id);
       return id;
     } else {
@@ -314,6 +322,16 @@ export class Environment extends Instance {
     }
   }
 
+  releaseSuspension(): Environment {
+    this.suspensionId = undefined;
+    this.preGeneratedSuspensionId = crypto.randomUUID();
+    return this;
+  }
+
+  fetchSuspensionId(): string {
+    return this.preGeneratedSuspensionId;
+  }
+
   markForReturn(): Environment {
     if (this.parent) {
       this.parent.markForReturn();
@@ -326,6 +344,14 @@ export class Environment extends Instance {
     return this.returnFlag;
   }
 
+  propagateLastResult(): Environment {
+    if (this.parent) {
+      this.parent.lastResult = this.lastResult;
+      this.parent.propagateLastResult();
+    }
+    return this;
+  }
+
   resetReturnFlag(): Environment {
     if (this.returnFlag) {
       this.returnFlag = false;
@@ -570,11 +596,53 @@ export class Environment extends Instance {
     }
     return r;
   }
+
+  setEventExecutor(exec: Function): Environment {
+    this.eventExecutor = exec;
+    return this;
+  }
+
+  getEventExecutor(): Function | undefined {
+    return this.eventExecutor;
+  }
+
+  unsetEventExecutor(): Environment {
+    this.eventExecutor = undefined;
+    return this;
+  }
+
+  setStatementsExecutor(f: Function): Environment {
+    this.statementsExecutor = f;
+    return this;
+  }
+
+  getStatementsExecutor(): Function | undefined {
+    return this.statementsExecutor;
+  }
+
+  async callWithStatementsExecutor(exec: Function, f: Function): Promise<any> {
+    const oldExec = this.statementsExecutor;
+    this.statementsExecutor = exec;
+    try {
+      return await f();
+    } finally {
+      this.statementsExecutor = oldExec;
+    }
+  }
+
+  setActiveUserData(data: any): Environment {
+    this.activeUserData = data;
+    return this;
+  }
+
+  getActiveUserData(): any {
+    return this.activeUserData;
+  }
 }
 
 export const GlobalEnvironment = new Environment();
 
-export async function evaluate(
+export let evaluate = async function (
   eventInstance: Instance,
   continuation?: Function,
   activeEnv?: Environment,
@@ -626,6 +694,12 @@ export async function evaluate(
       await env.commitAllTransactions();
     }
   }
+};
+
+export function setEvaluateFn(f: any): Function {
+  const oldf = evaluate;
+  evaluate = f;
+  return oldf;
 }
 
 export async function evaluateAsEvent(
@@ -661,27 +735,6 @@ export function makeEventEvaluator(moduleName: string): Function {
   };
 }
 
-function statemtentString(stmt: Statement): string {
-  if (stmt.$cstNode) {
-    return stmt.$cstNode.text;
-  } else {
-    throw new Error(`Failed to fetch text for statement - ${stmt}`);
-  }
-}
-
-async function saveSuspension(cont: Statement[], env: Environment) {
-  if (cont.length > 0) {
-    const suspId = await createSuspension(
-      env.getSuspensionId(),
-      cont.map((stmt: Statement) => {
-        return statemtentString(stmt);
-      }),
-      env
-    );
-    env.setLastResult({ suspension: suspId || 'null' });
-  }
-}
-
 export async function evaluateStatements(
   stmts: Statement[],
   env: Environment,
@@ -710,7 +763,17 @@ async function evaluateAsyncPattern(
     await evaluatePattern(pat, env);
     maybeBindStatementResultToAlias(hints, env);
     if (env.isSuspended()) {
-      await saveSuspension(thenStmts, env);
+      await createSuspension(
+        env.fetchSuspensionId(),
+        thenStmts.map((s: Statement) => {
+          if (s.$cstNode) {
+            return s.$cstNode.text;
+          } else {
+            throw new Error('failed to extract code for suspension statement');
+          }
+        }),
+        env
+      );
     } else {
       await evaluateStatements(thenStmts, env);
     }
@@ -722,7 +785,7 @@ async function evaluateAsyncPattern(
   }
 }
 
-async function evaluateStatement(stmt: Statement, env: Environment): Promise<void> {
+export async function evaluateStatement(stmt: Statement, env: Environment): Promise<void> {
   const hints = stmt.hints;
   const hasHints = hints && hints.length > 0;
   const thenStmts: Statement[] | undefined = hasHints ? maybeFindThenStatements(hints) : undefined;
@@ -735,9 +798,13 @@ async function evaluateStatement(stmt: Statement, env: Environment): Promise<voi
       hints,
       Environment.from(env, env.name + 'async', true)
     );
+    env.setLastResult(env.fetchSuspensionId());
     if (isReturn(stmt.pattern)) {
       env.markForReturn();
     }
+    if (hasHints) {
+      maybeBindStatementResultToAlias(hints, env);
+    }
     return;
   }
   let handlersPushed = false;
@@ -768,7 +835,9 @@ async function maybeHandleNotFound(handlers: CatchHandlers | undefined, env: Env
   ) {
     const onNotFound = handlers ? handlers.get('not_found') : undefined;
     if (onNotFound) {
-      await evaluateStatement(onNotFound, env);
+      const newEnv = new Environment('not-found-env', env).unsetEventExecutor();
+      await evaluateStatement(onNotFound, newEnv);
+      env.setLastResult(newEnv.getLastResult());
     }
   }
 }
@@ -780,13 +849,15 @@ async function maybeHandleError(
 ) {
   const handler = handlers ? handlers.get('error') : undefined;
   if (handler) {
-    await evaluateStatement(handler, env);
+    const newEnv = new Environment('handler-env', env).unsetEventExecutor();
+    await evaluateStatement(handler, newEnv);
+    env.setLastResult(newEnv.getLastResult());
   } else {
     throw reason;
   }
 }
 
-function maybeBindStatementResultToAlias(hints: RuntimeHint[], env: Environment) {
+export function maybeBindStatementResultToAlias(hints: RuntimeHint[], env: Environment) {
   for (let i = 0; i < hints.length; ++i) {
     const rh = hints[i];
     if (rh.aliasSpec) {
@@ -842,7 +913,7 @@ function maybeFindThenStatements(hints: RuntimeHint[]): Statement[] | undefined
   return undefined;
 }
 
-export async function parseAndEvaluateStatement(
+export let parseAndEvaluateStatement = async function (
   stmtString: string,
   activeUserId?: string,
   actievEnv?: Environment
@@ -872,25 +943,71 @@ export async function parseAndEvaluateStatement(
       }
     }
   }
+};
+
+export function setParseAndEvaluateStatementFn(f: any): Function {
+  const oldf = parseAndEvaluateStatement;
+  parseAndEvaluateStatement = f;
+  return oldf;
 }
 
-async function evaluatePattern(pat: Pattern, env: Environment): Promise<void> {
+export class PatternHandler {
+  async handleExpression(expr: Expr, env: Environment) {
+    await evaluateExpression(expr, env);
+  }
+
+  async handleCrudMap(crudMap: CrudMap, env: Environment) {
+    await evaluateCrudMap(crudMap, env);
+  }
+
+  async handleForEach(forEach: ForEach, env: Environment) {
+    await evaluateForEach(forEach, env);
+  }
+
+  async handleIf(_if: If, env: Environment) {
+    await evaluateIf(_if, env);
+  }
+
+  async handleDelete(del: Delete, env: Environment) {
+    await evaluateDelete(del, env);
+  }
+
+  async handlePurge(purge: Purge, env: Environment) {
+    await evaluatePurge(purge, env);
+  }
+
+  async handleFullTextSearch(fullTextSearch: FullTextSearch, env: Environment) {
+    await evaluateFullTextSearch(fullTextSearch, env);
+  }
+
+  async handleReturn(ret: Return, env: Environment) {
+    await evaluatePattern(ret.pattern, env);
+  }
+}
+
+const DefaultPatternHandler = new PatternHandler();
+
+export async function evaluatePattern(
+  pat: Pattern,
+  env: Environment,
+  handler: PatternHandler = DefaultPatternHandler
+): Promise<void> {
   if (pat.expr) {
-    await evaluateExpression(pat.expr, env);
+    await handler.handleExpression(pat.expr, env);
   } else if (pat.crudMap) {
-    await evaluateCrudMap(pat.crudMap, env);
+    await handler.handleCrudMap(pat.crudMap, env);
   } else if (pat.forEach) {
-    await evaluateForEach(pat.forEach, env);
+    await handler.handleForEach(pat.forEach, env);
   } else if (pat.if) {
-    await evaluateIf(pat.if, env);
+    await handler.handleIf(pat.if, env);
   } else if (pat.delete) {
-    await evaluateDelete(pat.delete, env);
+    await handler.handleDelete(pat.delete, env);
   } else if (pat.purge) {
-    await evaluatePurge(pat.purge, env);
+    await handler.handlePurge(pat.purge, env);
   } else if (pat.fullTextSearch) {
-    await evaluateFullTextSearch(pat.fullTextSearch, env);
+    await handler.handleFullTextSearch(pat.fullTextSearch, env);
   } else if (pat.return) {
-    await evaluatePattern(pat.return.pat, env);
+    await handler.handleReturn(pat.return, env);
     env.markForReturn();
   }
 }
@@ -1247,7 +1364,12 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     else if (isOpenApiEventInstance(inst)) await handleOpenApiEvent(inst, env);
     else if (isDocEventInstance(inst)) await handleDocEvent(inst, env);
     else {
-      await evaluate(inst, (result: Result) => env.setLastResult(result), env);
+      const eventExec = env.getEventExecutor();
+      if (eventExec) {
+        await eventExec(inst, env);
+      } else {
+        await evaluate(inst, (result: Result) => env.setLastResult(result), env);
+      }
       env.resetReturnFlag();
     }
   } else {
@@ -1256,7 +1378,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
 }
 
 const CoreAIModuleName = makeCoreModuleName('ai');
-const DocEventName = `${CoreAIModuleName}/doc`;
+export const DocEventName = `${CoreAIModuleName}/doc`;
 
 function isDocEventInstance(inst: Instance): boolean {
   return isInstanceOfType(inst, DocEventName);
@@ -1406,6 +1528,7 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
   let result: string | undefined = env.getLastResult();
   logger.debug(`Agent ${agent.name} result: ${result}`);
   const isPlanner = agent.isPlanner();
+  const stmtsExec = env.getStatementsExecutor();
   if (result) {
     if (isPlanner) {
       let retries = 0;
@@ -1428,9 +1551,18 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
           }
           if (isWf) {
             const wf = await parseWorkflow(rs);
-            await evaluateStatements(wf.statements, env);
+            if (stmtsExec) {
+              await stmtsExec(wf.statements, env);
+            } else {
+              await evaluateStatements(wf.statements, env);
+            }
           } else {
-            env.setLastResult(await parseAndEvaluateStatement(rs, undefined, env));
+            if (stmtsExec) {
+              const stmt = await parseStatement(rs);
+              env.setLastResult(await stmtsExec([stmt], env));
+            } else {
+              env.setLastResult(await parseAndEvaluateStatement(rs, undefined, env));
+            }
           }
           break;
         } catch (err: any) {
@@ -1448,19 +1580,19 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
         }
       }
     }
-    if (agent.output) {
-      await pushToAgent(agent.output, env.getLastResult(), env);
-    }
   } else {
     throw new Error(`Agent ${agent.name} failed to generate a response`);
   }
 }
 
-async function handleAgentInvocation(agentEventInst: Instance, env: Environment): Promise<void> {
+export async function handleAgentInvocation(
+  agentEventInst: Instance,
+  env: Environment
+): Promise<void> {
   const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
   const origMsg: any = agentEventInst.lookup('message');
   const msg: string = isString(origMsg) ? origMsg : agentInputAsString(origMsg);
-  const flow = getAgentFlow(agent.name);
+  const flow = getAgentFlow(agent.name, agent.moduleName);
   if (flow) {
     await handleAgentInvocationWithFlow(agent, flow, msg, env);
   } else {
@@ -1476,6 +1608,7 @@ async function handleAgentInvocationWithFlow(
   msg: string,
   env: Environment
 ): Promise<void> {
+  rootAgent.markAsFlowExecutor();
   await iterateOnFlow(flow, rootAgent, msg, env);
 }
 
@@ -1499,9 +1632,9 @@ export async function restartFlow(
   env: Environment
 ): Promise<void> {
   const [_, agentName, step, ctx] = flowContext;
-  const flow = getAgentFlow(agentName);
+  const rootAgent: AgentInstance = await findAgentByName(agentName, env);
+  const flow = getAgentFlow(agentName, rootAgent.moduleName);
   if (flow) {
-    const rootAgent = await findAgentByName(agentName, env);
     const newCtx = `${ctx}\n${step} --> ${userData}\n`;
     await iterateOnFlow(flow, rootAgent, newCtx, env);
   }
@@ -1541,6 +1674,7 @@ async function iterateOnFlow(
     if (env.isSuspended()) {
       console.debug(`${iterId} suspending iteration on step ${step}`);
       await saveFlowSuspension(rootAgent, context, step, env);
+      env.releaseSuspension();
       return;
     }
     const r = env.getLastResult();
@@ -1570,13 +1704,7 @@ function agentInputAsString(result: any): string {
   return result;
 }
 
-async function pushToAgent(agentName: string, result: any, env: Environment) {
-  const r = escapeSpecialChars(agentInputAsString(result));
-  const pat = `{${agentName} {message "\n${r}"}}`;
-  env.setLastResult(await parseAndEvaluateStatement(pat, undefined, env));
-}
-
-async function handleOpenApiEvent(eventInst: Instance, env: Environment): Promise<void> {
+export async function handleOpenApiEvent(eventInst: Instance, env: Environment): Promise<void> {
   const r = await invokeOpenApiEvent(
     eventInst.moduleName,
     eventInst.name,
@@ -1628,11 +1756,19 @@ async function evaluateDeleteHelper(
 ): Promise<void> {
   const newEnv = Environment.from(env).setInDeleteMode(true);
   await evaluatePattern(pattern, newEnv);
-  const inst: Instance[] | Instance = newEnv.getLastResult();
+  await maybeDeleteQueriedInstances(newEnv, env, purge);
+}
+
+export async function maybeDeleteQueriedInstances(
+  queryEnv: Environment,
+  env: Environment,
+  purge: boolean = false
+): Promise<void> {
+  const inst: Instance[] | Instance = queryEnv.getLastResult();
   let resolver: Resolver = Resolver.Default;
   if (inst instanceof Array) {
     if (inst.length > 0) {
-      resolver = await getResolverForPath(inst[0].name, inst[0].moduleName, newEnv);
+      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) {
         await runPreDeleteEvents(inst[i], env);
@@ -1640,18 +1776,18 @@ async function evaluateDeleteHelper(
         await runPostDeleteEvents(inst[i], env);
         finalResult.push(r);
       }
-      newEnv.setLastResult(finalResult);
+      queryEnv.setLastResult(finalResult);
     } else {
-      newEnv.setLastResult(inst);
+      queryEnv.setLastResult(inst);
     }
   } else {
-    resolver = await getResolverForPath(inst.name, inst.moduleName, newEnv);
+    resolver = await getResolverForPath(inst.name, inst.moduleName, queryEnv);
     await runPreDeleteEvents(inst, env);
     const r: Instance | null = await resolver.deleteInstance(inst, purge);
     await runPostDeleteEvents(inst, env);
-    newEnv.setLastResult(r);
+    queryEnv.setLastResult(r);
   }
-  env.setLastResult(newEnv.getLastResult());
+  env.setLastResult(queryEnv.getLastResult());
 }
 
 async function evaluateDelete(delStmt: Delete, env: Environment): Promise<void> {
@@ -1662,7 +1798,7 @@ async function evaluatePurge(purgeStmt: Purge, env: Environment): Promise<void>
   await evaluateDeleteHelper(purgeStmt.pattern, true, env);
 }
 
-async function evaluateExpression(expr: Expr, env: Environment): Promise<void> {
+export async function evaluateExpression(expr: Expr, env: Environment): Promise<void> {
   let result: Result = EmptyResult;
   if (isBinExpr(expr)) {
     await evaluateExpression(expr.e1, env);

package/src/runtime/loader.ts

@@ -29,6 +29,7 @@ import {
   Expr,
   FlowDefinition,
   isFlowDefinition,
+  Literal,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -68,7 +69,17 @@ import { maybeGetValidationErrors, parse, parseModule, parseWorkflow } from '../
 import { logger } from './logger.js';
 import { Environment, evaluateStatements, GlobalEnvironment } from './interpreter.js';
 import { createPermission, createRole } from './modules/auth.js';
-import { AgentEntityName, CoreAIModuleName, LlmEntityName } from './modules/ai.js';
+import {
+  AgentCondition,
+  AgentEntityName,
+  AgentGlossaryEntry,
+  AgentScenario,
+  CoreAIModuleName,
+  LlmEntityName,
+  registerAgentDirectives,
+  registerAgentGlossary,
+  registerAgentScenarios,
+} from './modules/ai.js';
 import { getDefaultLLMService } from './agents/registry.js';
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
 import { registerResolver, setResolver } from './resolvers/registry.js';
@@ -77,7 +88,7 @@ import { getModuleFn, importModule } from './jsmodules.js';
 import { SetSubscription } from './defs.js';
 import { ExtendedFileSystem } from '../utils/fs/interfaces.js';
 import z from 'zod';
-import { registerAgentFlow, registerFlow } from './agents/common.js';
+import { registerAgentFlow, registerFlow } from './agents/flows.js';
 
 export async function extractDocument(
   fileName: string,
@@ -462,6 +473,99 @@ export async function runStandaloneStatements() {
   }
 }
 
+function processAgentDirectives(agentName: string, value: Literal): AgentCondition[] | undefined {
+  if (value.array) {
+    const conds = new Array<AgentCondition>();
+    value.array.vals.forEach((stmt: Statement) => {
+      const expr = stmt.pattern.expr;
+      if (expr && isLiteral(expr) && expr.map) {
+        let cond: string | undefined;
+        let then: string | undefined;
+        expr.map.entries.forEach((me: MapEntry) => {
+          const v = isLiteral(me.value) ? me.value.str : undefined;
+          if (v) {
+            if (me.key.str == 'if') {
+              cond = v;
+            } else if (me.key.str == 'then') {
+              then = v;
+            }
+          }
+        });
+        if (cond && then) {
+          conds?.push({ cond, then });
+        } else {
+          throw new Error(`Invalid condition spec in agent ${agentName}`);
+        }
+      }
+    });
+    return conds;
+  }
+  return undefined;
+}
+
+function processAgentScenarios(agentName: string, value: Literal): AgentScenario[] | undefined {
+  if (value.array) {
+    const scenarios = new Array<AgentScenario>();
+    value.array.vals.forEach((stmt: Statement) => {
+      const expr = stmt.pattern.expr;
+      if (expr && isLiteral(expr) && expr.map) {
+        let user: string | undefined;
+        let ai: string | undefined;
+        expr.map.entries.forEach((me: MapEntry) => {
+          const v = isLiteral(me.value) ? me.value.str : undefined;
+          if (v) {
+            if (me.key.str == 'user') {
+              user = v;
+            } else if (me.key.str == 'ai') {
+              ai = v;
+            }
+          }
+        });
+        if (user && ai) {
+          scenarios.push({ user, ai });
+        } else {
+          throw new Error(`Invalid glossary spec in agent ${agentName}`);
+        }
+      }
+    });
+    return scenarios;
+  }
+  return undefined;
+}
+
+function processAgentGlossary(agentName: string, value: Literal): AgentGlossaryEntry[] | undefined {
+  if (value.array) {
+    const gls = new Array<AgentGlossaryEntry>();
+    value.array.vals.forEach((stmt: Statement) => {
+      const expr = stmt.pattern.expr;
+      if (expr && isLiteral(expr) && expr.map) {
+        let name: string | undefined;
+        let meaning: string | undefined;
+        let synonyms: string | undefined;
+        expr.map.entries.forEach((me: MapEntry) => {
+          const v = isLiteral(me.value) ? me.value.str : undefined;
+          if (v) {
+            if (me.key.str == 'name') {
+              name = v;
+            } else if (me.key.str == 'meaning') {
+              meaning = v;
+            } else if (me.key.str == 'synonyms') {
+              synonyms = v;
+            }
+          }
+        });
+        if (name && meaning) {
+          gls.push({ name, meaning, synonyms });
+        } else {
+          throw new Error(`Invalid glossary spec in agent ${agentName}`);
+        }
+      }
+    });
+    return gls;
+  }
+  return undefined;
+}
+
 async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   let llmName: string | undefined = undefined;
   const name = def.name;
@@ -470,6 +574,9 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   const attrs = newInstanceAttributes();
   attrsStrs.push(`moduleName "${moduleName}"`);
   attrs.set('moduleName', moduleName);
+  let conds: AgentCondition[] | undefined = undefined;
+  let scenarios: AgentScenario[] | undefined = undefined;
+  let glossary: AgentGlossaryEntry[] | undefined = undefined;
   def.body?.attributes.forEach((apdef: GenericPropertyDef) => {
     if (apdef.name == 'flows') {
       let fnames: string | undefined = undefined;
@@ -491,6 +598,12 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
       } else {
         throw new Error(`Invalid flows list in agent ${name}`);
       }
+    } else if (apdef.name == 'directives') {
+      conds = processAgentDirectives(name, apdef.value);
+    } else if (apdef.name == 'scenarios') {
+      scenarios = processAgentScenarios(name, apdef.value);
+    } else if (apdef.name == 'glossary') {
+      glossary = processAgentGlossary(name, apdef.value);
     } else {
       let v: any = undefined;
       if (apdef.value.array) {
@@ -544,6 +657,15 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   (await parseWorkflow(`workflow A {${wf}}`)).statements.forEach((stmt: Statement) => {
     addStandaloneStatement(stmt, moduleName, false);
   });
+  if (conds) {
+    registerAgentDirectives(moduleName, name, conds);
+  }
+  if (scenarios) {
+    registerAgentScenarios(moduleName, name, scenarios);
+  }
+  if (glossary) {
+    registerAgentGlossary(moduleName, name, glossary);
+  }
   // Don't add llm to module attrs if it wasn't originally specified
   addAgent(def.name, attrs, moduleName);
 }