agentlang 0.0.8 → 0.0.11

package/src/language/parser.ts

@@ -89,6 +89,11 @@ export async function parseStatement(stmt: string): Promise<Statement> {
   }
 }
 
+export async function parseStatements(stmts: string[]): Promise<Statement[]> {
+  const wf = await parseWorkflow(`workflow W {${stmts.join(';\n')}}`);
+  return wf.statements;
+}
+
 export async function parseWorkflow(workflowDef: string): Promise<WorkflowDefinition> {
   const mod = await parseModule(`module Temp ${workflowDef}`);
   if (isWorkflowDefinition(mod.defs[0])) {

package/src/language/syntax.ts

@@ -39,9 +39,9 @@ export class BasePattern {
 
   private aliasesAsString(): string | undefined {
     if (this.alias) {
-      return ` as ${this.alias}`;
+      return ` @as ${this.alias}`;
     } else if (this.aliases) {
-      return ` as [${this.aliases.join(',')}]`;
+      return ` @as [${this.aliases.join(',')}]`;
     } else {
       return undefined;
     }

package/src/runtime/agents/common.ts

@@ -92,24 +92,24 @@ Note the value passed to the 'salary' attribute - it's an arithmetic expression.
 A successful query pattern will return an array of instances. The 'for' pattern can be used to iterate over an array. An example follows:
 
 workflow NotifyEmployees {
-    {Erp/Employee {salary?> 1000}} as employees;
+    {Erp/Employee {salary?> 1000}} @as employees;
     for emp in employees {
         {Erp/SendMail {email emp.email, body "You are selected for an increment!"}}
     }
 }
 
-Also note the use of the 'as' keyword - this binds the result of a pattern to an 'alias'. Here the result of the query is bound to the
+Also note the use of the '@as' keyword - this binds the result of a pattern to an 'alias'. Here the result of the query is bound to the
 alias named 'employees'. Any pattern can have an alias, including 'if' and 'for'. An alias can be used to refer to the attributes of the instance, 
 via the dot(.) notation. Aliases can also be used to destructure a query result - here's an example:
 
 workflow FindFirstTwoEmployees {
-    {Erp/Employee {salary?> 1000}} as [emp1, emp2];
+    {Erp/Employee {salary?> 1000}} @as [emp1, emp2];
     [emp1, emp2]
 }
 
 This alias will bind the first two instances to 'a' and 'b' and the rest of the instances to an array named 'xs':
 
-{SomeEntity {id?> 1}} as [a, b, _, xs]
+{SomeEntity {id?> 1}} @as [a, b, _, xs]
 
 Examples of binding aliases to 'if' and 'for':
 
@@ -117,11 +117,11 @@ if (IncrementSalary.percentage > 10) {
     {Erp/Employee {employeeId IncrementSalary.employeeId, salary salary + salary * IncrementSalary.percentage}}
 } else {
     {Erp/Employee {employeeId IncrementSalary.employeeId, salary salary + 1500}}
-} as emp
+} @as emp
 
 for emp in employees {
     {Erp/SendMail {email emp.email, body "You are selected for an increment!"}}
-} as emails
+} @as emails
 
 Make sure all references based on a preceding pattern is based either on an actual alias or the name of the workflow. For example, the following sequence of patterns
 are invalid, because the alias 'employee' is not defined:
@@ -131,7 +131,7 @@ 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"}}
 
 Entities in a module can be connected together in relationships. There are two types of relationships - 'contains' and 'between'.
@@ -198,7 +198,7 @@ fill-in values from the available context. For example, if your instruction is "
 'please call me as soon as possible'", the best workflow to return is:
 
 workflow sendEmail {
-    {employee {id? 101}} as emp;
+    {employee {id? 101}} @as emp;
     {email {to emp.email body "please call me as soon as possible"}}
 }
 
@@ -206,7 +206,7 @@ because all the information needed is available in the context. If the instructi
 'please call me as soon as possible'", then you can return:
 
 workflow sendEmail {
-    {employee {id? sendEmail.employeeId}} as emp;
+    {employee {id? sendEmail.employeeId}} @as emp;
     {email {to emp.email body "please call me as soon as possible"}}
 }
 
@@ -215,7 +215,7 @@ The point is use the immediate context to fill-in values in generated patterns,
 Also generate a workflow only if required explicitly by the user or the contextual information is incomplete. Otherwise, just return an array of patterns.
 As an example, if the user request is "send an email to employee 101 with this message - 'please call me as soon as possible'", you must return:
 
-[{employee {id? 101}} as emp;
+[{employee {id? 101}} @as emp;
  {email {to emp.email, body "please call me as soon as possible"}}]
 
 Note that each pattern in the array is separated by a ; and not a comma(,).

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;
 
@@ -111,6 +114,7 @@ export class Environment extends Instance {
   private activeUser: string = AdminUserId;
   private activeUserSet: boolean = false;
   private lastResult: Result;
+  private returnFlag: boolean = false;
   private parentPath: string | undefined;
   private normalizedParentPath: string | undefined;
   private betweenRelInfo: BetweenRelInfo | undefined;
@@ -119,6 +123,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 +144,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 +158,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) {
@@ -173,6 +223,17 @@ export class Environment extends Instance {
     return this;
   }
 
+  static SuspensionUserData = '^';
+
+  bindSuspensionUserData(userData: string): Environment {
+    this.bind(Environment.SuspensionUserData, userData);
+    return this;
+  }
+
+  lookupSuspensionUserData(): string | undefined {
+    return this.lookup(Environment.SuspensionUserData);
+  }
+
   maybeLookupAgentInstance(entryName: string): Instance | undefined {
     const v = this.lookup(entryName);
     if (v && isInstanceOfType(v, AgentFqName)) {
@@ -200,6 +261,47 @@ 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;
+    }
+  }
+
+  markForReturn(): Environment {
+    if (this.parent) {
+      this.parent.markForReturn();
+    }
+    this.returnFlag = true;
+    return this;
+  }
+
+  isMarkedForReturn(): boolean {
+    return this.returnFlag;
+  }
+
+  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 +387,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 +395,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 +495,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 +524,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 +537,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 +593,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 +608,22 @@ 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;
+      }
+    } else if (env.isMarkedForReturn()) {
+      break;
+    }
   }
   if (continuation != undefined) {
     continuation(env.getLastResult());
@@ -482,10 +633,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 +661,10 @@ async function evaluateStatement(stmt: Statement, env: Environment): Promise<voi
     } else {
       throw reason;
     }
+  } finally {
+    if (handlersPushed && env.hasHandlers()) {
+      env.popHandlers();
+    }
   }
 }
 
