agentlang 0.0.18 → 0.0.20

package/src/runtime/loader.ts

@@ -57,15 +57,17 @@ 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 { parse, parseModule, parseWorkflow } from '../language/parser.js';
+import { maybeGetValidationErrors, 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';
 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,
@@ -87,11 +89,6 @@ export async function extractDocument(
 
     if (!fileExists) {
       const errorMsg = `File ${fileName} does not exist.`;
-      if (chalk) {
-        console.error(chalk.red(errorMsg));
-      } else {
-        console.error(errorMsg);
-      }
       throw new Error(errorMsg);
     }
   } else if (!isNodeEnv && typeof fileName === 'string') {
@@ -100,7 +97,7 @@ export async function extractDocument(
     const fileExists = await exists(fullFilePath);
 
     if (!fileExists) {
-      console.error(`File ${fileName} does not exist.`);
+      throw new Error(`File ${fileName} does not exist.`);
     }
   } else {
     throw new Error('Invalid input: expected file path (Node.js) or File object/content (browser)');
@@ -116,27 +113,11 @@ export async function extractDocument(
   });
 
   // Handle validation errors
-  const validationErrors = (document.diagnostics ?? []).filter(e => e.severity === 1);
-
-  if (validationErrors.length > 0) {
-    console.error(
-      isNodeEnv && chalk
-        ? chalk.red('There are validation errors:')
-        : 'There are validation errors:'
-    );
-
-    for (const validationError of validationErrors) {
-      const errorMsg = `line ${validationError.range.start.line + 1}: ${
-        validationError.message
-      } [${document.textDocument.getText(validationError.range)}]`;
-      if (isNodeEnv && chalk) {
-        console.error(chalk.red(errorMsg));
-      } else {
-        console.error(errorMsg);
-      }
-    }
+  const errs = maybeGetValidationErrors(document);
 
-    throw new Error('Validation errors found');
+  if (errs) {
+    const errorMsg = `${errs.join('\n')}`;
+    throw new Error(errorMsg);
   }
 
   return document;
@@ -156,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);
@@ -163,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;
     }
@@ -183,14 +181,21 @@ async function loadApp(appDir: string, fsOptions?: any, callback?: Function): Pr
   }
   if (appSpec.dependencies != undefined) {
     for (const [depName, _] of Object.entries(appSpec.dependencies)) {
-      const depDirName = `./node_modules/${depName}`;
-      const files = await fs.readdir(depDirName);
-      if (
-        files.find(file => {
-          return path.extname(file).toLowerCase() == '.al';
-        })
-      ) {
-        await loadApp(depDirName, fsOptions);
+      try {
+        const depDirName = `./node_modules/${depName}`;
+        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';
+          })
+        ) {
+          await loadApp(depDirName, fsOptions);
+        }
+      } catch (error) {
+        logger.error(`Error loading dependency ${depName}: ${error}`);
       }
     }
   }
@@ -373,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[]>();
@@ -506,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();
     }
   });
@@ -554,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) {
@@ -586,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() {}
 
@@ -228,8 +230,12 @@ export async function findProviderForLLM(
       const llm: Instance = result[0];
       const service = llm.lookup('service');
       const pclass = provider(service);
-      const providerConfig: Map<string, any> =
-        llm.lookup('config') || new Map().set('service', service);
+      const configValue = llm.lookup('config');
+      const providerConfig: Map<string, any> = configValue
+        ? configValue instanceof Map
+          ? configValue
+          : new Map(Object.entries(configValue))
+        : new Map().set('service', service);
       p = new pclass(providerConfig);
       if (p) ProviderDb.set(llmName, p);
     }

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: [
         '!=','*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'

package/out/cli/docs.d.ts

@@ -1,2 +0,0 @@
-export declare const generateSwaggerDoc: (fileName: string) => Promise<void>;
-//# sourceMappingURL=docs.d.ts.map

package/out/cli/docs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/cli/docs.ts"],"names":[],"mappings":"AA8OA,eAAO,MAAM,kBAAkB,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAcvE,CAAC"}