agentlang 0.0.67 → 0.1.0

package/src/runtime/module.ts

@@ -1393,8 +1393,21 @@ export class Flow extends ModuleEntry {
     return result;
   }
 
+  static asFlowName(n: string): string {
+    return `${n}.flow`;
+  }
+
+  static normaliseFlowName(n: string): string {
+    const i = n.lastIndexOf('.flow');
+    if (i > 0) {
+      return n.substring(0, i);
+    } else {
+      return n;
+    }
+  }
+
   override toString(): string {
-    return `flow ${this.name} {
+    return `flow ${Flow.normaliseFlowName(this.name)} {
       ${this.getFlow()}
     }`;
   }
@@ -1491,16 +1504,18 @@ export class Module {
   }
 
   addFlow(name: string, flowString?: string): Flow {
-    const flow: Flow = new Flow(name, this.name, flowString);
+    const flow: Flow = new Flow(Flow.asFlowName(name), this.name, flowString);
     this.addEntry(flow);
     return flow;
   }
 
   getFlow(name: string): Flow | undefined {
-    if (this.hasEntry(name)) {
-      return this.getEntry(name) as Flow;
+    const n = Flow.asFlowName(name);
+    if (this.hasEntry(n)) {
+      return this.getEntry(n) as Flow;
+    } else {
+      return undefined;
     }
-    return undefined;
   }
 
   getAllFlows(): Flow[] {
@@ -1511,7 +1526,7 @@ export class Module {
 
   removeFlow(name: string): boolean {
     if (this.getFlow(name)) {
-      return this.removeEntry(name);
+      return this.removeEntry(Flow.asFlowName(name));
     }
     return false;
   }
@@ -2231,12 +2246,21 @@ function getEntityDef(entityName: string, moduleName: string): Entity | undefine
 }
 
 export function getWorkflow(eventInstance: Instance): Workflow {
-  const eventName: string = eventInstance.name;
-  const moduleName: string = eventInstance.moduleName;
-  const wfName: string = asWorkflowName(eventName);
-  const module: Module = fetchModule(moduleName);
-  if (module.hasEntry(wfName)) {
-    return module.getEntry(wfName) as Workflow;
+  return getWorkflowForEvent(eventInstance.name, eventInstance.moduleName);
+}
+
+export function getWorkflowForEvent(eventName: string, moduleName?: string): Workflow {
+  if (isFqName(eventName)) {
+    const parts = splitFqName(eventName);
+    eventName = parts.getEntryName();
+    moduleName = parts.getModuleName();
+  }
+  if (moduleName) {
+    const wfName: string = asWorkflowName(eventName);
+    const module: Module = fetchModule(moduleName);
+    if (module.hasEntry(wfName)) {
+      return module.getEntry(wfName) as Workflow;
+    }
   }
   return EmptyWorkflow;
 }

package/src/runtime/modules/ai.ts

@@ -22,9 +22,10 @@ import {
   systemMessage,
 } from '../agents/provider.js';
 import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { FlowExecInstructions, FlowStep, PlannerInstructions } from '../agents/common.js';
+import { FlowExecInstructions, PlannerInstructions } from '../agents/common.js';
 import { PathAttributeNameQuery } from '../defs.js';
 import { logger } from '../logger.js';
+import { FlowStep } from '../agents/flows.js';
 
 export const CoreAIModuleName = makeCoreModuleName('ai');
 export const AgentEntityName = 'Agent';
@@ -47,7 +48,6 @@ 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
     role String @optional,
     flows String @optional,
     llm String
@@ -83,6 +83,52 @@ export const AgentFqName = makeFqName(CoreAIModuleName, AgentEntityName);
 
 const ProviderDb = new Map<string, AgentServiceProvider>();
 
+export type AgentCondition = {
+  cond: string;
+  then: string;
+};
+
+const AgentDirectives = new Map<string, AgentCondition[]>();
+
+export function registerAgentDirectives(
+  moduleName: string,
+  agentName: string,
+  conds: AgentCondition[]
+) {
+  AgentDirectives.set(makeFqName(moduleName, agentName), conds);
+}
+
+export type AgentScenario = {
+  user: string;
+  ai: string;
+};
+
+const AgentScenarios = new Map<string, AgentScenario[]>();
+
+export function registerAgentScenarios(
+  moduleName: string,
+  agentName: string,
+  scenarios: AgentScenario[]
+) {
+  AgentScenarios.set(makeFqName(moduleName, agentName), scenarios);
+}
+
+export type AgentGlossaryEntry = {
+  name: string;
+  meaning: string;
+  synonyms: string | undefined;
+};
+
+const AgentGlossary = new Map<string, AgentGlossaryEntry[]>();
+
+export function registerAgentGlossary(
+  moduleName: string,
+  agentName: string,
+  glossary: AgentGlossaryEntry[]
+) {
+  AgentGlossary.set(makeFqName(moduleName, agentName), glossary);
+}
+
 export class AgentInstance {
   llm: string = '';
   name: string = '';
@@ -94,7 +140,6 @@ export class AgentInstance {
   documents: string | undefined;
   channels: string | undefined;
   runWorkflows: boolean = true;
-  output: string | undefined;
   role: string | undefined;
   flows: string | undefined;
   private toolsArray: string[] | undefined = undefined;
@@ -175,6 +220,56 @@ export class AgentInstance {
     return this.type == 'flow-exec';
   }
 
+  private directivesAsString(fqName: string): string {
+    const conds = AgentDirectives.get(fqName);
+    if (conds) {
+      const ss = new Array<string>();
+      ss.push(
+        '\nUse the following guidelines to take more accurate decisions in relevant scenarios.\n'
+      );
+      conds.forEach((ac: AgentCondition) => {
+        ss.push(`if ${ac.cond}, then ${ac.then}`);
+      });
+      return `${ss.join('\n')}\n`;
+    }
+    return '';
+  }
+
+  private cachedInstruction: string | undefined = undefined;
+
+  private getFullInstructions(): string {
+    if (this.cachedInstruction) {
+      return this.cachedInstruction;
+    }
+    const fqName = makeFqName(this.moduleName, this.name);
+    this.cachedInstruction = `${this.instruction || ''} ${this.directivesAsString(fqName)}`;
+    const gls = AgentGlossary.get(fqName);
+    if (gls) {
+      const glss = new Array<string>();
+      gls.forEach((age: AgentGlossaryEntry) => {
+        glss.push(
+          `${age.name}: ${age.meaning}. ${age.synonyms ? `These words are synonyms for ${age.name}: ${age.synonyms}` : ''}`
+        );
+      });
+      this.cachedInstruction = `${this.cachedInstruction}\nThe following glossary will be helpful for understanding user requests.
+      ${glss.join('\n')}\n`;
+    }
+    const scenarios = AgentScenarios.get(fqName);
+    if (scenarios) {
+      const scs = new Array<string>();
+      scenarios.forEach((sc: AgentScenario) => {
+        scs.push(`User: ${sc.user}\nAI: ${sc.ai}\n`);
+      });
+      this.cachedInstruction = `${this.cachedInstruction}\nHere are some example user requests and the corresponding responses you are supposed to produce:\n${scs.join('\n')}`;
+    }
+    return this.cachedInstruction;
+  }
+
+  markAsFlowExecutor(): AgentInstance {
+    this.type = 'flow-exec';
+    return this;
+  }
+
   async invoke(message: string, env: Environment) {
     const p = await findProviderForLLM(this.llm, env);
     const agentName = this.name;
@@ -192,14 +287,16 @@ export class AgentInstance {
     if (sess) {
       msgs = sess.lookup('messages');
     } else {
-      msgs = [systemMessage(this.instruction || '')];
+      msgs = [systemMessage(this.getFullInstructions() || '')];
     }
     if (msgs) {
       try {
         const sysMsg = msgs[0];
         if (isplnr || isflow) {
           const s = isplnr ? PlannerInstructions : FlowExecInstructions;
-          const newSysMsg = systemMessage(`${s}\n${this.toolsAsString()}\n${this.instruction}`);
+          const newSysMsg = systemMessage(
+            `${s}\n${this.toolsAsString()}\n${this.getFullInstructions()}`
+          );
           msgs[0] = newSysMsg;
         }
         msgs.push(humanMessage(await this.maybeAddRelevantDocuments(message, env)));

package/src/runtime/resolvers/interface.ts

@@ -57,6 +57,11 @@ export class Resolver {
     return this.env;
   }
 
+  public suspend(): Resolver {
+    this.env?.suspend();
+    return this;
+  }
+
   public getName(): string {
     return this.name;
   }

package/src/utils/runtime.ts

@@ -12,6 +12,16 @@ if (isNodeEnv) {
   });
 }
 
+export function isExecGraphEnabled(): boolean {
+  if (isNodeEnv) {
+    const flag = process.env['AL_EXEC_GRAPH_ENABLED'];
+    if (flag != undefined && flag == 'false') {
+      return false;
+    }
+  }
+  return true;
+}
+
 // Browser-compatible path utilities
 export const browserPath = {
   extname: (path: string): string => {