@@ -604,6 +761,9 @@ async function evaluatePattern(pat: Pattern, env: Environment): Promise<void> {
     await evaluatePurge(pat.purge, env);
   } else if (pat.fullTextSearch) {
     await evaluateFullTextSearch(pat.fullTextSearch, env);
+  } else if (pat.return) {
+    await evaluatePattern(pat.return.pat, env);
+    env.markForReturn();
   }
 }
 
@@ -652,7 +812,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 +1544,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('.')) && moduleFileName) {
+    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

@@ -45,6 +45,7 @@ import {
   addAgent,
 } from './module.js';
 import {
+  escapeSpecialChars,
   findRbacSchema,
   isString,
   makeFqName,
@@ -64,7 +65,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 +259,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) {
@@ -446,8 +447,10 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
       hasUserLlm = true;
     }
     const ov = v;
-    if (apdef.value.str || apdef.value.id || apdef.value.array) {
+    if (apdef.value.id || apdef.value.array) {
       v = `"${v}"`;
+    } else if (apdef.value.str) {
+      v = `"${escapeSpecialChars(v)}"`;
     }
     attrsStrs.push(`${apdef.name} ${v}`);
     attrs.set(apdef.name, ov);
@@ -544,12 +547,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
 }
 
@@ -42,7 +43,7 @@ entity agentChatSession {
 }
 
 workflow findAgentChatSession {
-  {agentChatSession {id? findAgentChatSession.id}} as [sess];
+  {agentChatSession {id? findAgentChatSession.id}} @as [sess];
   sess
 }
 
@@ -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)) {