agentlang 0.7.0 → 0.7.2

package/src/runtime/defs.ts

@@ -94,6 +94,26 @@ export function setSubscriptionFn(f: Function) {
   SetSubscription = f;
 }
 
+// Module loader configuration for browser-compatible resolver loading
+export type FileReader = (filePath: string) => Promise<string>;
+export type DependencyProvider = (moduleName: string) => any | undefined;
+
+export interface ModuleLoaderConfig {
+  fileReader: FileReader;
+  dependencyProvider?: DependencyProvider;
+  basePath?: string;
+}
+
+let _moduleLoader: ModuleLoaderConfig | undefined = undefined;
+
+export function setModuleLoader(config: ModuleLoaderConfig) {
+  _moduleLoader = config;
+}
+
+export function getModuleLoader(): ModuleLoaderConfig | undefined {
+  return _moduleLoader;
+}
+
 export const ForceReadPermFlag = 'f-r-f';
 export const FlowSuspensionTag = `--`;
 
@@ -105,6 +125,7 @@ export enum SubGraphType {
   PURGE,
   RETURN,
   AGENT,
+  THROW,
   NONE,
 }
 
@@ -386,3 +407,29 @@ export function isRuntimeMode_generate_migration(): boolean {
 export function isRuntimeMode_undo_migration(): boolean {
   return RuntimeMode === RuntimeModeTag.UNDO_MIGRATION;
 }
+
+let UpdateEventEndpoints: Function | undefined;
+let UpdateEntityEndpoints: Function | undefined;
+
+export function setEventEndpointsUpdater(f: Function) {
+  UpdateEventEndpoints = f;
+}
+
+export function setEntityEndpointsUpdater(f: Function) {
+  UpdateEntityEndpoints = f;
+}
+
+export function updateEndpoints(moduleName: string) {
+  if (UpdateEventEndpoints !== undefined) {
+    UpdateEventEndpoints(moduleName);
+  }
+  if (UpdateEntityEndpoints !== undefined) {
+    UpdateEntityEndpoints(moduleName);
+  }
+}
+
+export let InternDynamicModule: Function | undefined;
+
+export function setInternDynamicModuleFn(f: Function) {
+  InternDynamicModule = f;
+}

package/src/runtime/exec-graph.ts

@@ -13,6 +13,7 @@ import {
   Purge,
   Return,
   Statement,
+  ThrowError,
 } from '../language/generated/ast.js';
 import { parseModule, parseStatement } from '../language/parser.js';
 import { ExecGraph, ExecGraphNode, ExecGraphWalker, SubGraphType } from './defs.js';
@@ -157,6 +158,15 @@ class GraphGenerator extends PatternHandler {
     this.handleSubPattern(SubGraphType.RETURN, ret.pattern, env);
   }
 
+  override async handleThrow(throwErr: ThrowError, env: Environment) {
+    const handler = new GraphGenerator();
+    await handler.handleExpression(
+      throwErr.reason,
+      Environment.from(env).setActiveUserData(throwErr.reason)
+    );
+    this.addSubGraph(SubGraphType.THROW, handler.getGraph(), env);
+  }
+
   getGraph(): ExecGraph {
     return this.graph;
   }
@@ -261,6 +271,9 @@ export async function executeGraph(execGraph: ExecGraph, env: Environment): Prom
               case SubGraphType.RETURN:
                 await executeReturnSubGraph(subg, env);
                 return;
+              case SubGraphType.THROW:
+                await evaluateExpression(subg.getRootNodes()[0].code as Expr, env);
+                throw new Error(env.getLastResult());
               default:
                 throw new Error(`Invalid sub-graph type: ${node.subGraphType}`);
             }

package/src/runtime/interpreter.ts

@@ -27,6 +27,7 @@ import {
   SelectIntoSpec,
   SetAttribute,
   Statement,
+  ThrowError,
 } from '../language/generated/ast.js';
 import {
   maybeInstanceAsString,
@@ -1217,6 +1218,10 @@ export class PatternHandler {
   async handleReturn(ret: Return, env: Environment) {
     await evaluatePattern(ret.pattern, env);
   }
+
+  async handleThrow(throwErr: ThrowError, env: Environment) {
+    await evaluateThrowError(throwErr, env);
+  }
 }
 
 const DefaultPatternHandler = new PatternHandler();
@@ -1243,9 +1248,16 @@ export async function evaluatePattern(
   } else if (pat.return) {
     await handler.handleReturn(pat.return, env);
     env.markForReturn();
+  } else if (pat.throwError) {
+    await handler.handleThrow(pat.throwError, env);
   }
 }
 
