agentlang 0.0.19 → 0.0.20

package/src/runtime/agents/common.ts

@@ -145,9 +145,12 @@ are invalid, because the alias 'employee' is not defined:
 
 A fix for the reference-error is shown below:
 
-{Employee {id? 101}} @as employee;
+{Employee {id? 101}} @as [employee];
 {SendEmail {to employee.email, body "hello"}}
 
+Note that the alias for the query is '[employee]' so that the resultset is destructured to select exactly one instance of Employee 
+selected into the reference. You must follow this pattern if your goal is to select exactly a single instance.
+
 Keep in mind that the only valid syntax for the 'if' condition is:
 
 if (<expr>) {

package/src/runtime/defs.ts

@@ -76,3 +76,15 @@ export class CodeMismatchError extends Error {
     super(message || 'The verification code is incorrect. Please try again.', options);
   }
 }
+
+export let FetchModuleFn: any = undefined;
+
+export function setModuleFnFetcher(f: Function) {
+  FetchModuleFn = f;
+}
+
+export let SetSubscription: any = undefined;
+
+export function setSubscriptionFn(f: Function) {
+  SetSubscription = f;
+}

package/src/runtime/interpreter.ts

@@ -54,6 +54,7 @@ import {
   DefaultModuleName,
   escapeFqName,
   escapeQueryName,
+  escapeSpecialChars,
   fqNameFromPath,
   isFqName,
   isPath,
@@ -80,6 +81,7 @@ import {
   setTimerRunning,
 } from './modules/core.js';
 import { invokeModuleFn } from './jsmodules.js';
+import { invokeOpenApiEvent, isOpenApiEventInstance } from './openapi.js';
 
 export type Result = any;
 
@@ -545,6 +547,15 @@ export async function evaluate(
         }
         await evaluateStatements(wf.statements, env, continuation);
         return env.getLastResult();
+      } else if (isOpenApiEventInstance(eventInstance)) {
+        env = new Environment(eventInstance.name + '.env', activeEnv);
+        await handleOpenApiEvent(eventInstance, env);
+        const r = env.getLastResult();
+        if (continuation) continuation(r);
+        return r;
+      } else {
+        if (continuation) continuation(null);
+        return null;
       }
     } else {
       throw new Error('Not an event - ' + eventInstance.name);
@@ -1180,6 +1191,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     }
   } else if (isEventInstance(inst)) {
     if (isAgentEventInstance(inst)) await handleAgentInvocation(inst, env);
+    else if (isOpenApiEventInstance(inst)) await handleOpenApiEvent(inst, env);
     else await evaluate(inst, (result: Result) => env.setLastResult(result), env);
   } else {
     env.setLastResult(inst);
@@ -1350,11 +1362,37 @@ async function handleAgentInvocation(agentEventInst: Instance, env: Environment)
         }
       }
     }
+    if (agent.output) {
+      await pushToAgent(agent.output, env.getLastResult(), env);
+    }
   } else {
     logger.warn(`Agent ${agent.name} failed to generate a response`);
   }
 }
 
+function agentInputAsString(result: any): string {
+  if (!isString(result)) {
+    if (result instanceof Instance) {
+      return JSON.stringify((result as Instance).asObject());
+    } else if (result instanceof Array) {
+      return `[${(result as Array<any>)
+        .map((r: any) => {
+          return agentInputAsString(r);
+        })
+        .join(',')}]`;
+    } else {
+      return JSON.stringify(result);
+    }
+  }
+  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));
+}
+
 function cleanupAgentResponse(response: string | undefined): string | undefined {
   if (response) {
     const resp = response.trim();
@@ -1387,6 +1425,15 @@ function cleanupAgentResponse(response: string | undefined): string | undefined
   }
 }
 
