agentlang 0.7.9 → 0.7.11

package/src/language/parser.ts

@@ -33,7 +33,7 @@ import {
   Statement,
   WorkflowDefinition,
 } from './generated/ast.js';
-import { firstAliasSpec, firstCatchSpec, QuerySuffix } from '../runtime/util.js';
+import { firstAliasSpec, firstCatchSpec, isString, QuerySuffix } from '../runtime/util.js';
 import {
   BasePattern,
   CrudPattern,
@@ -291,7 +291,7 @@ function introspectPattern(pat: Pattern): BasePattern {
 
 function introspectInto(intoSpec: SelectIntoSpec, p: CrudPattern): CrudPattern {
   intoSpec.entries.forEach((se: SelectIntoEntry) => {
-    p.addInto(se.alias, se.attribute);
+    if (se.attribute) p.addInto(se.alias, se.attribute);
   });
   return p;
 }
@@ -340,12 +340,14 @@ function introspectPrimExpr(expr: PrimExpr): BasePattern {
   }
 }
 
-function introspectExpression(expr: Expr | Expr): BasePattern {
-  if (isPrimExpr(expr)) {
-    return introspectPrimExpr(expr);
-  }
-  if (expr.$cstNode) {
-    return new ExpressionPattern(expr.$cstNode.text);
+function introspectExpression(expr: Expr | undefined): BasePattern {
+  if (expr !== undefined) {
+    if (isPrimExpr(expr)) {
+      return introspectPrimExpr(expr);
+    }
+    if (expr.$cstNode) {
+      return new ExpressionPattern(expr.$cstNode.text);
+    }
   }
   throw new Error('Failed to introspect expression - ' + expr);
 }
@@ -507,3 +509,36 @@ export function canParse(s: string): boolean {
   }
   return false;
 }
+
+export function objectToQueryPattern(obj: any): string {
+  const strs = new Array<string>();
+  Object.keys(obj).forEach((k: string) => {
+    if (k.startsWith('@')) {
+      const xs: any = obj[k];
+      if (k.endsWith('join')) {
+        xs.forEach((x: any[]) => {
+          strs.push(`${k} ${x[0]} ${objectToQuerySpecPattern(x[1], true)}`);
+        });
+      } else if (k === '@groupBy' || k === '@orderBy') {
+        strs.push(`${k} ( ${xs.join(', ')} )`);
+      } else {
+        strs.push(`${k} ${objectToQuerySpecPattern(xs, true)}`);
+      }
+    } else {
+      strs.push(`${k} ${objectToQuerySpecPattern(obj[k])}`);
+    }
+  });
+  return `{${strs.join(',\n')}}`;
+}
+
+function objectToQuerySpecPattern(obj: any, refMode: boolean = false): string {
+  const strs = new Array<string>();
+  Object.keys(obj).forEach((k: string) => {
+    let v = obj[k];
+    if (!refMode && isString(v) && !v.startsWith('@')) {
+      v = `"${v}"`;
+    }
+    strs.push(`${k} ${v}`);
+  });
+  return `{${strs.join(', ')}}`;
+}

package/src/language/syntax.ts

@@ -1,6 +1,11 @@
 import { parseHelper } from 'langium/test';
 import { escapeQueryName, trimQuotes } from '../runtime/util.js';
-import { isDecisionDefinition, ModuleDefinition } from './generated/ast.js';
+import {
+  FlowEntry,
+  isDecisionDefinition,
+  isFlowDefinition,
+  ModuleDefinition,
+} from './generated/ast.js';
 import { createAgentlangServices } from './agentlang-module.js';
 import { EmptyFileSystem } from 'langium';
 import { introspect, parseModule } from './parser.js';
@@ -811,18 +816,26 @@ export class FlowStepPattern extends BasePattern {
     this.condition = condition ? trimQuotes(condition) : undefined;
   }
 
-  static Parse(s: string): FlowStepPattern {
-    const parts = s.trim().split(' ');
-    const first = parts[0];
-    if (parts[1] == '-->') {
-      if (parts.length == 3) {
-        return new FlowStepPattern(first, parts[2]);
-      } else {
-        return new FlowStepPattern(first, parts[3], parts[2]);
-      }
-    } else {
-      throw new Error(`Invalid flow-step format in ${s}`);
+  static async Parse(s: string): Promise<FlowStepPattern> {
+    const p = await parseModule(`module Temp
+      flow tempFlow {
+          ${s}
+      }`);
+    let result: FlowStepPattern | undefined;
+    const d = p.defs[0];
+    if (isFlowDefinition(d)) {
+      d.body?.entries.forEach((fe: FlowEntry) => {
+        if (fe.cond) {
+          result = new FlowStepPattern(fe.root, fe.cond.next.$cstNode?.text || '', fe.cond.expr);
+        } else {
+          result = new FlowStepPattern(fe.root, fe.next?.$cstNode?.text || '');
+        }
+      });
+    }
+    if (result !== undefined) {
+      return result;
     }
+    throw new Error(`Failed to parse flow-step - ${s}`);
   }
 
   override toString(): string {

package/src/runtime/api.ts

@@ -4,11 +4,14 @@ import {
   isInstanceOfType as al_isInstanceOfType,
 } from './module.js';
 import { getLocalEnv as al_getLocalEnv, setLocalEnv as al_setLocalEnv } from './auth/defs.js';
+import { now } from './util.js';
 
 declare global {
   var agentlang: any | undefined;
   function getLocalEnv(k: string, defaultValue?: string): string | undefined;
   function setLocalEnv(k: string, v: string): string;
+  function uuid(): string;
+  function now(): string;
 }
 
 let ApiInited = false;
@@ -20,6 +23,11 @@ export function initGlobalApi() {
     globalThis.agentlang.isInstanceOfType = al_isInstanceOfType;
     globalThis.agentlang.fetchConfig = al_fetchConfig;
 
+    globalThis.uuid = () => {
+      return crypto.randomUUID();
+    };
+    globalThis.now = now;
+
     // Expose environment variable functions globally (like readSecret pattern)
     globalThis.getLocalEnv = al_getLocalEnv;
     globalThis.setLocalEnv = al_setLocalEnv;

package/src/runtime/defs.ts

@@ -419,6 +419,7 @@ export function isRuntimeMode_undo_migration(): boolean {
 
 let UpdateEventEndpoints: Function | undefined;
 let UpdateEntityEndpoints: Function | undefined;
+let UpdateRelationshipEndpoints: Function | undefined;
 
 export function setEventEndpointsUpdater(f: Function) {
   UpdateEventEndpoints = f;
@@ -428,6 +429,10 @@ export function setEntityEndpointsUpdater(f: Function) {
   UpdateEntityEndpoints = f;
 }
 
+export function setRelationshipEndpointsUpdater(f: Function) {
+  UpdateRelationshipEndpoints = f;
+}
+
 export function updateEndpoints(moduleName: string) {
   if (UpdateEventEndpoints !== undefined) {
     UpdateEventEndpoints(moduleName);
@@ -435,6 +440,9 @@ export function updateEndpoints(moduleName: string) {
   if (UpdateEntityEndpoints !== undefined) {
     UpdateEntityEndpoints(moduleName);
   }
+  if (UpdateRelationshipEndpoints !== undefined) {
+    UpdateRelationshipEndpoints(moduleName);
+  }
 }
 
 export let InternDynamicModule: Function | undefined;

package/src/runtime/interpreter.ts

@@ -28,6 +28,7 @@ import {
   SetAttribute,
   Statement,
   ThrowError,
+  WhereSpec,
 } from '../language/generated/ast.js';
 import {
   maybeInstanceAsString,
@@ -52,7 +53,7 @@ import {
   Workflow,
   setMetaAttributes,
 } from './module.js';
-import { JoinInfo, Resolver } from './resolvers/interface.js';
+import { JoinInfo, Resolver, WhereClause } from './resolvers/interface.js';
 import { ResolverAuthInfo } from './resolvers/authinfo.js';
 import { SqlDbResolver } from './resolvers/sqldb/impl.js';
 import {
@@ -97,8 +98,7 @@ import {
   addUpdateAudit,
   createSuspension,
   flushMonitoringData,
-  maybeCancelTimer,
-  setTimerRunning,
+  triggerTimer,
 } from './modules/core.js';
 import { invokeModuleFn } from './jsmodules.js';
 import { invokeOpenApiEvent, isOpenApiEventInstance } from './openapi.js';
@@ -106,6 +106,7 @@ import { fetchDoc } from './docs.js';
 import { FlowSpec, FlowStep, getAgentFlow } from './agents/flows.js';
 import { isMonitoringEnabled } from './state.js';
 import { Monitor, MonitorEntry } from './monitor.js';
+import { detailedDiff } from 'deep-object-diff';
 
 export type Result = any;
 
@@ -1341,6 +1342,11 @@ async function lookupOneOfVals(fqName: string, env: Environment): Promise<Instan
   return await parseAndEvaluateStatement(`{${fqName}? {}}`, undefined, env);
 }
 
+export type AggregateFunctionCall = {
+  name: string;
+  args: string[];
+};
+
 async function patternToInstance(
   entryName: string,
   attributes: SetAttribute[] | undefined,
@@ -1349,6 +1355,7 @@ async function patternToInstance(
   const attrs: InstanceAttributes = newInstanceAttributes();
   let qattrs: InstanceAttributes | undefined;
   let qattrVals: InstanceAttributes | undefined;
+  let aggregates: Map<string, AggregateFunctionCall> | undefined;
   const isQueryAll: boolean = entryName.endsWith(QuerySuffix);
   if (isQueryAll) {
     entryName = entryName.slice(0, entryName.length - 1);
@@ -1356,20 +1363,25 @@ async function patternToInstance(
   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 (a.value !== undefined) {
+        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);
+      } else if (a.aggregate !== undefined) {
+        if (aggregates === undefined) aggregates = new Map<string, AggregateFunctionCall>();
+        aggregates.set(escapeQueryName(a.name), { name: a.aggregate.name, args: a.aggregate.args });
       }
     }
   }
@@ -1379,7 +1391,11 @@ async function patternToInstance(
     if (p.hasModule()) moduleName = p.getModuleName();
     if (p.hasEntry()) entryName = p.getEntryName();
   }
-  return makeInstance(moduleName, entryName, attrs, qattrs, qattrVals, isQueryAll);
+  const inst = makeInstance(moduleName, entryName, attrs, qattrs, qattrVals, isQueryAll);
+  if (aggregates !== undefined) {
+    return inst.setAggregates(aggregates);
+  }
+  return inst;
 }
 
 async function instanceFromSource(crud: CrudMap, env: Environment): Promise<Instance> {
@@ -1431,6 +1447,15 @@ async function maybeValidateOneOfRefs(inst: Instance, env: Environment) {
   }
 }
 
+function maybeSetQueryClauses(inst: Instance, crud: CrudMap) {
+  if (crud.groupByClause) {
+    inst.setGroupBy(crud.groupByClause.colNames);
+  }
+  if (crud.orderByClause) {
+    inst.setOrderBy(crud.orderByClause.colNames, crud.orderByClause.order === '@desc');
+  }
+}
+
 async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   if (!env.isInUpsertMode() && crud.upsert.length > 0) {
     return await evaluateUpsert(crud, env);
@@ -1442,8 +1467,10 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   const moduleName = inst.moduleName;
   const attrs = inst.attributes;
   const qattrs = inst.queryAttributes;
-  const isQueryAll = crud.name.endsWith(QuerySuffix);
+  const onlyAggregates = inst.aggregates !== undefined && qattrs === undefined;
+  const isQueryAll = onlyAggregates || crud.name.endsWith(QuerySuffix);
   const distinct: boolean = crud.distinct.length > 0;
+  maybeSetQueryClauses(inst, crud);
   if (attrs.size > 0) {
     await maybeValidateOneOfRefs(inst, env);
   }
@@ -1456,8 +1483,8 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     if (qattrs === undefined && !isQueryAll) {
       throw new Error(`Pattern for ${entryName} with 'into' clause must be a query`);
     }
-    if (crud.join) {
-      await evaluateJoinQuery(crud.join, crud.into, inst, distinct, env);
+    if (crud.joins.length > 0) {
+      await evaluateJoinQuery(crud.joins, crud.into, crud.where, inst, distinct, env);
     } else {
       await evaluateJoinQueryWithRelationships(crud.into, inst, crud.relationships, distinct, env);
     }
@@ -1671,51 +1698,6 @@ async function handleDocEvent(inst: Instance, env: Environment): Promise<void> {
   }
 }
 
-function triggerTimer(timerInst: Instance): Instance {
-  const dur = timerInst.lookup('duration');
-  const unit = timerInst.lookup('unit');
-  let millisecs = 0;
-  switch (unit) {
-    case 'millisecond': {
-      millisecs = dur;
-      break;
-    }
-    case 'second': {
-      millisecs = dur * 1000;
-      break;
-    }
-    case 'minute': {
-      millisecs = dur * 60 * 1000;
-      break;
-    }
-    case 'hour': {
-      millisecs = dur * 60 * 60 * 1000;
-      break;
-    }
-  }
-  const eventName = nameToPath(timerInst.lookup('trigger'));
-  const m = eventName.hasModule() ? eventName.getModuleName() : timerInst.moduleName;
-  const n = eventName.getEntryName();
-  const inst = makeInstance(m, n, newInstanceAttributes());
-  const name = timerInst.lookup('name');
-  const timer = setInterval(async () => {
-    const env = new Environment();
-    try {
-      await evaluate(
-        inst,
-        (result: Result) => logger.debug(`Timer ${name} ran with result ${result}`),
-        env
-      );
-      await env.commitAllTransactions();
-      await maybeCancelTimer(name, timer, env);
-    } catch (reason: any) {
-      logger.error(`Timer ${name} raised error: ${reason}`);
-    }
-  }, millisecs);
-  setTimerRunning(timerInst);
-  return timerInst;
-}
-
 async function computeExprAttributes(
   inst: Instance,
   origAttrs: SetAttribute[] | undefined,
@@ -1749,7 +1731,7 @@ async function computeExprAttributes(
       for (let i = 0; i < origAttrs.length; ++i) {
         const a: SetAttribute = origAttrs[i];
         const n = a.name;
-        if (!n.endsWith(QuerySuffix) && updatedAttrs.has(n)) {
+        if (!n.endsWith(QuerySuffix) && updatedAttrs.has(n) && a.value !== undefined) {
           await evaluateExpression(a.value, newEnv);
           const v: Result = newEnv.getLastResult();
           updatedAttrs.set(n, v);
@@ -1760,19 +1742,51 @@ async function computeExprAttributes(
   }
 }
 
+async function evalWhereClauses(whereSpec: WhereSpec, env: Environment): Promise<WhereClause[]> {
+  const result = new Array<WhereClause>();
+  const e = new Environment(undefined, env);
+  for (let i = 0; i < whereSpec.clauses.length; ++i) {
+    const c = whereSpec.clauses[i];
+    await evaluateExpression(c.rhs, e);
+    result.push({
+      attrName: escapeQueryName(c.lhs),
+      op: c.op === undefined ? '=' : c.op,
+      qval: e.getLastResult(),
+    });
+  }
+  return result;
+}
+
 async function evaluateJoinQuery(
-  joinSpec: JoinSpec,
+  joinSpec: JoinSpec[],
   intoSpec: SelectIntoSpec,
+  whereSpec: WhereSpec | undefined,
   inst: Instance,
   distinct: boolean,
   env: Environment
 ): Promise<void> {
   const normIntoSpec = new Map<string, string>();
+  let aggregates: Map<string, AggregateFunctionCall> | undefined;
   intoSpec.entries.forEach((entry: SelectIntoEntry) => {
-    normIntoSpec.set(entry.alias, entry.attribute);
+    if (entry.attribute !== undefined) normIntoSpec.set(entry.alias, entry.attribute);
+    else {
+      if (aggregates === undefined) aggregates = new Map<string, AggregateFunctionCall>();
+      if (entry.aggregate !== undefined) aggregates?.set(entry.alias, entry.aggregate);
+    }
   });
+  if (aggregates !== undefined) {
+    inst.setAggregates(aggregates);
+  }
+  const clauses = whereSpec ? await evalWhereClauses(whereSpec, env) : undefined;
   const resolver = await getResolverForPath(inst.name, inst.moduleName, env);
-  const result: Result = await resolver.queryByJoin(inst, [], normIntoSpec, distinct, joinSpec);
+  const result: Result = await resolver.queryByJoin(
+    inst,
+    [],
+    normIntoSpec,
+    distinct,
+    joinSpec,
+    clauses
+  );
 
   const transformedResult = transformDateFieldsInJoinResult(result);
 
@@ -1787,9 +1801,17 @@ async function evaluateJoinQueryWithRelationships(
   env: Environment
 ): Promise<void> {
   const normIntoSpec = new Map<string, string>();
+  let aggregates: Map<string, AggregateFunctionCall> | undefined;
   intoSpec.entries.forEach((entry: SelectIntoEntry) => {
-    normIntoSpec.set(entry.alias, entry.attribute);
+    if (entry.attribute !== undefined) normIntoSpec.set(entry.alias, entry.attribute);
+    else {
+      if (aggregates === undefined) aggregates = new Map<string, AggregateFunctionCall>();
+      if (entry.aggregate !== undefined) aggregates?.set(entry.alias, entry.aggregate);
+    }
   });
+  if (aggregates !== undefined) {
+    inst.setAggregates(aggregates);
+  }
   const moduleName = inst.moduleName;
   let joinsSpec = new Array<JoinInfo>();
   for (let i = 0; i < relationships.length; ++i) {
@@ -2126,7 +2148,7 @@ async function preprocessStep(spec: string, env: Environment): Promise<string> {
       const step = crudMap.name;
       if (crudMap.body) {
         crudMap.body.attributes.forEach((sa: SetAttribute) => {
-          const v = sa.value.$cstNode?.text;
+          const v = sa.value?.$cstNode?.text;
           if (v) env.setTemplateMapping(sa.name, v);
         });
       }
@@ -2202,7 +2224,7 @@ export async function maybeDeleteQueriedInstances(
   const inst: Instance[] | Instance = queryEnv.getLastResult();
   let resolver: Resolver = Resolver.Default;
   if (inst instanceof Array) {
-    if (inst.length > 0 && isEntityInstance(inst[0])) {
+    if (inst.length > 0) {
       resolver = await getResolverForPath(inst[0].name, inst[0].moduleName, queryEnv);
       const finalResult: Array<any> = new Array<any>();
       for (let i = 0; i < inst.length; ++i) {
@@ -2215,7 +2237,7 @@ export async function maybeDeleteQueriedInstances(
     } else {
       queryEnv.setLastResult(inst);
     }
-  } else if (isEntityInstance(inst)) {
+  } else {
     resolver = await getResolverForPath(inst.name, inst.moduleName, queryEnv);
     await runPreDeleteEvents(inst, env);
     const r: Instance | null = await resolver.deleteInstance(inst, purge);
@@ -2479,7 +2501,7 @@ async function runPreCreateEvents(inst: Instance, env: Environment) {
 
 export async function runPostCreateEvents(inst: Instance, env: Environment) {
   if (inst.requireAudit()) {
-    await addCreateAudit(inst.getPath(), env);
+    await addCreateAudit(inst.getPath(), env, { original: inst.userAttributesAsObject() });
   }
   await runPrePostEvents(CrudType.CREATE, false, inst, env);
 }
@@ -2494,7 +2516,13 @@ export async function runPostUpdateEvents(
   env: Environment
 ) {
   if (inst.requireAudit()) {
-    await addUpdateAudit(inst.getPath(), oldInst, env);
+    let diff: object | undefined;
+    if (oldInst !== undefined) {
+      const oldAttrs = oldInst.userAttributesAsObject();
+      const d = detailedDiff(oldAttrs, inst.userAttributesAsObject());
+      diff = { original: oldAttrs, updated: d.updated };
+    }
+    await addUpdateAudit(inst.getPath(), diff, env);
   }
   await runPrePostEvents(CrudType.UPDATE, false, inst, env);
 }
@@ -2505,7 +2533,7 @@ async function runPreDeleteEvents(inst: Instance, env: Environment) {
 
 export async function runPostDeleteEvents(inst: Instance, env: Environment) {
   if (inst.requireAudit()) {
-    await addDeleteAudit(inst.getPath(), inst, env);
+    await addDeleteAudit(inst.getPath(), { deleted: inst.userAttributesAsObject() }, env);
   }
   await runPrePostEvents(CrudType.DELETE, false, inst, env);
 }

package/src/runtime/loader.ts

@@ -69,6 +69,7 @@ import {
   addAgent,
   fetchModule,
   Retry,
+  addGlobalRetry,
 } from './module.js';
 import {
   asStringLiteralsMap,
@@ -81,6 +82,7 @@ import {
   preprocessRawConfig,
   registerInitFunction,
   rootRef,
+  ScratchModuleName,
 } from './util.js';
 import { getFileSystem, toFsPath, readFile, readdir, exists } from '../utils/fs-utils.js';
 import { URI } from 'vscode-uri';
@@ -348,10 +350,14 @@ async function evaluateConfigPatterns(cfgPats: string): Promise<any> {
   const wf = await parseWorkflow(cfgWf);
   const cfgStmts = new Array<Statement>();
   const initInsts = new Array<Statement>();
+  const deleted = new Set<string>();
   for (let i = 0; i < wf.statements.length; ++i) {
     const stmt: Statement = wf.statements[i];
     if (stmt.pattern.crudMap) {
-      initInsts.push(await makeDeleteAllConfigStatement(stmt.pattern.crudMap));
+      if (!deleted.has(stmt.pattern.crudMap?.name)) {
+        initInsts.push(await makeDeleteAllConfigStatement(stmt.pattern.crudMap));
+        deleted.add(stmt.pattern.crudMap.name);
+      }
       initInsts.push(stmt);
     } else {
       cfgStmts.push(stmt);
@@ -377,20 +383,37 @@ async function evaluateConfigPatterns(cfgPats: string): Promise<any> {
   return undefined;
 }
 
-export async function loadAppConfig(configDir: string): Promise<Config> {
+function isStringContent(content: string): boolean {
+  return content.includes('{');
+}
+
+export async function loadAppConfig(configDirOrContent: string): Promise<Config> {
+  const stringContent = isStringContent(configDirOrContent);
+
   let cfgObj: any = undefined;
-  const fs = await getFileSystem();
-  const alCfgFile = `${configDir}${path.sep}config.al`;
-  if (await fs.exists(alCfgFile)) {
-    const cfgPats = await fs.readFile(alCfgFile);
-    if (canParse(cfgPats)) {
-      cfgObj = await evaluateConfigPatterns(cfgPats);
+
+  if (!stringContent) {
+    const fs = await getFileSystem();
+    const alCfgFile = `${configDirOrContent}${path.sep}config.al`;
+    if (await fs.exists(alCfgFile)) {
+      configDirOrContent = await fs.readFile(alCfgFile);
     }
   }
+
+  if (canParse(configDirOrContent)) {
+    cfgObj = await evaluateConfigPatterns(configDirOrContent);
+  }
+
   try {
-    const cfg = cfgObj
+    let cfg = cfgObj
       ? await configFromObject(cfgObj)
-      : await loadRawConfig(`${configDir}${path.sep}app.config.json`);
+      : await loadRawConfig(`${configDirOrContent}${path.sep}app.config.json`);
+
+    const envAppConfig = typeof process !== 'undefined' ? process.env.APP_CONFIG : undefined;
+    if (envAppConfig) {
+      const envConfig = JSON.parse(envAppConfig);
+      cfg = { ...cfg, ...envConfig };
+    }
     return setAppConfig(cfg);
   } catch (err: any) {
     if (err instanceof z.ZodError) {
@@ -891,7 +914,7 @@ function addFlowDefinition(def: FlowDefinition, moduleName: string) {
       f = sdef;
     }
   }
-  m.addFlow(def.name, f);
+  m.addFlow(def.name, def);
   registerFlow(`${moduleName}/${def.name}`, f);
 }
 
@@ -1161,6 +1184,7 @@ export async function internModule(
   // Process imports sequentially to ensure all JS modules are loaded before definitions
   for (const imp of module.imports as Import[]) {
     await importModule(imp.path, imp.name, moduleFileName);
+    r.addImport({ name: imp.name, path: imp.path });
   }
   for (let i = 0; i < module.defs.length; ++i) {
     const def = module.defs[i];
@@ -1186,31 +1210,57 @@ export async function loadRawConfig(
   }
 }
 
-function filterConfigEntityInstances(rawConfig: any): [any, Map<string, any>] {
-  const cfg = new Map<string, any>();
-  const insts = new Map<string, any>();
-  Object.entries(rawConfig).forEach(([key, value]: [string, any]) => {
-    if (isFqName(key)) {
-      insts.set(key, value);
-    } else {
-      cfg.set(key, value);
-    }
+function filterConfigEntityInstances(rawConfig: any): [any, Array<any>] {
+  let cfg: any = undefined;
+  const insts = new Array<any>();
+  const oldFormat = Object.keys(rawConfig).some((k: string) => {
+    return k === 'store' || k === 'service';
   });
-  return [Object.fromEntries(cfg), insts];
+  const newFormat = !oldFormat;
+  if (newFormat) {
+    Object.entries(rawConfig).forEach(([key, value]: [string, any]) => {
+      if (key === 'agentlang') {
+        cfg = value;
+      } else {
+        if (value instanceof Array) {
+          value.forEach((v: any) => {
+            insts.push(v);
+          });
+        } else {
+          insts.push(value);
+        }
+      }
+    });
+    if (cfg === undefined) cfg = {};
+    return [cfg, insts];
+  } else {
+    return [rawConfig, insts];
+  }
 }
 
 async function configFromObject(cfgObj: any, validate: boolean = true): Promise<any> {
   const rawConfig = preprocessRawConfig(cfgObj);
-  if (validate) {
+  if (validate && rawConfig) {
     const [cfg, insts] = filterConfigEntityInstances(rawConfig);
     const pats = new Array<string>();
-    insts.forEach((v: any, k: string) => {
-      pats.push(`{${k} ${objectAsString(v)}}`);
+    insts.forEach((v: any) => {
+      const n = Object.keys(v)[0];
+      const attrs = v[n];
+      pats.push(`{${n} ${objectAsString(attrs)}}`);
     });
     if (pats.length > 0) {
       await evaluateConfigPatterns(pats.join('\n'));
     }
-    return ConfigSchema.parse(cfg);
+    const result = ConfigSchema.parse(cfg);
+    cfg.retry?.forEach((r: any) => {
+      const retry: Retry = new Retry(r.name, ScratchModuleName, r.attempts)
+        .setBackoffDelay(r.backoff.delay)
+        .setBackoffFactor(r.backoff.factor)
+        .setBackoffStrategy(r.backoff.strategy[0])
+        .setBackoffMagnitude(r.backoff.magnitude);
+      addGlobalRetry(retry);
+    });
+    return result;
   }
   return rawConfig;
 }