+async function evaluateThrowError(throwErr: ThrowError, env: Environment) {
+  await evaluateExpression(throwErr.reason, env);
+  throw new Error(env.getLastResult());
+}
+
 async function evaluateFullTextSearch(fts: FullTextSearch, env: Environment): Promise<void> {
   let n = escapeQueryName(fts.name);
   if (!isFqName(n)) {

package/src/runtime/jsmodules.ts

@@ -1,7 +1,14 @@
 import { logger } from './logger.js';
 import { now, splitRefs } from './util.js';
 import { isNodeEnv } from '../utils/runtime.js';
-import { setModuleFnFetcher } from './defs.js';
+import { setModuleFnFetcher, getModuleLoader } from './defs.js';
+import {
+  transformModule,
+  wrapModuleCode,
+  evaluateModule,
+  wrapCommonJSCode,
+  evaluateCommonJS,
+} from './module-transform.js';
 
 let dirname: any = undefined;
 let sep: any = undefined;
@@ -24,39 +31,199 @@ if (isNodeEnv) {
 
 const importedModules = new Map<string, any>();
 
-// Usage: importModule("./mymodels/acme.js")
-export async function importModule(path: string, name: string, moduleFileName?: string) {
-  if (isNodeEnv) {
-    if (importedModules.has(name)) {
-      logger.warn(`Alias '${name}' will overwrite a previously imported module`);
+/**
+ * Load dependencies for a module using the configured dependency provider
+ */
+async function loadModuleDependencies(
+  imports: Array<{ defaultImport?: string; namedImports?: string[]; moduleSpecifier: string }>
+): Promise<Map<string, any>> {
+  const loadedDeps = new Map<string, any>();
+
+  for (const imp of imports) {
+    const moduleSpecifier = imp.moduleSpecifier;
+
+    logger.debug(`Loading dependency: ${moduleSpecifier}`);
+
+    // Try to get from dependency provider first
+    let module: any;
+    const moduleLoader = getModuleLoader();
+    if (moduleLoader?.dependencyProvider) {
+      module = moduleLoader.dependencyProvider(moduleSpecifier);
     }
-    if (moduleFileName) {
-      let s: string = dirname(moduleFileName);
-      if (s.startsWith('./')) {
-        s = s.substring(2);
-      } else if (s == '.') {
-        s = process.cwd();
+
+    if (!module) {
+      // In browser without dependency provider, we can't load external modules
+      if (!isNodeEnv) {
+        throw new Error(
+          `Failed to load dependency "${moduleSpecifier}". ` +
+            `Please add it to the dependency provider via setModuleLoader().`
+        );
+      }
+
+      // In Node.js, try dynamic import
+      try {
+        module = await import(/* @vite-ignore */ moduleSpecifier);
+        logger.debug(`Loaded ${moduleSpecifier} via dynamic import`);
+      } catch (error) {
+        throw new Error(`Failed to load dependency "${moduleSpecifier}": ${error}`);
       }
-      path = `${s}${sep}${path}`;
+    } else {
+      logger.debug(`Using pre-imported dependency: ${moduleSpecifier}`);
     }
-    if (!(path.startsWith(sep) || path.startsWith('.'))) {
-      path = process.cwd() + sep + path;
+
+    // Handle default import
+    if (imp.defaultImport) {
+      loadedDeps.set(imp.defaultImport, module.default || module);
     }
-    const m = await import(/* @vite-ignore */ path);
-    importedModules.set(name, m);
-    // e.g of dynamic fn-call:
-    //// let f = eval("(a, b) => m.add(a, b)");
-    //// console.log(f(10, 20))
-    return m;
-  } else {
+
+    // Handle named imports
+    if (imp.namedImports) {
+      for (const name of imp.namedImports) {
+        loadedDeps.set(name, module[name]);
+      }
+    }
+  }
+
+  return loadedDeps;
+}
+
+/**
+ * Load a JavaScript module in the browser environment
+ */
+async function loadModuleInBrowser(
+  path: string,
+  name: string,
+  moduleFileName?: string
+): Promise<any> {
+  const moduleLoader = getModuleLoader();
+  if (!moduleLoader) {
+    throw new Error(
+      'ModuleLoader not configured. Call setModuleLoader() with a fileReader and dependencyProvider.'
+    );
+  }
+
+  logger.info(`Loading module in browser: ${path} as ${name}`);
+
+  // Resolve path relative to the module file
+  let resolvedPath = path;
+  if (moduleFileName) {
+    const dir = dirname(moduleFileName);
+    resolvedPath = dir ? `${dir}${sep}${path}` : path;
+  }
+
+  // Add basePath if configured
+  if (moduleLoader.basePath) {
+    if (!resolvedPath.startsWith('/')) {
+      resolvedPath = `${moduleLoader.basePath}${sep}${resolvedPath}`;
+    }
+  }
+
+  logger.debug(`Resolved path: ${resolvedPath}`);
+
+  // Read the module content
+  const content = await moduleLoader.fileReader(resolvedPath);
+
+  if (!content || content.trim().length === 0) {
+    logger.warn(`Module file ${resolvedPath} is empty`);
     return {};
   }
+
+  logger.debug(`Read ${content.length} characters from ${resolvedPath}`);
+
+  // Check if the file uses ES6 import syntax
+  const hasImports = /\bimport\s+/.test(content);
+
+  let moduleExports: any;
+
+  if (hasImports) {
+    logger.debug(`Processing ES6 imports for: ${name}`);
+
+    // Transform the module
+    const { transformedCode, imports } = transformModule(content);
+
+    // Load all import dependencies
+    const loadedDeps = await loadModuleDependencies(imports);
+
+    logger.debug(`Loaded ${loadedDeps.size} dependencies, executing transformed code...`);
+
+    // Create wrapped code with injected dependencies
+    const wrappedCode = wrapModuleCode(transformedCode, loadedDeps);
+
+    // Evaluate and get exports
+    moduleExports = evaluateModule(wrappedCode, loadedDeps);
+
+    logger.debug(`Module exports:`, Object.keys(moduleExports));
+  } else {
+    logger.debug(`Loading as CommonJS module: ${name}`);
+
+    // Wrap and evaluate as CommonJS
+    const wrappedCode = wrapCommonJSCode(content);
+    moduleExports = evaluateCommonJS(wrappedCode);
+  }
+
+  return moduleExports;
+}
+
+/**
+ * Load a JavaScript module in Node.js environment
+ */
+async function loadModuleInNode(path: string, name: string, moduleFileName?: string): Promise<any> {
+  if (moduleFileName) {
+    let s: string = dirname(moduleFileName);
+    if (s.startsWith('./')) {
+      s = s.substring(2);
+    } else if (s == '.') {
+      s = process.cwd();
+    }
+    path = `${s}${sep}${path}`;
+  }
+  if (!(path.startsWith(sep) || path.startsWith('.'))) {
+    path = process.cwd() + sep + path;
+  }
+
+  const m = await import(/* @vite-ignore */ path);
+  return m;
+}
+
+// Usage: importModule("./mymodels/acme.js")
+export async function importModule(path: string, name: string, moduleFileName?: string) {
+  if (importedModules.has(name)) {
+    logger.warn(`Alias '${name}' will overwrite a previously imported module`);
+  }
+
+  let moduleExports: any;
+
+  if (isNodeEnv) {
+    moduleExports = await loadModuleInNode(path, name, moduleFileName);
+  } else {
+    moduleExports = await loadModuleInBrowser(path, name, moduleFileName);
+  }
+
+  importedModules.set(name, moduleExports);
+
+  logger.info(`Successfully imported module: ${name}`, Object.keys(moduleExports));
+
+  return moduleExports;
 }
 
 export function moduleImported(moduleName: string): boolean {
   return importedModules.has(moduleName);
 }
 
+/**
+ * Get an imported module by its alias name
+ */
+export function getImportedModule(moduleName: string): any | undefined {
+  return importedModules.get(moduleName);
+}
+
+/**
+ * Get all imported module names
+ */
+export function getImportedModuleNames(): string[] {
+  return Array.from(importedModules.keys());
+}
+
 function maybeEvalFunction(fnName: string): Function | undefined {
   try {
     return eval(fnName);

package/src/runtime/loader.ts

@@ -1137,15 +1137,23 @@ export async function parseAndIntern(code: string, moduleName?: string) {
   await internModule(r.parseResult.value);
 }
 
+export async function refreshModuleDefinition(moduleName: string, moduleDefinition: string) {
+  removeModule(moduleName);
+  const r = await parse(moduleDefinition);
+  maybeRaiseParserErrors(r);
+  await internModule(r.parseResult.value);
+}
+
 export async function internModule(
   module: ModuleDefinition,
   moduleFileName?: string
 ): Promise<Module> {
   const mn = module.name;
   const r = addModule(mn);
-  module.imports.forEach(async (imp: Import) => {
+  // 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);
-  });
+  }
   for (let i = 0; i < module.defs.length; ++i) {
     const def = module.defs[i];
     await addFromDef(def, mn);

package/src/runtime/module-transform.ts

@@ -0,0 +1,277 @@
+/**
+ * ES6 Module Transformation Utilities
+ *
+ * Transforms ES6 import/export syntax into code that can be evaluated
+ * in a browser environment without native ES6 module support.
+ */
+
+import { logger } from './logger.js';
+
+export interface ImportInfo {
+  defaultImport?: string;
+  namedImports?: string[];
+  moduleSpecifier: string;
+  fullStatement: string;
+}
+
+export interface DynamicImportInfo {
+  fullMatch: string;
+  templateString: string;
+}
+
+export interface TransformResult {
+  transformedCode: string;
+  imports: ImportInfo[];
+  dynamicImports: DynamicImportInfo[];
+  exports: string[];
+}
+
+/**
+ * Parse ES6 import statements from code
+ * Matches: import ... from 'url'
+ */
+export function parseImports(content: string): ImportInfo[] {
+  const imports: ImportInfo[] = [];
+
+  // Match: import ... from 'url'
+  const importRegex = /import\s+(?:(\w+)|{([^}]+)})\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+
+  while ((match = importRegex.exec(content)) !== null) {
+    const [fullStatement, defaultImport, namedImports, moduleSpecifier] = match;
+
+    imports.push({
+      defaultImport,
+      namedImports: namedImports ? namedImports.split(',').map(n => n.trim()) : undefined,
+      moduleSpecifier,
+      fullStatement,
+    });
+  }
+
+  return imports;
+}
+
+/**
+ * Parse dynamic import statements
+ * Matches: await import(`${process.cwd()}/...`)
+ */
+export function parseDynamicImports(content: string): DynamicImportInfo[] {
+  const dynamicImports: DynamicImportInfo[] = [];
+
+  const dynamicImportRegex = /await\s+import\s*\(\s*`([^`]+)`\s*\)/g;
+  let match;
+
+  while ((match = dynamicImportRegex.exec(content)) !== null) {
+    const [fullMatch, templateString] = match;
+    dynamicImports.push({
+      fullMatch,
+      templateString,
+    });
+  }
+
+  return dynamicImports;
+}
+
+/**
+ * Parse export statements and extract exported names
+ */
+export function parseExports(content: string): string[] {
+  const exportedNames: string[] = [];
+
+  // Handle: export function name() {}
+  const exportFnRegex = /export\s+(async\s+)?function\s+(\w+)/g;
+  let match;
+
+  while ((match = exportFnRegex.exec(content)) !== null) {
+    exportedNames.push(match[2]);
+  }
+
+  // Handle: export const name = ...
+  const exportConstRegex = /export\s+(const|let|var)\s+(\w+)/g;
+
+  while ((match = exportConstRegex.exec(content)) !== null) {
+    exportedNames.push(match[2]);
+  }
+
+  // Handle: export { name1, name2 }
+  const exportListRegex = /export\s*{\s*([^}]+)\s*}/g;
+
+  while ((match = exportListRegex.exec(content)) !== null) {
+    const names = match[1].split(',').map(n => n.trim().split(' as ')[0].trim());
+    exportedNames.push(...names);
+  }
+
+  return exportedNames;
+}
+
+/**
+ * Remove import statements from code
+ */
+export function removeImportStatements(content: string, imports: ImportInfo[]): string {
+  let result = content;
+
+  for (const imp of imports) {
+    result = result.replace(imp.fullStatement, '');
+  }
+
+  return result;
+}
+
+/**
+ * Remove export keywords from code
+ */
+export function removeExportKeywords(content: string): string {
+  let result = content;
+
+  // Remove: export function name() {}
+  result = result.replace(
+    /export\s+(async\s+)?function\s+(\w+)/g,
+    (match, async, name) => `${async || ''}function ${name}`
+  );
+
+  // Remove: export const name = ...
+  result = result.replace(
+    /export\s+(const|let|var)\s+(\w+)/g,
+    (match, keyword, name) => `${keyword} ${name}`
+  );
+
+  // Remove: export { name1, name2 }
+  result = result.replace(/export\s*{\s*[^}]+\s*}/g, '');
+
+  return result;
+}
+
+/**
+ * Replace dynamic imports with variable references
+ */
+export function replaceDynamicImports(
+  content: string,
+  dynamicImports: DynamicImportInfo[]
+): { code: string; varNames: Map<string, string> } {
+  let result = content;
+  const varNames = new Map<string, string>();
+
+  for (const dynImp of dynamicImports) {
+    // Clean up process.cwd() references
+    const cleanedPath = dynImp.templateString.replace(/\$\{process\.cwd\(\)\}/g, '');
+
+    // Create a variable name from the path
+    const varName = cleanedPath.split('/').pop()?.replace(/\.js$/, '') || 'dynamicModule';
+
+    varNames.set(cleanedPath, varName);
+    result = result.replace(dynImp.fullMatch, varName);
+  }
+
+  return { code: result, varNames };
+}
+
+/**
+ * Generate export assignments
+ */
+export function generateExportAssignments(exportedNames: string[]): string {
+  if (exportedNames.length === 0) {
+    return '';
+  }
+
+  const assignments = exportedNames.map(name => `exports.${name} = ${name};`).join('\n');
+
+  return `\n\n// Export assignments\n${assignments}`;
+}
+
+/**
+ * Transform ES6 module code to CommonJS-style code
+ */
+export function transformModule(content: string): TransformResult {
+  logger.debug('Transforming ES6 module code');
+
+  // Parse imports, exports, and dynamic imports
+  const imports = parseImports(content);
+  const dynamicImports = parseDynamicImports(content);
+  const exports = parseExports(content);
+
+  // Remove import statements
+  let transformedCode = removeImportStatements(content, imports);
+
+  // Handle dynamic imports
+  const { code: codeWithoutDynImports } = replaceDynamicImports(transformedCode, dynamicImports);
+  transformedCode = codeWithoutDynImports;
+
+  // Remove export keywords
+  transformedCode = removeExportKeywords(transformedCode);
+
+  // Add export assignments
+  transformedCode += generateExportAssignments(exports);
+
+  logger.debug(
+    `Found ${imports.length} imports, ${dynamicImports.length} dynamic imports, ${exports.length} exports`
+  );
+
+  return {
+    transformedCode,
+    imports,
+    dynamicImports,
+    exports,
+  };
+}
+
+/**
+ * Create a wrapped function that evaluates the transformed code
+ * with injected dependencies
+ */
+export function wrapModuleCode(transformedCode: string, importedModules: Map<string, any>): string {
+  const importNames = Array.from(importedModules.keys());
+
+  const wrappedCode = `
+    (function(exports, ${importNames.join(', ')}) {
+      ${transformedCode}
+      return exports;
+    })
+  `;
+
+  return wrappedCode;
+}
+
+/**
+ * Evaluate wrapped module code and return the exports
+ */
+export function evaluateModule(wrappedCode: string, importedModules: Map<string, any>): any {
+  const exportObj: any = {};
+  const importValues = Array.from(importedModules.values());
+
+  try {
+    const moduleFactory = eval(wrappedCode);
+    return moduleFactory(exportObj, ...importValues);
+  } catch (error) {
+    logger.error('Failed to evaluate module:', error);
+    throw error;
+  }
+}
+
+/**
+ * Create CommonJS-style wrapper for code without ES6 imports
+ */
+export function wrapCommonJSCode(content: string): string {
+  return `
+    (function(module, exports) {
+      ${content}
+      return module.exports || exports;
+    })
+  `;
+}
+
+/**
+ * Evaluate CommonJS-style code
+ */
+export function evaluateCommonJS(wrappedCode: string): any {
+  const moduleObj: any = { exports: {} };
+  const exportsObj: any = {};
+
+  try {
+    const moduleFactory = eval(wrappedCode);
+    const result = moduleFactory(moduleObj, exportsObj);
+    return result || moduleObj.exports || exportsObj;
+  } catch (error) {
+    logger.error('Failed to evaluate CommonJS module:', error);
+    throw error;
+  }
+}