agentlang 0.0.4 → 0.0.6

package/src/language/parser.ts

@@ -8,6 +8,7 @@ import {
   Group,
   Handler,
   If,
+  isExpr,
   isGroup,
   isLiteral,
   isNegExpr,
@@ -21,6 +22,8 @@ import {
   Pattern,
   PrimExpr,
   RelationshipPattern,
+  SelectIntoEntry,
+  SelectIntoSpec,
   SetAttribute,
   Statement,
   WorkflowDefinition,
@@ -91,7 +94,7 @@ export async function parseWorkflow(workflowDef: string): Promise<WorkflowDefini
   if (isWorkflowDefinition(mod.defs[0])) {
     return mod.defs[0] as WorkflowDefinition;
   } else {
-    throw new Error(`Failed to generated workflow from ${workflowDef}`);
+    throw new Error(`Failed to generate workflow from ${workflowDef}`);
   }
 }
 
@@ -172,8 +175,11 @@ function introspectPattern(pat: Pattern): BasePattern {
     } else {
       r = introspectCreatePattern(pat.crudMap);
     }
-  } else if (pat.literal) {
-    r = introspectLiteral(pat.literal);
+    if (pat.crudMap.into) {
+      r = introspectInto(pat.crudMap.into, r as CrudPattern);
+    }
+  } else if (pat.expr) {
+    r = introspectExpression(pat.expr);
   } else if (pat.forEach) {
     r = introspectForEach(pat.forEach);
   } else if (pat.if) {
@@ -187,6 +193,13 @@ function introspectPattern(pat: Pattern): BasePattern {
   }
 }
 
