agentlang 0.6.9 → 0.7.1

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

@@ -1143,9 +1143,10 @@ export async function internModule(
 ): 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;
+  }
+}

package/src/runtime/modules/ai.ts

@@ -15,6 +15,7 @@ import {
   parseAndEvaluateStatement,
 } from '../interpreter.js';
 import {
+  Agent,
   asJSONSchema,
   Decision,
   fetchModule,
@@ -663,12 +664,25 @@ Only return a pure JSON object with no extra text, annotations etc.`;
           if (entryName) {
             const hasmod = slimModules.has(moduleName);
             const defs = hasmod ? slimModules.get(moduleName) : new Array<string>();
-            const entry = m.getEntry(entryName);
-            const s =
-              entry instanceof Record ? (entry as Record).toString_(true) : entry.toString();
-            defs?.push(s);
-            if (!hasmod && defs) {
-              slimModules.set(moduleName, defs);
+            // Try to get entry directly first, then try as an agent (agents have _agent suffix)
+            let entry = m.getEntrySafe(entryName);
+            if (!entry) {
+              // Try with agent suffix - agents are stored with escaped names
+              entry = m.getEntrySafe(Agent.EscapeName(entryName));
+            }
+            if (entry) {
+              const s =
+                entry instanceof Record ? (entry as Record).toString_(true) : entry.toString();
+              // Add full qualified name comment so LLM knows how to reference it
+              const fqName = `${moduleName}/${entryName}`;
+              defs?.push(
+                `# Tool: ${fqName}\n# Use as: {${fqName} {...}} or {${fqName}? {...}}\n${s}`
+              );
+              if (!hasmod && defs) {
+                slimModules.set(moduleName, defs);
+              }
+            } else {
+              logger.warn(`Tool entry '${entryName}' not found in module '${moduleName}'`);
             }
           } else {
             tooldefs.push(fetchModule(moduleName).toString());

package/src/runtime/modules/auth.ts

@@ -180,6 +180,19 @@ relationship RolePermission between(Role, Permission)
     }
 }
 
+@public workflow GetPermissionsForRole {
+    {Role {__path__? GetPermissionsForRole.Role},
+      RolePermission {Permission? {}},
+      @into 
+       {Id Permission.id,
+        resourceFqName Permission.resourceFqName,
+        c Permission.c,
+        r Permission.r,
+        u Permission.u,
+        d Permission.d}
+    }
+}
+
 @public workflow AssignUserToRole {
     {User {id? AssignUserToRole.userId}} @as [user];
     {Role {name? AssignUserToRole.roleName}} @as [role];
@@ -1358,7 +1371,7 @@ export async function getUserInfo(
         }
         if (role) {
           permissions = await evalEvent(
-            'ListRolePermissions',
+            'GetPermissionsForRole',
             {
               Role: role,
             },
@@ -1408,7 +1421,7 @@ export async function getUserInfoByEmail(
         }
         if (role) {
           permissions = await evalEvent(
-            'ListRolePermissions',
+            'GetPermissionsForRole',
             {
               Role: role,
             },

package/src/runtime/modules/core.ts

@@ -7,6 +7,7 @@ import {
   escapeSpecialChars,
   isString,
   restoreSpecialChars,
+  makeCoreModuleName,
 } from '../util.js';
 import { Instance, isInstanceOfType, makeInstance, newInstanceAttributes } from '../module.js';
 import {
@@ -139,9 +140,18 @@ export const CoreModules: string[] = [];
 export function registerCoreModules() {
   DefaultModules.add(DefaultModuleName);
   CoreModules.push(CoreModuleDefinition);
-  [auth, ai, files].forEach((mdef: string) => {
-    CoreModules.push(mdef);
-    DefaultModules.add(mdef);
+
+  // Map of module definitions to their names for proper DefaultModules registration
+  const coreModuleInfo: Array<{ def: string; name: string }> = [
+    { def: auth, name: makeCoreModuleName('auth') },
+    { def: ai, name: makeCoreModuleName('ai') },
+    { def: files, name: makeCoreModuleName('files') },
+  ];
+
+  coreModuleInfo.forEach(({ def, name }) => {
+    CoreModules.push(def);
+    // Add module NAME (not definition) to DefaultModules so flushAllModules() doesn't remove core modules
+    DefaultModules.add(name);
   });
 }