agentlang 0.0.3 → 0.0.5

package/src/runtime/auth/defs.ts

@@ -4,13 +4,29 @@ import { AppConfig } from '../state.js';
 export const AdminUserId = '00000000-0000-0000-0000-000000000000';
 
 export function isAuthEnabled(): boolean {
-  if (AppConfig && AppConfig.rbacEnabled == true) {
+  if (AppConfig?.auth?.enabled == true) {
     return true;
   } else {
     return false;
   }
 }
 
+export let InternalRbacEnabled = false;
+
+export function isRbacEnabled(): boolean {
+  return InternalRbacEnabled || (isAuthEnabled() && AppConfig?.rbac?.enabled == true);
+}
+
+export async function callWithRbac(f: Function): Promise<void> {
+  const old = InternalRbacEnabled;
+  InternalRbacEnabled = true;
+  try {
+    await f();
+  } finally {
+    InternalRbacEnabled = old;
+  }
+}
+
 export type ActiveSessionInfo = {
   sessionId: string;
   userId: string;

package/src/runtime/auth/interface.ts

@@ -10,6 +10,9 @@ export type SessionInfo = {
   sessionId: string; // a UUID
   userId: string; // UUID
   authToken: string;
+  idToken?: string;
+  accessToken?: string;
+  refreshToken?: string;
   systemSesionInfo?: any;
 };
 
@@ -27,5 +30,7 @@ export interface AgentlangAuth {
   ): any;
   login(username: string, password: string, env: Environment, cb: LoginCallback): any;
   logout(sessionInfo: SessionInfo, env: Environment, cb?: LogoutCallback): any;
-  verifyToken(token: string, env: Environment): any;
+  verifyToken(token: string, env?: Environment): any;
+  getUser(userId: string, env: Environment): Promise<UserInfo>;
+  getUserByEmail(email: string, env: Environment): Promise<UserInfo>;
 }

package/src/runtime/defs.ts

@@ -31,3 +31,48 @@ export class BadRequestError extends Error {
     super(message ? asUnauthMessage(message) : 'BadRequest', options);
   }
 }
+
+export class UserNotFoundError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message || 'User not found', options);
+  }
+}
+
+export class UserNotConfirmedError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(
+      message || 'User account is not confirmed. Please check your email for verification code.',
+      options
+    );
+  }
+}
+
+export class PasswordResetRequiredError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message || 'Password reset is required for this account', options);
+  }
+}
+
+export class TooManyRequestsError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message || 'Too many requests. Please try again later.', options);
+  }
+}
+
+export class InvalidParameterError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message || 'Invalid parameters provided', options);
+  }
+}
+
+export class ExpiredCodeError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message || 'The verification code has expired. Please request a new one.', options);
+  }
+}
+
+export class CodeMismatchError extends Error {
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message || 'The verification code is incorrect. Please try again.', options);
+  }
+}

package/src/runtime/interpreter.ts

