agentlang 0.9.5 → 0.9.7

package/src/runtime/interpreter.ts

@@ -32,8 +32,8 @@ import {
   WhereSpec,
 } from '../language/generated/ast.js';
 import {
-  maybeInstanceAsString,
   defineAgentEvent,
+  Event,
   getOneOfRef,
   getRelationship,
   getWorkflow,
@@ -46,15 +46,15 @@ import {
   isEntityInstance,
   isEventInstance,
   isInstanceOfType,
+  isOneToOneBetweenRelationship,
   isTimer,
   makeInstance,
+  maybeInstanceAsString,
   newInstanceAttributes,
   PlaceholderRecordEntry,
   Relationship,
-  Workflow,
   setMetaAttributes,
-  Event,
-  isOneToOneBetweenRelationship,
+  Workflow,
 } from './module.js';
 import { JoinInfo, Resolver, WhereClause } from './resolvers/interface.js';
 import { ResolverAuthInfo } from './resolvers/authinfo.js';
@@ -65,28 +65,28 @@ import {
   escapeFqName,
   escapeQueryName,
   fqNameFromPath,
+  isCoreModule,
   isFqName,
   isPath,
   isString,
   makeCoreModuleName,
   makeFqName,
+  nameToPath,
   Path,
+  preprocessRawConfig,
   QuerySuffix,
   restoreSpecialChars,
-  nameToPath,
   splitRefs,
-  isCoreModule,
-  preprocessRawConfig,
 } from './util.js';
 import { getResolver, getResolverNameForPath } from './resolvers/registry.js';
 import { parseStatement, parseWorkflow } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession, AdminUserId } from './auth/defs.js';
 import {
-  AgentInstance,
   AgentEntityName,
   AgentFqName,
+  AgentInstance,
   findAgentByName,
-  trimGeneratedCode,
+  normalizeGeneratedCode,
 } from './modules/ai.js';
 import { logger } from './logger.js';
 import {
@@ -165,6 +165,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 activeUserData: any = undefined;
 
@@ -191,6 +192,7 @@ export class Environment extends Instance {
       this.eventExecutor = parent.eventExecutor;
       this.agentChatId = parent.agentChatId;
       this.monitor = parent.monitor;
+      this.escalatedRole = parent.escalatedRole;
     } else {
       this.activeModule = DefaultModuleName;
       this.activeResolvers = new Map<string, Resolver>();
@@ -287,6 +289,20 @@ export class Environment extends Instance {
     return this;
   }
 
+  setEscalatedRole(s: string): Environment {
+    this.escalatedRole = s;
+    return this;
+  }
+
+  getEscalatedRole(): string | undefined {
+    return this.escalatedRole;
+  }
+
+  resetEscalatedRole(): Environment {
+    this.escalatedRole = undefined;
+    return this;
+  }
+
   private static FlowContextTag = 'flow-context';
 
   setFlowContext(s: string): Environment {
@@ -900,6 +916,8 @@ export let evaluate = async function (
       if (!isEmptyWorkflow(wf)) {
         env = new Environment(eventInstance.name + '.env', activeEnv);
         env.setActiveEvent(eventInstance);
+        const er = wf.getRoleEscalation();
+        if (er) env.setEscalatedRole(er);
         if (kernelCall) {
           env.setInKernelMode(true);
         }
@@ -934,6 +952,7 @@ export let evaluate = async function (
       throw err;
     }
   } finally {
+    env?.resetEscalatedRole();
     if (!txnRolledBack && env !== undefined && activeEnv === undefined) {
       await env.commitAllTransactions();
     }
@@ -1736,11 +1755,15 @@ async function handleDocEvent(inst: Instance, env: Environment): Promise<void> {
   const s = await fetchDoc(inst.lookup('url'));
   if (s) {
     const title = inst.lookup('title');
-    await parseAndEvaluateStatement(
-      `{${CoreAIModuleName}/Document {title "${title}", content "${s}"}}`,
-      undefined,
-      env
+    const doc = makeInstance(
+      CoreAIModuleName,
+      'Document',
+      newInstanceAttributes().set('title', title).set('content', s)
     );
+    await computeExprAttributes(doc, undefined, undefined, env);
+    await setMetaAttributes(doc.attributes, env);
+    const res: Resolver = await getResolverForPath('Document', CoreAIModuleName, env);
+    await res.createInstance(doc);
   }
 }
 
@@ -1959,7 +1982,7 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
       let retries = 0;
       while (true) {
         try {
-          let rs: string = result ? trimGeneratedCode(result) : '';
+          let rs: string = result ? normalizeGeneratedCode(result) : '';
           let isWf = rs.startsWith('workflow');
           if (isWf && !agent.runWorkflows) {
             await parseWorkflow(rs);
@@ -2013,7 +2036,7 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
       let retries = 0;
       while (true) {
         try {
-          result = trimGeneratedCode(result);
+          result = normalizeGeneratedCode(result);
           const obj = agent.maybeValidateJsonResponse(result);
           if (obj !== undefined) {
             env.setLastResult(obj);
@@ -2219,7 +2242,7 @@ async function preprocessStep(
   env: Environment
 ): Promise<PreprocStepResult> {
   let needAgentProcessing = true;
-  spec = trimGeneratedCode(spec);
+  spec = normalizeGeneratedCode(spec);
   if (spec.startsWith('{') || spec.indexOf(' ') > 0) {
     const newEnv = Environment.from(env, env.name + '_flow_eval', false, true).setActiveModuleName(
       activeModuleName

package/src/runtime/loader.ts

@@ -1,4 +1,3 @@
-import chalk from 'chalk';
 import { createAgentlangServices } from '../language/agentlang-module.js';
 import {
   Import,
@@ -48,6 +47,8 @@ import {
   RetryDefinition,
   SetAttribute,
   CrudMap,
+  isAgentEvaluatorDefinition,
+  AgentEvaluatorDefinition,
 } from '../language/generated/ast.js';
 import {
   addEntity,
@@ -70,6 +71,7 @@ import {
   fetchModule,
   Retry,
   addGlobalRetry,
+  AgentEvaluator,
 } from './module.js';
 import {
   asStringLiteralsMap,
@@ -102,7 +104,13 @@ import {
 import { logger } from './logger.js';
 import { Environment, evaluateStatements, GlobalEnvironment } from './interpreter.js';
 import { createPermission, createRole } from './modules/auth.js';
-import { AgentEntityName, CoreAIModuleName, LlmEntityName } from './modules/ai.js';
+import {
+  AgentEntityName,
+  AgentInstance,
+  AgentLearnerType,
+  CoreAIModuleName,
+  LlmEntityName,
+} from './modules/ai.js';
 import { getDefaultLLMService } from './agents/registry.js';
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
 import { registerResolver, setResolver } from './resolvers/registry.js';
@@ -125,6 +133,7 @@ import {
   registerAgentScenarios,
   registerAgentScratchNames,
 } from './agents/common.js';
+import chalk from 'chalk';
 
 export async function extractDocument(
   fileName: string,
@@ -584,7 +593,7 @@ export function addWorkflowFromDef(
   moduleName: string,
   ispub: boolean = false
 ): Workflow {
-  return addWorkflow(def.name || '', moduleName, def.statements, def.header, ispub);
+  return addWorkflow(def.name || '', moduleName, def.statements, def.header, def.directives, ispub);
 }
 
 const StandaloneStatements = new Map<string, Statement[]>();
@@ -842,6 +851,12 @@ async function addAgentDefinition(
     const service = getDefaultLLMService();
     wf = `{${CoreAIModuleName}/${LlmEntityName} {name "${llmName}", service "${service}"}, @upsert}; ${wf}`;
   }
+  if (attrs.get('type') === 'planner' || attrs.get('tools')) {
+    const llmn = llmName || attrs.get('llm');
+    wf = `${wf}; {${CoreAIModuleName}/${AgentEntityName}
+        {name "${name}_${AgentLearnerType}", moduleName "${moduleName}", llm "${llmn}",
+         type "${AgentLearnerType}", role "You are an agent that summarizes user-provided scenarios."}, @upsert}`;
+  }
   (await parseWorkflow(`workflow A {${wf}}`)).statements.forEach((stmt: Statement) => {
     addStandaloneStatement(stmt, moduleName, false);
   });
@@ -1090,6 +1105,29 @@ function addRetryDefinition(def: RetryDefinition, moduleName: string) {
   fetchModule(moduleName).addRetry(retry);
 }
 
+function addAgentEvaluatorDefinition(def: AgentEvaluatorDefinition, moduleName: string) {
+  if (!def.name) throw new Error('Evaluator definition must have a name');
+  const e = new AgentEvaluator(def.name, moduleName);
+  def.attributes.forEach((sa: SetAttribute) => {
+    const isins = sa.name === 'instruction';
+    if (isins || sa.name === 'llm') {
+      if (isLiteral(sa.value)) {
+        const s = sa.value.id || sa.value.str;
+        if (s) {
+          if (isins) e.setInstruction(s);
+          else e.setLlm(s);
+        } else throw new Error(`Invalid value for evaluator-${sa.name} in ${def.name}`);
+      } else {
+        throw new Error(`evaluator ${sa.name} must be a string in ${def.name}`);
+      }
+    } else {
+      throw new Error(`invalid attribute ${sa.name} in evaluator ${def.name}`);
+    }
+  });
+  fetchModule(moduleName).addAgentEvaluator(e);
+  AgentInstance.RegisterEvaluator(e);
+}
+
 function addResolverDefinition(def: ResolverDefinition, moduleName: string) {
   const resolverName = `${moduleName}/${def.name}`;
   const paths = def.paths;
@@ -1157,6 +1195,7 @@ export async function addFromDef(def: Definition, moduleName: string) {
   else if (isDirectiveDefinition(def)) addDirectiveDefintion(def, moduleName);
   else if (isGlossaryEntryDefinition(def)) addGlossaryEntryDefintion(def, moduleName);
   else if (isRetryDefinition(def)) addRetryDefinition(def, moduleName);
+  else if (isAgentEvaluatorDefinition(def)) addAgentEvaluatorDefinition(def, moduleName);
 }
 
 export async function parseAndIntern(code: string, moduleName?: string) {

package/src/runtime/module.ts

@@ -1,56 +1,57 @@
 import chalk from 'chalk';
 import {
-  Statement,
-  KvPair,
-  Literal,
+  AttributeDefinition,
+  Expr,
+  FlowDefinition,
+  FlowEntry,
   FnCall,
-  RelNodes,
+  isLiteral,
   isRelNodes,
-  AttributeDefinition,
-  PropertyDefinition,
-  NodeDefinition,
-  RecordSchemaDefinition,
+  KvPair,
+  Literal,
   MapEntry,
-  isLiteral,
   MetaDefinition,
+  NodeDefinition,
   PrePostTriggerDefinition,
-  TriggerEntry,
-  Expr,
-  RbacSpecEntry,
-  RbacSpecEntries,
+  PropertyDefinition,
   RbacOpr,
+  RbacSpecEntries,
+  RbacSpecEntry,
+  RecordSchemaDefinition,
+  RelNodes,
+  Statement,
+  TriggerEntry,
+  WorkflowDirectives,
   WorkflowHeader,
-  FlowDefinition,
-  FlowEntry,
 } from '../language/generated/ast.js';
 import {
-  Path,
-  nameToPath,
-  isString,
-  isNumber,
-  isBoolean,
-  isFqName,
-  makeFqName,
+  asCrudType,
+  CrudType,
   DefaultModuleName,
   DefaultModules,
-  joinStatements,
-  isMinusZero,
-  now,
-  findMetaSchema,
+  encryptPassword,
+  escapeFqName,
   findAllPrePostTriggerSchema,
-  CrudType,
-  asCrudType,
-  isPath,
+  findMetaSchema,
   findUqCompositeAttributes,
-  escapeFqName,
-  encryptPassword,
-  splitFqName,
-  splitRefs,
   forceAsFqName,
-  validateIdFormat,
+  isBoolean,
+  isFqName,
+  isMinusZero,
+  isNumber,
+  isPath,
+  isString,
+  joinStatements,
+  makeFqName,
   nameContainsSepEscape,
+  nameToPath,
+  now,
+  Path,
   registerInitFunction,
   ScratchModuleName,
+  splitFqName,
+  splitRefs,
+  validateIdFormat,
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
@@ -512,7 +513,10 @@ export class Record extends ModuleEntry {
   }
 
   getFullTextSearchAttributes(): string[] | undefined {
-    const fts: string[] | string | undefined = this.getMeta('fullTextSearch');
+    let fts: string[] | string | undefined = this.getMeta('fullTextSearchAttributes');
+    if (!fts) {
+      fts = this.getMeta('fullTextSearch');
+    }
     if (fts) {
       if (fts instanceof Array) {
         return fts as string[];
@@ -526,6 +530,14 @@ export class Record extends ModuleEntry {
     }
   }
 
+  getEmbeddingConfig(): { [key: string]: any } | undefined {
+    const config = this.getMeta('embeddingConfig');
+    if (config && typeof config === 'object') {
+      return config as { [key: string]: any };
+    }
+    return undefined;
+  }
+
   private resetUserAttrs() {
     this.userAttrNames = undefined;
     this.userAttrsSchema = undefined;
@@ -1517,11 +1529,19 @@ export class Relationship extends Record {
 export class Workflow extends ModuleEntry {
   statements: Statement[];
   isPrePost: boolean;
+  directives: WorkflowDirectives | undefined;
 
-  constructor(name: string, patterns: Statement[], moduleName: string, isPrePost: boolean = false) {
+  constructor(
+    name: string,
+    patterns: Statement[],
+    moduleName: string,
+    isPrePost: boolean = false,
+    directives?: WorkflowDirectives
+  ) {
     super(name, moduleName);
     this.statements = patterns;
     this.isPrePost = isPrePost;
+    this.directives = directives;
   }
 
   async addStatement(stmtCode: string): Promise<Workflow> {
@@ -1648,10 +1668,29 @@ export class Workflow extends ModuleEntry {
     return this;
   }
 
+  getRoleEscalation(): string | undefined {
+    if (this.directives !== undefined) {
+      for (let i = 0; i < this.directives.entries.length; ++i) {
+        const e = this.directives.entries[i];
+        if (e.tag === '@withRole') {
+          return e.value;
+        }
+      }
+    }
+    return undefined;
+  }
+
+  private directivesToString(): string {
+    if (this.directives !== undefined) {
+      return ` ${this.directives.$cstNode?.text || ''} `;
+    }
+    return ' ';
+  }
+
   override toString() {
     const n = this.isPrePost ? untangleWorkflowName(this.name) : this.name;
     const nn = normalizeWorkflowName(n);
-    let s: string = `workflow ${nn} {\n`;
+    let s: string = `workflow ${nn}${this.directivesToString()}{\n`;
     const ss = this.statementsToStringsHelper(this.statements);
     s = s.concat(joinStatements(ss));
     if (!this.isPrePost) {
@@ -2091,6 +2130,49 @@ export class Retry extends ModuleEntry {
   }
 }
 
+export class AgentEvaluator extends ModuleEntry {
+  instruction: string | undefined;
+  llm: string | undefined;
+
+  constructor(name: string, moduleName: string) {
+    super(name, moduleName);
+  }
+
+  setInstruction(ins: string): AgentEvaluator {
+    this.instruction = ins;
+    return this;
+  }
+
+  setLlm(llm: string): AgentEvaluator {
+    this.llm = llm;
+    return this;
+  }
+
+  private static suffix = '_eval';
+
+  escapeName(): AgentEvaluator {
+    this.name = `${this.name}${AgentEvaluator.suffix}`;
+    return this;
+  }
+
+  normalizedName(): string {
+    const i = this.name.lastIndexOf(AgentEvaluator.suffix);
+    if (i >= 0) {
+      return this.name.substring(0, i);
+    }
+    return this.name;
+  }
+
+  override toString(): string {
+    let s = '';
+    if (this.instruction) s = `    instruction "${this.instruction}"`;
+    if (this.llm) s = `${s}\n    llm "${this.llm}"`;
+    return `evaluator ${this.normalizedName()} {
+    ${s}
+    }`;
+  }
+}
+
 export class Decision extends ModuleEntry {
   cases: string[];
 
@@ -2395,6 +2477,11 @@ export class Module {
     return this;
   }
 
+  addAgentEvaluator(e: AgentEvaluator): Module {
+    this.addEntry(e.escapeName());
+    return this;
+  }
+
   getRetry(name: string): Retry | undefined {
     if (this.hasEntry(name)) {
       const e = this.getEntry(name);
@@ -2420,7 +2507,7 @@ export class Module {
 
   private getEntryIndex(entryName: string): number {
     return this.entries.findIndex((v: ModuleEntry) => {
-      return v.name == entryName;
+      return v.name === entryName;
     });
   }
 
@@ -2706,8 +2793,6 @@ export function removeModule(name: string): boolean {
   return false;
 }
 
-addModule(DefaultModuleName);
-addRecord('env', DefaultModuleName);
 addModule(ScratchModuleName);
 
 export function getModuleNames(): string[] {
@@ -3092,6 +3177,7 @@ export function addWorkflow(
   moduleName = activeModule,
   statements?: Statement[],
   hdr?: WorkflowHeader | ThinWfHeader,
+  directives?: WorkflowDirectives,
   ispub: boolean = false
 ): Workflow {
   if (hdr) {
@@ -3130,7 +3216,7 @@ export function addWorkflow(
     });
   }
   return module.addEntry(
-    new Workflow(asWorkflowName(name), statements, moduleName, hdr ? true : false)
+    new Workflow(asWorkflowName(name), statements, moduleName, hdr ? true : false, directives)
   ) as Workflow;
 }