agentlang 0.2.6 → 0.3.1

package/src/runtime/agents/common.ts

@@ -356,6 +356,7 @@ Now apply the same analysis to the following context and cases provided by the u
 export type AgentCondition = {
   cond: string;
   then: string;
+  internal: boolean;
 };
 
 const AgentDirectives = new Map<string, AgentCondition[]>();
@@ -368,8 +369,14 @@ export function getAgentDirectives(agentFqName: string): AgentCondition[] | unde
   return AgentDirectives.get(agentFqName);
 }
 
+export function getAgentDirectivesInternal(agentFqName: string): AgentCondition[] | undefined {
+  return AgentDirectives.get(agentFqName)?.filter((ac: AgentCondition) => {
+    return ac.internal;
+  });
+}
+
 export function getAgentDirectivesJson(agentFqName: string): string | undefined {
-  const conds = AgentDirectives.get(agentFqName);
+  const conds = getAgentDirectivesInternal(agentFqName);
   if (conds) {
     const fmted = conds.map((c: AgentCondition) => {
       return { if: c.cond, then: c.then };
@@ -383,9 +390,16 @@ export function removeAgentDirectives(agentFqName: string) {
   AgentDirectives.delete(agentFqName);
 }
 
+export function addAgentDirective(agentFqName: string, newDirective: AgentCondition) {
+  const dirs = getAgentDirectives(agentFqName) || new Array<AgentCondition>();
+  dirs.push(newDirective);
+  registerAgentDirectives(agentFqName, dirs);
+}
+
 export type AgentScenario = {
   user: string;
   ai: string;
+  internal: boolean;
 };
 
 const AgentScenarios = new Map<string, AgentScenario[]>();
@@ -398,14 +412,41 @@ export function getAgentScenarios(agentFqName: string): AgentScenario[] | undefi
   return AgentScenarios.get(agentFqName);
 }
 
+export function getAgentScenariosJson(agentFqName: string): string | undefined {
+  const scns = getAgentScenariosInternal(agentFqName);
+  if (scns) {
+    const fmtd = scns.map((scn: AgentScenario) => {
+      return {
+        user: scn.user,
+        ai: scn.ai,
+      };
+    });
+    return JSON.stringify(fmtd);
+  }
+  return undefined;
+}
+
+export function getAgentScenariosInternal(agentFqName: string): AgentScenario[] | undefined {
+  return AgentScenarios.get(agentFqName)?.filter((asc: AgentScenario) => {
+    return asc.internal;
+  });
+}
+
 export function removeAgentScenarios(agentFqName: string) {
   AgentScenarios.delete(agentFqName);
 }
 
+export function addAgentScenario(agentFqName: string, newScn: AgentScenario) {
+  const scns = getAgentScenarios(agentFqName) || new Array<AgentScenario>();
+  scns.push(newScn);
+  registerAgentScenarios(agentFqName, scns);
+}
+
 export type AgentGlossaryEntry = {
   name: string;
   meaning: string;
   synonyms: string | undefined;
+  internal: boolean;
 };
 
 const AgentGlossary = new Map<string, AgentGlossaryEntry[]>();
@@ -418,10 +459,37 @@ export function getAgentGlossary(agentFqName: string): AgentGlossaryEntry[] | un
   return AgentGlossary.get(agentFqName);
 }
 
+export function getAgentGlossaryInternal(agentFqName: string): AgentGlossaryEntry[] | undefined {
+  return AgentGlossary.get(agentFqName)?.filter((age: AgentGlossaryEntry) => {
+    return age.internal;
+  });
+}
+
+export function getAgentGlossaryJson(agentFqName: string): string | undefined {
+  const gls = getAgentGlossaryInternal(agentFqName);
+  if (gls) {
+    const fmtd = gls.map((ge: AgentGlossaryEntry) => {
+      return {
+        name: ge.name,
+        meaning: ge.meaning,
+        synonyms: ge.synonyms,
+      };
+    });
+    return JSON.stringify(fmtd);
+  }
+  return undefined;
+}
+
 export function removeAgentGlossary(agentFqName: string) {
   AgentGlossary.delete(agentFqName);
 }
 
+export function addAgentGlossaryEntry(agentFqName: string, newEntry: AgentGlossaryEntry) {
+  const entries = getAgentGlossary(agentFqName) || new Array<AgentGlossaryEntry>();
+  entries.push(newEntry);
+  registerAgentGlossary(agentFqName, entries);
+}
+
 const AgentResponseSchema = new Map<string, string>();
 
 export function registerAgentResponseSchema(agentFqName: string, responseSchema: string) {

package/src/runtime/exec-graph.ts

@@ -175,12 +175,6 @@ async function graphFromStatements(
   return handler.getGraph().setActiveModuleName(activeModuleName);
 }
 
-async function eventExecutor(eventInst: Instance, env: Environment) {
-  const newEnv = new Environment(`${eventInst.name}-env`, env);
-  await executeEventHelper(eventInst, newEnv);
-  env.setLastResult(newEnv.getLastResult());
-}
-
 function makeStatementsExecutor(execGraph: ExecGraph, triggeringNode: ExecGraphNode): Function {
   return async (stmts: Statement[], env: Environment): Promise<any> => {
     const g = await graphFromStatements(stmts, env.getActiveModuleName());
@@ -195,7 +189,7 @@ function makeStatementsExecutor(execGraph: ExecGraph, triggeringNode: ExecGraphN
 
 export async function executeGraph(execGraph: ExecGraph, env: Environment): Promise<any> {
   const activeModuleName = execGraph.getActiveModuleName();
-  env.setEventExecutor(eventExecutor);
+  env.setEventExecutor(executeEventHelper);
   let oldModule: string | undefined = undefined;
   if (activeModuleName) {
     oldModule = env.switchActiveModuleName(activeModuleName);
@@ -339,7 +333,6 @@ export async function executeEvent(
   let txnRolledBack: boolean = false;
   try {
     if (isEventInstance(eventInstance)) {
-      env.setActiveEvent(eventInstance);
       if (kernelCall) {
         env.setInKernelMode(true);
       }

package/src/runtime/interpreter.ts

@@ -1268,7 +1268,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
       }
       const res: Resolver = await getResolverForPath(entryName, moduleName, env);
       let r: Instance | undefined;
-      await computeExprAttributes(inst, env);
+      await computeExprAttributes(inst, undefined, undefined, env);
       if (env.isInUpsertMode()) {
         await runPreUpdateEvents(inst, env);
         r = await res.upsertInstance(inst);
@@ -1279,7 +1279,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
         r = await res.createInstance(inst);
         await runPostCreateEvents(inst, env);
       }
-      if (r && entryName == AgentEntityName) {
+      if (r && entryName == AgentEntityName && inst.moduleName == CoreAIModuleName) {
         defineAgentEvent(env.getActiveModuleName(), r.lookup('name'), r.lookup('instruction'));
       }
       env.setLastResult(r);
@@ -1385,7 +1385,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
             );
             const res: Array<Instance> = new Array<Instance>();
             for (let i = 0; i < lastRes.length; ++i) {
-              await computeExprAttributes(lastRes[i], env);
+              await computeExprAttributes(lastRes[i], crud.body?.attributes, attrs, env);
               await runPreUpdateEvents(lastRes[i], env);
               const finalInst: Instance = await resolver.updateInstance(lastRes[i], attrs);
               await runPostUpdateEvents(finalInst, lastRes[i], env);
@@ -1397,7 +1397,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           }
         } else {
           const res: Resolver = await getResolverForPath(lastRes.name, lastRes.moduleName, env);
-          await computeExprAttributes(lastRes, env);
+          await computeExprAttributes(lastRes, crud.body?.attributes, attrs, env);
           await runPreUpdateEvents(lastRes, env);
           const finalInst: Instance = await res.updateInstance(lastRes, attrs);
           await runPostUpdateEvents(finalInst, lastRes, env);
@@ -1489,22 +1489,45 @@ function triggerTimer(timerInst: Instance): Instance {
   return timerInst;
 }
 
-async function computeExprAttributes(inst: Instance, env: Environment) {
+async function computeExprAttributes(
+  inst: Instance,
+  origAttrs: SetAttribute[] | undefined,
+  updatedAttrs: InstanceAttributes | undefined,
+  env: Environment
+) {
   const exprAttrs = inst.getExprAttributes();
-  if (exprAttrs) {
+  if (exprAttrs || origAttrs) {
     const newEnv = new Environment('expr-env', env);
     inst.attributes.forEach((v: any, k: string) => {
-      newEnv.bind(k, v);
+      if (v != undefined) newEnv.bind(k, v);
     });
-    const ks = [...exprAttrs.keys()];
-    for (let i = 0; i < ks.length; ++i) {
-      const n = ks[i];
-      const expr: Expr | undefined = exprAttrs.get(n);
-      if (expr) {
-        await evaluateExpression(expr, newEnv);
-        const v: Result = newEnv.getLastResult();
-        newEnv.bind(n, v);
-        inst.attributes.set(n, v);
+    updatedAttrs?.forEach((v: any, k: string) => {
+      if (v != undefined) newEnv.bind(k, v);
+    });
+    if (exprAttrs) {
+      const ks = [...exprAttrs.keys()];
+      for (let i = 0; i < ks.length; ++i) {
+        const n = ks[i];
+        const expr: Expr | undefined = exprAttrs.get(n);
+        if (expr) {
+          await evaluateExpression(expr, newEnv);
+          const v: Result = newEnv.getLastResult();
+          newEnv.bind(n, v);
+          inst.attributes.set(n, v);
+          updatedAttrs?.set(n, v);
+        }
+      }
+    }
+    if (origAttrs && updatedAttrs) {
+      for (let i = 0; i < origAttrs.length; ++i) {
+        const a: SetAttribute = origAttrs[i];
+        const n = a.name;
+        if (!n.endsWith(QuerySuffix) && updatedAttrs.has(n)) {
+          await evaluateExpression(a.value, newEnv);
+          const v: Result = newEnv.getLastResult();
+          updatedAttrs.set(n, v);
+          newEnv.bind(n, v);
+        }
       }
     }
   }
@@ -1929,8 +1952,16 @@ export async function evaluateExpression(expr: Expr, env: Environment): Promise<
       await evaluateExpression(expr.e2, env);
       return;
     }
+    if (v1 == null || v1 == undefined) {
+      env.setLastResult(undefined);
+      return;
+    }
     await evaluateExpression(expr.e2, env);
     const v2 = env.getLastResult();
+    if (v2 == null || v2 == undefined) {
+      env.setLastResult(undefined);
+      return;
+    }
     switch (expr.op) {
       // arithmetic operators
       case '+':

package/src/runtime/loader.ts

@@ -33,6 +33,15 @@ import {
   isDecisionDefinition,
   DecisionDefinition,
   CaseEntry,
+  isScenarioDefinition,
+  ScenarioDefinition,
+  DirectiveDefinition,
+  GlossaryEntryDefinition,
+  isDirectiveDefinition,
+  isGlossaryEntryDefinition,
+  isPublicWorkflowDefinition,
+  isPublicAgentDefinition,
+  isPublicEventDefinition,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -55,6 +64,7 @@ import {
   fetchModule,
 } from './module.js';
 import {
+  asStringLiteralsMap,
   escapeSpecialChars,
   findRbacSchema,
   isFqName,
@@ -62,6 +72,7 @@ import {
   makeFqName,
   maybeExtends,
   registerInitFunction,
+  rootRef,
 } from './util.js';
 import { getFileSystem, toFsPath, readFile, readdir, exists } from '../utils/fs-utils.js';
 import { URI } from 'vscode-uri';
@@ -89,6 +100,9 @@ import { ExtendedFileSystem } from '../utils/fs/interfaces.js';
 import z from 'zod';
 import { registerAgentFlow, registerFlow } from './agents/flows.js';
 import {
+  addAgentDirective,
+  addAgentGlossaryEntry,
+  addAgentScenario,
   AgentCondition,
   AgentGlossaryEntry,
   AgentScenario,
@@ -423,14 +437,23 @@ function addEntityFromDef(def: EntityDefinition, moduleName: string): Entity {
   return entity;
 }
 
-export function addSchemaFromDef(def: SchemaDefinition, moduleName: string): Record {
+function addSchemaFromDef(
+  def: SchemaDefinition,
+  moduleName: string,
+  ispub: boolean = false
+): Record {
   let result: Record | undefined;
   if (isEntityDefinition(def)) {
     result = addEntityFromDef(def, moduleName);
   } else if (isEventDefinition(def)) {
     result = addEvent(def.name, moduleName, def.schema, maybeExtends(def.extends));
-  } else {
+  } else if (isRecordDefinition(def)) {
     result = addRecord(def.name, moduleName, def.schema, maybeExtends(def.extends));
+  } else {
+    throw new Error(`Cannot add schema defintiion in module ${moduleName} for ${def}`);
+  }
+  if (ispub) {
+    result.setPublic(true);
   }
   return result;
 }
@@ -442,8 +465,12 @@ export function addRelationshipFromDef(
   return addRelationship(def.name, def.type, def.nodes, moduleName, def.schema, def.properties);
 }
 
-export function addWorkflowFromDef(def: WorkflowDefinition, moduleName: string): Workflow {
-  return addWorkflow(def.name || '', moduleName, def.statements, def.header);
+export function addWorkflowFromDef(
+  def: WorkflowDefinition,
+  moduleName: string,
+  ispub: boolean = false
+): Workflow {
+  return addWorkflow(def.name || '', moduleName, def.statements, def.header, ispub);
 }
 
 const StandaloneStatements = new Map<string, Statement[]>();
@@ -501,7 +528,8 @@ function processAgentDirectives(agentName: string, value: Literal): AgentConditi
           }
         });
         if (cond && then) {
-          conds?.push({ cond, then });
+          const internal = true;
+          conds?.push({ cond, then, internal });
         } else {
           throw new Error(`Invalid condition spec in agent ${agentName}`);
         }
@@ -531,7 +559,8 @@ function processAgentScenarios(agentName: string, value: Literal): AgentScenario
           }
         });
         if (user && ai) {
-          scenarios.push({ user, ai });
+          const internal = true;
+          scenarios.push({ user, ai, internal });
         } else {
           throw new Error(`Invalid glossary spec in agent ${agentName}`);
         }
@@ -564,7 +593,8 @@ function processAgentGlossary(agentName: string, value: Literal): AgentGlossaryE
           }
         });
         if (name && meaning) {
-          gls.push({ name, meaning, synonyms });
+          const internal = true;
+          gls.push({ name, meaning, synonyms, internal });
         } else {
           throw new Error(`Invalid glossary spec in agent ${agentName}`);
         }
@@ -589,7 +619,11 @@ function processAgentScratchNames(agentName: string, value: Literal): string[] |
   return undefined;
 }
 
-async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
+async function addAgentDefinition(
+  def: AgentDefinition,
+  moduleName: string,
+  ispub: boolean = false
+) {
   let llmName: string | undefined = undefined;
   const name = def.name;
   const attrsStrs = new Array<string>();
@@ -712,7 +746,11 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
     registerAgentScratchNames(agentFqName, scratchNames);
   }
   // Don't add llm to module attrs if it wasn't originally specified
-  addAgent(def.name, attrs, moduleName);
+  const agent = addAgent(def.name, attrs, moduleName);
+  if (ispub) {
+    agent.setPublic(true);
+  }
+  return agent;
 }
 
 function processAgentArray(array: ArrayLiteral, attrName: string): string {
@@ -774,6 +812,58 @@ function addDecisionDefinition(def: DecisionDefinition, moduleName: string) {
   }
 }
 
+function addScenarioDefintion(def: ScenarioDefinition, moduleName: string) {
+  if (def.body) {
+    let n = rootRef(def.name);
+    if (!isFqName(n)) {
+      n = makeFqName(moduleName, n);
+    }
+    const m = asStringLiteralsMap(def.body);
+    const user = m.get('user');
+    const ai = m.get('ai');
+    if (user && ai) addAgentScenario(n, { user: user, ai: ai, internal: false });
+    else throw new Error(`scenario ${def.name} requires both user and ai entries`);
+    fetchModule(moduleName).addScenario(def);
+  }
+}
+
+function addDirectiveDefintion(def: DirectiveDefinition, moduleName: string) {
+  if (def.body) {
+    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) addAgentDirective(n, { cond: cond, then: then, internal: false });
+    else throw new Error(`directive ${def.name} requires both if and then entries`);
+    fetchModule(moduleName).addDirective(def);
+  }
+}
+
+function addGlossaryEntryDefintion(def: GlossaryEntryDefinition, moduleName: string) {
+  if (def.body) {
+    let n = rootRef(def.name);
+    if (!isFqName(n)) {
+      n = makeFqName(moduleName, n);
+    }
+    const m = asStringLiteralsMap(def.body);
+    const name = m.get('name');
+    const meaning = m.get('meaning');
+    const syn = m.get('synonyms');
+    if (name && meaning)
+      addAgentGlossaryEntry(n, {
+        name: name,
+        meaning: meaning,
+        synonyms: syn,
+        internal: false,
+      });
+    else throw new Error(`glossaryEntry ${def.name} requires both name and meaning keys`);
+    fetchModule(moduleName).addGlossaryEntry(def);
+  }
+}
+
 function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
   const resolverName = `${moduleName}/${def.name}`;
   const paths = def.paths;
@@ -826,14 +916,20 @@ function asResolverFn(fname: string): Function {
 export async function addFromDef(def: Definition, moduleName: string) {
   if (isEntityDefinition(def)) addSchemaFromDef(def, moduleName);
   else if (isEventDefinition(def)) addSchemaFromDef(def, moduleName);
+  else if (isPublicEventDefinition(def)) addSchemaFromDef(def.def, moduleName, true);
   else if (isRecordDefinition(def)) addSchemaFromDef(def, moduleName);
   else if (isRelationshipDefinition(def)) addRelationshipFromDef(def, moduleName);
   else if (isWorkflowDefinition(def)) addWorkflowFromDef(def, moduleName);
+  else if (isPublicWorkflowDefinition(def)) addWorkflowFromDef(def.def, moduleName, true);
   else if (isAgentDefinition(def)) await addAgentDefinition(def, moduleName);
+  else if (isPublicAgentDefinition(def)) await addAgentDefinition(def.def, moduleName, true);
   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);
+  else if (isScenarioDefinition(def)) addScenarioDefintion(def, moduleName);
+  else if (isDirectiveDefinition(def)) addDirectiveDefintion(def, moduleName);
+  else if (isGlossaryEntryDefinition(def)) addGlossaryEntryDefintion(def, moduleName);
 }
 
 export async function parseAndIntern(code: string, moduleName?: string) {