@@ -24,7 +24,6 @@ import {
   SelectIntoSpec,
   SetAttribute,
   Statement,
-  Upsert,
 } from '../language/generated/ast.js';
 import {
   defineAgentEvent,
@@ -33,7 +32,7 @@ import {
   getWorkflow,
   Instance,
   InstanceAttributes,
-  isAgentEvent,
+  isAgentEventInstance,
   isBetweenRelationship,
   isContainsRelationship,
   isEmptyWorkflow,
@@ -62,13 +61,14 @@ import {
   makeFqName,
   Path,
   QuerySuffix,
+  restoreSpecialChars,
   splitFqName,
   splitRefs,
 } from './util.js';
 import { getResolver, getResolverNameForPath } from './resolvers/registry.js';
 import { parseStatement, parseWorkflow } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession, AdminUserId } from './auth/defs.js';
-import { Agent, AgentFqName, findAgentByName } from './modules/ai.js';
+import { AgentInstance, AgentEntityName, AgentFqName, findAgentByName } from './modules/ai.js';
 import { logger } from './logger.js';
 import { ParentAttributeName, PathAttributeName, PathAttributeNameQuery } from './defs.js';
 import {
@@ -602,8 +602,6 @@ async function evaluatePattern(pat: Pattern, env: Environment): Promise<void> {
     await evaluateDelete(pat.delete, env);
   } else if (pat.purge) {
     await evaluatePurge(pat.purge, env);
-  } else if (pat.upsert) {
-    await evaluateUpsert(pat.upsert, env);
   } else if (pat.fullTextSearch) {
     await evaluateFullTextSearch(pat.fullTextSearch, env);
   }
@@ -644,7 +642,7 @@ async function evaluateLiteral(lit: Literal, env: Environment): Promise<void> {
   else if (lit.array != undefined) await realizeArray(lit.array, env);
   else if (lit.map != undefined) await realizeMap(lit.map, env);
   else if (lit.num != undefined) env.setLastResult(lit.num);
-  else if (lit.str != undefined) env.setLastResult(lit.str);
+  else if (lit.str != undefined) env.setLastResult(restoreSpecialChars(lit.str));
   else if (lit.bool != undefined) env.setLastResult(lit.bool == 'true' ? true : false);
 }
 
@@ -694,7 +692,7 @@ async function lookupOneOfVals(fqName: string, env: Environment): Promise<Instan
 
 async function patternToInstance(
   entryName: string,
-  attributes: SetAttribute[],
+  attributes: SetAttribute[] | undefined,
   env: Environment
 ): Promise<Instance> {
   const attrs: InstanceAttributes = newInstanceAttributes();
@@ -704,22 +702,24 @@ async function patternToInstance(
   if (isQueryAll) {
     entryName = entryName.slice(0, entryName.length - 1);
   }
-  for (let i = 0; i < attributes.length; ++i) {
-    const a: SetAttribute = attributes[i];
-    await evaluateExpression(a.value, env);
-    const v: Result = env.getLastResult();
-    let aname: string = a.name;
-    if (aname.endsWith(QuerySuffix)) {
-      if (isQueryAll) {
-        throw new Error(`Cannot specifiy query attribute ${aname} here`);
+  if (attributes) {
+    for (let i = 0; i < attributes.length; ++i) {
+      const a: SetAttribute = attributes[i];
+      await evaluateExpression(a.value, env);
+      const v: Result = env.getLastResult();
+      let aname: string = a.name;
+      if (aname.endsWith(QuerySuffix)) {
+        if (isQueryAll) {
+          throw new Error(`Cannot specifiy query attribute ${aname} here`);
+        }
+        if (qattrs == undefined) qattrs = newInstanceAttributes();
+        if (qattrVals == undefined) qattrVals = newInstanceAttributes();
+        aname = aname.slice(0, aname.length - 1);
+        qattrs.set(aname, a.op == undefined ? '=' : a.op);
+        qattrVals.set(aname, v);
+      } else {
+        attrs.set(aname, v);
       }
-      if (qattrs == undefined) qattrs = newInstanceAttributes();
-      if (qattrVals == undefined) qattrVals = newInstanceAttributes();
-      aname = aname.slice(0, aname.length - 1);
-      qattrs.set(aname, a.op == undefined ? '=' : a.op);
-      qattrVals.set(aname, v);
-    } else {
-      attrs.set(aname, v);
     }
   }
   let moduleName = env.getActiveModuleName();
@@ -761,7 +761,10 @@ async function maybeValidateOneOfRefs(inst: Instance, env: Environment) {
 }
 
 async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
-  const inst: Instance = await patternToInstance(crud.name, crud.attributes, env);
+  if (!env.isInUpsertMode() && crud.upsert) {
+    return await evaluateUpsert(crud, env);
+  }
+  const inst: Instance = await patternToInstance(crud.name, crud.body?.attributes, env);
   const entryName = inst.name;
   const moduleName = inst.moduleName;
   const attrs = inst.attributes;
@@ -802,7 +805,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
         r = await res.createInstance(inst);
         await runPostCreateEvents(inst, env);
       }
-      if (r && entryName == 'agent') {
+      if (r && entryName == AgentEntityName) {
         defineAgentEvent(env.getActiveModuleName(), r.lookup('name'));
       }
       env.setLastResult(r);
@@ -922,7 +925,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
       }
     }
   } else if (isEventInstance(inst)) {
-    if (isAgentEvent(inst)) await handleAgentInvocation(inst, env);
+    if (isAgentEventInstance(inst)) await handleAgentInvocation(inst, env);
     else await evaluate(inst, (result: Result) => env.setLastResult(result), env);
   } else {
     env.setLastResult(inst);
@@ -1029,7 +1032,7 @@ async function walkJoinQueryPattern(
         await walkJoinQueryPattern(crudMap.relationships[i], subJoins, env);
       }
     }
-    const qInst = await patternToInstance(crudMap.name, crudMap.attributes, env);
+    const qInst = await patternToInstance(crudMap.name, crudMap.body?.attributes, env);
     joinsSpec.push({
       relationship: getRelationship(rp.name, qInst.moduleName),
       queryInstance: qInst,
@@ -1042,24 +1045,30 @@ async function walkJoinQueryPattern(
 }
 
 async function handleAgentInvocation(agentEventInst: Instance, env: Environment): Promise<void> {
-  const agent: Agent = await findAgentByName(agentEventInst.name, env);
+  const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
   await agent.invoke(agentEventInst.lookup('message'), env);
   const result: string = env.getLastResult();
   if (agent.isPlanner()) {
     logger.debug(`Agent ${agent.name} generated pattern: ${result}`);
-    if (result.trimStart().startsWith('workflow')) {
-      await parseWorkflow(result); // check for errors
-      return;
-    } else {
-      env.setLastResult(await parseAndEvaluateStatement(result, undefined, env));
+    try {
+      if (result.trimStart().startsWith('workflow')) {
+        await parseWorkflow(result);
+        return;
+      } else {
+        env.setLastResult(await parseAndEvaluateStatement(result, undefined, env));
+      }
+    } catch (err: any) {
+      logger.error(
+        `Failed to evaluate pattern generated by agent ${agent.name} - ${result}, ${err}`
+      );
     }
   }
 }
 
-async function evaluateUpsert(upsert: Upsert, env: Environment): Promise<void> {
+async function evaluateUpsert(crud: CrudMap, env: Environment): Promise<void> {
   env.setInUpsertMode(true);
   try {
-    await evaluateCrudMap(upsert.pattern, env);
+    await evaluateCrudMap(crud, env);
   } finally {
     env.setInUpsertMode(false);
   }

package/src/runtime/loader.ts

@@ -3,8 +3,6 @@ import { createAgentlangServices } from '../language/agentlang-module.js';
 import {
   Import,
   RbacSpecEntries,
-  RbacSpecEntry,
-  RbacOpr,
   ModuleDefinition,
   Definition,
   isEntityDefinition,
@@ -19,6 +17,12 @@ import {
   Statement,
   isStandaloneStatement,
   SchemaDefinition,
+  isAgentDefinition,
+  AgentDefinition,
+  isResolverDefinition,
+  ResolverDefinition,
+  ResolverMethodSpec,
+  AgentPropertyDef,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -36,10 +40,14 @@ import {
   isModule,
   getUserModuleNames,
   removeModule,
+  newInstanceAttributes,
+  addAgent,
 } from './module.js';
 import {
   findRbacSchema,
+  getModuleFn,
   importModule,
+  isString,
   makeFqName,
   maybeExtends,
   registerInitFunction,
@@ -51,10 +59,14 @@ 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 } from '../language/parser.js';
+import { 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 { ConfigSchema } from './state.js';
 
 export async function extractDocument(
   fileName: string,
@@ -231,7 +243,7 @@ export async function loadCoreModules() {
     registerCoreModules();
   }
   for (let i = 0; i < CoreModules.length; ++i) {
-    internModule(await parseModule(CoreModules[i]));
+    await internModule(await parseModule(CoreModules[i]));
   }
 }
 
@@ -248,7 +260,7 @@ async function loadModule(fileName: string, fsOptions?: any, callback?: Function
 
   // Extract the AST node
   const module = await extractAstNode<ModuleDefinition>(fileName, services);
-  const result: Module = internModule(module);
+  const result: Module = await internModule(module);
   console.log(chalk.green(`Module ${chalk.bold(result.name)} loaded`));
   logger.info(`Module ${result.name} loaded`);
   if (callback) {
@@ -295,25 +307,8 @@ function getFsAdapter(fs: any) {
 }
 
 function setRbacForEntity(entity: Entity, rbacSpec: RbacSpecDefinition) {
-  const rbac: RbacSpecification[] = new Array<RbacSpecification>();
-  rbacSpec.specEntries.forEach((specEntries: RbacSpecEntries) => {
-    const rs: RbacSpecification = new RbacSpecification().setResource(
-      makeFqName(entity.moduleName, entity.name)
-    );
-    specEntries.entries.forEach((spec: RbacSpecEntry) => {
-      if (spec.allow) {
-        rs.setPermissions(
-          spec.allow.oprs.map((v: RbacOpr) => {
-            return v.value;
-          })
-        );
-      } else if (spec.role) {
-        rs.setRoles(spec.role.roles);
-      } else if (spec.expr) {
-        rs.setExpression(spec.expr.lhs, spec.expr.rhs);
-      }
-    });
-    rbac.push(rs);
+  const rbac: RbacSpecification[] = rbacSpec.specEntries.map((rs: RbacSpecEntries) => {
+    return RbacSpecification.from(rs).setResource(makeFqName(entity.moduleName, entity.name));
   });
   if (rbac.length > 0) {
     const f = async () => {
@@ -414,13 +409,126 @@ export async function runStandaloneStatements() {
   }
 }
 
-export function addFromDef(def: Definition, moduleName: string) {
+async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
+  let llmName: string | undefined = undefined;
+  const name = def.name;
+  let hasUserLlm = false;
+  const attrsStrs = new Array<string>();
+  attrsStrs.push(`name "${name}"`);
+  const attrs = newInstanceAttributes();
+  def.body?.attributes.forEach((apdef: AgentPropertyDef) => {
+    let v: any = undefined;
+    if (apdef.value.array) {
+      v = apdef.value.array.vals
+        .map((stmt: Statement) => {
+          if (stmt.pattern.literal) {
+            const s = stmt.pattern.literal.str;
+            if (s == undefined) {
+              throw new Error(`Only arrays of string-literals are to be passed to agent ${name}`);
+            }
+            return s;
+          } else {
+            throw new Error(`Invalid value in array passed to agent ${name}`);
+          }
+        })
+        .join(',');
+    } else {
+      v = apdef.value.str || apdef.value.id || apdef.value.num;
+      if (v == undefined) {
+        v = apdef.value.bool;
+      }
+    }
+    if (v == undefined) {
+      throw new Error(`Cannot initialize agent ${name}, only literals can be set for attributes`);
+    }
+    if (llmName == undefined && apdef.name == 'llm') {
+      llmName = v;
+      hasUserLlm = true;
+    }
+    const ov = v;
+    if (apdef.value.str || apdef.value.id || apdef.value.array) {
+      v = `"${v}"`;
+    }
+    attrsStrs.push(`${apdef.name} ${v}`);
+    attrs.set(apdef.name, ov);
+  });
+  if (!attrs.has('llm')) {
+    llmName = `${name}_llm`;
+    attrsStrs.push(`llm "${llmName}"`);
+    if (hasUserLlm) attrs.set('llm', llmName);
+  }
+  const createAgent = `{${CoreAIModuleName}/${AgentEntityName} {
+    ${attrsStrs.join(',')}
+  }, @upsert}`;
+  let wf = createAgent;
+  if (llmName) {
+    wf = `{${CoreAIModuleName}/${LlmEntityName} {name "${llmName}"}, @upsert}; ${wf}`;
+  }
+  (await parseWorkflow(`workflow A {${wf}}`)).statements.forEach((stmt: Statement) => {
+    addStandaloneStatement(stmt, moduleName);
+  });
+  addAgent(def.name, attrs, moduleName);
+}
+
+function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
+  const resolverName = `${moduleName}/${def.name}`;
+  const paths = def.paths;
+  if (paths.length == 0) {
+    logger.warn(`Resolver has no associated paths - ${resolverName}`);
+    return;
+  }
+  registerInitFunction(() => {
+    const methods = new Map<string, Function>();
+    let subsFn: Function | undefined;
+    let subsEvent: string | undefined;
+    def.methods.forEach((spec: ResolverMethodSpec) => {
+      const n = spec.key.name;
+      if (n == 'subscribe') {
+        subsFn = asResolverFn(spec.fn.name);
+      } else if (n == 'onSubscription') {
+        subsEvent = spec.fn.name;
+      } else {
+        methods.set(n, asResolverFn(spec.fn.name));
+      }
+    });
+    const methodsObj = Object.fromEntries(methods.entries()) as GenericResolverMethods;
+    const resolver = new GenericResolver(resolverName, methodsObj);
+    registerResolver(resolverName, () => {
+      return resolver;
+    });
+    paths.forEach((path: string) => {
+      setResolver(path, resolverName);
+    });
+    if (subsFn && subsEvent) {
+      resolver.subs = {
+        subscribe: subsFn,
+        onSubscriptionEvent: subsEvent,
+      };
+      setSubscription(subsEvent, resolverName);
+      resolver.subscribe();
+    }
+  });
+}
+
+function asResolverFn(fname: string): Function {
+  let fn = getModuleFn(fname);
+  if (fn) return fn;
+  fn = eval(fname);
+  if (!(fn instanceof Function)) {
+    throw new Error(`${fname} is not a function`);
+  }
+  return fn as Function;
+}
+
+export async function addFromDef(def: Definition, moduleName: string) {
   if (isEntityDefinition(def)) addSchemaFromDef(def, moduleName);
   else if (isEventDefinition(def)) addSchemaFromDef(def, moduleName);
   else if (isRecordDefinition(def)) addSchemaFromDef(def, moduleName);
   else if (isRelationshipDefinition(def)) addRelationshipFromDef(def, moduleName);
   else if (isWorkflowDefinition(def)) addWorkflowFromDef(def, moduleName);
+  else if (isAgentDefinition(def)) await addAgentDefinition(def, moduleName);
   else if (isStandaloneStatement(def)) addStandaloneStatement(def.stmt, moduleName);
+  else if (isResolverDefinition(def)) addResolverDefinition(def, moduleName);
 }
 
 export async function parseAndIntern(code: string, moduleName?: string) {
@@ -434,17 +542,51 @@ export async function parseAndIntern(code: string, moduleName?: string) {
   if (r.parseResult.parserErrors.length > 0) {
     throw new Error(`Parser errors: ${r.parseResult.parserErrors.join('\n')}`);
   }
-  internModule(r.parseResult.value);
+  await internModule(r.parseResult.value);
 }
 
-export function internModule(module: ModuleDefinition): Module {
+export async function internModule(module: ModuleDefinition): Promise<Module> {
   const mn = module.name;
   const r = addModule(mn);
   module.imports.forEach(async (imp: Import) => {
     await importModule(imp.path, imp.name);
   });
-  module.defs.forEach((def: Definition) => {
-    addFromDef(def, mn);
-  });
+  for (let i = 0; i < module.defs.length; ++i) {
+    const def = module.defs[i];
+    await addFromDef(def, mn);
+  }
   return r;
 }
+
+const JS_PREFIX = '#js';
+
+function preprocessRawConfig(rawConfig: any): any {
+  const keys = Object.keys(rawConfig);
+  keys.forEach((k: any) => {
+    const v = rawConfig[k];
+    if (isString(v) && v.startsWith(JS_PREFIX)) {
+      const s = v.substring(3).trim();
+      rawConfig[k] = eval(s);
+    } else if (typeof v == 'object') {
+      preprocessRawConfig(v);
+    }
+  });
+  return rawConfig;
+}
+
+export async function loadRawConfig(
+  configFileName: string,
+  validate: boolean = true,
+  fsOptions?: any
+): Promise<any> {
+  const fs = await getFileSystem(fsOptions);
+  let rawConfig = preprocessRawConfig(JSON.parse(await fs.readFile(configFileName)));
+  if (validate) {
+    rawConfig = ConfigSchema.parse(rawConfig);
+  }
+  return rawConfig;
+}
+
+export function generateRawConfig(configObj: any): string {
+  return JSON.stringify(configObj);
+}