agentlang 0.0.40 → 0.0.51

package/src/runtime/module.ts

@@ -816,42 +816,65 @@ export class Agent extends Record {
     return this.removeAgentAttribute('type');
   }
 
-  setTools(tools: string[]): Agent {
-    this.attributes.set('tools', tools.join(','));
+  private setStrings(attrName: string, v: string[]): Agent {
+    this.attributes.set(attrName, v.join(','));
     return this;
   }
 
-  getTools(): string[] | undefined {
-    const tools = this.attributes.get('tools');
-    if (tools) {
-      return tools.split(',');
+  private getStrings(attrName: string): string[] | undefined {
+    const v = this.attributes.get(attrName);
+    if (v) {
+      return v.split(',');
     } else {
       return undefined;
     }
   }
 
+  setTools(tools: string[]): Agent {
+    return this.setStrings('tools', tools);
+  }
+
+  getTools(): string[] | undefined {
+    return this.getStrings('tools');
+  }
+
   removeTools(): Agent {
     return this.removeAgentAttribute('tools');
   }
 
   setDocuments(docs: string[]): Agent {
-    this.attributes.set('documents', docs.join(','));
-    return this;
+    return this.setStrings('documents', docs);
   }
 
-  getDocuments(): string {
-    return this.attributes.get('documents');
+  getDocuments(): string[] | undefined {
+    return this.getStrings('documents');
   }
 
   removeDocuments(): Agent {
     return this.removeAgentAttribute('documents');
   }
 
+  setFlows(flows: string[]): Agent {
+    return this.setStrings('flows', flows);
+  }
+
+  getFlows(): string[] | undefined {
+    return this.getStrings('flows');
+  }
+
   override toString(): string {
     const attrs = new Array<string>();
     this.attributes.forEach((value: any, key: string) => {
-      const v = isString(value) ? `"${value}"` : value;
-      attrs.push(`    ${key} ${v}`);
+      const skip = key == 'moduleName' || (key == 'type' && value == 'flow-exec');
+      if (!skip) {
+        let v = value;
+        if (key == 'flows') {
+          v = `[${v}]`;
+        } else if (isString(v)) {
+          v = `"${v}"`;
+        }
+        attrs.push(`    ${key} ${v}`);
+      }
     });
     return `agent ${Agent.NormalizeName(this.name)}
 {
@@ -1293,6 +1316,59 @@ export class Workflow extends ModuleEntry {
   }
 }
 
+export class Flow extends ModuleEntry {
+  flowSteps: string[];
+
+  constructor(name: string, moduleName: string, flow?: string) {
+    super(name, moduleName);
+    this.flowSteps = new Array<string>();
+    flow?.split('\n').forEach((step: string) => {
+      const s = step.trim();
+      if (s.length > 0) {
+        this.flowSteps.push(s);
+      }
+    });
+  }
+
+  getFlow(): string {
+    return this.flowSteps.join('\n');
+  }
+
+  removeStep(index: number): Flow {
+    this.flowSteps.splice(index, 1);
+    return this;
+  }
+
+  insertStep(index: number, s: string): Flow {
+    this.flowSteps.splice(index, 0, s);
+    return this;
+  }
+
+  stepsCount(): number {
+    return this.flowSteps.length;
+  }
+
+  override toString(): string {
+    return `flow ${this.name} {
+      ${this.getFlow()}
+    }`;
+  }
+}
+
+class StandaloneStatement extends ModuleEntry {
+  stmt: Statement;
+
+  constructor(stmt: Statement, moduleName: string) {
+    super(crypto.randomUUID(), moduleName);
+    this.stmt = stmt;
+  }
+
+  override toString(): string {
+    if (this.stmt.$cstNode) return this.stmt.$cstNode?.text;
+    else return '';
+  }
+}
+
 const EmptyWorkflow: Workflow = new Workflow('', [], DefaultModuleName);
 
 export function isEmptyWorkflow(wf: Workflow): boolean {
@@ -1338,6 +1414,32 @@ export class Module {
     return this.removeEntry(Agent.EscapeName(agentName));
   }
 
+  addFlow(name: string, flowString?: string): Flow {
+    const flow: Flow = new Flow(name, this.name, flowString);
+    this.addEntry(flow);
+    return flow;
+  }
+
+  getFlow(name: string): Flow | undefined {
+    if (this.hasEntry(name)) {
+      return this.getEntry(name) as Flow;
+    }
+    return undefined;
+  }
+
+  addStandaloneStatement(stmt: Statement): StandaloneStatement {
+    const s = new StandaloneStatement(stmt, this.name);
+    this.addEntry(s);
+    return s;
+  }
+
+  getStandaloneStatement(name: string): StandaloneStatement | undefined {
+    if (this.hasEntry(name)) {
+      return this.getEntry(name) as StandaloneStatement;
+    }
+    return undefined;
+  }
+
   private getEntryIndex(entryName: string): number {
     return this.entries.findIndex((v: ModuleEntry) => {
       return v.name == entryName;
@@ -2848,14 +2950,22 @@ export function assertInstance(obj: any) {
 
 const IsAgentEventMeta = 'is-agent-event';
 const EventAgentName = 'event-agent-name';
+const DocumentationMetaTag = 'documentation';
 
-export function defineAgentEvent(moduleName: string, agentName: string) {
+export function defineAgentEvent(moduleName: string, agentName: string, instruction?: string) {
   const module = fetchModule(moduleName);
   const event: Record = new Event(agentName, moduleName);
   event.addAttribute('message', { type: 'Any' });
   event.addAttribute('chatId', { type: 'String' });
   event.addMeta(IsAgentEventMeta, 'y');
   event.addMeta(EventAgentName, agentName);
+  if (instruction) {
+    event.addMeta(
+      DocumentationMetaTag,
+      `This event will trigger an agent which has the instruction - "${instruction}".
+    So make sure to pass all relevant information in the 'message' attribute of this event.`
+    );
+  }
   module.addEntry(event);
 }
 

package/src/runtime/modules/ai.ts

@@ -5,7 +5,14 @@ import {
   makeEventEvaluator,
   parseAndEvaluateStatement,
 } from '../interpreter.js';
-import { fetchModule, Instance, instanceToObject, isModule } from '../module.js';
+import {
+  fetchModule,
+  Instance,
+  instanceToObject,
+  isModule,
+  makeInstance,
+  newInstanceAttributes,
+} from '../module.js';
 import { provider } from '../agents/registry.js';
 import {
   AgentServiceProvider,
@@ -15,7 +22,7 @@ import {
   systemMessage,
 } from '../agents/provider.js';
 import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
-import { PlannerInstructions } from '../agents/common.js';
+import { FlowExecInstructions, FlowStep, PlannerInstructions } from '../agents/common.js';
 import { PathAttributeNameQuery } from '../defs.js';
 import { logger } from '../logger.js';
 
@@ -33,7 +40,8 @@ entity ${LlmEntityName} {
 
 entity ${AgentEntityName} {
     name String @id,
-    type @enum("chat", "planner") @default("chat"),
+    moduleName String @default("${CoreAIModuleName}"),
+    type @enum("chat", "planner", "flow-exec") @default("chat"),
     runWorkflows Boolean @default(true),
     instruction String @optional,
     tools String @optional, // comma-separated list of tool names
@@ -41,6 +49,7 @@ entity ${AgentEntityName} {
     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
 }
 
@@ -77,6 +86,7 @@ const ProviderDb = new Map<string, AgentServiceProvider>();
 export class AgentInstance {
   llm: string = '';
   name: string = '';
+  moduleName: string = CoreAIModuleName;
   chatId: string | undefined;
   instruction: string = '';
   type: string = 'chat';
@@ -86,8 +96,10 @@ export class AgentInstance {
   runWorkflows: boolean = true;
   output: string | undefined;
   role: string | undefined;
+  flows: string | undefined;
   private toolsArray: string[] | undefined = undefined;
   private hasModuleTools = false;
+  private withSession = true;
 
   private constructor() {}
 
@@ -123,29 +135,71 @@ export class AgentInstance {
     return agent;
   }
 
+  static FromFlowStep(step: FlowStep, flowAgent: AgentInstance): AgentInstance {
+    const fqs = isFqName(step) ? step : `${flowAgent.moduleName}/${step}`;
+    const instruction = `Analyse the context and generate the pattern required to invoke ${fqs}.
+    Never include references in the pattern. All attribute values must be literals derived from the context.`;
+    const inst = makeInstance(
+      CoreAIModuleName,
+      AgentEntityName,
+      newInstanceAttributes()
+        .set('llm', flowAgent.llm)
+        .set('name', `${step}_agent`)
+        .set('moduleName', flowAgent.moduleName)
+        .set('instruction', instruction)
+        .set('tools', fqs)
+        .set('type', 'planner')
+    );
+    return AgentInstance.FromInstance(inst);
+  }
+
+  disableSession(): AgentInstance {
+    this.withSession = false;
+    return this;
+  }
+
+  enableSession(): AgentInstance {
+    this.withSession = true;
+    return this;
+  }
+
+  hasSession(): boolean {
+    return this.withSession;
+  }
+
   isPlanner(): boolean {
     return this.hasModuleTools || this.type == 'planner';
   }
 
+  isFlowExecutor(): boolean {
+    return this.type == 'flow-exec';
+  }
+
   async invoke(message: string, env: Environment) {
     const p = await findProviderForLLM(this.llm, env);
     const agentName = this.name;
     const chatId = this.chatId || agentName;
-    const sess: Instance | null = await findAgentChatSession(chatId, env);
-    let msgs: BaseMessage[] | undefined;
     const isplnr = this.isPlanner();
+    const isflow = !isplnr && this.isFlowExecutor();
+    if (isplnr && this.withSession) {
+      this.withSession = false;
+    }
+    if (isflow) {
+      this.withSession = false;
+    }
+    const sess: Instance | null = this.withSession ? await findAgentChatSession(chatId, env) : null;
+    let msgs: BaseMessage[] | undefined;
     if (sess) {
       msgs = sess.lookup('messages');
     } else {
-      msgs = [systemMessage(this.instruction)];
+      msgs = [systemMessage(this.instruction || '')];
     }
     if (msgs) {
       try {
         const sysMsg = msgs[0];
-        if (isplnr) {
-          const newSysMsg = systemMessage(
-            `${PlannerInstructions}\n${this.toolsAsString()}\n${this.instruction}`
-          );
+        if (isplnr || isflow) {
+          const s = isplnr ? PlannerInstructions : FlowExecInstructions;
+          const newSysMsg = systemMessage(`${s}\n${this.toolsAsString()}\n${this.instruction}`);
           msgs[0] = newSysMsg;
         }
         msgs.push(humanMessage(await this.maybeAddRelevantDocuments(message, env)));
@@ -155,7 +209,9 @@ export class AgentInstance {
         if (isplnr) {
           msgs[0] = sysMsg;
         }
-        await saveAgentChatSession(chatId, msgs, env);
+        if (this.withSession) {
+          await saveAgentChatSession(chatId, msgs, env);
+        }
         env.setLastResult(response.content);
       } catch (err: any) {
         logger.error(`Error while invoking ${agentName} - ${err}`);

package/src/runtime/modules/auth.ts

@@ -324,7 +324,12 @@ export async function findUserByEmail(email: string, env: Environment): Promise<
   );
 }
 
-export async function updateUser(userId: string, firstName: string, lastName: string, env: Environment): Promise<Result> {
+export async function updateUser(
+  userId: string,
+  firstName: string,
+  lastName: string,
+  env: Environment
+): Promise<Result> {
   return await evalEvent(
     'UpdateUser',
     {

package/src/runtime/modules/core.ts

@@ -7,12 +7,13 @@ import {
   evaluate,
   evaluateStatements,
   parseAndEvaluateStatement,
+  restartFlow,
 } from '../interpreter.js';
 import { logger } from '../logger.js';
 import { Statement } from '../../language/generated/ast.js';
 import { parseStatements } from '../../language/parser.js';
 import { Resolver } from '../resolvers/interface.js';
-import { ForceReadPermFlag, PathAttributeName } from '../defs.js';
+import { FlowSuspensionTag, ForceReadPermFlag, PathAttributeName } from '../defs.js';
 
 const CoreModuleDefinition = `module ${DefaultModuleName}
 
@@ -165,9 +166,14 @@ export async function createSuspension(
 
 export type Suspension = {
   continuation: Statement[];
+  flowContext?: string[];
   env: Environment;
 };
 
+function isFlowSuspension(cont: string[]): boolean {
+  return cont.length > 0 && cont[0] == FlowSuspensionTag;
+}
+
 async function loadSuspension(suspId: string, env?: Environment): Promise<Suspension | undefined> {
   const newEnv = new Environment('auditlog', env).setInKernelMode(true);
   const r: any = await parseAndEvaluateStatement(
@@ -178,12 +184,14 @@ async function loadSuspension(suspId: string, env?: Environment): Promise<Suspen
   if (r instanceof Array && r.length > 0) {
     const inst: Instance = r[0];
     const cont = inst.lookup('continuation');
-    const stmts: Statement[] = await parseStatements(cont);
+    const ifs = isFlowSuspension(cont);
+    const stmts: Statement[] = ifs ? new Array<Statement>() : await parseStatements(cont);
     const envStr = inst.lookup('env');
     const suspEnv: Environment = Environment.FromSerializableObject(JSON.parse(envStr));
     return {
       continuation: stmts,
       env: suspEnv,
+      flowContext: ifs ? cont : undefined,
     };
   }
   return undefined;
@@ -210,8 +218,12 @@ export async function restartSuspension(
 ): Promise<any> {
   const susp = await loadSuspension(suspId, env);
   if (susp) {
-    susp.env.bindSuspensionUserData(userData);
-    await evaluateStatements(susp.continuation, susp.env);
+    if (susp.flowContext) {
+      await restartFlow(susp.flowContext, userData, susp.env);
+    } else {
+      susp.env.bindSuspensionUserData(userData);
+      await evaluateStatements(susp.continuation, susp.env);
+    }
     await deleteSuspension(suspId, env);
     return susp.env.getLastResult();
   } else {

package/src/runtime/resolvers/authinfo.ts

@@ -0,0 +1,14 @@
+export class ResolverAuthInfo {
+  userId: string;
+  readForUpdate = false;
+  readForDelete = false;
+
+  constructor(userId: string, readForUpdate?: boolean, readForDelete?: boolean) {
+    this.userId = userId;
+    if (readForUpdate != undefined) this.readForUpdate = readForUpdate;
+    if (readForDelete != undefined) this.readForDelete = readForDelete;
+  }
+}
+
+// This user-id is only for testing. Override per session from the HTTP layer.
+export const DefaultAuthInfo = new ResolverAuthInfo('9459a305-5ee6-415d-986d-caaf6d6e2828');

package/src/runtime/resolvers/interface.ts

@@ -1,7 +1,6 @@
 import {
   callPostEventOnSubscription,
   Environment,
-  evaluate,
   runPostCreateEvents,
   runPostDeleteEvents,
   runPostUpdateEvents,
@@ -15,24 +14,7 @@ import {
   Relationship,
 } from '../module.js';
 import { CrudType, splitFqName } from '../util.js';
-
-export class ResolverAuthInfo {
-  userId: string;
-  readForUpdate: boolean = false;
-  readForDelete: boolean = false;
-
-  constructor(userId: string, readForUpdate?: boolean, readForDelete?: boolean) {
-    this.userId = userId;
-    if (readForUpdate != undefined) this.readForUpdate = readForUpdate;
-    if (readForDelete != undefined) this.readForDelete = readForDelete;
-  }
-}
-
-export const DefaultAuthInfo = new ResolverAuthInfo(
-  // This user-id is only for testing, per-session user-id needs to be set from
-  // the HTTP layer.
-  '9459a305-5ee6-415d-986d-caaf6d6e2828'
-);
+import { DefaultAuthInfo, ResolverAuthInfo } from './authinfo.js';
 
 export type JoinInfo = {
   relationship: Relationship;
@@ -242,6 +224,7 @@ export class Resolver {
               path.getEntryName(),
               newInstanceAttributes().set('data', result)
             );
+            const { evaluate } = await import('../interpreter.js');
             return await evaluate(inst);
           }
         }

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

@@ -6,7 +6,7 @@ import {
   OwnersSuffix,
   VectorSuffix,
 } from './dbutil.js';
-import { DefaultAuthInfo, ResolverAuthInfo } from '../interface.js';
+import { DefaultAuthInfo, ResolverAuthInfo } from '../authinfo.js';
 import { canUserCreate, canUserDelete, canUserRead, canUserUpdate } from '../../modules/auth.js';
 import { Environment, GlobalEnvironment } from '../../interpreter.js';
 import {
@@ -17,7 +17,6 @@ import {
   RbacSpecification,
   Relationship,
 } from '../../module.js';
-import pgvector from 'pgvector';
 import { isString } from '../../util.js';
 import {
   DeletedFlagAttributeName,
@@ -194,10 +193,60 @@ function makeSqliteDataSource(
   });
 }
 
+function isBrowser(): boolean {
+  // window for DOM pages, self+importScripts for web workers
+  return (
+    (typeof window !== 'undefined' && typeof (window as any).document !== 'undefined') ||
+    (typeof self !== 'undefined' && typeof (self as any).importScripts === 'function')
+  );
+}
+
+function defaultLocateFile(file: string): string {
+  // Out-of-the-box: use the official CDN in browsers.
+  if (isBrowser()) {
+    return `https://sql.js.org/dist/${file}`;
+  }
+  // Node: resolve from node_modules/sql.js/dist
+  try {
+    /* eslint-disable-next-line @typescript-eslint/no-require-imports */
+    const path = require('path');
+
+    const base = require.resolve('sql.js/dist/sql-wasm.js');
+    return path.join(path.dirname(base), file);
+  } catch {
+    return file;
+  }
+}
+
+function makeSqljsDataSource(
+  entities: EntitySchema[],
+  _config: DatabaseConfig | undefined,
+  synchronize: boolean = true
+): DataSource {
+  return new DataSource({
+    type: 'sqljs',
+    autoSave: false,
+    sqlJsConfig: {
+      locateFile: defaultLocateFile,
+    },
+    synchronize: synchronize,
+    entities: entities,
+  });
+}
+
 const DbType = 'sqlite';
 
 function getDbType(config?: DatabaseConfig): string {
-  return process.env.AL_DB_TYPE || config?.type || DbType;
+  if (config?.type) return config.type;
+  let envType: string | undefined;
+  try {
+    if (typeof process !== 'undefined' && process.env) {
+      envType = process.env.AL_DB_TYPE;
+    }
+  } catch {}
+  if (envType) return envType;
+  if (isBrowser()) return 'sqljs';
+  return DbType;
 }
 
 function getDsFunction(
@@ -212,6 +261,8 @@ function getDsFunction(
       return makeSqliteDataSource;
     case 'postgres':
       return makePostgresDataSource;
+    case 'sqljs':
+      return makeSqljsDataSource;
     default:
       throw new Error(`Unsupported database type - ${config?.type}`);
   }
@@ -221,6 +272,15 @@ export function isUsingSqlite(): boolean {
   return getDbType() == 'sqlite';
 }
 
+export function isUsingSqljs(): boolean {
+  return getDbType() == 'sqljs';
+}
+
+export function isVectorStoreSupported(): boolean {
+  // Only Postgres supports pgvector
+  return getDbType() === 'postgres';
+}
+
 export async function initDatabase(config: DatabaseConfig | undefined) {
   if (defaultDataSource == undefined) {
     const mkds = getDsFunction(config);
@@ -268,9 +328,11 @@ export async function addRowForFullTextSearch(
   vect: number[],
   ctx: DbContext
 ) {
+  if (!isVectorStoreSupported()) return;
   try {
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
+    const { default: pgvector } = await import('pgvector');
     await qb
       .insert()
       .into(vecTableName)
@@ -282,6 +344,10 @@ export async function addRowForFullTextSearch(
 }
 
 export async function initVectorStore(tableNames: string[], ctx: DbContext) {
+  if (!isVectorStoreSupported()) {
+    logger.info(`Vector store not supported for ${getDbType()}, skipping init...`);
+    return;
+  }
   let notInited = true;
   tableNames.forEach(async (vecTableName: string) => {
     const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
@@ -312,9 +378,14 @@ export async function vectorStoreSearch(
   limit: number,
   ctx: DbContext
 ): Promise<any> {
+  if (!isVectorStoreSupported()) {
+    // Not supported on sqljs/sqlite
+    return [];
+  }
   try {
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
+    const { default: pgvector } = await import('pgvector');
     return await qb.query(
       `select id from ${vecTableName} order by embedding <-> $1 LIMIT ${limit}`,
       [pgvector.toSql(searchVec)]
@@ -329,6 +400,7 @@ export async function vectorStoreSearchEntryExists(
   id: string,
   ctx: DbContext
 ): Promise<boolean> {
+  if (!isVectorStoreSupported()) return false;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
@@ -341,6 +413,7 @@ export async function vectorStoreSearchEntryExists(
 }
 
 export async function deleteFullTextSearchEntry(tableName: string, id: string, ctx: DbContext) {
+  if (!isVectorStoreSupported()) return;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;

package/src/syntaxes/agentlang.monarch.ts

@@ -1,12 +1,12 @@
 // 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','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','flow','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: [
-        '!=','*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'
+        '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','>','>=','?','@'
     ],
-    symbols: /!=|\(|\)|\*|\+|,|-|\.|\/|:|;|<|<=|<>|=|>|>=|\?|@|\[|\]|\{|\}/,
+    symbols: /!=|\(|\)|\*|\+|,|-|-->|\.|\/|:|;|<|<=|<>|=|>|>=|\?|@|\[|\]|\{|\}/,
 
     tokenizer: {
         initial: [