agentlang 0.0.3 → 0.0.5

package/src/runtime/module.ts

@@ -16,6 +16,9 @@ import {
   PrePostTriggerDefinition,
   TriggerEntry,
   Expr,
+  RbacSpecEntry,
+  RbacSpecEntries,
+  RbacOpr,
 } from '../language/generated/ast.js';
 import {
   Path,
@@ -26,6 +29,7 @@ import {
   isFqName,
   makeFqName,
   DefaultModuleName,
+  DefaultModules,
   joinStatements,
   isMinusZero,
   now,
@@ -97,7 +101,7 @@ function recordSchemaToString(scm: RecordSchema): string {
       ss.push(`    ${n} ${attributeSpecToString(attrSpec)}`);
     }
   });
-  return `{ \n${ss.join(',\n')} \n}`;
+  return `\n${ss.join(',\n')} \n`;
 }
 
 function attributeSpecToString(attrSpec: AttributeSpec): string {
@@ -105,8 +109,8 @@ function attributeSpecToString(attrSpec: AttributeSpec): string {
   if (attrSpec.properties) {
     const ps: Array<string> = [];
     attrSpec.properties.forEach((v: any, k: string) => {
-      if (v == true) ps.push(`@${k}`);
-      else ps.push(`@${k}${v}`);
+      if (v == true) ps.push(` @${k}`);
+      else ps.push(` @${k}(${v})`);
     });
     s = s.concat(ps.join(' '));
   }
@@ -128,6 +132,7 @@ export enum RecordType {
   ENTITY,
   EVENT,
   RELATIONSHIP,
+  AGENT,
 }
 
 function normalizeMetaValue(metaValue: any): any {
@@ -181,6 +186,7 @@ export class Record extends ModuleEntry {
   beforeTriggers: Map<CrudType, TriggerInfo> | undefined;
   compositeUqAttributes: Array<string> | undefined;
   oneOfRefAttributes: Array<string> | undefined;
+  protected rbac: RbacSpecification[] | undefined;
 
   constructor(
     name: string,
@@ -413,8 +419,14 @@ export class Record extends ModuleEntry {
     if (this.parentEntryName) {
       s = s.concat(` extends ${this.parentEntryName}`);
     }
-    const scms = recordSchemaToString(this.schema);
-    return s.concat('\n', scms, '\n');
+    let scms = recordSchemaToString(this.schema);
+    if (this.rbac && this.rbac.length > 0) {
+      const rbs = this.rbac.map((rs: RbacSpecification) => {
+        return rs.toString();
+      });
+      scms = `${scms}    @rbac [${rbs.join(',\n')}]`;
+    }
+    return s.concat('\n{', scms, '}\n');
   }
 
   getUserAttributes(): RecordSchema {
@@ -562,6 +574,24 @@ export class RbacSpecification {
     this.permissions = new Set();
   }
 
+  static from(def: RbacSpecEntries): RbacSpecification {
+    const result = new RbacSpecification();
+    def.entries.forEach((se: RbacSpecEntry) => {
+      if (se.role) {
+        result.setRoles(se.role.roles);
+      } else if (se.allow) {
+        result.setPermissions(
+          se.allow.oprs.map((opr: RbacOpr) => {
+            return opr.value;
+          })
+        );
+      } else if (se.expr) {
+        result.setExpression(se.expr.lhs, se.expr.rhs);
+      }
+    });
+    return result;
+  }
+
   setResource(s: string): RbacSpecification {
     this.resource = s;
     return this;
@@ -624,11 +654,146 @@ export class RbacSpecification {
     };
     return this;
   }
+
+  toString(): string {
+    const rs = new Array<string>();
+    this.roles.forEach((r: string) => {
+      rs.push(r);
+    });
+    let cond = '';
+    if (this.expression) {
+      cond = `where: ${this.expression.lhs} = ${this.expression.rhs}`;
+    } else {
+      cond = `roles: [${rs.join(',')}]`;
+    }
+    const perms = new Array<string>();
+    this.permissions.forEach((p: RbacPermissionFlag) => {
+      perms.push(RbacPermissionFlag[p].toLowerCase());
+    });
+    return `(${cond}, allow: [${perms.join(',')}])`;
+  }
+}
+
+export class Agent extends Record {
+  override type: RecordType = RecordType.AGENT;
+  attributes: InstanceAttributes;
+
+  constructor(name: string, moduleName: string, attrs?: InstanceAttributes) {
+    super(Agent.EscapeName(name), moduleName);
+    this.attributes = attrs ? attrs : newInstanceAttributes();
+  }
+
+  setName(n: string): Agent {
+    this.name = Agent.EscapeName(n);
+    return this;
+  }
+
+  setLLM(llm: string): Agent {
+    this.attributes.set('llm', llm);
+    return this;
+  }
+
+  getLLM(): string {
+    return this.attributes.get('llm');
+  }
+
+  private removeAgentAttribute(n: string): Agent {
+    this.attributes.delete(n);
+    return this;
+  }
+
+  removeLLM(): Agent {
+    return this.removeAgentAttribute('llm');
+  }
+
+  setInstruction(s: string): Agent {
+    this.attributes.set('instruction', s);
+    return this;
+  }
+
+  getInstruction(): string {
+    return this.attributes.get('instruction');
+  }
+
+  removeInstruction(): Agent {
+    return this.removeAgentAttribute('instruction');
+  }
+
+  setType(type: 'chat' | 'planner'): Agent {
+    this.attributes.set('type', type);
+    return this;
+  }
+
+  getType(): string {
+    return this.attributes.get('type');
+  }
+
+  removeType(): Agent {
+    return this.removeAgentAttribute('type');
+  }
+
+  setTools(tools: string[]): Agent {
+    this.attributes.set('tools', tools.join(','));
+    return this;
+  }
+
+  getTools(): string {
+    return this.attributes.get('tools');
+  }
+
+  removeTools(): Agent {
+    return this.removeAgentAttribute('tools');
+  }
+
+  setDocuments(docs: string[]): Agent {
+    this.attributes.set('documents', docs.join(','));
+    return this;
+  }
+
+  getDocuments(): string {
+    return this.attributes.get('documents');
+  }
+
+  removeDocuments(): Agent {
+    return this.removeAgentAttribute('documents');
+  }
+
+  override toString(): string {
+    const attrs = new Array<string>();
+    this.attributes.forEach((value: any, key: string) => {
+      const v = isString(value) ? `"${value}"` : value;
+      attrs.push(`    ${key} ${v}`);
+    });
+    return `agent ${Agent.NormalizeName(this.name)}
+{
+${attrs.join(',\n')}
+}`;
+  }
+
+  static Suffix = '__agent';
+
+  static EscapeName(n: string): string {
+    if (n.endsWith(Agent.Suffix)) {
+      return n;
+    }
+    return `${n}${Agent.Suffix}`;
+  }
+
+  static NormalizeName(n: string): string {
+    if (n.endsWith(Agent.Suffix)) {
+      return n.substring(0, n.lastIndexOf(Agent.Suffix));
+    } else {
+      return n;
+    }
+  }
+
+  getName(): string {
+    return Agent.NormalizeName(this.name);
+  }
 }
 
 export class Entity extends Record {
   override type: RecordType = RecordType.ENTITY;
-  rbac: RbacSpecification[] | undefined;
 
   constructor(
     name: string,
@@ -651,6 +816,10 @@ export class Entity extends Record {
     this.rbac = rbac;
     return this;
   }
+
+  getRbacSpecifications(): RbacSpecification[] | undefined {
+    return this.rbac;
+  }
 }
 
 export class Event extends Record {
@@ -1015,6 +1184,22 @@ export class Module {
     return entry;
   }
 
+  addAgent(agentEntry: Agent): Agent {
+    return this.addEntry(agentEntry) as Agent;
+  }
+
+  getAgent(agentName: string): Agent | undefined {
+    const n = Agent.EscapeName(agentName);
+    if (this.hasEntry(n)) {
+      return this.getEntry(n) as Agent;
+    }
+    return undefined;
+  }
+
+  removeAgent(agentName: string): boolean {
+    return this.removeEntry(Agent.EscapeName(agentName));
+  }
+
   private getEntryIndex(entryName: string): number {
     return this.entries.findIndex((v: ModuleEntry) => {
       return v.name == entryName;
@@ -1078,6 +1263,16 @@ export class Module {
     return this.getEntriesOfType(RecordType.RECORD) as Record[];
   }
 
+  getAgents(): Agent[] {
+    return this.getEntriesOfType(RecordType.AGENT) as Agent[];
+  }
+
+  getAgentNames(): string[] {
+    return this.getAgents().map((ae: Agent) => {
+      return Agent.NormalizeName(ae.name);
+    });
+  }
+
   getRelationshipEntries(): Relationship[] {
     return this.getEntriesOfType(RecordType.RELATIONSHIP) as Relationship[];
   }
@@ -1182,6 +1377,9 @@ export class Module {
   toString(): string {
     const ss: Array<string> = [];
     this.entries.forEach((me: ModuleEntry) => {
+      if (me instanceof Event && isAgentEvent(me)) {
+        return;
+      }
       ss.push(me.toString());
     });
     return `module ${this.name}\n\n${ss.join('\n')}`;
@@ -1221,7 +1419,7 @@ export function getModuleNames(): string[] {
 export function getUserModuleNames(): string[] {
   const result: Array<string> = new Array<string>();
   Array.from(moduleDb.keys()).forEach((n: string) => {
-    if (n != DefaultModuleName) {
+    if (!DefaultModules.has(n)) {
       result.push(n);
     }
   });
@@ -1486,6 +1684,11 @@ export function addContainsRelationship(
   return addRelationship(name, 'contains', nodes, moduleName);
 }
 
+export function addAgent(name: string, attrs: InstanceAttributes, moduleName: string): Agent {
+  const m = fetchModule(moduleName);
+  return m.addAgent(new Agent(name, moduleName, attrs)) as Agent;
+}
+
 function asWorkflowName(n: string): string {
   return n + '--workflow';
 }
@@ -1536,6 +1739,28 @@ export function getEntity(name: string, moduleName: string): Entity {
   throw new Error(`Entity ${fr.entryName} not found in module ${fr.moduleName}`);
 }
 
+function isEntryOfType(t: RecordType, fqName: string): boolean {
+  const path = splitFqName(fqName);
+  const mod = fetchModule(path.getModuleName());
+  return mod.isEntryOfType(t, path.getEntryName());
+}
+
+export function isEntity(fqName: string): boolean {
+  return isEntryOfType(RecordType.ENTITY, fqName);
+}
+
+export function isEvent(fqName: string): boolean {
+  return isEntryOfType(RecordType.EVENT, fqName);
+}
+
+export function isRecord(fqName: string): boolean {
+  return isEntryOfType(RecordType.RECORD, fqName);
+}
+
+export function isRelationship(fqName: string): boolean {
+  return isEntryOfType(RecordType.RELATIONSHIP, fqName);
+}
+
 export function getEvent(name: string, moduleName: string): Event {
   const fr: FetchModuleByEntryNameResult = fetchModuleByEntryName(name, moduleName);
   if (fr.module.isEvent(fr.entryName)) {
@@ -1819,10 +2044,14 @@ export class Instance {
     return this.record.getMeta('audit');
   }
 
-  lookup(k: string): any | undefined {
+  lookup(k: string): any {
     return this.attributes.get(k);
   }
 
+  lookupQueryVal(k: string): any {
+    return this.queryAttributeValues?.get(k);
+  }
+
   getPath(): string {
     return this.lookup(PathAttributeName);
   }
@@ -2171,11 +2400,15 @@ export function isTimer(eventInst: Instance): boolean {
   return eventInst.getFqName() == 'agentlang/timer';
 }
 
-export function isAgentEvent(eventInst: Instance): boolean {
-  const flag = eventInst.record.getMeta(IsAgentEventMeta);
+export function isAgentEvent(record: Record): boolean {
+  const flag = record.getMeta(IsAgentEventMeta);
   return flag != undefined && flag == 'y';
 }
 
+export function isAgentEventInstance(eventInst: Instance): boolean {
+  return isAgentEvent(eventInst.record);
+}
+
 export function eventAgentName(eventInst: Instance): string | undefined {
   return eventInst.record.getMeta(EventAgentName);
 }
@@ -2186,3 +2419,17 @@ export function instanceToObject<Type>(inst: Instance, obj: any): Type {
   });
   return obj as Type;
 }
+
+export function getEntityRbacRules(entityFqName: string): RbacSpecification[] | undefined {
+  const p = splitFqName(entityFqName);
+  const mn = p.getModuleName();
+  const en = p.getEntryName();
+  const m = isModule(mn) && fetchModule(mn);
+  if (m && m.isEntity(en)) {
+    const entity = getEntity(en, mn);
+    return entity.getRbacSpecifications()?.filter((spec: RbacSpecification) => {
+      return spec.expression != undefined;
+    });
+  }
+  return undefined;
+}

package/src/runtime/modules/ai.ts

@@ -1,4 +1,4 @@
-import { makeCoreModuleName, makeFqName } from '../util.js';
+import { isFqName, makeCoreModuleName, makeFqName, splitFqName } from '../util.js';
 import { Environment, makeEventEvaluator, parseAndEvaluateStatement } from '../interpreter.js';
 import { fetchModule, Instance, instanceToObject, isModule } from '../module.js';
 import { provider } from '../agents/registry.js';
@@ -14,21 +14,23 @@ import { PlannerInstructions } from '../agents/common.js';
 import { PathAttributeNameQuery } from '../defs.js';
 
 export const CoreAIModuleName = makeCoreModuleName('ai');
+export const AgentEntityName = 'Agent';
+export const LlmEntityName = 'LLM';
 
 export default `module ${CoreAIModuleName}
 
-entity llm {
+entity ${LlmEntityName} {
     name String @id,
     service String @default("openai"),
     config Map @optional
 }
 
-entity agent {
+entity ${AgentEntityName} {
     name String @id,
     type @enum("chat", "planner") @default("chat"),
     instruction String @optional,
-    tools String[] @optional,
-    documents String[] @optional,
+    tools String @optional, // comma-separated values
+    documents String @optional, // comma-separated values
     llm String
 }
 
@@ -43,33 +45,33 @@ workflow findAgentChatSession {
 }
 
 workflow saveAgentChatSession {
-  upsert {agentChatSession {id saveAgentChatSession.id, messages saveAgentChatSession.messages}}
+  {agentChatSession {id saveAgentChatSession.id, messages saveAgentChatSession.messages}, @upsert}
 }
 
-entity document {
+entity Document {
   title String @id,
   content String,
   @meta {"fullTextSearch": "*"}
 }
 `;
 
-export const AgentFqName = makeFqName(CoreAIModuleName, 'agent');
+export const AgentFqName = makeFqName(CoreAIModuleName, AgentEntityName);
 
 const ProviderDb = new Map<string, AgentServiceProvider>();
 
-export class Agent {
+export class AgentInstance {
   llm: string = '';
   name: string = '';
   chatId: string | undefined;
   instruction: string = '';
   type: string = 'chat';
-  tools: string[] | undefined;
-  documents: string[] | undefined;
+  tools: string | undefined;
+  documents: string | undefined;
 
   private constructor() {}
 
-  static FromInstance(agentInstance: Instance): Agent {
-    return instanceToObject<Agent>(agentInstance, new Agent());
+  static FromInstance(agentInstance: Instance): AgentInstance {
+    return instanceToObject<AgentInstance>(agentInstance, new AgentInstance());
   }
 
   isPlanner(): boolean {
@@ -111,14 +113,14 @@ export class Agent {
 
   private async maybeAddRelevantDocuments(message: string, env: Environment): Promise<string> {
     if (this.documents && this.documents.length > 0) {
-      const s = `${message}. Relevant documents are: ${this.documents.join(',')}`;
-      const result: any[] = await parseHelper(`{agentlang_ai/document? "${s}"}`, env);
+      const s = `${message}. Relevant documents are: ${this.documents}`;
+      const result: any[] = await parseHelper(`{agentlang_ai/Document? "${s}"}`, env);
       if (result && result.length > 0) {
         const docs: Instance[] = [];
         for (let i = 0; i < result.length; ++i) {
           const v: any = result[i];
           const r: Instance[] = await parseHelper(
-            `{agentlang_ai/document {${PathAttributeNameQuery} "${v.id}"}}`,
+            `{agentlang_ai/Document {${PathAttributeNameQuery} "${v.id}"}}`,
             env
           );
           if (r && r.length > 0) {
@@ -141,14 +143,36 @@ export class Agent {
 
   private toolsAsString(): string {
     if (this.tools) {
-      return this.tools
-        .filter((s: string) => {
-          return isModule(s);
-        })
-        .map((moduleName: string) => {
-          return fetchModule(moduleName).toString();
-        })
-        .join('\n');
+      const tooldefs = new Array<string>();
+      const slimModules = new Map<string, string[]>();
+      this.tools.split(',').forEach((n: string) => {
+        let moduleName: string | undefined;
+        let entryName: string | undefined;
+        if (isFqName(n)) {
+          const parts = splitFqName(n);
+          moduleName = parts.getModuleName();
+          entryName = parts.getEntryName();
+        } else {
+          moduleName = n;
+        }
+        if (isModule(moduleName)) {
+          const m = fetchModule(moduleName);
+          if (entryName) {
+            const hasmod = slimModules.has(moduleName);
+            const defs = hasmod ? slimModules.get(moduleName) : new Array<string>();
+            defs?.push(m.getEntry(entryName).toString());
+            if (!hasmod && defs) {
+              slimModules.set(moduleName, defs);
+            }
+          } else {
+            tooldefs.push(fetchModule(moduleName).toString());
+          }
+        }
+      });
+      slimModules.forEach((defs: string[], modName: string) => {
+        tooldefs.push(`module ${modName}\n${defs.join('\n')}`);
+      });
+      return tooldefs.join('\n');
     } else {
       return '';
     }
@@ -160,11 +184,11 @@ async function parseHelper(stmt: string, env: Environment): Promise<any> {
   return env.getLastResult();
 }
 
-export async function findAgentByName(name: string, env: Environment): Promise<Agent> {
-  const result = await parseHelper(`{agentlang_ai/agent {name? "${name}"}}`, env);
+export async function findAgentByName(name: string, env: Environment): Promise<AgentInstance> {
+  const result = await parseHelper(`{${AgentFqName} {name? "${name}"}}`, env);
   if (result instanceof Array && result.length > 0) {
     const agentInstance: Instance = result[0];
-    return Agent.FromInstance(agentInstance);
+    return AgentInstance.FromInstance(agentInstance);
   } else {
     throw new Error(`Failed to fine agent ${name}`);
   }
@@ -177,7 +201,7 @@ export async function findProviderForLLM(
   let p: AgentServiceProvider | undefined = ProviderDb.get(llmName);
   if (p == undefined) {
     const result: Instance[] = await parseAndEvaluateStatement(
-      `{${CoreAIModuleName}/llm {name? "${llmName}"}}`,
+      `{${CoreAIModuleName}/${LlmEntityName} {name? "${llmName}"}}`,
       undefined,
       env
     );