agentlang 0.10.0 → 0.10.2

package/src/runtime/monitor.ts

@@ -10,6 +10,9 @@ export class MonitorEntry {
   private llm: boolean = false;
   private llmPrompt: string | undefined;
   private llmResponse: string | undefined;
+  private llmInputTokens: number | undefined;
+  private llmOutputTokens: number | undefined;
+  private llmTotalTokens: number | undefined;
   private planner: boolean = false;
   private flowStep: boolean = false;
   private flow: boolean = false;
@@ -25,6 +28,10 @@ export class MonitorEntry {
     return this.input;
   }
 
+  getTimestamp(): number {
+    return this.timestamp;
+  }
+
   setResult(result: any): MonitorEntry {
     if (this.result === undefined) {
       this.result = result;
@@ -68,6 +75,13 @@ export class MonitorEntry {
     return this;
   }
 
+  setLlmTokenUsage(input: number, output: number, total: number): MonitorEntry {
+    this.llmInputTokens = input;
+    this.llmOutputTokens = output;
+    this.llmTotalTokens = total;
+    return this;
+  }
+
   flagAsPlanner(): MonitorEntry {
     this.llm = true;
     if (this.flowStep || this.flow || this.decision) {
@@ -137,6 +151,11 @@ export class MonitorEntry {
       llmObj.isFlowStep = this.flowStep;
       llmObj.isDecision = this.decision;
       llmObj.isFlow = this.flow;
+      if (this.llmInputTokens !== undefined) {
+        llmObj.inputTokens = this.llmInputTokens;
+        llmObj.outputTokens = this.llmOutputTokens;
+        llmObj.totalTokens = this.llmTotalTokens;
+      }
       obj.llm = llmObj;
     }
     obj.label = this.input;
@@ -269,9 +288,16 @@ export class Monitor {
     return this;
   }
 
+  setEntryLlmTokenUsage(input: number, output: number, total: number): Monitor {
+    if (this.lastEntry !== undefined) {
+      this.lastEntry.setLlmTokenUsage(input, output, total);
+    }
+    return this;
+  }
+
   private finalizeLastEntry(): void {
     if (this.lastEntry) {
-      const ms = Date.now() - this.lastEntrySetAtMs;
+      const ms = Date.now() - this.lastEntry.getTimestamp();
       this.lastEntry.setLatencyMs(ms);
       if (MonitoringCallback !== undefined) {
         MonitoringCallback(this.lastEntry);

package/src/runtime/relgraph.ts

@@ -51,8 +51,11 @@ export class RelationshipGraph {
     node: RelationshipGraphNode,
     onNode: Function,
     onContainsRelationship: Function,
-    onBetweenRelationship: Function
+    onBetweenRelationship: Function,
+    visited: Set<RelationshipGraphNode>
   ) {
+    if (visited.has(node)) return;
+    visited.add(node);
     const n = node.entity.asFqName();
     onNode(n, node.edges);
     node.edges.forEach((edge: RelationshipGraphEdge) => {
@@ -60,13 +63,14 @@ export class RelationshipGraph {
         ? onContainsRelationship
         : onBetweenRelationship;
       rf(n, edge.node.entity.asFqName(), edge.relationship);
-      this.walkEdges(edge.node, onNode, onContainsRelationship, onBetweenRelationship);
+      this.walkEdges(edge.node, onNode, onContainsRelationship, onBetweenRelationship, visited);
     });
   }
 
   walk(onNode: Function, onContainsRelationship: Function, onBetweenRelationship: Function) {
+    const visited = new Set<RelationshipGraphNode>();
     this.nodes.forEach((node: RelationshipGraphNode) => {
-      this.walkEdges(node, onNode, onContainsRelationship, onBetweenRelationship);
+      this.walkEdges(node, onNode, onContainsRelationship, onBetweenRelationship, visited);
     });
   }
 }

package/src/runtime/resolvers/interface.ts

@@ -121,13 +121,15 @@ export class Resolver {
   /**
    * Return all instances connected to connectedInstance via the given between-relationship
    * @param relationship Between relationship
-   * @param connectedInstance The instance to traveres the relationship from
+   * @param connectedInstance The instance to traverse the relationship from
    * @param inst Target instance with query attributes
+   * @param connectedAlias For self-referencing relationships, the alias of the connected instance's role
    */
   public async queryConnectedInstances(
     relationship: Relationship,
     connectedInstance: Instance,
-    inst: Instance
+    inst: Instance,
+    connectedAlias?: string
   ): Promise<any> {
     return this.notImpl(`queryConnectedInstances(${relationship}, ${connectedInstance}, ${inst})`);
   }

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

@@ -188,13 +188,27 @@ function ormSchemaFromRecordSchema(
   const fqName = makeFqName(moduleName, entityName);
   getAllOneToOneRelationshipsForEntity(moduleName, entityName, allBetRels).forEach(
     (re: Relationship) => {
-      const colName = re.getInverseAliasForName(fqName);
-      if (cols.has(colName)) {
-        throw new Error(
-          `Cannot establish relationship ${re.name}, ${entityName}.${colName} already exists`
-        );
+      if (re.isSelfReferencing()) {
+        // Self-referencing one-to-one: add columns for both aliases
+        // so each side of the relationship can be stored on the entity.
+        // Both must be nullable since they're set after entity creation.
+        [re.node1.alias, re.node2.alias].forEach((colName: string) => {
+          if (cols.has(colName)) {
+            throw new Error(
+              `Cannot establish relationship ${re.name}, ${entityName}.${colName} already exists`
+            );
+          }
+          cols.set(colName, { type: 'varchar', unique: true });
+        });
+      } else {
+        const colName = re.getInverseAliasForName(fqName);
+        if (cols.has(colName)) {
+          throw new Error(
+            `Cannot establish relationship ${re.name}, ${entityName}.${colName} already exists`
+          );
+        }
+        cols.set(colName, { type: 'varchar', unique: true });
       }
-      cols.set(colName, { type: 'varchar', unique: true });
     }
   );
   if (relsSpec.size > 0) {

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

@@ -480,16 +480,17 @@ export class SqlDbResolver extends Resolver {
   public override async queryConnectedInstances(
     relationship: Relationship,
     connectedInstance: Instance,
-    inst: Instance
+    inst: Instance,
+    connectedAlias?: string
   ): Promise<Instance[]> {
     let result = SqlDbResolver.EmptyResultSet;
     if (relationship.isOneToOne()) {
-      const col = relationship.getAliasFor(connectedInstance);
+      const col = relationship.getAliasForConnected(connectedInstance, connectedAlias);
       inst.addQuery(col, '=', connectedInstance.lookup(PathAttributeName));
       return await this.queryInstances(inst, false);
     } else {
-      const from = relationship.getAliasFor(connectedInstance);
-      const to = relationship.getInverseAliasFor(connectedInstance);
+      const from = relationship.getAliasForConnected(connectedInstance, connectedAlias);
+      const to = relationship.getInverseAliasForConnected(connectedInstance, connectedAlias);
       await getAllConnected(
         asTableReference(inst.moduleName, inst.name),
         inst.queryAttributesAsObject(),
@@ -797,9 +798,18 @@ function ensureOneToOneAttributes(inst: Instance) {
   const betRels = getAllBetweenRelationships();
   getAllOneToOneRelationshipsForEntity(inst.moduleName, inst.name, betRels).forEach(
     (re: Relationship) => {
-      const n = re.getInverseAliasFor(inst);
-      if (!inst.attributes.has(n)) {
-        inst.attributes.set(n, crypto.randomUUID());
+      if (re.isSelfReferencing()) {
+        // Self-referencing one-to-one: ensure both alias columns have placeholder values
+        [re.node1.alias, re.node2.alias].forEach((n: string) => {
+          if (!inst.attributes.has(n)) {
+            inst.attributes.set(n, crypto.randomUUID());
+          }
+        });
+      } else {
+        const n = re.getInverseAliasFor(inst);
+        if (!inst.attributes.has(n)) {
+          inst.attributes.set(n, crypto.randomUUID());
+        }
       }
     }
   );

package/src/runtime/services/documentFetcher.ts

@@ -1,5 +1,5 @@
 import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { readFile } from 'node:fs/promises';
+import { readFile } from '../../utils/fs-utils.js';
 import { logger } from '../logger.js';
 import { parseAndEvaluateStatement } from '../interpreter.js';
 import { CoreAIModuleName } from '../modules/ai.js';
@@ -443,7 +443,7 @@ class DocumentFetcherService {
 
   private async fetchFromLocal(filePath: string): Promise<string> {
     try {
-      const content = await readFile(filePath, 'utf-8');
+      const content = await readFile(filePath);
       const lowerPath = filePath.toLowerCase();
       const isMarkdown = lowerPath.endsWith('.md') || lowerPath.endsWith('.markdown');
 

package/src/runtime/util.ts

@@ -1,7 +1,8 @@
-import { isNodeEnv } from '../utils/runtime.js';
+import { isNodeEnv, path } from '../utils/runtime.js';
 import {
   AliasSpec,
   CatchSpec,
+  EmptySpec,
   ExtendsClause,
   isLiteral,
   MapEntry,
@@ -15,7 +16,6 @@ import {
 } from '../language/generated/ast.js';
 import { readFile } from '../utils/fs-utils.js';
 import bcrypt from 'bcryptjs';
-import path from 'node:path';
 
 export const QuerySuffix = '?';
 
@@ -442,6 +442,18 @@ export function firstCatchSpec(stmt: Statement): CatchSpec | undefined {
   return undefined;
 }
 
+export function firstEmptySpec(stmt: Statement): EmptySpec | undefined {
+  if (stmt.hints) {
+    for (let i = 0; i < stmt.hints.length; ++i) {
+      const rh = stmt.hints[i];
+      if (rh.emptySpec) {
+        return rh.emptySpec;
+      }
+    }
+  }
+  return undefined;
+}
+
 function maybeExtractEntryName(n: string): string {
   const i = n.indexOf('$');
   if (i > 0) {
@@ -665,3 +677,51 @@ export function objectAsString(obj: any, keyAsString: boolean = false) {
   });
   return `{${entries.join(', ')}}`;
 }
+
+export type ExtractedText = {
+  extracted: string[] | undefined;
+  updatedText: string;
+};
+
+// extract all data between a given xml tag from within an arbitray text.
+export function extractAndRemoveAllXmlTaggedText(
+  text: string,
+  tagName: string,
+  replaceWith: string = ''
+): ExtractedText {
+  const pattern = `<${tagName}\\b[^>]*>([\\s\\S]*?)</${tagName}>`;
+  const regex = new RegExp(pattern, 'gi');
+
+  const extracted = [];
+  let updatedText = text;
+
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    extracted.push(match[1]);
+  }
+
+  updatedText = text.replace(regex, replaceWith);
+
+  return { extracted, updatedText };
+}
+
+export type ExtractedCode = {
+  language: string | null;
+  code: string;
+};
+
+// extract tick-quoted code from markdown-formatted text.
+export function extractFencedCodeBlocks(markdown: string): ExtractedCode[] {
+  const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
+  const blocks: ExtractedCode[] = [];
+  let match;
+
+  while ((match = codeBlockRegex.exec(markdown)) !== null) {
+    blocks.push({
+      language: match[1] || null,
+      code: match[2],
+    });
+  }
+
+  return blocks;
+}

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@asc','@async','@before','@catch','@desc','@distinct','@enum','@expr','@from','@full_join','@groupBy','@inner_join','@into','@join','@left_join','@meta','@oneof','@orderBy','@public','@rbac','@ref','@right_join','@then','@upsert','@where','@withRole','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','eval','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@asc','@async','@before','@catch','@desc','@distinct','@empty','@enum','@expr','@from','@full_join','@groupBy','@inner_join','@into','@join','@left_join','@meta','@oneof','@orderBy','@public','@rbac','@ref','@right_join','@then','@upsert','@where','@withRole','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','eval','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','==','>','>=','?','@'