+async function handleOpenApiEvent(eventInst: Instance, env: Environment): Promise<void> {
+  const r = await invokeOpenApiEvent(
+    eventInst.moduleName,
+    eventInst.name,
+    eventInst.attributesAsObject()
+  );
+  env.setLastResult(r);
+}
+
 async function evaluateUpsert(crud: CrudMap, env: Environment): Promise<void> {
   env.setInUpsertMode(true);
   try {
@@ -1650,7 +1697,7 @@ async function runPrePostEvents(
       if (env.hasHandlers()) {
         throw reason;
       } else {
-        logger.error(`${prefix}: ${reason}`);
+        throw new Error(`${prefix}: ${reason}`);
       }
     };
     if (trigInfo.async) {

package/src/runtime/jsmodules.ts

@@ -1,7 +1,7 @@
 import { logger } from './logger.js';
-import { setSubscription } from './resolvers/registry.js';
 import { now, splitRefs } from './util.js';
 import { isNodeEnv } from '../utils/runtime.js';
+import { setModuleFnFetcher } from './defs.js';
 
 let dirname: any = undefined;
 let sep: any = undefined;
@@ -26,39 +26,37 @@ const importedModules = new Map<string, any>();
 
 // Usage: importModule("./mymodels/acme.js")
 export async function importModule(path: string, name: string, moduleFileName?: string) {
-  if (importedModules.has(name)) {
-    logger.warn(`Alias '${name}' will overwrite a previously imported module`);
-  }
-  if (moduleFileName) {
-    let s: string = dirname(moduleFileName);
-    if (s.startsWith('./')) {
-      s = s.substring(2);
+  if (isNodeEnv) {
+    if (importedModules.has(name)) {
+      logger.warn(`Alias '${name}' will overwrite a previously imported module`);
     }
-    path = `${s}${sep}${path}`;
-  }
-  if (!(path.startsWith(sep) || path.startsWith('.'))) {
-    path = process.cwd() + sep + path;
+    if (moduleFileName) {
+      let s: string = dirname(moduleFileName);
+      if (s.startsWith('./')) {
+        s = s.substring(2);
+      } else if (s == '.') {
+        s = process.cwd();
+      }
+      path = `${s}${sep}${path}`;
+    }
+    if (!(path.startsWith(sep) || path.startsWith('.'))) {
+      path = process.cwd() + sep + path;
+    }
+    const m = await import(/* @vite-ignore */ path);
+    importedModules.set(name, m);
+    // e.g of dynamic fn-call:
+    //// let f = eval("(a, b) => m.add(a, b)");
+    //// console.log(f(10, 20))
+    return m;
+  } else {
+    return {};
   }
-  const m = await import(/* @vite-ignore */ path);
-  importedModules.set(name, m);
-  // e.g of dynamic fn-call:
-  //// let f = eval("(a, b) => m.add(a, b)");
-  //// console.log(f(10, 20))
-  return m;
 }
 
 export function moduleImported(moduleName: string): boolean {
   return importedModules.has(moduleName);
 }
 
-const ReservedImports = new Set<string>(['resolvers']);
-
-export function validateImportName(n: string) {
-  if (ReservedImports.has(n)) {
-    throw new Error(`${n} is an import reserved by the runtime`);
-  }
-}
-
 function maybeEvalFunction(fnName: string): Function | undefined {
   try {
     return eval(fnName);
@@ -68,14 +66,6 @@ function maybeEvalFunction(fnName: string): Function | undefined {
   }
 }
 
-function invokeReservedFn(moduleName: string, fnName: string, args: Array<any> | null) {
-  if (moduleName == 'resolvers' && fnName == 'setSubscription' && args != null) {
-    return setSubscription(args[0], args[1]);
-  } else {
-    throw new Error(`Failed to call ${moduleName}.${fnName} with the given arguments`);
-  }
-}
-
 async function invokeBuiltInFn(fnName: string, args: Array<any> | null, isAsync: boolean = false) {
   if (fnName == 'now') {
     return now();
@@ -112,9 +102,6 @@ export async function invokeModuleFn(
       }
     }
     const mname = refs[0];
-    if (ReservedImports.has(mname)) {
-      return invokeReservedFn(mname, refs[1], args);
-    }
     const m = importedModules.get(mname);
     if (m != undefined) {
       const f = m[refs[1]];
@@ -151,3 +138,5 @@ export function getModuleFn(fqFnName: string): Function | undefined {
     return m[refs[1]];
   } else return undefined;
 }
+
+setModuleFnFetcher(getModuleFn);

package/src/runtime/loader.ts

@@ -63,9 +63,11 @@ import { Environment, evaluateStatements, GlobalEnvironment } from './interprete
 import { createPermission, createRole } from './modules/auth.js';
 import { AgentEntityName, CoreAIModuleName, LlmEntityName } from './modules/ai.js';
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
-import { registerResolver, setResolver, setSubscription } from './resolvers/registry.js';
+import { registerResolver, setResolver } from './resolvers/registry.js';
 import { ConfigSchema } from './state.js';
-import { getModuleFn, importModule, validateImportName } from './jsmodules.js';
+import { getModuleFn, importModule } from './jsmodules.js';
+import { SetSubscription } from './defs.js';
+import { ExtendedFileSystem } from '../utils/fs/interfaces.js';
 
 export async function extractDocument(
   fileName: string,
@@ -135,6 +137,31 @@ export const DefaultAppSpec: ApplicationSpec = {
   version: '0.0.1',
 };
 
+async function getAllModules(
+  dir: string,
+  fs: ExtendedFileSystem,
+  drill: boolean = true
+): Promise<string[]> {
+  let alFiles = new Array<string>();
+  if (!(await fs.exists(dir))) {
+    return alFiles;
+  }
+  const directoryContents = await fs.readdir(dir);
+  for (let i = 0; i < directoryContents.length; ++i) {
+    const file = directoryContents[i];
+    if (path.extname(file).toLowerCase() == '.al') {
+      alFiles.push(dir + path.sep + file);
+    } else if (drill) {
+      const fullPath = dir + path.sep + file;
+      const stat = await fs.stat(fullPath);
+      if (stat.isDirectory()) {
+        alFiles = alFiles.concat(await getAllModules(fullPath, fs));
+      }
+    }
+  }
+  return alFiles;
+}
+
 async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Promise<string> {
   // Initialize filesystem if not already done
   const fs = await getFileSystem(fsOptions);
@@ -142,19 +169,11 @@ async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Pr
   const appJsonFile = `${appDir}${path.sep}package.json`;
   const s: string = await fs.readFile(appJsonFile);
   const appSpec: ApplicationSpec = JSON.parse(s);
-  const alFiles: Array<string> = new Array<string>();
-  const directoryContents = await fs.readdir(appDir);
   let lastModuleLoaded: string = '';
   async function cont2() {
-    if (!directoryContents) {
-      console.error(chalk.red(`Directory ${appDir} does not exist or is empty.`));
-      return;
-    }
-    directoryContents.forEach(file => {
-      if (path.extname(file).toLowerCase() == '.al') {
-        alFiles.push(appDir + path.sep + file);
-      }
-    });
+    const fls01 = await getAllModules(appDir, fs, false);
+    const fls02 = await getAllModules(appDir + path.sep + 'src', fs);
+    const alFiles = fls01.concat(fls02);
     for (let i = 0; i < alFiles.length; ++i) {
       lastModuleLoaded = (await loadModule(alFiles[i], fsOptions)).name;
     }
@@ -164,7 +183,10 @@ async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Pr
     for (const [depName, _] of Object.entries(appSpec.dependencies)) {
       try {
         const depDirName = `./node_modules/${depName}`;
-        const files = await fs.readdir(depDirName);
+        const fls01 = await fs.readdir(depDirName);
+        const srcDir = depDirName + path.sep + 'src';
+        const hasSrc = await fs.exists(srcDir);
+        const files = hasSrc ? fls01.concat(await fs.readdir(srcDir)) : fls01;
         if (
           files.find(file => {
             return path.extname(file).toLowerCase() == '.al';
@@ -356,7 +378,7 @@ export function addRelationshipFromDef(
 }
 
 export function addWorkflowFromDef(def: WorkflowDefinition, moduleName: string): Workflow {
-  return addWorkflow(def.name, moduleName, def.statements);
+  return addWorkflow(def.name, moduleName, def.statements, def.hints);
 }
 
 const StandaloneStatements = new Map<string, Statement[]>();
@@ -489,7 +511,7 @@ function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
       resolver.subs = {
         subscribe: subsFn,
       };
-      if (subsEvent) setSubscription(subsEvent, resolverName);
+      if (subsEvent) SetSubscription(subsEvent, resolverName);
       resolver.subscribe();
     }
   });
@@ -537,7 +559,6 @@ export async function internModule(
   const mn = module.name;
   const r = addModule(mn);
   module.imports.forEach(async (imp: Import) => {
-    validateImportName(imp.name);
     await importModule(imp.path, imp.name, moduleFileName);
   });
   for (let i = 0; i < module.defs.length; ++i) {
@@ -569,11 +590,15 @@ export async function loadRawConfig(
   fsOptions?: any
 ): Promise<any> {
   const fs = await getFileSystem(fsOptions);
-  let rawConfig = preprocessRawConfig(JSON.parse(await fs.readFile(configFileName)));
-  if (validate) {
-    rawConfig = ConfigSchema.parse(rawConfig);
+  if (await fs.exists(configFileName)) {
+    let rawConfig = preprocessRawConfig(JSON.parse(await fs.readFile(configFileName)));
+    if (validate) {
+      rawConfig = ConfigSchema.parse(rawConfig);
+    }
+    return rawConfig;
+  } else {
+    return { service: { port: 8080 } };
   }
-  return rawConfig;
 }
 
 export function generateRawConfig(configObj: any): string {

package/src/runtime/module.ts

@@ -19,6 +19,7 @@ import {
   RbacSpecEntry,
   RbacSpecEntries,
   RbacOpr,
+  WorkflowHint,
 } from '../language/generated/ast.js';
 import {
   Path,
@@ -43,7 +44,12 @@ import {
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
-import { DefaultIdAttributeName, PathAttributeName } from './defs.js';
+import {
+  DefaultIdAttributeName,
+  FetchModuleFn,
+  PathAttributeName,
+  SetSubscription,
+} from './defs.js';
 import { logger } from './logger.js';
 
 export class ModuleEntry {
@@ -1594,6 +1600,7 @@ export const propertyNames = new Set([
   '@indexed',
   '@default',
   '@optional',
+  '@check',
   '@unique',
   '@autoincrement',
   '@array',
@@ -1856,7 +1863,8 @@ function normalizeWorkflowName(n: string): string {
 export function addWorkflow(
   name: string,
   moduleName = activeModule,
-  statements?: Statement[]
+  statements?: Statement[],
+  hints?: WorkflowHint[]
 ): Workflow {
   const module: Module = fetchModule(moduleName);
   if (module.hasEntry(name)) {
@@ -1869,6 +1877,13 @@ export function addWorkflow(
     event.addMeta(SystemDefinedEvent, 'true');
   }
   if (!statements) statements = new Array<Statement>();
+  if (hints && hints.length > 0) {
+    hints.forEach((hint: WorkflowHint) => {
+      if (hint.subs) {
+        SetSubscription(makeFqName(moduleName, name), hint.subs.resolverName);
+      }
+    });
+  }
   return module.addEntry(new Workflow(asWorkflowName(name), statements, moduleName)) as Workflow;
 }
 
@@ -2103,13 +2118,22 @@ function checkOneOfValue(attrSpec: AttributeSpec, attrName: string, attrValue: a
   return false;
 }
 
+function getCheckPredicate(attrSpec: AttributeSpec): any {
+  const p = getAnyProperty('check', attrSpec);
+  if (isString(p)) {
+    return FetchModuleFn(p);
+  }
+  return undefined;
+}
+
 function validateType(attrName: string, attrValue: any, attrSpec: AttributeSpec) {
   if (attrSpec.type == 'Path') {
     if (!isPath(attrValue, getRefSpec(attrSpec))) {
       throw new Error(`Failed to validate Path ${attrValue} passed to ${attrName}`);
     }
   }
-  const predic = builtInChecks.get(attrSpec.type);
+  let predic = getCheckPredicate(attrSpec);
+  predic = predic ? predic : builtInChecks.get(attrSpec.type);
   if (predic != undefined) {
     if (isArrayAttribute(attrSpec)) {
       if (!(attrValue instanceof Array)) {

package/src/runtime/modules/ai.ts

@@ -34,6 +34,7 @@ entity ${AgentEntityName} {
     tools String @optional, // comma-separated list of tool names
     documents String @optional, // comma-separated list of document names
     channels String @optional, // comma-separated list of channel names
+    output String @optional, // fq-name of another agent to which the result will be pushed
     llm String
 }
 
@@ -72,6 +73,7 @@ export class AgentInstance {
   documents: string | undefined;
   channels: string | undefined;
   runWorkflows: boolean = true;
+  output: string | undefined;
 
   private constructor() {}
 

package/src/runtime/modules/core.ts

@@ -48,7 +48,7 @@ entity activeSuspension {
   id UUID @id
 }
 
-resolver servicenow ["${DefaultModuleName}/activeSuspension"] {
+resolver suspensionResolver ["${DefaultModuleName}/activeSuspension"] {
     query Core.lookupActiveSuspension
 }
 

package/src/runtime/openapi.ts

@@ -0,0 +1,74 @@
+import { parseAndIntern } from './loader.js';
+import { logger } from './logger.js';
+import { Instance } from './module.js';
+import { isReservedName } from './util.js';
+import { OpenAPIClient, OpenAPIClientAxios } from 'openapi-client-axios';
+
+export type OpenApiHandle = {
+  api: OpenAPIClientAxios;
+  client: OpenAPIClient;
+};
+
+let OpenApiModules: Map<string, OpenApiHandle> | undefined = undefined;
+
+export async function registerOpenApiModule(
+  moduleName: string,
+  handle: OpenApiHandle
+): Promise<string> {
+  if (OpenApiModules == undefined) {
+    OpenApiModules = new Map();
+  }
+  const m = new Map(Object.entries(handle.client));
+  const events = new Array<string>();
+  m.forEach((v: any, k: string) => {
+    if (v instanceof Function) {
+      if (isReservedName(k)) {
+        k = `_${k}`;
+      }
+      logger.debug(`OpenAPI event: ${moduleName}/${k}`);
+      events.push(
+        `event ${k} {parameters Any @optional, data Any @optional, config Any @optional}`
+      );
+    }
+  });
+  await parseAndIntern(`module ${moduleName}\n${events.join('\n')}`);
+  OpenApiModules.set(moduleName, handle);
+  return moduleName;
+}
+
+export function isOpenApiModule(moduleName: string): boolean {
+  return OpenApiModules != undefined && OpenApiModules.has(moduleName);
+}
+
+export type OpenApiArgs = {
+  parameters?: any;
+  data?: any;
+  config?: any;
+};
+
+export async function invokeOpenApiEvent(
+  moduleName: string,
+  eventName: string,
+  params: OpenApiArgs
+): Promise<any> {
+  if (OpenApiModules) {
+    const handle = OpenApiModules.get(moduleName);
+    if (handle) {
+      const f = handle.client[eventName];
+      if (!f) {
+        throw new Error(`No event ${eventName} found in ${moduleName}`);
+      } else {
+        const r: any = await f(params.parameters, params.data, params.config);
+        return r.data;
+      }
+    } else {
+      throw new Error(`No OpenAPI module found - ${moduleName}`);
+    }
+  } else {
+    throw new Error(`OpenAPI module ${moduleName} not initialized`);
+  }
+}
+
+export function isOpenApiEventInstance(eventInst: Instance): boolean {
+  return isOpenApiModule(eventInst.moduleName);
+}

package/src/runtime/resolvers/interface.ts

@@ -193,15 +193,20 @@ export class Resolver {
 
   public async onSubscription(result: any): Promise<any> {
     if (result != undefined) {
-      const eventName = getSubscriptionEvent(this.name);
-      if (eventName) {
-        const path = splitFqName(eventName);
-        const inst = makeInstance(
-          path.getModuleName(),
-          path.getEntryName(),
-          newInstanceAttributes().set('data', result)
-        );
-        return await evaluate(inst);
+      try {
+        const eventName = getSubscriptionEvent(this.name);
+        if (eventName) {
+          const path = splitFqName(eventName);
+          const inst = makeInstance(
+            path.getModuleName(),
+            path.getEntryName(),
+            newInstanceAttributes().set('data', result)
+          );
+          return await evaluate(inst);
+        }
+      } catch (err: any) {
+        logger.error(`Resolver ${this.name} raised error in onSubscription handler: ${err}`);
+        return undefined;
       }
     }
   }

package/src/runtime/resolvers/registry.ts

@@ -1,3 +1,4 @@
+import { setSubscriptionFn } from '../defs.js';
 import { Resolver, setSubscriptionEvent } from './interface.js';
 
 type MakeResolver = () => Resolver;
@@ -17,8 +18,6 @@ export function setResolver(fqEntryName: string, resolverName: string) {
   }
 }
 
-export const setSubscription = setSubscriptionEvent;
-
 export function getResolverNameForPath(fqEntryName: string): string | undefined {
   return resolverPathMappings.get(fqEntryName);
 }
@@ -31,3 +30,5 @@ export function getResolver(fqEntryName: string): Resolver {
   }
   throw new Error(`No resolver registered for ${fqEntryName}`);
 }
+
+setSubscriptionFn(setSubscriptionEvent);

package/src/runtime/state.ts

@@ -93,6 +93,15 @@ export const ConfigSchema = z.object({
       }),
     ])
     .optional(),
+  openapi: z
+    .array(
+      z.object({
+        specUrl: z.string(),
+        baseUrl: z.string().optional(),
+        name: z.string(),
+      })
+    )
+    .optional(),
 });
 
 export type Config = z.infer<typeof ConfigSchema>;

package/src/runtime/util.ts

@@ -472,3 +472,25 @@ export function areSetsEqual<T>(set1: Set<T>, set2: Set<T>): boolean {
   }
   return true;
 }
+
+const ReservedNames = new Set([
+  'if',
+  'else',
+  'for',
+  'or',
+  'and',
+  'entity',
+  'record',
+  'event',
+  'workflow',
+  'create',
+  'delete',
+  'update',
+  'upsert',
+  'agent',
+  'resolver',
+]);
+
+export function isReservedName(s: string): boolean {
+  return ReservedNames.has(s);
+}

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@subs','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'