agentlang 0.0.8 → 0.0.10

package/src/runtime/interpreter.ts

@@ -74,6 +74,7 @@ import {
   addCreateAudit,
   addDeleteAudit,
   addUpdateAudit,
+  createSuspension,
   maybeCancelTimer,
   setTimerRunning,
 } from './modules/core.js';
@@ -103,6 +104,8 @@ function mkEnvName(name: string | undefined, parent: Environment | undefined): s
   }
 }
 
+type CatchHandlers = Map<string, Statement>;
+
 export class Environment extends Instance {
   parent: Environment | undefined;
 
@@ -119,6 +122,8 @@ export class Environment extends Instance {
   private inUpsertMode: boolean = false;
   private inDeleteMode: boolean = false;
   private inKernelMode: boolean = false;
+  private suspensionId: string | undefined;
+  private activeCatchHandlers: Array<CatchHandlers>;
 
   constructor(name?: string, parent?: Environment) {
     super(
@@ -138,10 +143,13 @@ export class Environment extends Instance {
       this.activeResolvers = parent.activeResolvers;
       this.inUpsertMode = parent.inUpsertMode;
       this.inKernelMode = parent.inKernelMode;
+      this.activeCatchHandlers = parent.activeCatchHandlers;
+      this.suspensionId = parent.suspensionId;
     } else {
       this.activeModule = DefaultModuleName;
       this.activeResolvers = new Map<string, Resolver>();
       this.activeTransactions = new Map<string, string>();
+      this.activeCatchHandlers = new Array<CatchHandlers>();
     }
   }
 
@@ -149,6 +157,47 @@ export class Environment extends Instance {
     return new Environment(undefined, parent);
   }
 
+  static fromInstance(inst: Instance): Environment {
+    const env = new Environment();
+    env.attributes = inst.attributes;
+    return env;
+  }
+
+  override asSerializableObject(): object {
+    const obj: any = super.asSerializableObject();
+    obj.activeModule = this.activeModule;
+    if (this.activeEventInstance) {
+      obj.activeEventInstance = this.activeEventInstance.asSerializableObject();
+    }
+    obj.activeUser = this.activeUser;
+    obj.activeUserSet = this.activeUserSet;
+    obj.inUpsertMode = this.inUpsertMode;
+    obj.inDeleteMode = this.inDeleteMode;
+    obj.inKernelMode = this.inKernelMode;
+    if (this.parent) {
+      obj.parent = this.parent.asSerializableObject();
+    }
+    return obj;
+  }
+
+  static override FromSerializableObject(obj: any): Environment {
+    const inst = Instance.FromSerializableObject(obj, PlaceholderRecordEntry);
+    const env = Environment.fromInstance(inst);
+    env.activeModule = obj.activeModule;
+    if (obj.activeEventInstance) {
+      env.activeEventInstance = Instance.FromSerializableObject(obj.activeEventInstance);
+    }
+    env.activeUser = obj.activeUser;
+    env.activeUserSet = obj.activeUserSet;
+    env.inUpsertMode = obj.inUpsertMode;
+    env.inDeleteMode = obj.inDeleteMode;
+    env.inKernelMode = obj.inKernelMode;
+    if (obj.parent) {
+      env.parent = Environment.FromSerializableObject(obj.parent);
+    }
+    return env;
+  }
+
   override lookup(k: string): Result {
     const v = this.attributes.get(k);
     if (v == undefined) {
@@ -200,6 +249,35 @@ export class Environment extends Instance {
     return this.activeEventInstance;
   }
 
+  isSuspended(): boolean {
+    return this.suspensionId != undefined;
+  }
+
+  suspend(): string {
+    if (this.suspensionId == undefined) {
+      const id = crypto.randomUUID();
+      this.propagateSuspension(id);
+      return id;
+    } else {
+      return this.suspensionId;
+    }
+  }
+
+  protected propagateSuspension(suspId: string) {
+    this.suspensionId = suspId;
+    if (this.parent) {
+      this.parent.propagateSuspension(suspId);
+    }
+  }
+
+  getSuspensionId(): string {
+    if (this.suspensionId) {
+      return this.suspensionId;
+    } else {
+      throw new Error('SuspensionId is not set');
+    }
+  }
+
   getActiveAuthContext(): ActiveSessionInfo | undefined {
     if (this.activeEventInstance) {
       return this.activeEventInstance.getAuthContext();
@@ -285,7 +363,7 @@ export class Environment extends Instance {
   getResolver(resolverName: string): Resolver | undefined {
     const r: Resolver | undefined = this.getActiveResolvers().get(resolverName);
     if (r) {
-      return r.setUserData(this);
+      return r.setEnvironment(this);
     }
     return undefined;
   }
@@ -293,7 +371,7 @@ export class Environment extends Instance {
   async addResolver(resolver: Resolver): Promise<Environment> {
     this.getActiveResolvers().set(resolver.getName(), resolver);
     await this.ensureTransactionForResolver(resolver);
-    resolver.setUserData(this);
+    resolver.setEnvironment(this);
     return this;
   }
 
@@ -393,6 +471,26 @@ export class Environment extends Instance {
   isInKernelMode(): boolean {
     return this.inKernelMode;
   }
+
+  pushHandlers(handlers: CatchHandlers): boolean {
+    if (handlers.has('error')) {
+      this.activeCatchHandlers.push(handlers);
+      return true;
+    }
+    return false;
+  }
+
+  hasHandlers(): boolean {
+    return this.activeCatchHandlers.length > 0;
+  }
+
+  popHandlers(): CatchHandlers {
+    const r = this.activeCatchHandlers.pop();
+    if (r == undefined) {
+      throw new Error(`No more handlers to pop`);
+    }
+    return r;
+  }
 }
 
 export const GlobalEnvironment = new Environment();
@@ -402,7 +500,7 @@ export async function evaluate(
   continuation?: Function,
   activeEnv?: Environment,
   kernelCall?: boolean
-): Promise<void> {
+): Promise<Result> {
   let env: Environment | undefined;
   let txnRolledBack: boolean = false;
   try {
@@ -415,17 +513,22 @@ export async function evaluate(
           env.setInKernelMode(true);
         }
         await evaluateStatements(wf.statements, env, continuation);
+        return env.getLastResult();
       }
     } else {
       throw new Error('Not an event - ' + eventInstance.name);
     }
   } catch (err) {
-    if (env != undefined && activeEnv == undefined) {
-      await env.rollbackAllTransactions().then(() => {
-        txnRolledBack = true;
-      });
+    if (env && env.hasHandlers()) {
+      throw err;
+    } else {
+      if (env != undefined && activeEnv == undefined) {
+        await env.rollbackAllTransactions().then(() => {
+          txnRolledBack = true;
+        });
+      }
+      throw err;
     }
-    throw err;
   } finally {
     if (!txnRolledBack && env != undefined && activeEnv == undefined) {
       await env.commitAllTransactions();
@@ -466,6 +569,14 @@ 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}`);
+  }
+}
+
 export async function evaluateStatements(
   stmts: Statement[],
   env: Environment,
@@ -473,6 +584,20 @@ export async function evaluateStatements(
 ) {
   for (let i = 0; i < stmts.length; ++i) {
     await evaluateStatement(stmts[i], env);
+    if (env.isSuspended()) {
+      const cont = stmts.slice(i + 1, stmts.length);
+      if (cont.length > 0) {
+        const suspId = await createSuspension(
+          env.getSuspensionId(),
+          cont.map((stmt: Statement) => {
+            return statemtentString(stmt);
+          }),
+          env
+        );
+        env.setLastResult({ suspension: suspId || 'null' });
+        break;
+      }
+    }
   }
   if (continuation != undefined) {
     continuation(env.getLastResult());
@@ -482,10 +607,12 @@ export async function evaluateStatements(
 async function evaluateStatement(stmt: Statement, env: Environment): Promise<void> {
   const hints = stmt.hints;
   const hasHints = hints && hints.length > 0;
-  const handlers: Map<string, Statement> | undefined = hasHints
-    ? maybeFindHandlers(hints)
-    : undefined;
+  const handlers: CatchHandlers | undefined = hasHints ? maybeFindHandlers(hints) : undefined;
+  let handlersPushed = false;
   try {
+    if (handlers) {
+      handlersPushed = env.pushHandlers(handlers);
+    }
     await evaluatePattern(stmt.pattern, env);
     if (hasHints) {
       maybeBindStatementResultToAlias(hints, env);
@@ -508,6 +635,10 @@ async function evaluateStatement(stmt: Statement, env: Environment): Promise<voi
     } else {
       throw reason;
     }
+  } finally {
+    if (handlersPushed && env.hasHandlers()) {
+      env.popHandlers();
+    }
   }
 }
 
@@ -652,7 +783,7 @@ function getMapKey(k: MapKey): Result {
   else if (k.bool != undefined) k.bool == 'true' ? true : false;
 }
 
-const DefaultResolverName: string = '--default-resolver--';
+const DefaultResolverName: string = '-';
 
 async function getResolverForPath(
   entryName: string,
@@ -1384,7 +1515,11 @@ async function runPrePostEvents(
       logger.debug(`${prefix}: ${value}`);
     };
     const catchHandler = (reason: any) => {
-      logger.error(`${prefix}: ${reason}`);
+      if (env.hasHandlers()) {
+        throw reason;
+      } else {
+        logger.error(`${prefix}: ${reason}`);
+      }
     };
     if (trigInfo.async) {
       evaluate(eventInst, callback).catch(catchHandler);

package/src/runtime/jsmodules.ts

@@ -1,3 +1,4 @@
+import { dirname, sep } from 'path';
 import { logger } from './logger.js';
 import { setSubscription } from './resolvers/registry.js';
 import { now, splitRefs } from './util.js';
@@ -5,12 +6,19 @@ import { now, splitRefs } from './util.js';
 const importedModules = new Map<string, any>();
 
 // Usage: importModule("./mymodels/acme.js")
-export async function importModule(path: string, name: string) {
+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 (!(path.startsWith('/') || path.startsWith('.'))) {
-    path = process.cwd() + '/' + path;
+  if (moduleFileName) {
+    let s: string = dirname(moduleFileName);
+    if (s.startsWith('./')) {
+      s = s.substring(2);
+    }
+    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);
@@ -26,7 +34,7 @@ export function moduleImported(moduleName: string): boolean {
 
 const ReservedImports = new Set<string>(['resolvers']);
 
-export function valiadteImportName(n: string) {
+export function validateImportName(n: string) {
   if (ReservedImports.has(n)) {
     throw new Error(`${n} is an import reserved by the runtime`);
   }

package/src/runtime/loader.ts

@@ -64,7 +64,7 @@ import { AgentEntityName, CoreAIModuleName, LlmEntityName } from './modules/ai.j
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
 import { registerResolver, setResolver, setSubscription } from './resolvers/registry.js';
 import { ConfigSchema } from './state.js';
-import { getModuleFn, importModule, valiadteImportName } from './jsmodules.js';
+import { getModuleFn, importModule, validateImportName } from './jsmodules.js';
 
 export async function extractDocument(
   fileName: string,
@@ -258,7 +258,7 @@ async function loadModule(fileName: string, fsOptions?: any, callback?: Function
 
   // Extract the AST node
   const module = await extractAstNode<ModuleDefinition>(fileName, services);
-  const result: Module = await internModule(module);
+  const result: Module = await internModule(module, fileName);
   console.log(chalk.green(`Module ${chalk.bold(result.name)} loaded`));
   logger.info(`Module ${result.name} loaded`);
   if (callback) {
@@ -544,12 +544,15 @@ export async function parseAndIntern(code: string, moduleName?: string) {
   await internModule(r.parseResult.value);
 }
 
-export async function internModule(module: ModuleDefinition): Promise<Module> {
+export async function internModule(
+  module: ModuleDefinition,
+  moduleFileName?: string
+): Promise<Module> {
   const mn = module.name;
   const r = addModule(mn);
   module.imports.forEach(async (imp: Import) => {
-    valiadteImportName(imp.name);
-    await importModule(imp.path, imp.name);
+    validateImportName(imp.name);
+    await importModule(imp.path, imp.name, moduleFileName);
   });
   for (let i = 0; i < module.defs.length; ++i) {
     const def = module.defs[i];

package/src/runtime/module.ts

@@ -469,6 +469,11 @@ export class Record extends ModuleEntry {
       });
       scms = `${scms},\n    @rbac [${rbs.join(',\n')}]`;
     }
+    if (this.meta && this.meta.size > 0) {
+      const metaObj = Object.fromEntries(this.meta);
+      const ms = `@meta ${JSON.stringify(metaObj)}`;
+      scms = `${scms},\n    ${ms}`;
+    }
     return s.concat('\n{', scms, '\n}\n');
   }
 
@@ -2189,21 +2194,66 @@ export class Instance {
     return this.lookup(PathAttributeName);
   }
 
+  asSerializableObject(): object {
+    const obj = {
+      AL_INSTANCE: true,
+      name: this.name,
+      moduleName: this.moduleName,
+      attributes: this.attributesAsObject(true),
+      queryAttributes: this.queryAttributesAsObject(),
+      queryAttributeValues: this.queryAttributeValuesAsObject(),
+    };
+    return obj;
+  }
+
+  static FromSerializableObject(obj: any, record?: Record): Instance {
+    if (obj.AL_INSTANCE == true) {
+      const m = fetchModule(obj.moduleName);
+      return new Instance(
+        record || (m.getEntry(obj.name) as Record),
+        obj.moduleName,
+        obj.name,
+        new Map(Object.entries(obj.attributes)),
+        new Map(Object.entries(obj.queryAttributes)),
+        new Map(Object.entries(obj.queryAttributeValues))
+      );
+    } else {
+      throw new Error(`Cannot deserialize ${JSON.stringify(obj)} to an Instance`);
+    }
+  }
+
   asObject(): object {
     const result: Map<string, object> = new Map<string, object>();
-    result.set(this.name, Object.fromEntries(this.attributes));
+    result.set(this.name, this.attributesAsObject());
     return Object.fromEntries(result);
   }
 
-  attributesAsObject(stringifyObjects: boolean = true): object {
-    if (stringifyObjects) {
-      this.attributes.forEach((v: any, k: string) => {
-        if (v instanceof Object) {
-          this.attributes.set(k, JSON.stringify(v instanceof Map ? Object.fromEntries(v) : v));
-        }
-      });
-    }
-    return Object.fromEntries(this.attributes);
+  attributesAsObject(forSerialization: boolean = false): object {
+    const attrs = newInstanceAttributes();
+    this.attributes.forEach((v: any, k: string) => {
+      if (v instanceof Instance) {
+        const inst = v as Instance;
+        attrs.set(k, forSerialization ? inst.asSerializableObject() : inst.asObject());
+      } else if (v instanceof Object) {
+        const obj = v instanceof Map ? Object.fromEntries(v) : v;
+        attrs.set(k, obj);
+      } else {
+        attrs.set(k, v);
+      }
+    });
+    return Object.fromEntries(attrs);
+  }
+
+  attributesWithStringifiedObjects(): object {
+    const attrs = newInstanceAttributes();
+    this.attributes.forEach((v: any, k: string) => {
+      if (v instanceof Object) {
+        attrs.set(k, JSON.stringify(v instanceof Map ? Object.fromEntries(v) : v));
+      } else {
+        attrs.set(k, v);
+      }
+    });
+    return Object.fromEntries(attrs);
   }
 
   queryAttributesAsObject(): object {
@@ -2414,7 +2464,7 @@ export function makeInstance(
         throw new Error(`Invalid attribute ${key} specified for ${moduleName}/${entryName}`);
       }
       const spec: AttributeSpec = getAttributeSpec(schema, key);
-      validateType(key, value, spec);
+      if (value != null && value != undefined) validateType(key, value, spec);
     });
   }
   if (!queryAttributes && !queryAll) {

package/src/runtime/modules/ai.ts

@@ -31,8 +31,9 @@ entity ${AgentEntityName} {
     type @enum("chat", "planner") @default("chat"),
     runWorkflows Boolean @default(true),
     instruction String @optional,
-    tools String @optional, // comma-separated values
-    documents String @optional, // comma-separated values
+    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
     llm String
 }
 
@@ -69,6 +70,7 @@ export class AgentInstance {
   type: string = 'chat';
   tools: string | undefined;
   documents: string | undefined;
+  channels: string | undefined;
   runWorkflows: boolean = true;
 
   private constructor() {}
@@ -150,10 +152,19 @@ export class AgentInstance {
   }
 
   private toolsAsString(): string {
-    if (this.tools) {
+    let finalTools: string | undefined = undefined;
+    if (this.tools) finalTools = this.tools;
+    if (this.channels) {
+      if (finalTools) {
+        finalTools = `${finalTools},${this.channels}`;
+      } else {
+        finalTools = this.channels;
+      }
+    }
+    if (finalTools) {
       const tooldefs = new Array<string>();
       const slimModules = new Map<string, string[]>();
-      this.tools.split(',').forEach((n: string) => {
+      finalTools.split(',').forEach((n: string) => {
         let moduleName: string | undefined;
         let entryName: string | undefined;
         if (isFqName(n)) {

package/src/runtime/modules/core.ts

@@ -1,11 +1,21 @@
 import { default as ai } from './ai.js';
 import { default as auth } from './auth.js';
 import { DefaultModuleName, DefaultModules } from '../util.js';
-import { Instance, isInstanceOfType } from '../module.js';
-import { Environment, parseAndEvaluateStatement } from '../interpreter.js';
+import { Instance, isInstanceOfType, makeInstance, newInstanceAttributes } from '../module.js';
+import {
+  Environment,
+  evaluate,
+  evaluateStatements,
+  parseAndEvaluateStatement,
+} from '../interpreter.js';
 import { logger } from '../logger.js';
+import { Statement } from '../../language/generated/ast.js';
+import { parseStatements } from '../../language/parser.js';
 
 const CoreModuleDefinition = `module ${DefaultModuleName}
+
+import "./modules/core.js" as Core
+
 entity timer {
   name String @id,
   duration Int,
@@ -23,6 +33,26 @@ entity auditlog {
   user String,
   token String @optional
 }
+
+entity suspension {
+  id UUID @id,
+  continuation String[], // rest of the patterns to execute
+  env Any, // serialized environment-object
+  createdOn DateTime @default(now()),
+  createdBy String
+}
+
+workflow createSuspension {
+  {suspension 
+    {id createSuspension.id
+     continuation createSuspension.continuation,
+     env createSuspension.env,
+     createdBy createSuspension.createdBy}}
+}
+
+workflow restartSuspension {
+  await Core.restartSuspension(restartSuspension.id)
+}
 `;
 export const CoreModules: string[] = [];
 
@@ -95,3 +125,80 @@ export async function addUpdateAudit(
 ) {
   await addAudit(env, 'u', resource, previous_value);
 }
+
+export async function createSuspension(
+  suspId: string,
+  continuation: string[],
+  env: Environment
+): Promise<string | undefined> {
+  const user = env.getActiveUser();
+  const newEnv = new Environment('susp', env).setInKernelMode(true);
+  const envObj = env.asSerializableObject();
+  const inst = makeInstance(
+    'agentlang',
+    'createSuspension',
+    newInstanceAttributes()
+      .set('id', suspId)
+      .set('continuation', continuation)
+      .set('env', envObj)
+      .set('createdBy', user)
+  );
+  const r: any = await evaluate(inst, undefined, newEnv);
+  if (!isInstanceOfType(r, 'agentlang/suspension')) {
+    logger.warn(`Failed to create suspension for user ${user}`);
+    return undefined;
+  }
+  return (r as Instance).lookup('id');
+}
+
+export type Suspension = {
+  continuation: Statement[];
+  env: Environment;
+};
+
+async function loadSuspension(suspId: string, env?: Environment): Promise<Suspension | undefined> {
+  const newEnv = new Environment('auditlog', env).setInKernelMode(true);
+  const r: any = await parseAndEvaluateStatement(
+    `{agentlang/suspension {id? "${suspId}"}}`,
+    undefined,
+    newEnv
+  );
+  if (r instanceof Array && r.length > 0) {
+    const inst: Instance = r[0];
+    const cont = inst.lookup('continuation');
+    const stmts: Statement[] = await parseStatements(cont);
+    const envStr = inst.lookup('env');
+    const suspEnv: Environment = Environment.FromSerializableObject(JSON.parse(envStr));
+    return {
+      continuation: stmts,
+      env: suspEnv,
+    };
+  }
+  return undefined;
+}
+
+async function deleteSuspension(suspId: string, env?: Environment): Promise<any> {
+  try {
+    await parseAndEvaluateStatement(
+      `purge {agentlang/suspension {id? "${suspId}"}}`,
+      undefined,
+      env
+    );
+    return suspId;
+  } catch (err: any) {
+    logger.warn(`Failed to delete suspension ${suspId} - ${err}`);
+    return undefined;
+  }
+}
+
+export async function restartSuspension(suspId: string, env?: Environment): Promise<any> {
+  const susp = await loadSuspension(suspId, env);
+  if (susp) {
+    await evaluateStatements(susp.continuation, susp.env);
+    await deleteSuspension(suspId, env);
+    return susp.env.getLastResult();
+  } else {
+    logger.warn(`Suspension ${suspId} not found`);
+    return undefined;
+  }
+}

package/src/runtime/resolvers/interface.ts

@@ -1,4 +1,4 @@
-import { evaluate } from '../interpreter.js';
+import { Environment, evaluate } from '../interpreter.js';
 import { logger } from '../logger.js';
 import {
   Instance,
@@ -45,7 +45,7 @@ export function getSubscriptionEvent(resolverName: string): string | undefined {
 
 export class Resolver {
   protected authInfo: ResolverAuthInfo = DefaultAuthInfo;
-  protected userData: any;
+  protected env: Environment | undefined;
   protected name: string = 'default';
 
   static Default = new Resolver();
@@ -59,13 +59,13 @@ export class Resolver {
     return this;
   }
 
-  public setUserData(userData: any): Resolver {
-    this.userData = userData;
+  public setEnvironment(env: Environment): Resolver {
+    this.env = env;
     return this;
   }
 
-  public getUserData(): any {
-    return this.userData;
+  public getEnvironment(): Environment | undefined {
+    return this.env;
   }
 
   public getName(): string {

package/src/runtime/resolvers/sqldb/impl.ts

@@ -65,7 +65,7 @@ export class SqlDbResolver extends Resolver {
   }
 
   private getDbContext(resourceFqName: string): DbContext {
-    const activeEnv: Environment = this.getUserData() as Environment;
+    const activeEnv: Environment = this.getEnvironment() as Environment;
     if (!activeEnv) {
       throw new Error('Active environment context is required by SqlDbResolver');
     }
@@ -104,7 +104,7 @@ export class SqlDbResolver extends Resolver {
         attrs.set(PathAttributeName, p);
       }
       const n: string = asTableName(inst.moduleName, inst.name);
-      const rowObj: object = inst.attributesAsObject();
+      const rowObj: object = inst.attributesWithStringifiedObjects();
       const ctx = this.getDbContext(inst.getFqName());
       await insertRow(n, rowObj, ctx, orUpdate);
       if (inst.record.getFullTextSearchAttributes()) {