agentlang 0.10.1 → 0.10.3

package/src/runtime/loader.ts

@@ -72,6 +72,9 @@ import {
   Retry,
   addGlobalRetry,
   AgentEvaluator,
+  getAllBetweenRelationshipsForEntity,
+  getAttributeExpr,
+  AttributeSpec,
 } from './module.js';
 import {
   asStringLiteralsMap,
@@ -85,6 +88,7 @@ import {
   registerInitFunction,
   rootRef,
   ScratchModuleName,
+  splitRefs,
 } from './util.js';
 import { getFileSystem, toFsPath, readFile, readdir, exists } from '../utils/fs-utils.js';
 import { URI } from 'vscode-uri';
@@ -102,7 +106,12 @@ import {
   parseWorkflow,
 } from '../language/parser.js';
 import { logger } from './logger.js';
-import { Environment, evaluateStatements, GlobalEnvironment } from './interpreter.js';
+import {
+  Environment,
+  evaluateStatements,
+  extractRefsFromExpr,
+  GlobalEnvironment,
+} from './interpreter.js';
 import { createPermission, createRole } from './modules/auth.js';
 import {
   AgentEntityName,
@@ -114,7 +123,7 @@ import {
 import { getDefaultLLMService } from './agents/registry.js';
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
 import { registerResolver, setResolver } from './resolvers/registry.js';
-import { Config, ConfigSchema, setAppConfig } from './state.js';
+import { AppConfig, Config, ConfigSchema, setAppConfig } from './state.js';
 import { getModuleFn, importModule } from './jsmodules.js';
 import { SetSubscription } from './defs.js';
 import { ExtendedFileSystem } from '../utils/fs/interfaces.js';
@@ -178,12 +187,14 @@ export async function extractDocument(
     validation: true,
   });
 
+  // Handle parser/lexer errors (with human-friendly messages)
+  maybeRaiseParserErrors(document);
+
   // Handle validation errors
   const errs = maybeGetValidationErrors(document);
 
   if (errs) {
-    const errorMsg = `${errs.join('\n')}`;
-    throw new Error(errorMsg);
+    throw new Error('\n' + errs);
   }
 
   return document;
@@ -423,7 +434,9 @@ export async function loadAppConfig(configDirOrContent: string): Promise<Config>
       const envConfig = JSON.parse(envAppConfig);
       cfg = { ...cfg, ...envConfig };
     }
-    return setAppConfig(cfg);
+    const result = setAppConfig(cfg);
+
+    return result;
   } catch (err: any) {
     if (err instanceof z.ZodError) {
       console.log(chalk.red('Config validation failed:'));
@@ -1152,6 +1165,16 @@ function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
     });
     const methodsObj = Object.fromEntries(methods.entries()) as GenericResolverMethods;
     const resolver = new GenericResolver(resolverName, methodsObj);
+    const connections = AppConfig?.integrations?.connections;
+    if (connections) {
+      for (const [integName, conn] of Object.entries(connections)) {
+        const resolvers = typeof conn === 'string' ? [] : conn.resolvers;
+        if (resolvers.includes(resolverName)) {
+          resolver.setIntegrationName(integName);
+          break;
+        }
+      }
+    }
     registerResolver(resolverName, () => {
       return resolver;
     });
@@ -1215,6 +1238,60 @@ export async function refreshModuleDefinition(moduleName: string, moduleDefiniti
   await internModule(r.parseResult.value);
 }
 
