agentlang 0.0.5 → 0.0.7

package/src/runtime/module.ts

@@ -44,6 +44,7 @@ import {
 import { parseStatement } from '../language/parser.js';
 import { ActiveSessionInfo, AdminSession } from './auth/defs.js';
 import { DefaultIdAttributeName, PathAttributeName } from './defs.js';
+import { logger } from './logger.js';
 
 export class ModuleEntry {
   name: string;
@@ -101,7 +102,7 @@ function recordSchemaToString(scm: RecordSchema): string {
       ss.push(`    ${n} ${attributeSpecToString(attrSpec)}`);
     }
   });
-  return `\n${ss.join(',\n')} \n`;
+  return `\n${ss.join(',\n')}`;
 }
 
 function attributeSpecToString(attrSpec: AttributeSpec): string {
@@ -142,7 +143,7 @@ function normalizeMetaValue(metaValue: any): any {
   const v: Literal = metaValue as Literal;
   if (v.array) {
     return v.array.vals.map((value: Statement) => {
-      return normalizeMetaValue(value.pattern.literal);
+      return normalizeMetaValue(value.pattern.expr);
     });
   } else if (v.bool != undefined) {
     return v.bool;
@@ -177,6 +178,23 @@ function asTriggerInfo(te: TriggerEntry): TriggerInfo {
   };
 }
 
+const EnumPropertyName = 'one-of';
+const OneOfPropertyName = 'one-of-ref';
+
+export function enumAttributeSpec(values: Set<string>): AttributeSpec {
+  return {
+    type: 'String',
+    properties: new Map().set(EnumPropertyName, values),
+  };
+}
+
+export function oneOfAttributeSpec(ref: string): AttributeSpec {
+  return {
+    type: 'String',
+    properties: new Map().set(OneOfPropertyName, ref),
+  };
+}
+
 export class Record extends ModuleEntry {
   schema: RecordSchema;
   meta: Meta | undefined;
@@ -241,9 +259,9 @@ export class Record extends ModuleEntry {
           }
           if (isArrayType) props.set('array', true);
           if (isObjectType) props.set('object', true);
-          if (enumValues) props.set('one-of', new Set(enumValues));
+          if (enumValues) props.set(EnumPropertyName, new Set(enumValues));
           if (oneOfRef) {
-            props.set('one-of-ref', oneOfRef);
+            props.set(OneOfPropertyName, oneOfRef);
             this.addOneOfRefAttribute(a.name);
           }
         }
@@ -424,9 +442,9 @@ export class Record extends ModuleEntry {
       const rbs = this.rbac.map((rs: RbacSpecification) => {
         return rs.toString();
       });
-      scms = `${scms}    @rbac [${rbs.join(',\n')}]`;
+      scms = `${scms},\n    @rbac [${rbs.join(',\n')}]`;
     }
-    return s.concat('\n{', scms, '}\n');
+    return s.concat('\n{', scms, '\n}\n');
   }
 
   getUserAttributes(): RecordSchema {
@@ -532,7 +550,7 @@ function normalizeKvPairValue(kvp: KvPair): any | null {
   } else if (v.num != undefined) {
     return v.num;
   } else if (v.bool != undefined) {
-    return v.bool;
+    return v.bool == 'true' ? true : false;
   } else if (v.id != undefined) {
     return v.id;
   } else if (v.ref != undefined) {
@@ -602,14 +620,16 @@ export class RbacSpecification {
   }
 
   setPermissions(perms: Array<string>): RbacSpecification {
+    const ps = new Set<RbacPermissionFlag>();
     perms.forEach((v: string) => {
       const idx: any = v.toUpperCase();
       const a: any = RbacPermissionFlag[idx];
       if (a == undefined) {
         throw new Error(`Not a valid RBAC permission - ${v}`);
       }
-      this.permissions.add(a);
+      ps.add(a);
     });
+    this.permissions = ps;
     return this;
   }
 
@@ -644,9 +664,15 @@ export class RbacSpecification {
     return this;
   }
 
+  removeRoles(): RbacSpecification {
+    this.roles = RbacSpecification.EmptyRoles;
+    return this;
+  }
+
   setExpression(lhs: string, rhs: string): RbacSpecification {
     if (this.roles != RbacSpecification.EmptyRoles) {
-      throw new Error('Cannot set `where` expression along with roles');
+      logger.warn('Cannot set `where` expression along with roles, removing roles');
+      this.removeRoles();
     }
     this.expression = {
       lhs: lhs,
@@ -655,7 +681,15 @@ export class RbacSpecification {
     return this;
   }
 
+  removeExpression(): RbacSpecification {
+    this.expression = undefined;
+    return this;
+  }
+
   toString(): string {
+    if (this.permissions.size <= 0) {
+      throw new Error(`Cannot emit RbacSpecification, no permissions are set`);
+    }
     const rs = new Array<string>();
     this.roles.forEach((r: string) => {
       rs.push(r);
@@ -875,6 +909,10 @@ function asRelNodeEntry(n: NodeDefinition): RelationshipNode {
   };
 }
 
+const OneToOne = 'one_one';
+const OneToMany = 'one_many';
+const ManyToMany = 'many_many';
+
 export class Relationship extends Record {
   override type: RecordType = RecordType.RELATIONSHIP;
   relType: RelType = RelType.CONTAINS;
@@ -953,25 +991,52 @@ export class Relationship extends Record {
     return false;
   }
 
+  private setProperty(p: string, v: any): Relationship {
+    if (this.properties == undefined) {
+      this.properties = new Map();
+    }
+    this.properties.set(p, v);
+    return this;
+  }
+
   isOneToOne(): boolean {
-    return this.isBetween() && this.hasBooleanFlagSet('one_one');
+    return this.isBetween() && this.hasBooleanFlagSet(OneToOne);
   }
 
   isOneToMany(): boolean {
-    return this.isBetween() && this.hasBooleanFlagSet('one_many');
+    return this.isBetween() && this.hasBooleanFlagSet(OneToMany);
   }
 
   isManyToMany(): boolean {
     if (this.isBetween()) {
       return (
-        this.hasBooleanFlagSet('many_many') ||
-        (!this.hasBooleanFlagSet('one_one') && !this.hasBooleanFlagSet('one_many'))
+        this.hasBooleanFlagSet(ManyToMany) ||
+        (!this.hasBooleanFlagSet(OneToOne) && !this.hasBooleanFlagSet(OneToMany))
       );
     } else {
       return false;
     }
   }
 
+  setOneToOne(flag: boolean = true): Relationship {
+    if (flag) {
+      this.setOneToMany(false).setManyToMany(false);
+    }
+    return this.setProperty(OneToOne, flag);
+  }
+
+  setOneToMany(flag: boolean = true): Relationship {
+    if (flag) {
+      this.setOneToOne(false).setManyToMany(false);
+    }
+    return this.setProperty(OneToMany, flag);
+  }
+
+  setManyToMany(flag: boolean = true): Relationship {
+    this.setOneToOne(false).setOneToMany(false);
+    return this.setProperty(ManyToMany, flag);
+  }
+
   isFirstNode(inst: Instance): boolean {
     return this.isFirstNodeName(inst.getFqName());
   }
@@ -1561,22 +1626,46 @@ function getAnyProperty(propName: string, attrSpec: AttributeSpec): any | undefi
   return undefined;
 }
 
+function setAnyProperty(propName: string, value: any, attrSpec: AttributeSpec): AttributeSpec {
+  if (attrSpec.properties == undefined) {
+    attrSpec.properties = new Map();
+  }
+  attrSpec.properties.set(propName, value);
+  return attrSpec;
+}
+
 export function isIdAttribute(attrSpec: AttributeSpec): boolean {
   return getBooleanProperty('id', attrSpec);
 }
 
+export function asIdAttribute(attrSpec: AttributeSpec): AttributeSpec {
+  return setAnyProperty('id', true, attrSpec);
+}
+
 export function isUniqueAttribute(attrSpec: AttributeSpec): boolean {
   return getBooleanProperty('unique', attrSpec);
 }
 
+export function asUniqueAttribute(attrSpec: AttributeSpec): AttributeSpec {
+  return setAnyProperty('unique', true, attrSpec);
+}
+
 export function isIndexedAttribute(attrSpec: AttributeSpec): boolean {
   return getBooleanProperty('indexed', attrSpec);
 }
 
+export function asIndexedAttribute(attrSpec: AttributeSpec): AttributeSpec {
+  return setAnyProperty('indexed', true, attrSpec);
+}
+
 export function isOptionalAttribute(attrSpec: AttributeSpec): boolean {
   return getBooleanProperty('optional', attrSpec);
 }
 
+export function asOptionalAttribute(attrSpec: AttributeSpec): AttributeSpec {
+  return setAnyProperty('optional', true, attrSpec);
+}
+
 export function isArrayAttribute(attrSpec: AttributeSpec): boolean {
   return getBooleanProperty('array', attrSpec);
 }
@@ -1601,6 +1690,10 @@ export function getAttributeDefaultValue(attrSpec: AttributeSpec): any | undefin
   return getAnyProperty('default', attrSpec);
 }
 
+export function setDefaultAttributeValue(attrSpec: AttributeSpec, value: any): AttributeSpec {
+  return setAnyProperty('default', value, attrSpec);
+}
+
 export function getAttributeLength(attrSpec: AttributeSpec): number | undefined {
   return getAnyProperty('length', attrSpec);
 }
@@ -2212,12 +2305,14 @@ export class Instance {
   }
 }
 
-export function objectAsInstanceAttributes(obj: object): InstanceAttributes {
+export function objectAsInstanceAttributes(obj: object | undefined): InstanceAttributes {
   const attrs: InstanceAttributes = newInstanceAttributes();
-  Object.entries(obj).forEach((v: [string, any]) => {
-    const obj = v[1];
-    attrs.set(v[0], obj);
-  });
+  if (obj) {
+    Object.entries(obj).forEach((v: [string, any]) => {
+      const obj = v[1];
+      attrs.set(v[0], obj);
+    });
+  }
   return attrs;
 }
 

package/src/runtime/modules/ai.ts

@@ -12,6 +12,7 @@ import {
 import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
 import { PlannerInstructions } from '../agents/common.js';
 import { PathAttributeNameQuery } from '../defs.js';
+import { logger } from '../logger.js';
 
 export const CoreAIModuleName = makeCoreModuleName('ai');
 export const AgentEntityName = 'Agent';
@@ -28,6 +29,7 @@ entity ${LlmEntityName} {
 entity ${AgentEntityName} {
     name String @id,
     type @enum("chat", "planner") @default("chat"),
+    runWorkflows Boolean @default(true),
     instruction String @optional,
     tools String @optional, // comma-separated values
     documents String @optional, // comma-separated values
@@ -67,6 +69,7 @@ export class AgentInstance {
   type: string = 'chat';
   tools: string | undefined;
   documents: string | undefined;
+  runWorkflows: boolean = true;
 
   private constructor() {}
 
@@ -91,21 +94,26 @@ export class AgentInstance {
       msgs = [systemMessage(this.instruction)];
     }
     if (msgs) {
-      const sysMsg = msgs[0];
-      if (isplnr) {
-        const newSysMsg = systemMessage(
-          `${PlannerInstructions}\n${this.toolsAsString()}\n${this.instruction}`
-        );
-        msgs[0] = newSysMsg;
-      }
-      msgs.push(humanMessage(await this.maybeAddRelevantDocuments(message, env)));
-      const response: AIResponse = await p.invoke(msgs);
-      msgs.push(assistantMessage(response.content));
-      if (isplnr) {
-        msgs[0] = sysMsg;
+      try {
+        const sysMsg = msgs[0];
+        if (isplnr) {
+          const newSysMsg = systemMessage(
+            `${PlannerInstructions}\n${this.toolsAsString()}\n${this.instruction}`
+          );
+          msgs[0] = newSysMsg;
+        }
+        msgs.push(humanMessage(await this.maybeAddRelevantDocuments(message, env)));
+        const response: AIResponse = await p.invoke(msgs);
+        msgs.push(assistantMessage(response.content));
+        if (isplnr) {
+          msgs[0] = sysMsg;
+        }
+        await saveAgentChatSession(chatId, msgs, env);
+        env.setLastResult(response.content);
+      } catch (err: any) {
+        logger.error(`Error while invoking ${agentName} - ${err}`);
+        env.setLastResult(undefined);
       }
-      await saveAgentChatSession(chatId, msgs, env);
-      env.setLastResult(response.content);
     } else {
       throw new Error(`failed to initialize messages for agent ${agentName}`);
     }

package/src/runtime/modules/auth.ts

@@ -130,6 +130,8 @@ entity Session {
   id UUID @id,
   userId UUID @indexed,
   authToken String @optional,
+  accessToken String @optional,
+  refreshToken String @optional,
   isActive Boolean,
   @rbac [(allow: [read, delete, update, create], where: auth.user = this.userId)]
 }
@@ -137,7 +139,18 @@ entity Session {
 
 workflow CreateSession {
   {Session {id CreateSession.id, userId CreateSession.userId,
-            authToken CreateSession.authToken, isActive true}}
+            authToken CreateSession.authToken,
+            accessToken CreateSession.accessToken,
+            refreshToken CreateSession.refreshToken,
+            isActive true}}
+}
+
+workflow UpdateSession {
+  {Session {id? UpdateSession.id,
+            authToken UpdateSession.authToken,
+            accessToken UpdateSession.accessToken,
+            refreshToken UpdateSession.refreshToken,
+            isActive true}, @upsert}
 }
 
 workflow FindSession {
@@ -146,7 +159,7 @@ workflow FindSession {
 }
 
 workflow FindUserSession {
-  {Session {userId? FindUserSession.id}} as [session];
+  {Session {userId? FindUserSession.userId}} as [session];
   session
 }
 
@@ -167,6 +180,18 @@ workflow login {
   await Auth.loginUser(login.email, login.password)
 }
 
+workflow logout {
+  await Auth.logoutUser()
+}
+
+workflow changePassword {
+  await Auth.changePassword(changePassword.newPassword, changePassword.password)
+}
+
+workflow refreshToken {
+  await Auth.refreshUserToken(refreshToken.refreshToken)
+}
+
 workflow getUser {
   await Auth.getUserInfo(getUser.userId)
 }
@@ -230,18 +255,32 @@ export async function ensureUser(
   return await createUser(crypto.randomUUID(), email, firstName, lastName, env);
 }
 
-export async function ensureUserSession(userId: string, token: string, env: Environment) {
+export async function ensureUserSession(
+  userId: string,
+  token: string,
+  accessToken: string,
+  refreshToken: string,
+  env: Environment
+): Promise<Instance> {
   const sess: Instance = await findUserSession(userId, env);
   if (sess) {
-    await removeSession(sess.lookup('id'), env);
+    // Update existing session instead of deleting and recreating
+    await updateSession(sess.lookup('id'), token, accessToken, refreshToken, env);
+    // Return the updated session by finding it again
+    return await findUserSession(userId, env);
   }
-  return await createSession(crypto.randomUUID(), userId, token, env);
+  const sessionId = crypto.randomUUID();
+  await createSession(sessionId, userId, token, accessToken, refreshToken, env);
+  // Return the created session by finding it
+  return await findSession(sessionId, env);
 }
 
 export async function createSession(
   id: string,
   userId: string,
   token: string,
+  accessToken: string,
+  refreshToken: string,
   env: Environment
 ): Promise<Result> {
   return await evalEvent(
@@ -250,6 +289,8 @@ export async function createSession(
       id: id,
       userId: userId,
       authToken: token,
+      accessToken: accessToken,
+      refreshToken: refreshToken,
     },
     env
   );
@@ -275,6 +316,25 @@ export async function findUserSession(userId: string, env: Environment): Promise
   );
 }
 
+export async function updateSession(
+  id: string,
+  token: string,
+  accessToken: string,
+  refreshToken: string,
+  env: Environment
+): Promise<Result> {
+  return await evalEvent(
+    'UpdateSession',
+    {
+      id: id,
+      authToken: token,
+      accessToken: accessToken,
+      refreshToken: refreshToken,
+    },
+    env
+  );
+}
+
 export async function removeSession(id: string, env: Environment): Promise<Result> {
   return await evalEvent(
     'RemoveSession',
@@ -539,6 +599,61 @@ export async function loginUser(
   }
 }
 
+async function logoutSession(userId: string, sess: Instance, env: Environment): Promise<string> {
+  const sessId = sess.lookup('id');
+  const tok = sess.lookup('authToken');
+  await fetchAuthImpl().logout(
+    {
+      sessionId: sessId,
+      userId: userId,
+      authToken: tok,
+      idToken: tok,
+      accessToken: sess.lookup('accessToken'),
+      refreshToken: sess.lookup('refreshToken'),
+    },
+    env
+  );
+  await removeSession(sessId, env);
+  return 'ok';
+}
+
+export async function logoutUser(env: Environment): Promise<string | undefined> {
+  const user = env.getActiveUser();
+  const sess = await findUserSession(user, env);
+  if (sess) {
+    return await logoutSession(user, sess, env);
+  }
+  return undefined;
+}
+
+export async function changePassword(
+  newPassword: string,
+  password: string,
+  env: Environment
+): Promise<string | undefined> {
+  const user = env.getActiveUser();
+  const sess = await findUserSession(user, env);
+  if (sess) {
+    const sessId = sess.lookup('id');
+    const tok = sess.lookup('authToken');
+    const sessInfo = {
+      sessionId: sessId,
+      userId: user,
+      authToken: tok,
+      idToken: tok,
+      accessToken: sess.lookup('accessToken'),
+      refreshToken: sess.lookup('refreshToken'),
+    };
+    if (await fetchAuthImpl().changePassword(sessInfo, newPassword, password, env)) {
+      return await logoutSession(user, sess, env);
+    } else {
+      return undefined;
+    }
+  } else {
+    throw new UnauthorisedError(`No active session for user ${user}`);
+  }
+}
+
 export async function verifySession(token: string, env?: Environment): Promise<ActiveSessionInfo> {
   if (!isAuthEnabled()) return BypassSession;
 
@@ -598,9 +713,12 @@ async function verifyJwtToken(token: string, env?: Environment): Promise<ActiveS
 
       // Use the local user's ID for consistency
       const localUserId = localUser.lookup('id');
-
+      const sess = await findUserSession(localUserId, env);
+      if (!sess) {
+        throw new UnauthorisedError(`No session found for user ${email}, UserId: ${userId}`);
+      }
       // For JWT tokens, we use the token itself as sessionId for tracking
-      return { sessionId: token.substring(0, 32), userId: localUserId };
+      return { sessionId: sess.lookup('id'), userId: localUserId };
     } catch (err: any) {
       if (err instanceof UnauthorisedError) {
         throw err;
@@ -690,8 +808,38 @@ export async function getUserInfoByEmail(email: string, env: Environment): Promi
   }
 }
 
+export async function refreshUserToken(refreshToken: string, env: Environment): Promise<object> {
+  const needCommit = env ? false : true;
+  env = env ? env : new Environment();
+  const f = async () => {
+    try {
+      const sessionInfo = await fetchAuthImpl().refreshToken(refreshToken, env);
+
+      return {
+        id_token: sessionInfo.idToken,
+        access_token: sessionInfo.accessToken,
+        refresh_token: sessionInfo.refreshToken,
+        token_type: 'Bearer',
+        expires_in: 3600,
+        userId: sessionInfo.userId,
+        sessionId: sessionInfo.sessionId,
+      };
+    } catch (err: any) {
+      logger.error(`Token refresh failed: ${err.message}`);
+      throw err;
+    }
+  };
+  if (needCommit) {
+    return await env.callInTransaction(f);
+  } else {
+    return await f();
+  }
+}
+
 export function requireAuth(moduleName: string, eventName: string): boolean {
-  const f = moduleName == CoreAuthModuleName && (eventName == 'login' || eventName == 'signup');
+  const f =
+    moduleName == CoreAuthModuleName &&
+    (eventName == 'login' || eventName == 'signup' || eventName == 'refreshToken');
   return !f;
 }
 

package/src/runtime/resolvers/interface.ts

@@ -217,7 +217,6 @@ export type GenericResolverMethods = {
 
 export type GenericResolverSubscription = {
   subscribe: MaybeFunction;
-  onSubscriptionEvent: string;
 };
 
 export class GenericResolver extends Resolver {

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

@@ -40,6 +40,7 @@ import { Environment } from '../../interpreter.js';
 import { OpenAIEmbeddings } from '@langchain/openai';
 import { Embeddings } from '@langchain/core/embeddings';
 import { DeletedFlagAttributeName, ParentAttributeName, PathAttributeName } from '../../defs.js';
+import { logger } from '../../logger.js';
 
 function maybeFindIdAttributeName(inst: Instance): string | undefined {
   const attrEntry: AttributeEntry | undefined = findIdAttribute(inst);
@@ -108,9 +109,13 @@ export class SqlDbResolver extends Resolver {
       await insertRow(n, rowObj, ctx, orUpdate);
       if (inst.record.getFullTextSearchAttributes()) {
         const path = attrs.get(PathAttributeName);
-        if (!(await vectorStoreSearchEntryExists(n, path, ctx))) {
-          const res = await this.embeddings.embedQuery(JSON.stringify(rowObj));
-          await addRowForFullTextSearch(n, path, res, ctx);
+        try {
+          if (!(await vectorStoreSearchEntryExists(n, path, ctx))) {
+            const res = await this.embeddings.embedQuery(JSON.stringify(rowObj));
+            await addRowForFullTextSearch(n, path, res, ctx);
+          }
+        } catch (reason: any) {
+          logger.warn(`Full text indexing failed for ${path} - ${reason}`);
         }
       }
       return inst;

package/src/runtime/util.ts

@@ -11,7 +11,6 @@ import {
   Statement,
 } from '../language/generated/ast.js';
 import { readFile } from '../utils/fs-utils.js';
-import { logger } from './logger.js';
 
 export const QuerySuffix = '?';
 
@@ -27,75 +26,6 @@ if (isNodeEnv) {
   promisify = nu.promisify;
 }
 
-const importedModules = new Map<string, any>();
-
-// Usage: importModule("./mymodels/acme.js")
-export async function importModule(path: string, name: string) {
-  const m = await import(/* @vite-ignore */ path);
-  importedModules.set(name, m);
-  // e.g of dynamic fn-call:
-  //// let f = eval("(a, b) => m.add(a, b)");
-  //// console.log(f(10, 20))
-  return m;
-}
-
-export function moduleImported(moduleName: string): boolean {
-  return importedModules.has(moduleName);
-}
-
-function maybeEvalFunction(fnName: string): Function | undefined {
-  try {
-    return eval(fnName);
-  } catch (reason: any) {
-    logger.debug(reason);
-    return undefined;
-  }
-}
-
-export async function invokeModuleFn(
-  fqFnName: string,
-  args: Array<any> | null,
-  isAsync: boolean = false
-): Promise<any> {
-  try {
-    const refs: string[] = splitRefs(fqFnName);
-    const m = importedModules.get(refs[0]);
-    if (m != undefined) {
-      const f = m[refs[1]];
-      if (f != undefined) {
-        if (args == null)
-          if (isAsync) {
-            return await f();
-          } else return f();
-        else if (isAsync) {
-          return await f(...args);
-        } else return f(...args);
-      } else throw new Error(`Function not found - ${fqFnName}`);
-    } else throw new Error(`JavaScript module ${refs[0]} not found`);
-  } catch (reason: any) {
-    const pf: Function | undefined = maybeEvalFunction(fqFnName);
-    if (pf instanceof Function) {
-      if (args == null) {
-        if (isAsync) return await pf();
-        else return pf();
-      } else {
-        if (isAsync) return await pf(...args.slice(0, args.length - 1));
-        else return pf(...args.slice(0, args.length - 1));
-      }
-    } else {
-      throw new Error(reason);
-    }
-  }
-}
-
-export function getModuleFn(fqFnName: string): Function | undefined {
-  const refs: string[] = splitRefs(fqFnName);
-  const m = importedModules.get(refs[0]);
-  if (m != undefined) {
-    return m[refs[1]];
-  } else return undefined;
-}
-
 export function isNumber(x: any): boolean {
   return typeof x === 'number';
 }