agentlang 0.0.21 → 0.0.23

package/src/runtime/docs.ts

@@ -0,0 +1,57 @@
+import { getFileSystem } from '../utils/fs-utils.js';
+import { logger } from './logger.js';
+
+const DocFetchers = new Map<string, Function>();
+
+export function registerDocFetcher(scheme: string, fetcher: Function): string {
+  DocFetchers.set(scheme, fetcher);
+  return scheme;
+}
+
+function getDocFetcher(scheme: string): Function | undefined {
+  const f = DocFetchers.get(scheme);
+  if (f) {
+    return f;
+  }
+  logger.warn(`No fetcher for ${scheme}`);
+  return undefined;
+}
+
+export async function fetchDoc(url: string): Promise<string | undefined> {
+  const idx = url.indexOf(':/');
+  const scheme = idx <= 0 ? 'file' : url.substring(0, idx);
+  const f = getDocFetcher(scheme);
+  if (f) return await f(url);
+  else return undefined;
+}
+
+async function httpFetcher(url: string): Promise<string | undefined> {
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+    });
+
+    if (!response.ok) {
+      logger.error(
+        `Failed to fetch document ${url}, HTTP error! status: ${response.status} ${response.text} ${response.statusText}`
+      );
+      return undefined;
+    }
+    return await response.text();
+  } catch (reason: any) {
+    logger.error(`Failed to fetch document ${url}: ${reason}`);
+  }
+  return undefined;
+}
+
+async function fetchFile(path: string): Promise<string> {
+  const fs = await getFileSystem();
+  if (path.startsWith('.')) {
+    path = `${process.cwd()}${path.substring(1)}`;
+  }
+  return fs.readFile(path);
+}
+
+registerDocFetcher('http', httpFetcher);
+registerDocFetcher('https', httpFetcher);
+registerDocFetcher('file', fetchFile);

package/src/runtime/integrations.ts