+function validateExprRelationshipRefs(moduleName: string, mod: Module) {
+  const entities = mod.getEntityEntries();
+  for (const entity of entities) {
+    const schema = entity.schema;
+    schema.forEach((attrSpec: AttributeSpec, attrName: string) => {
+      const expr = getAttributeExpr(attrSpec);
+      if (!expr) return;
+      const refs = extractRefsFromExpr(expr);
+      const entityFqName = makeFqName(moduleName, entity.name);
+      const rels = getAllBetweenRelationshipsForEntity(moduleName, entity.name);
+      if (rels.length === 0) return;
+      for (const ref of refs) {
+        const parts = splitRefs(ref);
+        if (parts.length < 3) continue;
+        const relName = parts[0];
+        const targetEntityAlias = parts[1];
+        const rel = rels.find((r: Relationship) => r.name === relName);
+        if (!rel) continue;
+        // Matched a relationship name - validate
+        if (targetEntityAlias !== rel.node1.alias && targetEntityAlias !== rel.node2.alias) {
+          throw new Error(
+            `Invalid @expr reference "${ref}" on ${entityFqName}.${attrName}: ` +
+              `"${targetEntityAlias}" does not match any entity alias in relationship ${relName} ` +
+              `(expected "${rel.node1.alias}" or "${rel.node2.alias}")`
+          );
+        }
+        // The target entity must be on the OTHER side from the current entity
+        const isFirstNode = rel.isFirstNodeName(entityFqName);
+        const targetIsFirst = targetEntityAlias === rel.node1.alias;
+        if ((isFirstNode && targetIsFirst) || (!isFirstNode && !targetIsFirst)) {
+          throw new Error(
+            `Invalid @expr reference "${ref}" on ${entityFqName}.${attrName}: ` +
+              `the referenced entity "${targetEntityAlias}" must be on the other side of relationship ${relName}`
+          );
+        }
+        // Cardinality check
+        if (rel.isManyToMany()) {
+          throw new Error(
+            `Invalid @expr reference "${ref}" on ${entityFqName}.${attrName}: ` +
+              `cannot reference through many-to-many relationship ${relName}`
+          );
+        }
+        if (rel.isOneToMany() && isFirstNode) {
+          throw new Error(
+            `Invalid @expr reference "${ref}" on ${entityFqName}.${attrName}: ` +
+              `cannot reference from the "one" side of one-to-many relationship ${relName} ` +
+              `(would resolve to multiple entities)`
+          );
+        }
+      }
+    });
+  }
+}
+
 export async function internModule(
   module: ModuleDefinition,
   moduleFileName?: string
@@ -1230,6 +1307,7 @@ export async function internModule(
     const def = module.defs[i];
     await addFromDef(def, mn);
   }
+  validateExprRelationshipRefs(mn, r);
   return r;
 }
 

package/src/runtime/logger.ts

@@ -36,6 +36,17 @@ export function initializeLogger() {
       maxFiles: '7d',
     });
 