+function introspectInto(intoSpec: SelectIntoSpec, p: CrudPattern): CrudPattern {
+  intoSpec.entries.forEach((se: SelectIntoEntry) => {
+    p.addInto(se.alias, se.attribute);
+  });
+  return p;
+}
+
 function isQueryPattern(pat: Pattern): boolean {
   if (pat.crudMap) {
     const crudMap: CrudMap = pat.crudMap;
@@ -250,6 +263,7 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
     crudMap.relationships.forEach((rp: RelationshipPattern) => {
       cp.addRelationship(rp.name, introspectPattern(rp.pattern) as CrudPattern | CrudPattern[]);
     });
+    cp.isCreate = false;
     cp.isQuery = true;
     return cp;
   }
@@ -259,6 +273,7 @@ function introspectQueryPattern(crudMap: CrudMap): CrudPattern {
 function introspectCreatePattern(crudMap: CrudMap): CrudPattern {
   if (crudMap) {
     const cp: CrudPattern = new CrudPattern(crudMap.name);
+    cp.isCreate = false;
     crudMap.body?.attributes.forEach((sa: SetAttribute) => {
       if (!cp.isQueryUpdate && sa.name.endsWith(QuerySuffix)) {
         cp.isQueryUpdate = true;
@@ -290,8 +305,12 @@ function introspectLiteral(lit: Literal): BasePattern {
   } else if (lit.fnCall) {
     return new FunctionCallPattern(
       lit.fnCall.name,
-      lit.fnCall.args.map((v: Literal) => {
-        return introspectLiteral(v);
+      lit.fnCall.args.map((v: Literal | Expr) => {
+        if (isExpr(v)) {
+          return introspectExpression(v);
+        } else {
+          return introspectLiteral(v);
+        }
       })
     );
   } else if (lit.array) {

package/src/language/syntax.ts

@@ -344,6 +344,7 @@ export class CrudPattern extends BasePattern {
   recordName: string;
   attributes: Array<AttributePattern>;
   relationships: Map<string, CrudPattern[] | CrudPattern> | undefined;
+  into: Map<string, string> | undefined;
   isQuery: boolean = false;
   isQueryUpdate: boolean = false;
   isCreate: boolean = false;
@@ -359,7 +360,7 @@ export class CrudPattern extends BasePattern {
     }
   }
 
-  addAttribute(n: string, p: BasePattern, op?: string) {
+  addAttribute(n: string, p: BasePattern, op?: string): CrudPattern {
     this.attributes.push({ name: n, op: op, value: p });
     if (this.recordName.endsWith('?')) {
       this.recordName = this.recordName.substring(0, this.recordName.length - 1);
@@ -368,7 +369,7 @@ export class CrudPattern extends BasePattern {
     return this;
   }
 
-  removeAttribute(n: string) {
+  removeAttribute(n: string): CrudPattern {
     const idx: number = this.attributes.findIndex((ap: AttributePattern) => {
       return n == ap.name;
     });
@@ -379,6 +380,34 @@ export class CrudPattern extends BasePattern {
     return this;
   }
 
+  addInto(alias: string, attr: string): CrudPattern {
+    if (this.into == undefined) {
+      this.into = new Map();
+    }
+    this.into.set(alias, attr);
+    return this;
+  }
+
+  removeInto(alias: string): CrudPattern {
+    if (this.into) {
+      this.into.delete(alias);
+    }
+    return this;
+  }
+
+  resetInto(into?: Map<string, string>): CrudPattern {
+    this.into = into;
+    return this;
+  }
+
+  hasInto(): boolean {
+    if (this.into && this.into.size > 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
   private flagType() {
     let hasq = false;
     let hasc = false;
@@ -421,7 +450,7 @@ export class CrudPattern extends BasePattern {
     return `{${s}}`;
   }
 
-  private relationshipsAsString(): string {
+  private relationshipsAsString(): string | undefined {
     if (this.relationships != undefined) {
       const result: Array<string> = [];
       this.relationships.forEach((p: CrudPattern | CrudPattern[], n: string) => {
@@ -430,7 +459,7 @@ export class CrudPattern extends BasePattern {
       });
       return result.join(',');
     } else {
-      return '';
+      return undefined;
     }
   }
 
@@ -438,12 +467,27 @@ export class CrudPattern extends BasePattern {
     return escapeQueryName(this.recordName);
   }
 
+  private intoAsString(): string | undefined {
+    if (this.into) {
+      const ss = new Array<string>();
+      this.into.forEach((attr: string, alias: string) => {
+        ss.push(`${alias} ${attr}`);
+      });
+      return `into { ${ss.join(',\n')} }`;
+    }
+    return undefined;
+  }
+
   override toString(): string {
     let s = `{${this.recordName} ${this.attributesAsString()}`;
     const rs = this.relationshipsAsString();
-    if (rs.length > 0) {
+    if (rs) {
       s = s.concat(`,${rs}`);
     }
+    const ins = this.intoAsString();
+    if (ins) {
+      s = s.concat(`,${ins}`);
+    }
     return s.concat('}', this.hintsAsString());
   }
 }
@@ -603,6 +647,7 @@ export function newCreatePattern(recName: string): CrudPattern {
 export function newQueryPattern(recName: string, forQueryUpdate: boolean = false): CrudPattern {
   recName = recName.charAt(recName.length - 1) == '?' ? recName : recName + '?';
   const cp: CrudPattern = new CrudPattern(recName);
+  cp.isCreate = false;
   if (forQueryUpdate) {
     cp.isQueryUpdate = true;
   } else {

package/src/runtime/agents/common.ts

@@ -15,6 +15,16 @@ entity Employee {
 The Empoyee entity is part of the "Erp" module and it has four attributes: employeeId, firstName, lastName, salary and email. The employeeId uniquely identifies an
 Employee and it's automatically filled-in by the system by calling the "uuid()" function. (In the place of the keyword 'entity', the keyword 'record' may also be used.
 The difference between an entity and a record is that, instances of an entity is persisted to the database, instances of records are not).
+
+This is an example of a record:
+
+record EmailMessage {
+    to Email,
+    from Email,
+    subject String,
+    body String
+}
+
 Workflows contains JSON "patterns" that perform CRUD operations on entities. For example, here's is a workflow that creates a new instance of the Employee entity:
 
 workflow CreateEmployee {
@@ -113,6 +123,17 @@ for emp in employees {
     {Erp/SendMail {email emp.email, body "You are selected for an increment!"}}
 } as emails
 
+Make sure all references based on a preceding pattern is based either on an actual alias or the name of the workflow. For example, the following sequence of patterns
+are invalid, because the alias 'employee' is not defined:
+
+{Employee {id? 101}};
+{SendEmail {to employee.email, body "hello"}}
+
+A fix for the reference-error is shown below:
+
+{Employee {id? 101}} as employee;
+{SendEmail {to employee.email, body "hello"}}
+
 Entities in a module can be connected together in relationships. There are two types of relationships - 'contains' and 'between'.
 'Contains' relationship is for hierarchical data, as in a Library entity containing Books. 'Between' relationship is for graph-like data,
 like two Profiles in a social media app is connected as friends. A 'between' relationship can be one of the following three types - 'one_one' (one-to-one),
@@ -172,6 +193,33 @@ workflow GetEmployeeTaskAssignments {
      Erp/EmployeeTaskAssignment {Erp/TaskAssignment? {}}}
 }
 
+A general rule regarding generating workflows - as much as possible, do not include references to the workflow event in the patterns. Try to
+fill-in values from the available context. For example, if your instruction is "create a workflow to send an email to employee 101 with this message - 
+'please call me as soon as possible'", the best workflow to return is:
+
+workflow sendEmail {
+    {employee {id? 101}} as emp;
+    {email {to emp.email body "please call me as soon as possible"}}
+}
+
+because all the information needed is available in the context. If the instruction is "create a workflow to send an email by employee-id with this message - 
+'please call me as soon as possible'", then you can return:
+
+workflow sendEmail {
+    {employee {id? sendEmail.employeeId}} as emp;
+    {email {to emp.email body "please call me as soon as possible"}}
+}
+
+The point is use the immediate context to fill-in values in generated patterns, as much as possible.
+
+Also generate a workflow only if required explicitly by the user or the contextual information is incomplete. Otherwise, just return an array of patterns.
+As an example, if the user request is "send an email to employee 101 with this message - 'please call me as soon as possible'", you must return:
+
+[{employee {id? 101}} as emp;
+ {email {to emp.email, body "please call me as soon as possible"}}]
+
+Note that each pattern in the array is separated by a ; and not a comma(,).
+
 Now consider the following module definition and generate appropriate patterns in response to the user instructions. You must return only valid patterns or workflows,
 no other descriptive text or comments are needed.
 `;

package/src/runtime/agents/impl/openai.ts

@@ -6,7 +6,7 @@ export class OpenAIProvider implements AgentServiceProvider {
   private model: ChatOpenAI;
 
   constructor(config?: Map<string, any>) {
-    let modelName = 'gpt-4';
+    let modelName = 'gpt-4.1-2025-04-14';
     if (config) {
       modelName = config.get('model') || modelName;
     }

package/src/runtime/auth/cognito.ts

@@ -6,14 +6,7 @@ import {
   SignUpCallback,
   UserInfo,
 } from './interface.js';
-import {
-  ensureUser,
-  ensureUserSession,
-  findUser,
-  findUserByEmail,
-  findUserSession,
-  removeSession,
-} from '../modules/auth.js';
+import { ensureUser, ensureUserSession, findUser, findUserByEmail } from '../modules/auth.js';
 import { logger } from '../logger.js';
 import { sleepMilliseconds } from '../util.js';
 import { Instance } from '../module.js';
@@ -36,9 +29,14 @@ let fromEnv: any = undefined;
 let CognitoIdentityProviderClient: any = undefined;
 let SignUpCommand: any = undefined;
 let AdminGetUserCommand: any = undefined;
+let InitiateAuthCommand: any = undefined;
 let AuthenticationDetails: any = undefined;
 let CognitoUser: any = undefined;
 let CognitoUserPool: any = undefined;
+let CognitoUserSession: any = undefined;
+let CognitoIdToken: any = undefined;
+let CognitoAccessToken: any = undefined;
+let CognitoRefreshToken: any = undefined;
 
 if (isNodeEnv) {
   const cp = await import('@aws-sdk/credential-providers');
@@ -48,11 +46,16 @@ if (isNodeEnv) {
   CognitoIdentityProviderClient = cip.CognitoIdentityProviderClient;
   SignUpCommand = cip.SignUpCommand;
   AdminGetUserCommand = cip.AdminGetUserCommand;
+  InitiateAuthCommand = cip.InitiateAuthCommand;
 
   const ci = await import('amazon-cognito-identity-js');
   AuthenticationDetails = ci.AuthenticationDetails;
   CognitoUser = ci.CognitoUser;
   CognitoUserPool = ci.CognitoUserPool;
+  CognitoUserSession = ci.CognitoUserSession;
+  CognitoIdToken = ci.CognitoIdToken;
+  CognitoAccessToken = ci.CognitoAccessToken;
+  CognitoRefreshToken = ci.CognitoRefreshToken;
 }
 
 const defaultConfig = isNodeEnv
@@ -441,7 +444,13 @@ export class CognitoAuth implements AgentlangAuth {
         const idToken = result.getIdToken().getJwtToken();
         const accessToken = result.getAccessToken().getJwtToken();
         const refreshToken = result.getRefreshToken().getToken();
-        const localSess: Instance = await ensureUserSession(userid, idToken, env);
+        const localSess: Instance = await ensureUserSession(
+          userid,
+          idToken,
+          accessToken,
+          refreshToken,
+          env
+        );
         const sessInfo: SessionInfo = {
           sessionId: localSess.lookup('id'),
           userId: userid,
@@ -513,7 +522,13 @@ export class CognitoAuth implements AgentlangAuth {
         const idToken = result.getIdToken().getJwtToken();
         const accessToken = result.getAccessToken().getJwtToken();
         const refreshToken = result.getRefreshToken().getToken();
-        const localSess: Instance = await ensureUserSession(userid, idToken, env);
+        const localSess: Instance = await ensureUserSession(
+          userid,
+          idToken,
+          accessToken,
+          refreshToken,
+          env
+        );
         const sessInfo: SessionInfo = {
           sessionId: localSess.lookup('id'),
           userId: userid,
@@ -540,25 +555,33 @@ export class CognitoAuth implements AgentlangAuth {
         return;
       }
       const user = new CognitoUser({
-        Username: localUser.email,
+        Username: localUser.lookup('email'),
         Pool: this.fetchUserPool(),
       });
+
       let done = false;
       let logoutError: any;
-      user.signOut(() => {
-        done = true;
+
+      const session = new CognitoUserSession({
+        IdToken: new CognitoIdToken({ IdToken: sessionInfo.idToken }),
+        AccessToken: new CognitoAccessToken({ AccessToken: sessionInfo.accessToken }),
+        RefreshToken: new CognitoRefreshToken({ RefreshToken: sessionInfo.refreshToken }),
       });
-      // Add error handling for signOut
-      user.signOut((err: any) => {
-        if (err) {
+      user.setSignInUserSession(session);
+      user.globalSignOut({
+        onSuccess: function () {
+          done = true;
+        },
+        onFailure: function (err: any) {
+          done = true;
           logger.error(`Cognito signOut error for user ${sessionInfo.userId}:`, {
             errorName: err.name,
             errorMessage: sanitizeErrorMessage(err.message),
           });
           logoutError = err;
-        }
-        done = true;
+        },
       });
+
       while (!done) {
         await sleepMilliseconds(100);
       }
@@ -568,10 +591,6 @@ export class CognitoAuth implements AgentlangAuth {
         );
         // Continue with local session cleanup even if Cognito logout fails
       }
-      const sess = await findUserSession(localUser.id, env);
-      if (sess) {
-        await removeSession(sess.id, env);
-      }
       logger.debug(`Successfully logged out user ${sessionInfo.userId}`);
       if (cb) cb(true);
     } catch (err: any) {
@@ -581,6 +600,50 @@ export class CognitoAuth implements AgentlangAuth {
     }
   }
 
+  async changePassword(
+    sessionInfo: SessionInfo,
+    newPassword: string,
+    oldPassword: string,
+    env: Environment
+  ): Promise<boolean> {
+    const localUser = await findUser(sessionInfo.userId, env);
+    if (!localUser) {
+      logger.warn(`User ${sessionInfo.userId} not found for password-change`);
+      return false;
+    }
+    const email = localUser.lookup('email');
+    const user = new CognitoUser({
+      Username: email,
+      Pool: this.fetchUserPool(),
+    });
+    const session = new CognitoUserSession({
+      IdToken: new CognitoIdToken({ IdToken: sessionInfo.idToken }),
+      AccessToken: new CognitoAccessToken({ AccessToken: sessionInfo.accessToken }),
+      RefreshToken: new CognitoRefreshToken({ RefreshToken: sessionInfo.refreshToken }),
+    });
+    user.setSignInUserSession(session);
+    let done = false;
+    let cpErr: any = undefined;
+    user.changePassword(oldPassword, newPassword, (err: any, _: any) => {
+      if (err) {
+        done = true;
+        cpErr = err;
+      } else {
+        done = true;
+      }
+    });
+
+    while (!done) {
+      await sleepMilliseconds(100);
+    }
+
+    if (cpErr) {
+      logger.warn(`Failed to change the password for ${email} - ${cpErr.message}`);
+      return false;
+    }
+    return true;
+  }
+
   private fetchUserPool() {
     if (this.userPool) {
       return this.userPool;
@@ -753,4 +816,71 @@ export class CognitoAuth implements AgentlangAuth {
       };
     }
   }
+
+  async refreshToken(refreshTokenString: string, env: Environment): Promise<SessionInfo> {
+    try {
+      // Use InitiateAuth with REFRESH_TOKEN_AUTH flow
+      const client = new CognitoIdentityProviderClient({
+        region: process.env.AWS_REGION || 'us-west-2',
+        credentials: fromEnv(),
+      });
+
+      const command = new InitiateAuthCommand({
+        AuthFlow: 'REFRESH_TOKEN_AUTH',
+        ClientId: this.fetchClientId(),
+        AuthParameters: {
+          REFRESH_TOKEN: refreshTokenString,
+        },
+      });
+
+      const response = await client.send(command);
+
+      if (!response.AuthenticationResult) {
+        throw new UnauthorisedError('Token refresh failed');
+      }
+
+      const newIdToken = response.AuthenticationResult.IdToken!;
+      const newAccessToken = response.AuthenticationResult.AccessToken!;
+      const newRefreshToken = response.AuthenticationResult.RefreshToken || refreshTokenString;
+
+      // Extract user info from the new ID token
+      const idTokenPayload = JSON.parse(atob(newIdToken.split('.')[1]));
+      const userEmail = idTokenPayload.email;
+
+      // Find or create local user
+      let localUser = await findUserByEmail(userEmail, env);
+      if (!localUser) {
+        localUser = await ensureUser(userEmail, '', '', env);
+      }
+      const userId = localUser.lookup('id');
+
+      // Update local session
+      const updatedSession = await ensureUserSession(
+        userId,
+        newIdToken,
+        newAccessToken,
+        newRefreshToken,
+        env
+      );
+
+      const sessInfo: SessionInfo = {
+        sessionId: updatedSession.lookup('id'),
+        userId: userId,
+        authToken: newIdToken,
+        idToken: newIdToken,
+        accessToken: newAccessToken,
+        refreshToken: newRefreshToken,
+        systemSesionInfo: response.AuthenticationResult,
+      };
+
+      return sessInfo;
+    } catch (err: any) {
+      logger.error(`Refresh token operation failed: ${err.message}`);
+      if (err.name === 'NotAuthorizedException') {
+        throw new UnauthorisedError('Invalid or expired refresh token');
+      }
+      handleCognitoError(err, 'refreshToken');
+      throw err; // This line won't be reached due to handleCognitoError throwing
+    }
+  }
 }

package/src/runtime/auth/interface.ts

@@ -33,4 +33,11 @@ export interface AgentlangAuth {
   verifyToken(token: string, env?: Environment): any;
   getUser(userId: string, env: Environment): Promise<UserInfo>;
   getUserByEmail(email: string, env: Environment): Promise<UserInfo>;
+  changePassword(
+    sessionInfo: SessionInfo,
+    newPassword: string,
+    oldPassword: string,
+    env: Environment
+  ): Promise<boolean>;
+  refreshToken(refreshToken: string, env: Environment): Promise<SessionInfo>;
 }

package/src/runtime/interpreter.ts

@@ -54,7 +54,6 @@ import {
   escapeFqName,
   escapeQueryName,
   fqNameFromPath,
-  invokeModuleFn,
   isFqName,
   isPath,
   isString,
@@ -78,6 +77,7 @@ import {
   maybeCancelTimer,
   setTimerRunning,
 } from './modules/core.js';
+import { invokeModuleFn } from './jsmodules.js';
 
 export type Result = any;
 
@@ -590,8 +590,8 @@ export async function parseAndEvaluateStatement(
 }
 
 async function evaluatePattern(pat: Pattern, env: Environment): Promise<void> {
-  if (pat.literal) {
-    await evaluateLiteral(pat.literal, env);
+  if (pat.expr) {
+    await evaluateExpression(pat.expr, env);
   } else if (pat.crudMap) {
     await evaluateCrudMap(pat.crudMap, env);
   } else if (pat.forEach) {
@@ -1047,21 +1047,61 @@ async function walkJoinQueryPattern(
 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 result: string = env.getLastResult();
-  if (agent.isPlanner()) {
-    logger.debug(`Agent ${agent.name} generated pattern: ${result}`);
-    try {
-      if (result.trimStart().startsWith('workflow')) {
-        await parseWorkflow(result);
-        return;
-      } else {
-        env.setLastResult(await parseAndEvaluateStatement(result, undefined, env));
+  const result: string | undefined = cleanupAgentResponse(env.getLastResult());
+  if (result) {
+    if (agent.isPlanner()) {
+      logger.debug(`Agent ${agent.name} generated pattern: ${result}`);
+      try {
+        let rs = result.trim();
+        if (rs.startsWith('[')) {
+          const stmts = rs.substring(1, rs.length - 1);
+          rs = `workflow T {${stmts}}`;
+        }
+        if (rs.startsWith('workflow')) {
+          const wf = await parseWorkflow(rs);
+          if (agent.runWorkflows) {
+            await evaluateStatements(wf.statements, env);
+          }
+        } else {
+          env.setLastResult(await parseAndEvaluateStatement(rs, undefined, env));
+        }
+      } catch (err: any) {
+        logger.error(
+          `Failed to evaluate pattern generated by agent ${agent.name} - ${result}, ${err}`
+        );
       }
-    } catch (err: any) {
-      logger.error(
-        `Failed to evaluate pattern generated by agent ${agent.name} - ${result}, ${err}`
-      );
     }
+  } else {
+    logger.warn(`Agent ${agent.name} failed to generate a response`);
+  }
+}
+
+function cleanupAgentResponse(response: string | undefined): string | undefined {
+  if (response) {
+    const resp = response.trim();
+    if (resp.startsWith('[') && resp.endsWith(']')) {
+      return resp;
+    }
+    const parts = resp.split('\n');
+    const validated = parts.filter((s: string) => {
+      const stmt = s.trim();
+      const r =
+        stmt.startsWith('{') ||
+        stmt.startsWith('}') ||
+        stmt.startsWith('if') ||
+        stmt.startsWith('for') ||
+        stmt.startsWith('delete') ||
+        stmt.startsWith('workflow');
+      if (!r) {
+        const i = stmt.indexOf('(');
+        return i > 0 && stmt.indexOf(')') > i;
+      } else {
+        return r;
+      }
+    });
+    return validated.join('\n');
+  } else {
+    return response;
   }
 }
 
@@ -1263,7 +1303,12 @@ async function applyFn(fnCall: FnCall, env: Environment, isAsync: boolean): Prom
     if (fnCall.args != undefined) {
       args = new Array<Result>();
       for (let i = 0; i < fnCall.args.length; ++i) {
-        await evaluateLiteral(fnCall.args[i], env);
+        const arg = fnCall.args[i];
+        if (isLiteral(arg)) {
+          await evaluateLiteral(arg, env);
+        } else {
+          await evaluateExpression(arg, env);
+        }
         args.push(env.getLastResult());
       }
       args.push(env);
@@ -1287,7 +1332,7 @@ async function realizeMap(mapLiteral: MapLiteral, env: Environment): Promise<voi
   for (let i = 0; i < mapLiteral.entries.length; ++i) {
     const entry = mapLiteral.entries[i];
     const k = getMapKey(entry.key);
-    await evaluateLiteral(entry.value, env);
+    await evaluateExpression(entry.value, env);
     result.set(k, env.getLastResult());
   }
   env.setLastResult(Object.fromEntries(result.entries()));