@@ -51,7 +51,7 @@ async function loginToIntegManager(
 ): Promise<any> {
   const defaultHdr = { 'Content-Type': 'application/json' };
   if (username && password && username.length > 0) {
-    const apiUrl = `${host}/agentlang_auth/login`;
+    const apiUrl = `${host}/agentlang.auth/login`;
     const data = { email: username, password: password };
     const response = await fetch(apiUrl, {
       method: 'POST',

package/src/runtime/interpreter.ts

@@ -59,6 +59,7 @@ import {
   isFqName,
   isPath,
   isString,
+  makeCoreModuleName,
   makeFqName,
   Path,
   QuerySuffix,
@@ -82,6 +83,7 @@ import {
 } from './modules/core.js';
 import { invokeModuleFn } from './jsmodules.js';
 import { invokeOpenApiEvent, isOpenApiEventInstance } from './openapi.js';
+import { fetchDoc } from './docs.js';
 
 export type Result = any;
 
@@ -547,6 +549,10 @@ export async function evaluate(
         }
         await evaluateStatements(wf.statements, env, continuation);
         return env.getLastResult();
+      } else if (isAgentEventInstance(eventInstance)) {
+        env = new Environment(eventInstance.name + '.env', activeEnv);
+        await handleAgentInvocation(eventInstance, env);
+        if (continuation) continuation(env.getLastResult());
       } else if (isOpenApiEventInstance(eventInstance)) {
         env = new Environment(eventInstance.name + '.env', activeEnv);
         await handleOpenApiEvent(eventInstance, env);
@@ -1192,12 +1198,32 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   } else if (isEventInstance(inst)) {
     if (isAgentEventInstance(inst)) await handleAgentInvocation(inst, env);
     else if (isOpenApiEventInstance(inst)) await handleOpenApiEvent(inst, env);
+    else if (isDocEventInstance(inst)) await handleDocEvent(inst, env);
     else await evaluate(inst, (result: Result) => env.setLastResult(result), env);
   } else {
     env.setLastResult(inst);
   }
 }
 
+const CoreAIModuleName = makeCoreModuleName('ai');
+const DocEventName = `${CoreAIModuleName}/doc`;
+
+function isDocEventInstance(inst: Instance): boolean {
+  return isInstanceOfType(inst, DocEventName);
+}
+
+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
+    );
+  }
+}
+
 function triggerTimer(timerInst: Instance): Instance {
   const dur = timerInst.lookup('duration');
   const unit = timerInst.lookup('unit');
@@ -1315,7 +1341,9 @@ const MAX_PLANNER_RETRIES = 3;
 
 async function handleAgentInvocation(agentEventInst: Instance, env: Environment): Promise<void> {
   const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
-  await agent.invoke(agentEventInst.lookup('message'), env);
+  const origMsg: any = agentEventInst.lookup('message');
+  const msg: string = isString(origMsg) ? origMsg : agentInputAsString(origMsg);
+  await agent.invoke(msg, env);
   const r: string | undefined = env.getLastResult();
   const isPlanner = agent.isPlanner();
   let result: string | undefined = isPlanner ? cleanupAgentResponse(r) : r;
@@ -1713,7 +1741,7 @@ async function runPreCreateEvents(inst: Instance, env: Environment) {
   await runPrePostEvents(CrudType.CREATE, true, inst, env);
 }
 
-async function runPostCreateEvents(inst: Instance, env: Environment) {
+export async function runPostCreateEvents(inst: Instance, env: Environment) {
   if (inst.requireAudit()) {
     await addCreateAudit(inst.getPath(), env);
   }
@@ -1724,7 +1752,7 @@ async function runPreUpdateEvents(inst: Instance, env: Environment) {
   await runPrePostEvents(CrudType.UPDATE, true, inst, env);
 }
 
-async function runPostUpdateEvents(inst: Instance, env: Environment) {
+export async function runPostUpdateEvents(inst: Instance, env: Environment) {
   if (inst.requireAudit()) {
     await addUpdateAudit(inst.getPath(), undefined, env);
   }
@@ -1735,7 +1763,7 @@ async function runPreDeleteEvents(inst: Instance, env: Environment) {
   await runPrePostEvents(CrudType.DELETE, true, inst, env);
 }
 
-async function runPostDeleteEvents(inst: Instance, env: Environment) {
+export async function runPostDeleteEvents(inst: Instance, env: Environment) {
   if (inst.requireAudit()) {
     await addDeleteAudit(inst.getPath(), undefined, env);
   }

package/src/runtime/jsmodules.ts

@@ -39,7 +39,7 @@ export async function importModule(path: string, name: string, moduleFileName?:
       }
       path = `${s}${sep}${path}`;
     }
-    if ((path.startsWith(sep) || path.startsWith('.')) && moduleFileName) {
+    if (!(path.startsWith(sep) || path.startsWith('.'))) {
       path = process.cwd() + sep + path;
     }
     const m = await import(/* @vite-ignore */ path);

package/src/runtime/module.ts

@@ -44,12 +44,7 @@ import {
 } from './util.js';
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
-import {
-  DefaultIdAttributeName,
-  FetchModuleFn,
-  PathAttributeName,
-  SetSubscription,
-} from './defs.js';
+import { FetchModuleFn, PathAttributeName, SetSubscription } from './defs.js';
 import { logger } from './logger.js';
 
 export class ModuleEntry {
@@ -809,8 +804,13 @@ export class Agent extends Record {
     return this;
   }
 
-  getTools(): string {
-    return this.attributes.get('tools');
+  getTools(): string[] | undefined {
+    const tools = this.attributes.get('tools');
+    if (tools) {
+      return tools.split(',');
+    } else {
+      return undefined;
+    }
   }
 
   removeTools(): Agent {
@@ -874,14 +874,6 @@ export class Entity extends Record {
     parentEntryName?: string
   ) {
     super(name, moduleName, scm, parentEntryName);
-    const idattr = this.getIdAttributeName();
-    if (idattr == undefined) {
-      const attrSpec: AttributeSpec = {
-        type: 'UUID',
-        properties: new Map().set('default', 'uuid()').set('id', true),
-      };
-      this.schema.set(DefaultIdAttributeName, attrSpec);
-    }
   }
 
   setRbacSpecifications(rbac: RbacSpecification[]): Entity {
@@ -2659,7 +2651,7 @@ const EventAgentName = 'event-agent-name';
 export function defineAgentEvent(moduleName: string, agentName: string) {
   const module = fetchModule(moduleName);
   const event: Record = new Event(agentName, moduleName);
-  event.addAttribute('message', { type: 'String' });
+  event.addAttribute('message', { type: 'Any' });
   event.addAttribute('chatId', { type: 'String' });
   event.addMeta(IsAgentEventMeta, 'y');
   event.addMeta(EventAgentName, agentName);

package/src/runtime/modules/ai.ts

@@ -1,5 +1,10 @@
 import { isFqName, makeCoreModuleName, makeFqName, splitFqName } from '../util.js';
-import { Environment, makeEventEvaluator, parseAndEvaluateStatement } from '../interpreter.js';
+import {
+  Environment,
+  GlobalEnvironment,
+  makeEventEvaluator,
+  parseAndEvaluateStatement,
+} from '../interpreter.js';
 import { fetchModule, Instance, instanceToObject, isModule } from '../module.js';
 import { provider } from '../agents/registry.js';
 import {
@@ -35,6 +40,7 @@ entity ${AgentEntityName} {
     documents String @optional, // comma-separated list of document names
     channels String @optional, // comma-separated list of channel names
     output String @optional, // fq-name of another agent to which the result will be pushed
+    role String @optional,
     llm String
 }
 
@@ -57,6 +63,11 @@ entity Document {
   content String,
   @meta {"fullTextSearch": "*"}
 }
+
+event doc {
+  title String,
+  url String
+}
 `;
 
 export const AgentFqName = makeFqName(CoreAIModuleName, AgentEntityName);
@@ -74,15 +85,46 @@ export class AgentInstance {
   channels: string | undefined;
   runWorkflows: boolean = true;
   output: string | undefined;
+  role: string | undefined;
+  private toolsArray: string[] | undefined = undefined;
+  private hasModuleTools = false;
 
   private constructor() {}
 
   static FromInstance(agentInstance: Instance): AgentInstance {
-    return instanceToObject<AgentInstance>(agentInstance, new AgentInstance());
+    const agent: AgentInstance = instanceToObject<AgentInstance>(
+      agentInstance,
+      new AgentInstance()
+    );
+    let finalTools: string | undefined = undefined;
+    if (agent.tools) finalTools = agent.tools;
+    if (agent.channels) {
+      if (finalTools) {
+        finalTools = `${finalTools},${agent.channels}`;
+      } else {
+        finalTools = agent.channels;
+      }
+    }
+    if (finalTools) {
+      agent.toolsArray = finalTools.split(',');
+    }
+    if (agent.toolsArray) {
+      for (let i = 0; i < agent.toolsArray.length; ++i) {
+        const n = agent.toolsArray[i];
+        if (isFqName(n)) {
+          const parts = splitFqName(n);
+          agent.hasModuleTools = isModule(parts.getModuleName());
+        } else {
+          agent.hasModuleTools = isModule(n);
+        }
+        if (agent.hasModuleTools) break;
+      }
+    }
+    return agent;
   }
 
   isPlanner(): boolean {
-    return (this.tools && this.tools.length > 0) || this.type == 'planner';
+    return this.hasModuleTools || this.type == 'planner';
   }
 
   async invoke(message: string, env: Environment) {
@@ -95,7 +137,8 @@ export class AgentInstance {
     if (sess) {
       msgs = sess.lookup('messages');
     } else {
-      msgs = [systemMessage(this.instruction)];
+      const msg = this.role ? `role: ${this.role}\n ${this.instruction}` : this.instruction;
+      msgs = [systemMessage(msg)];
     }
     if (msgs) {
       try {
@@ -107,7 +150,8 @@ export class AgentInstance {
           msgs[0] = newSysMsg;
         }
         msgs.push(humanMessage(await this.maybeAddRelevantDocuments(message, env)));
-        const response: AIResponse = await p.invoke(msgs);
+        const externalToolSpecs = this.getExternalToolSpecs();
+        const response: AIResponse = await p.invoke(msgs, externalToolSpecs);
         msgs.push(assistantMessage(response.content));
         if (isplnr) {
           msgs[0] = sysMsg;
@@ -123,16 +167,32 @@ export class AgentInstance {
     }
   }
 
+  private getExternalToolSpecs(): any[] | undefined {
+    let result: any[] | undefined = undefined;
+    if (this.toolsArray) {
+      this.toolsArray.forEach((n: string) => {
+        const v = GlobalEnvironment.lookup(n);
+        if (v) {
+          if (result == undefined) {
+            result = new Array<any>();
+          }
+          result.push(v);
+        }
+      });
+    }
+    return result;
+  }
+
   private async maybeAddRelevantDocuments(message: string, env: Environment): Promise<string> {
     if (this.documents && this.documents.length > 0) {
       const s = `${message}. Relevant documents are: ${this.documents}`;
-      const result: any[] = await parseHelper(`{agentlang_ai/Document? "${s}"}`, env);
+      const result: any[] = await parseHelper(`{${CoreAIModuleName}/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}"}}`,
+            `{${CoreAIModuleName}/Document {${PathAttributeNameQuery} "${v.id}"}}`,
             env
           );
           if (r && r.length > 0) {
@@ -153,20 +213,17 @@ export class AgentInstance {
     return message;
   }
 
+  private static ToolsCache = new Map<string, string>();
+
   private toolsAsString(): string {
-    let finalTools: string | undefined = undefined;
-    if (this.tools) finalTools = this.tools;
-    if (this.channels) {
-      if (finalTools) {
-        finalTools = `${finalTools},${this.channels}`;
-      } else {
-        finalTools = this.channels;
-      }
+    const cachedTools = AgentInstance.ToolsCache.get(this.name);
+    if (cachedTools) {
+      return cachedTools;
     }
-    if (finalTools) {
+    if (this.toolsArray) {
       const tooldefs = new Array<string>();
       const slimModules = new Map<string, string[]>();
-      finalTools.split(',').forEach((n: string) => {
+      this.toolsArray.forEach((n: string) => {
         let moduleName: string | undefined;
         let entryName: string | undefined;
         if (isFqName(n)) {
@@ -193,7 +250,9 @@ export class AgentInstance {
       slimModules.forEach((defs: string[], modName: string) => {
         tooldefs.push(`module ${modName}\n${defs.join('\n')}`);
       });
-      return tooldefs.join('\n');
+      const agentTools = tooldefs.join('\n');
+      AgentInstance.ToolsCache.set(this.name, agentTools);
+      return agentTools;
     } else {
       return '';
     }

package/src/runtime/resolvers/interface.ts

@@ -1,4 +1,10 @@
-import { Environment, evaluate } from '../interpreter.js';
+import {
+  Environment,
+  evaluate,
+  runPostCreateEvents,
+  runPostDeleteEvents,
+  runPostUpdateEvents,
+} from '../interpreter.js';
 import { logger } from '../logger.js';
 import {
   Instance,
@@ -7,7 +13,7 @@ import {
   newInstanceAttributes,
   Relationship,
 } from '../module.js';
-import { splitFqName } from '../util.js';
+import { CrudType, splitFqName } from '../util.js';
 
 export class ResolverAuthInfo {
   userId: string;
@@ -191,6 +197,35 @@ export class Resolver {
     return undefined;
   }
 
+  private async onOutOfBandCrud(
+    inst: Instance,
+    operation: CrudType,
+    env: Environment
+  ): Promise<any> {
+    switch (operation) {
+      case CrudType.CREATE:
+        return await runPostCreateEvents(inst, env);
+      case CrudType.UPDATE:
+        return await runPostUpdateEvents(inst, env);
+      case CrudType.DELETE:
+        return await runPostDeleteEvents(inst, env);
+      default:
+        return inst;
+    }
+  }
+
+  public async onCreate(inst: Instance, env: Environment): Promise<any> {
+    return this.onOutOfBandCrud(inst, CrudType.CREATE, env);
+  }
+
+  public async onUpdate(inst: Instance, env: Environment): Promise<any> {
+    return this.onOutOfBandCrud(inst, CrudType.UPDATE, env);
+  }
+
+  public async onDelete(inst: Instance, env: Environment): Promise<any> {
+    return this.onOutOfBandCrud(inst, CrudType.DELETE, env);
+  }
+
   public async onSubscription(result: any): Promise<any> {
     if (result != undefined) {
       try {

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

@@ -768,7 +768,7 @@ export async function getManyByJoin(
 function intoSpecToSql(intoSpec: Map<string, string>): string {
   const cols = new Array<string>();
   intoSpec.forEach((v: string, k: string) => {
-    cols.push(`${v} AS ${k}`);
+    cols.push(`${v} AS "${k}"`);
   });
   return cols.join(', ');
 }

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

@@ -94,8 +94,8 @@ export class SqlDbResolver extends Resolver {
       const idAttrName: string | undefined = maybeFindIdAttributeName(inst);
       ensureOneToOneAttributes(inst);
       const attrs: InstanceAttributes = inst.attributes;
-      if (idAttrName != undefined) {
-        const idAttrVal: any = attrs.get(idAttrName);
+      const idAttrVal: any = idAttrName ? attrs.get(idAttrName) : crypto.randomUUID();
+      if (idAttrVal != undefined) {
         const pp: string | undefined = attrs.get(PathAttributeName);
         const n: string = `${inst.moduleName}/${inst.name}`;
         let p: string = '';

package/src/runtime/util.ts

@@ -207,7 +207,7 @@ export const DefaultModuleName = 'agentlang';
 export const DefaultModules = new Set();
 
 export function makeCoreModuleName(n: string): string {
-  return DefaultModuleName + '_' + n;
+  return DefaultModuleName + '.' + n;
 }
 
 const InitFunctions: Function[] = [];