+    // Add console transport for visibility
+    const consoleTransport = new winston.transports.Console({
+      level: logLevel,
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.printf(({ level, message }: any) => {
+          return `${level}: ${message}`;
+        })
+      ),
+    });
+
     logger = winston.createLogger({
       level: logLevel,
       format: winston.format.combine(
@@ -44,7 +55,7 @@ export function initializeLogger() {
           return `[${timestamp}] ${level}: ${message}`;
         })
       ),
-      transports: [fileTransport],
+      transports: [fileTransport, consoleTransport],
     });
   } else {
     function mkLogger(tag: string): Function {

package/src/runtime/module.ts

@@ -1409,6 +1409,10 @@ export class Relationship extends Record {
     return this.relType == RelType.BETWEEN;
   }
 
+  isSelfReferencing(): boolean {
+    return this.node1.path.asFqName() === this.node2.path.asFqName();
+  }
+
   parentNode(): RelationshipNode {
     return this.node1;
   }
@@ -1502,6 +1506,28 @@ export class Relationship extends Record {
     }
   }
 
+  /**
+   * For self-referencing relationships, resolve the alias for the connected instance
+   * based on an explicit connectedAlias. Falls back to fqName-based lookup for
+   * non-self-referencing relationships.
+   */
+  getAliasForConnected(inst: Instance, connectedAlias?: string): string {
+    if (connectedAlias && this.isSelfReferencing()) {
+      return connectedAlias;
+    }
+    return this.getAliasFor(inst);
+  }
+
+  getInverseAliasForConnected(inst: Instance, connectedAlias?: string): string {
+    if (connectedAlias && this.isSelfReferencing()) {
+      if (connectedAlias === this.node1.alias) {
+        return this.node2.alias;
+      }
+      return this.node1.alias;
+    }
+    return this.getInverseAliasFor(inst);
+  }
+
   isParent(inst: Instance): boolean {
     return inst.getFqName() == this.node1.path.asFqName();
   }
@@ -2004,7 +2030,7 @@ export class Retry extends ModuleEntry {
 
   constructor(name: string, moduleName: string, attempts: number) {
     super(name, moduleName);
-    this.attempts = attempts <= 0 ? 0 : attempts;
+    this.attempts = attempts;
     this.backoff = {
       strategy: undefined,
       delay: undefined,
@@ -2096,7 +2122,7 @@ export class Retry extends ModuleEntry {
   }
 
   getNextDelayMs(attempt: number): number {
-    if (attempt >= this.attempts) {
+    if (this.attempts >= 0 && attempt >= this.attempts) {
       return 0;
     }
     const delay = this.backoff.delay === undefined ? 2 : this.backoff.delay;
@@ -2833,6 +2859,46 @@ export function resolveDocumentAliases(names: string[]): string[] {
   return names.map((name: string) => DocumentAliasMap.get(name) ?? name);
 }
 
+// TopicRegistry: maps topic name → list of document titles belonging to that topic
+const TopicRegistry: Map<string, string[]> = new Map();
+
+export function registerTopic(name: string, documents?: string): void {
+  if (!name) return;
+  const docs = documents
+    ? documents
+        .split(',')
+        .map(d => d.trim())
+        .filter(Boolean)
+    : [];
+  TopicRegistry.set(name, docs);
+}
+
+export function getTopicDocuments(topicName: string): string[] {
+  return TopicRegistry.get(topicName) ?? [];
+}
+
+export function resolveTopicNames(topicsCsv: string): string[] {
+  return topicsCsv
+    .split(',')
+    .map(t => t.trim())
+    .filter(Boolean);
+}
+
+export function getTopicContainerTags(topicNames: string[]): string[] {
+  return topicNames.filter(name => TopicRegistry.has(name));
+}
+
+export function getAllDocumentsForTopics(topicNames: string[]): string[] {
+  const docs: string[] = [];
+  for (const name of topicNames) {
+    const topicDocs = TopicRegistry.get(name);
+    if (topicDocs) {
+      docs.push(...topicDocs);
+    }
+  }
+  return [...new Set(docs)];
+}
+
 export function addGlobalRetry(r: Retry): Retry {
   if (GlobalRetries === undefined) {
     GlobalRetries = new Array<Retry>();
@@ -2929,6 +2995,19 @@ export function fetchModuleEntry(entryName: string, moduleName: string): ModuleE
   const module: Module = fetchModule(moduleName);
   return module.getEntry(entryName);
 }
+// UUID regex pattern
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+// containerTag format: alphanumeric with dashes/underscores, no spaces
+const CONTAINER_TAG_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+
+export function isTopicReference(value: any): boolean {
+  if (!isString(value)) {
+    return false;
+  }
+  // Topic can be a UUID or a containerTag format
+  return UUID_REGEX.test(value) || CONTAINER_TAG_REGEX.test(value);
+}
 
 const builtInChecks = new Map([
   ['String', isString],
@@ -2957,6 +3036,7 @@ const builtInChecks = new Map([
       return true;
     },
   ],
+  ['Topic', isTopicReference],
 ]);
 
 export const builtInTypes = new Set(Array.from(builtInChecks.keys()));
@@ -2980,7 +3060,16 @@ export const propertyNames = new Set([
   '@comment',
 ]);
 
-const TextualTypes = new Set(['String', 'Email', 'UUID', 'DateTime', 'Date', 'Time', 'Path']);
+const TextualTypes = new Set([
+  'String',
+  'Email',
+  'UUID',
+  'DateTime',
+  'Date',
+  'Time',
+  'Path',
+  'Topic',
+]);
 
 function isTextualType(type: string): boolean {
   return TextualTypes.has(type);
@@ -3749,6 +3838,8 @@ export class Instance {
   groupBy: string[] | undefined;
   orderBy: string[] | undefined;
   orderByDesc: boolean = false;
+  limit: number | undefined;
+  offset: number | undefined;
   private contextData: Map<string, any> | undefined;
   private ___id: string;
 
@@ -3861,6 +3952,16 @@ export class Instance {
     return this;
   }
 
+  setLimit(n: number): Instance {
+    this.limit = n;
+    return this;
+  }
+
+  setOffset(n: number): Instance {
+    this.offset = n;
+    return this;
+  }
+
   asSerializableObject(): object {
     const obj: any = {
       AL_INSTANCE: true,