agentlang 0.10.4 → 0.10.5

package/src/language/generated/grammar.ts

@@ -4359,33 +4359,16 @@ export const AgentlangGrammar = (): Grammar => loadedAgentlangGrammar ?? (loaded
             "value": "("
           },
           {
-            "$type": "Alternatives",
-            "elements": [
-              {
-                "$type": "Assignment",
-                "feature": "value",
-                "operator": "=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@135"
-                  },
-                  "arguments": []
-                }
+            "$type": "Assignment",
+            "feature": "value",
+            "operator": "=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@113"
               },
-              {
-                "$type": "Assignment",
-                "feature": "expr",
-                "operator": "=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@113"
-                  },
-                  "arguments": []
-                }
-              }
-            ]
+              "arguments": []
+            }
           },
           {
             "$type": "Keyword",
@@ -4412,33 +4395,16 @@ export const AgentlangGrammar = (): Grammar => loadedAgentlangGrammar ?? (loaded
             "value": "("
           },
           {
-            "$type": "Alternatives",
-            "elements": [
-              {
-                "$type": "Assignment",
-                "feature": "value",
-                "operator": "=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@135"
-                  },
-                  "arguments": []
-                }
+            "$type": "Assignment",
+            "feature": "value",
+            "operator": "=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@113"
               },
-              {
-                "$type": "Assignment",
-                "feature": "expr",
-                "operator": "=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@113"
-                  },
-                  "arguments": []
-                }
-              }
-            ]
+              "arguments": []
+            }
           },
           {
             "$type": "Keyword",

package/src/language/parser.ts

@@ -294,6 +294,13 @@ function introspectExpression(expr: Expr | undefined): BasePattern {
   throw new Error('Failed to introspect expression - ' + expr);
 }
 
+function exprToLimitOffset(expr: Expr): number | string | undefined {
+  if (isLiteral(expr) && expr.num !== undefined) {
+    return expr.num;
+  }
+  return expr.$cstNode?.text;
+}
+
 function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
   if (crudMap) {
     const cp: CrudPattern = new CrudPattern(crudMap.name);
@@ -327,10 +334,10 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
       cp.orderBy = opts.orderByClause.colNames;
     }
     if (opts.limitClause) {
-      cp.limit = opts.limitClause.value ?? opts.limitClause.expr?.$cstNode?.text;
+      cp.limit = exprToLimitOffset(opts.limitClause.value);
     }
     if (opts.offsetClause) {
-      cp.offset = opts.offsetClause.value ?? opts.offsetClause.expr?.$cstNode?.text;
+      cp.offset = exprToLimitOffset(opts.offsetClause.value);
     }
     cp.isCreate = false;
     cp.isQueryUpdate = false;

package/src/runtime/api.ts

@@ -1,5 +1,4 @@
 import { fetchConfig as al_fetchConfig } from './interpreter.js';
-import { defaultDataSource } from './resolvers/sqldb/database.js';
 import {
   makeInstance as al_makeInstance,
   isInstanceOfType as al_isInstanceOfType,
@@ -54,20 +53,6 @@ export function initGlobalApi() {
     globalThis.agentlang.exchangeOAuthCode = al_exchangeOAuthCode;
     globalThis.agentlang.getAccessToken = al_getAccessToken;
 
-    // Expose raw SQL query for resolvers that need direct database access (e.g. pgvector)
-    globalThis.agentlang.rawQuery = async (sql: string, params?: any[]) => {
-      if (!defaultDataSource || !defaultDataSource.isInitialized) {
-        throw new Error('Database not initialized');
-      }
-      return defaultDataSource.query(sql, params);
-    };
-
-    // Expose database type detection for resolvers
-    globalThis.agentlang.getDbType = () => {
-      if (!defaultDataSource || !defaultDataSource.isInitialized) return 'unknown';
-      return defaultDataSource.options.type;
-    };
-
     ApiInited = true;
   }
 }

package/src/runtime/defs.ts

@@ -4,8 +4,7 @@ export const PathAttributeName: string = '__path__';
 export const PathAttributeNameQuery: string = '__path__?';
 export const ParentAttributeName: string = '__parent__';
 export const DeletedFlagAttributeName: string = '__is_deleted__';
-export const AgentIdAttributeName: string = 'agentId';
-export const TenantAttributeName: string = 'agentId';
+export const TenantAttributeName: string = '__tenant__';
 
 export function isPathAttribute(n: string): boolean {
   return n.startsWith(PathAttributeName);

package/src/runtime/embeddings/chunker.ts

@@ -1,79 +1,41 @@
-/**
- * Streaming text chunker - yields chunks one at a time without storing all in memory.
- */
 export class TextChunker {
   private chunkSize: number;
   private chunkOverlap: number;
   private separators: string[] = ['\n\n', '\n', '. ', ' ', ''];
 
   constructor(chunkSize: number = 1000, chunkOverlap: number = 200) {
-    // Ensure valid values - overlap must be less than chunk size to avoid infinite loop
-    this.chunkSize = Math.max(100, chunkSize || 1000);
-    // Cap overlap to at most 20% of chunk size to ensure progress
-    this.chunkOverlap = Math.max(
-      0,
-      Math.min(chunkOverlap || 200, Math.floor(this.chunkSize * 0.2))
-    );
+    this.chunkSize = chunkSize;
+    this.chunkOverlap = chunkOverlap;
   }
 
-  /**
-   * Calculate total chunks without creating them all in memory.
-   * Used for logging/progress tracking.
-   */
-  estimateChunks(text: string): number {
-    if (text.length <= this.chunkSize) {
-      return 1;
-    }
-    // Rough estimate: (text length / effective chunk size) + 1
-    const effectiveChunkSize = this.chunkSize - this.chunkOverlap;
-    return Math.ceil(text.length / effectiveChunkSize);
-  }
-
-  /**
-   * Streaming generator that yields chunks one at a time.
-   * Memory-efficient: doesn't store all chunks in an array.
-   */
-  *streamChunks(text: string): Generator<string, void, unknown> {
+  splitText(text: string): string[] {
     if (text.length <= this.chunkSize) {
-      yield text;
-      return;
+      return [text];
     }
 
+    const chunks: string[] = [];
     let start = 0;
-    const minAdvance = Math.max(50, this.chunkSize - this.chunkOverlap); // Ensure we always advance
 
     while (start < text.length) {
       let end = Math.min(start + this.chunkSize, text.length);
 
       if (end < text.length) {
-        // Try to find a good split point, but ensure we advance by at least minAdvance
-        const splitPoint = this.findBestSplitPoint(text, start, end);
-        // Only use split point if it gives us reasonable progress
-        if (splitPoint - start >= minAdvance * 0.5) {
-          end = splitPoint;
-        }
-        // Otherwise use the hard end to ensure progress
+        end = this.findBestSplitPoint(text, start, end);
       }
 
-      yield text.substring(start, end);
-
-      // Advance by at least minAdvance characters to avoid infinite loops
-      const nextStart = end - this.chunkOverlap;
-      start = Math.max(nextStart, start + minAdvance * 0.5);
+      chunks.push(text.substring(start, end));
+      start = end - this.chunkOverlap;
 
-      if (start >= text.length) {
+      if (start < 0) start = 0;
+      if (start >= text.length - this.chunkOverlap) {
+        if (start < text.length) {
+          chunks.push(text.substring(start));
+        }
         break;
       }
     }
-  }
 
-  /**
-   * Legacy method for backwards compatibility.
-   * ⚠️ WARNING: This creates all chunks in memory and can cause OOM on large documents.
-   * Prefer streamChunks() for large documents.
-   */
-  splitText(text: string): string[] {
-    return Array.from(this.streamChunks(text));
+    return chunks;
   }
 
   private findBestSplitPoint(text: string, start: number, end: number): number {

package/src/runtime/embeddings/openai.ts

@@ -1,7 +1,6 @@
 import { OpenAIEmbeddings } from '@langchain/openai';
 import { EmbeddingProvider, EmbeddingProviderConfig } from './provider.js';
 import { getLocalEnv } from '../auth/defs.js';
-import { logger } from '../logger.js';
 
 export interface OpenAIEmbeddingConfig extends EmbeddingProviderConfig {
   model?: string;
@@ -15,9 +14,6 @@ export class OpenAIEmbeddingProvider extends EmbeddingProvider {
   constructor(config?: EmbeddingProviderConfig) {
     super(config || {});
     this.openaiConfig = (this.config as OpenAIEmbeddingConfig) || {};
-    logger.debug(
-      `[OPENAI-EMBEDDING] Provider created with model: ${this.openaiConfig.model || 'default'}`
-    );
   }
 
   protected createEmbeddings(): OpenAIEmbeddings {
@@ -25,40 +21,26 @@ export class OpenAIEmbeddingProvider extends EmbeddingProvider {
       apiKey: this.resolveApiKey(),
     };
 
-    // Use this.config directly since this.openaiConfig is not initialized yet
-    // during parent constructor (super() calls createEmbeddings before child init)
-    const openaiConfig = (this.config as OpenAIEmbeddingConfig) || {};
-
-    if (openaiConfig?.model) {
-      config.model = openaiConfig.model;
+    if (this.openaiConfig?.model) {
+      config.model = this.openaiConfig.model;
     }
 
-    if (openaiConfig?.dimensions) {
-      config.dimensions = openaiConfig.dimensions;
+    if (this.openaiConfig?.dimensions) {
+      config.dimensions = this.openaiConfig.dimensions;
     }
 
-    if (openaiConfig?.maxRetries !== undefined) {
-      config.maxRetries = openaiConfig.maxRetries;
+    if (this.openaiConfig?.maxRetries !== undefined) {
+      config.maxRetries = this.openaiConfig.maxRetries;
     }
 
     return new OpenAIEmbeddings(config);
   }
 
   protected resolveApiKey(): string {
-    // Use this.config directly since this.openaiConfig may not be initialized yet
-    // during constructor (createEmbeddings is called during super())
-    const config = this.openaiConfig || (this.config as OpenAIEmbeddingConfig) || {};
-    if (config.apiKey) {
-      return config.apiKey;
-    }
-    const envKey = process.env.AGENTLANG_OPENAI_KEY || getLocalEnv('AGENTLANG_OPENAI_KEY');
-    if (envKey) {
-      return envKey;
+    if (this.openaiConfig?.apiKey) {
+      return this.openaiConfig.apiKey;
     }
-    logger.warn(
-      `[OPENAI-EMBEDDING] No API key found! Set AGENTLANG_OPENAI_KEY environment variable.`
-    );
-    return '';
+    return process.env.AGENTLANG_OPENAI_KEY || getLocalEnv('AGENTLANG_OPENAI_KEY') || '';
   }
 
   getProviderName(): string {

package/src/runtime/embeddings/provider.ts

@@ -1,5 +1,4 @@
 import { Embeddings } from '@langchain/core/embeddings';
-import { logger } from '../logger.js';
 
 export interface EmbeddingProviderConfig {
   chunkSize?: number;
@@ -24,27 +23,7 @@ export abstract class EmbeddingProvider {
   abstract getProviderName(): string;
 
   async embedText(text: string): Promise<number[]> {
-    logger.debug(`[EMBEDDING-PROVIDER] embedText called (${text.length} chars)`);
-    const startTime = Date.now();
-    const result = await this.embeddings.embedQuery(text);
-    const duration = Date.now() - startTime;
-    logger.debug(
-      `[EMBEDDING-PROVIDER] embedText completed in ${duration}ms (${result.length} dimensions)`
-    );
-    return result;
-  }
-
-  async embedTexts(texts: string[]): Promise<number[][]> {
-    if (texts.length === 0) return [];
-    if (texts.length === 1) return [await this.embedText(texts[0])];
-    logger.debug(`[EMBEDDING-PROVIDER] embedTexts called (${texts.length} texts)`);
-    const startTime = Date.now();
-    const results = await this.embeddings.embedDocuments(texts);
-    const duration = Date.now() - startTime;
-    logger.debug(
-      `[EMBEDDING-PROVIDER] embedTexts completed in ${duration}ms (${texts.length} texts, ${results[0]?.length || 0} dimensions)`
-    );
-    return results;
+    return await this.embeddings.embedQuery(text);
   }
 
   getConfig(): EmbeddingProviderConfig {

package/src/runtime/exec-graph.ts

@@ -486,18 +486,18 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
     isLocalEnv = true;
   }
   let g: ExecGraph | undefined;
-  let escalatedRole: string | undefined;
+  let assumedRole: string | undefined;
   if (!isAgentEventInstance(eventInstance)) {
     g = await generateExecutionGraph(fqn);
     if (!g) {
       throw new Error(`Failed to generate graph for event ${fqn}`);
     }
-    escalatedRole = getWorkflowForEvent(fqn).getRoleEscalation();
+    assumedRole = getWorkflowForEvent(fqn).getRoleEscalation();
   }
   const oldModuleName = env.switchActiveModuleName(eventInstance.moduleName);
   env.bind(eventInstance.name, eventInstance);
   env.bind(eventInstance.getFqName(), eventInstance);
-  if (escalatedRole) env.setEscalatedRole(escalatedRole);
+  if (assumedRole) env.setAssumedRole(assumedRole);
   try {
     if (g) {
       await executeGraph(g, env);
@@ -522,7 +522,7 @@ export async function executeEventHelper(eventInstance: Instance, env?: Environm
     }
     throw err;
   } finally {
-    env.resetEscalatedRole();
+    env.resetAssumedRole();
     if (!isLocalEnv) env.switchActiveModuleName(oldModuleName);
   }
 }

package/src/runtime/interpreter.ts

@@ -182,7 +182,7 @@ export class Environment extends Instance {
   private agentMode: 'chat' | 'planner' | undefined = undefined;
   private agentChatId: string | undefined = undefined;
   private monitor: Monitor | undefined = undefined;
-  private escalatedRole: string | undefined;
+  private assumedRole: string | undefined;
   private activeChatId: string | undefined;
 
   private activeUserData: any = undefined;
@@ -210,7 +210,7 @@ export class Environment extends Instance {
       this.eventExecutor = parent.eventExecutor;
       this.agentChatId = parent.agentChatId;
       this.monitor = parent.monitor;
-      this.escalatedRole = parent.escalatedRole;
+      this.assumedRole = parent.assumedRole;
       this.activeChatId = parent.activeChatId;
     } else {
       this.activeModule = DefaultModuleName;
@@ -308,17 +308,17 @@ export class Environment extends Instance {
     return this;
   }
 
-  setEscalatedRole(s: string): Environment {
-    this.escalatedRole = s;
+  setAssumedRole(s: string): Environment {
+    this.assumedRole = s;
     return this;
   }
 
-  getEscalatedRole(): string | undefined {
-    return this.escalatedRole;
+  getAssumedRole(): string | undefined {
+    return this.assumedRole;
   }
 
-  resetEscalatedRole(): Environment {
-    this.escalatedRole = undefined;
+  resetAssumedRole(): Environment {
+    this.assumedRole = undefined;
     return this;
   }
 
@@ -856,7 +856,7 @@ export class Environment extends Instance {
       if (this.activeEventInstance && isCoreModule(this.activeEventInstance.moduleName)) {
         return this;
       }
-      this.monitor = new Monitor(this.activeEventInstance, this.activeUser);
+      this.monitor = new Monitor(this.activeEventInstance, this.activeUser, this.assumedRole);
     }
     this.monitor.addEntry(new MonitorEntry(stmt));
     return this;
@@ -971,7 +971,7 @@ export let evaluate = async function (
         env = new Environment(eventInstance.name + '.env', activeEnv);
         env.setActiveEvent(eventInstance);
         const er = wf.getRoleEscalation();
-        if (er) env.setEscalatedRole(er);
+        if (er) env.setAssumedRole(er);
         if (kernelCall) {
           env.setInKernelMode(true);
         }
@@ -1012,7 +1012,7 @@ export let evaluate = async function (
       throw err;
     }
   } finally {
-    env?.resetEscalatedRole();
+    env?.resetAssumedRole();
     if (!txnRolledBack && env !== undefined && activeEnv === undefined) {
       await env.commitAllTransactions();
     }
@@ -1590,25 +1590,17 @@ async function maybeSetQueryClauses(
     inst.setOrderBy(qopts.orderByClause.colNames, qopts.orderByClause.order === '@desc');
   }
   if (qopts.limitClause) {
-    if (qopts.limitClause.value !== undefined) {
-      inst.setLimit(qopts.limitClause.value);
-    } else if (qopts.limitClause.expr) {
-      await evaluateExpression(qopts.limitClause.expr, env);
-      const v = env.getLastResult();
-      if (typeof v === 'number') {
-        inst.setLimit(v);
-      }
+    await evaluateExpression(qopts.limitClause.value, env);
+    const v = env.getLastResult();
+    if (typeof v === 'number') {
+      inst.setLimit(v);
     }
   }
   if (qopts.offsetClause) {
-    if (qopts.offsetClause.value !== undefined) {
-      inst.setOffset(qopts.offsetClause.value);
-    } else if (qopts.offsetClause.expr) {
-      await evaluateExpression(qopts.offsetClause.expr, env);
-      const v = env.getLastResult();
-      if (typeof v === 'number') {
-        inst.setOffset(v);
-      }
+    await evaluateExpression(qopts.offsetClause.value, env);
+    const v = env.getLastResult();
+    if (typeof v === 'number') {
+      inst.setOffset(v);
     }
   }
 }
@@ -2191,8 +2183,8 @@ const MAX_PLANNER_RETRIES = 3;
 async function agentInvoke(agent: AgentInstance, msg: string, env: Environment): Promise<void> {
   // log invocation details
   let invokeDebugMsg = `\nInvoking agent ${agent.name}:`;
-  if (agent.role) {
-    invokeDebugMsg = `${invokeDebugMsg} Role=${agent.role}`;
+  if (agent.goal) {
+    invokeDebugMsg = `${invokeDebugMsg} Goal=${agent.goal}`;
   }
   console.debug(invokeDebugMsg);
   invokeDebugMsg = `\nMessage=${msg}`;
@@ -2319,6 +2311,9 @@ export async function handleAgentInvocation(
   env: Environment
 ): Promise<void> {
   const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
+  if (agent.role) {
+    env.setAssumedRole(agent.role);
+  }
   const chatId = agentEventInst.lookup('chatId');
   if (chatId) {
     env.setActiveChatId(chatId);

package/src/runtime/loader.ts

@@ -832,7 +832,14 @@ async function addAgentDefinition(
       }
       const ov = v;
       if (apdef.value.id || apdef.value.ref || apdef.value.array) {
-        if (!(apdef.name === 'instruction' || apdef.name === 'role' || apdef.name === 'llm'))
+        if (
+          !(
+            apdef.name === 'instruction' ||
+            apdef.name === 'goal' ||
+            apdef.name === 'role' ||
+            apdef.name === 'llm'
+          )
+        )
           v = `"${v}"`;
       } else if (apdef.value.str) {
         v = `"${escapeSpecialChars(v)}"`;
@@ -867,9 +874,10 @@ async function addAgentDefinition(
   }
   if (attrs.get('type') === 'planner' || attrs.get('tools')) {
     const llmn = llmName || attrs.get('llm');
+    const agentRole = attrs.get('role') || 'admin';
     wf = `${wf}; {${CoreAIModuleName}/${AgentEntityName}
         {name "${name}_${AgentLearnerType}", moduleName "${moduleName}", llm "${llmn}",
-         type "${AgentLearnerType}", role "You are an agent that summarizes user-provided scenarios."}, @upsert}`;
+         type "${AgentLearnerType}", role "${agentRole}", goal "You are an agent that summarizes user-provided scenarios."}, @upsert}`;
   }
   (await parseWorkflow(`workflow A {${wf}}`)).statements.forEach((stmt: Statement) => {
     addStandaloneStatement(stmt, moduleName, false);

package/src/runtime/logger.ts

@@ -36,17 +36,6 @@ 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(
@@ -55,7 +44,7 @@ export function initializeLogger() {
           return `[${timestamp}] ${level}: ${message}`;
         })
       ),
-      transports: [fileTransport, consoleTransport],
+      transports: [fileTransport],
     });
   } else {
     function mkLogger(tag: string): Function {

package/src/runtime/module.ts

@@ -2859,46 +2859,6 @@ 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>();
@@ -2995,19 +2955,6 @@ 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],
@@ -3036,7 +2983,6 @@ const builtInChecks = new Map([
       return true;
     },
   ],
-  ['Topic', isTopicReference],
 ]);
 
 export const builtInTypes = new Set(Array.from(builtInChecks.keys()));
@@ -3060,16 +3006,7 @@ export const propertyNames = new Set([
   '@comment',
 ]);
 
-const TextualTypes = new Set([
-  'String',
-  'Email',
-  'UUID',
-  'DateTime',
-  'Date',
-  'Time',
-  'Path',
-  'Topic',
-]);
+const TextualTypes = new Set(['String', 'Email', 'UUID', 'DateTime', 'Date', 'Time', 'Path']);
 
 function isTextualType(type: string): boolean {
   return TextualTypes.has(type);