agentlang 0.1.6 → 0.1.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentlang",
   "description": "The easiest way to build the most reliable AI agents - enterprise-grade teams of AI agents that collaborate with each other and humans",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "license": "Sustainable Use License",
   "author": "agentlang-ai",
   "homepage": "https://github.com/agentlang-ai/agentlang#readme",

package/src/runtime/auth/cognito.ts

@@ -1,5 +1,7 @@
 import {
   AgentlangAuth,
+  InviteUserCallback,
+  InvitationInfo,
   LoginCallback,
   LogoutCallback,
   SessionInfo,
@@ -40,6 +42,8 @@ let ForgotPasswordCommand: any = undefined;
 let ConfirmForgotPasswordCommand: any = undefined;
 let AdminGetUserCommand: any = undefined;
 let InitiateAuthCommand: any = undefined;
+let AdminCreateUserCommand: any = undefined;
+let RespondToAuthChallengeCommand: any = undefined;
 let AuthenticationDetails: any = undefined;
 let CognitoUser: any = undefined;
 let CognitoUserPool: any = undefined;
@@ -61,6 +65,8 @@ if (isNodeEnv) {
   ConfirmForgotPasswordCommand = cip.ConfirmForgotPasswordCommand;
   AdminGetUserCommand = cip.AdminGetUserCommand;
   InitiateAuthCommand = cip.InitiateAuthCommand;
+  AdminCreateUserCommand = cip.AdminCreateUserCommand;
+  RespondToAuthChallengeCommand = cip.RespondToAuthChallengeCommand;
 
   const ci = await import('amazon-cognito-identity-js');
   AuthenticationDetails = ci.AuthenticationDetails;
@@ -1013,4 +1019,150 @@ export class CognitoAuth implements AgentlangAuth {
       throw err; // This line won't be reached due to handleCognitoError throwing
     }
   }
+
+  async inviteUser(
+    email: string,
+    firstName: string,
+    lastName: string,
+    userData: Map<string, any> | undefined,
+    env: Environment,
+    cb: InviteUserCallback
+  ): Promise<void> {
+    try {
+      const client = new CognitoIdentityProviderClient({
+        region: process.env.AWS_REGION || 'us-west-2',
+      });
+
+      const userAttrs = [
+        {
+          Name: 'email',
+          Value: email,
+        },
+        {
+          Name: 'email_verified',
+          Value: 'true',
+        },
+        {
+          Name: 'given_name',
+          Value: firstName,
+        },
+        {
+          Name: 'family_name',
+          Value: lastName,
+        },
+      ];
+
+      if (userData) {
+        userData.forEach((v: any, k: string) => {
+          userAttrs.push({ Name: k, Value: String(v) });
+        });
+      }
+
+      let userExists = false;
+      try {
+        const getUserCommand = new AdminGetUserCommand({
+          UserPoolId: this.fetchUserPoolId(),
+          Username: email,
+        });
+        await client.send(getUserCommand);
+        userExists = true;
+        logger.debug(`User ${email} already exists, will resend invitation`);
+      } catch (err: any) {
+        if (err.name !== 'UserNotFoundException') {
+          throw err;
+        }
+        logger.debug(`User ${email} does not exist, will create new user`);
+      }
+
+      const command = new AdminCreateUserCommand({
+        UserPoolId: this.fetchUserPoolId(),
+        Username: email,
+        UserAttributes: userAttrs,
+        DesiredDeliveryMediums: ['EMAIL'],
+        ...(userExists ? { MessageAction: 'RESEND' } : {}),
+      });
+
+      logger.debug(`Attempting to invite user: ${email}`);
+      const response = await client.send(command);
+
+      if (response.$metadata.httpStatusCode === 200) {
+        logger.info(`User invitation successful for: ${email}`);
+
+        await ensureUser(email, firstName, lastName, env);
+
+        const invitationInfo: InvitationInfo = {
+          email: email,
+          firstName: firstName,
+          lastName: lastName,
+          invitationId: response.User?.Username,
+          systemInvitationInfo: response,
+        };
+
+        cb(invitationInfo);
+      } else {
+        logger.error(
+          `User invitation failed with HTTP status ${response.$metadata.httpStatusCode}`,
+          {
+            email: email,
+            statusCode: response.$metadata.httpStatusCode,
+          }
+        );
+        throw new BadRequestError(
+          `User invitation failed with status ${response.$metadata.httpStatusCode}`
+        );
+      }
+    } catch (err: any) {
+      if (err instanceof BadRequestError) throw err;
+      logger.error(`User invitation error for ${email}:`, {
+        errorName: err.name,
+        errorMessage: sanitizeErrorMessage(err.message),
+      });
+      handleCognitoError(err, 'inviteUser');
+    }
+  }
+
+  async acceptInvitation(
+    email: string,
+    tempPassword: string,
+    newPassword: string,
+    _env: Environment
+  ): Promise<void> {
+    try {
+      const client = new CognitoIdentityProviderClient({
+        region: process.env.AWS_REGION || 'us-west-2',
+        credentials: fromEnv(),
+      });
+
+      const initAuth = new InitiateAuthCommand({
+        AuthFlow: 'USER_PASSWORD_AUTH',
+        ClientId: this.fetchClientId(),
+        AuthParameters: {
+          USERNAME: email,
+          PASSWORD: tempPassword,
+        },
+      });
+
+      const initResponse = await client.send(initAuth);
+
+      if (initResponse.ChallengeName === 'NEW_PASSWORD_REQUIRED') {
+        const respond = new RespondToAuthChallengeCommand({
+          ClientId: this.fetchClientId(),
+          ChallengeName: 'NEW_PASSWORD_REQUIRED',
+          Session: initResponse.Session,
+          ChallengeResponses: {
+            USERNAME: email,
+            NEW_PASSWORD: newPassword,
+          },
+        });
+
+        await client.send(respond);
+        logger.info(`User invitation accepted successfully for: ${email}`);
+      } else {
+        throw new Error(`Unexpected challenge: ${initResponse.ChallengeName}`);
+      }
+    } catch (err: any) {
+      logger.error(`Accept invitation failed for ${email}: ${sanitizeErrorMessage(err.message)}`);
+      handleCognitoError(err, 'acceptInvitation');
+    }
+  }
 }

package/src/runtime/auth/interface.ts

@@ -21,6 +21,16 @@ export type SessionInfo = {
 export type SignUpCallback = (userInfo: UserInfo) => void;
 export type LoginCallback = (sessionInfo: SessionInfo) => void;
 export type LogoutCallback = (status: boolean) => void;
+export type InviteUserCallback = (invitationInfo: InvitationInfo) => void;
+
+export type InvitationInfo = {
+  email: string;
+  firstName: string;
+  lastName: string;
+  tempPassword?: string;
+  invitationId?: string;
+  systemInvitationInfo?: any;
+};
 
 export interface AgentlangAuth {
   signUp(
@@ -53,4 +63,18 @@ export interface AgentlangAuth {
     env: Environment
   ): Promise<boolean>;
   refreshToken(refreshToken: string, env: Environment): Promise<SessionInfo>;
+  inviteUser(
+    email: string,
+    firstName: string,
+    lastName: string,
+    userData: Map<string, any> | undefined,
+    env: Environment,
+    cb: InviteUserCallback
+  ): Promise<void>;
+  acceptInvitation(
+    email: string,
+    tempPassword: string,
+    newPassword: string,
+    env: Environment
+  ): Promise<void>;
 }

package/src/runtime/exec-graph.ts

@@ -218,12 +218,18 @@ export async function executeGraph(execGraph: ExecGraph, env: Environment): Prom
             case SubGraphType.EVENT:
               await evaluateStatement(node.code as Statement, env);
               break;
-            case SubGraphType.IF:
-              await executeIfSubGraph(subg, env);
+            case SubGraphType.IF: {
+              const newEnv = new Environment(`${env.name}-if`, env);
+              await executeIfSubGraph(subg, newEnv);
+              env.setLastResult(newEnv.getLastResult());
               break;
-            case SubGraphType.FOR_EACH:
-              await executeForEachSubGraph(subg, node, env);
+            }
+            case SubGraphType.FOR_EACH: {
+              const newEnv = new Environment(`${env.name}-forEach`, env);
+              await executeForEachSubGraph(subg, node, newEnv);
+              env.setLastResult(newEnv.getLastResult());
               break;
+            }
             case SubGraphType.DELETE:
               await executeDeleteSubGraph(subg, node, env);
               break;

package/src/runtime/interpreter.ts

@@ -140,6 +140,7 @@ export class Environment extends Instance {
   private activeCatchHandlers: Array<CatchHandlers>;
   private eventExecutor: Function | undefined = undefined;
   private statementsExecutor: Function | undefined = undefined;
+  private scratchPad: any = undefined;
 
   private activeUserData: any = undefined;
 
@@ -270,6 +271,28 @@ export class Environment extends Instance {
     return this.attributes.get(Environment.FlowContextTag);
   }
 
+  addToScratchPad(k: string, data: any): Environment {
+    if (this.scratchPad == undefined) {
+      this.scratchPad = {};
+    }
+    this.scratchPad[k] = data;
+    return this;
+  }
+
+  getScratchPad(): any {
+    return this.scratchPad;
+  }
+
+  resetScratchPad(): Environment {
+    this.scratchPad = undefined;
+    return this;
+  }
+
+  setScratchPad(obj: any): Environment {
+    this.scratchPad = obj;
+    return this;
+  }
+
   static SuspensionUserData = '^';
 
   bindSuspensionUserData(userData: string): Environment {
@@ -1365,10 +1388,12 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
     else if (isDocEventInstance(inst)) await handleDocEvent(inst, env);
     else {
       const eventExec = env.getEventExecutor();
+      const newEnv = new Environment(`${inst.name}.env`, env);
       if (eventExec) {
-        await eventExec(inst, env);
+        await eventExec(inst, newEnv);
+        env.setLastResult(newEnv.getLastResult());
       } else {
-        await evaluate(inst, (result: Result) => env.setLastResult(result), env);
+        await evaluate(inst, (result: Result) => env.setLastResult(result), newEnv);
       }
       env.resetReturnFlag();
     }
@@ -1480,31 +1505,7 @@ async function evaluateJoinQuery(
   }
   const resolver = await getResolverForPath(inst.name, moduleName, env);
   const result: Result = await resolver.queryByJoin(inst, joinsSpec, normIntoSpec, distinct);
-
-  const transformedResult = transformDateFieldsInJoinResult(result);
-
-  env.setLastResult(transformedResult);
-}
-
-function transformDateFieldsInJoinResult(result: any): any {
-  if (!result || !Array.isArray(result)) {
-    return result;
-  }
-  return result.map((row: any) => {
-    if (typeof row !== 'object' || row === null) {
-      return row;
-    }
-
-    for (const [key, value] of Object.entries(row)) {
-      if (value && value instanceof Date) {
-        if (value instanceof Date) {
-          row[key] = value.toLocaleDateString('en-CA');
-        }
-      }
-    }
-
-    return row;
-  });
+  env.setLastResult(result);
 }
 
 async function walkJoinQueryPattern(
@@ -1539,6 +1540,11 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
   const flowContext = env.getFlowContext();
   msg = flowContext ? `context: ${flowContext}\n${msg}` : msg;
 
+  const scratchPad = env.getScratchPad();
+  if (scratchPad) {
+    const spad = JSON.stringify(scratchPad);
+    msg = `${msg}\nScratchpad:\n${spad}`;
+  }
   // log invocation details
   let invokeDebugMsg = `\nInvoking agent ${agent.name}:`;
   if (agent.role) {
@@ -1589,6 +1595,7 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
               env.setLastResult(await parseAndEvaluateStatement(rs, undefined, env));
             }
           }
+          agent.maybeAddScratchData(env);
           break;
         } catch (err: any) {
           if (retries < MAX_PLANNER_RETRIES) {
@@ -1604,6 +1611,30 @@ async function agentInvoke(agent: AgentInstance, msg: string, env: Environment):
           }
         }
       }
+    } else {
+      let retries = 0;
+      while (true) {
+        try {
+          const obj = agent.maybeValidateJsonResponse(result);
+          if (obj != undefined) {
+            env.setLastResult(obj);
+            env.addToScratchPad(agent.getFqName(), obj);
+          }
+          break;
+        } catch (err: any) {
+          if (retries < MAX_PLANNER_RETRIES) {
+            await agent.invoke(`Please fix these errors:\n ${err}`, env);
+            const r: string | undefined = env.getLastResult();
+            result = r;
+            ++retries;
+          } else {
+            logger.error(
+              `Failed to validate JSON response generated by agent ${agent.name} - ${result}, ${err}`
+            );
+            break;
+          }
+        }
+      }
     }
   } else {
     throw new Error(`Agent ${agent.name} failed to generate a response`);
@@ -1635,6 +1666,7 @@ async function handleAgentInvocationWithFlow(
 ): Promise<void> {
   rootAgent.markAsFlowExecutor();
   await iterateOnFlow(flow, rootAgent, msg, env);
+  env.resetScratchPad();
 }
 
 async function saveFlowSuspension(
@@ -1643,9 +1675,10 @@ async function saveFlowSuspension(
   step: FlowStep,
   env: Environment
 ): Promise<void> {
+  const spad = env.getScratchPad() || {};
   const suspId = await createSuspension(
     env.getSuspensionId(),
-    [FlowSuspensionTag, agent.name, step, context],
+    [FlowSuspensionTag, agent.name, step, context, JSON.stringify(spad)],
     env
   );
   env.setLastResult({ suspension: suspId || 'null' });
@@ -1656,11 +1689,12 @@ export async function restartFlow(
   userData: string,
   env: Environment
 ): Promise<void> {
-  const [_, agentName, step, ctx] = flowContext;
+  const [_, agentName, step, ctx, spad] = flowContext;
   const rootAgent: AgentInstance = await findAgentByName(agentName, env);
   const flow = getAgentFlow(agentName, rootAgent.moduleName);
   if (flow) {
     const newCtx = `${ctx}\n${step} --> ${userData}\n`;
+    env.setScratchPad(JSON.parse(spad));
     await iterateOnFlow(flow, rootAgent, newCtx, env);
   }
 }
@@ -1674,7 +1708,7 @@ async function iterateOnFlow(
   env: Environment
 ): Promise<void> {
   rootAgent.disableSession();
-  const s = `Now consider the following flowchart and context:\n${flow}\n\n${msg}
+  const s = `Now consider the following flowchart and context:\n${flow}\n\nInitial context: ${msg}\n\n
   If you understand from the context that a step with no further possible steps has been evaluated,
   terminate the flowchart by returning DONE. Never return to the top or root step of the flowchart, instead return DONE.\n`;
   await agentInvoke(rootAgent, s, env);
@@ -1710,7 +1744,7 @@ async function iterateOnFlow(
     console.debug(
       `\n----> Completed execution of step ${step}, iteration id ${iterId} with result:\n${rs}`
     );
-    context = `${context}\nExecuted steps: ${[...executedSteps].join(', ')}\n${step} --> ${rs}\n`;
+    context = `${context}\nExecuted steps: ${[...executedSteps].join(', ')}`;
     await agentInvoke(rootAgent, `${s}\n${context}`, env);
     step = env.getLastResult().trim();
   }

package/src/runtime/loader.ts

@@ -78,7 +78,9 @@ import {
   LlmEntityName,
   registerAgentDirectives,
   registerAgentGlossary,
+  registerAgentResponseSchema,
   registerAgentScenarios,
+  registerAgentScratchNames,
 } from './modules/ai.js';
 import { getDefaultLLMService } from './agents/registry.js';
 import { GenericResolver, GenericResolverMethods } from './resolvers/interface.js';
@@ -566,6 +568,20 @@ function processAgentGlossary(agentName: string, value: Literal): AgentGlossaryE
   return undefined;
 }
 
+function processAgentScratchNames(agentName: string, value: Literal): string[] | undefined {
+  if (value.array) {
+    const scratch = new Array<string>();
+    value.array.vals.forEach((stmt: Statement) => {
+      const expr = stmt.pattern.expr;
+      if (expr && isLiteral(expr) && (expr.id || expr.str)) {
+        scratch.push(expr.id || expr.str || '');
+      }
+    });
+    return scratch;
+  }
+  return undefined;
+}
+
 async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   let llmName: string | undefined = undefined;
   const name = def.name;
@@ -577,6 +593,8 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   let conds: AgentCondition[] | undefined = undefined;
   let scenarios: AgentScenario[] | undefined = undefined;
   let glossary: AgentGlossaryEntry[] | undefined = undefined;
+  let responseSchema: string | undefined = undefined;
+  let scratchNames: string[] | undefined = undefined;
   def.body?.attributes.forEach((apdef: GenericPropertyDef) => {
     if (apdef.name == 'flows') {
       let fnames: string | undefined = undefined;
@@ -604,6 +622,19 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
       scenarios = processAgentScenarios(name, apdef.value);
     } else if (apdef.name == 'glossary') {
       glossary = processAgentGlossary(name, apdef.value);
+    } else if (apdef.name == 'responseSchema') {
+      const s = apdef.value.id || apdef.value.str || apdef.value.id;
+      if (s) {
+        if (isFqName(s)) {
+          responseSchema = s;
+        } else {
+          responseSchema = makeFqName(moduleName, s);
+        }
+      } else {
+        throw new Error(`responseSchema must be a valid name in agent ${name}`);
+      }
+    } else if (apdef.name == 'scratch') {
+      scratchNames = processAgentScratchNames(name, apdef.value);
     } else {
       let v: any = undefined;
       if (apdef.value.array) {
@@ -666,6 +697,12 @@ async function addAgentDefinition(def: AgentDefinition, moduleName: string) {
   if (glossary) {
     registerAgentGlossary(moduleName, name, glossary);
   }
+  if (responseSchema) {
+    registerAgentResponseSchema(moduleName, name, responseSchema);
+  }
+  if (scratchNames) {
+    registerAgentScratchNames(moduleName, name, scratchNames);
+  }
   // Don't add llm to module attrs if it wasn't originally specified
   addAgent(def.name, attrs, moduleName);
 }

package/src/runtime/module.ts

@@ -3139,3 +3139,23 @@ export function getEntityRbacRules(entityFqName: string): RbacSpecification[] |
   }
   return undefined;
 }
+
+export function asJSONSchema(fqName: string): string {
+  const parts = splitFqName(fqName);
+  if (parts.hasModule()) {
+    const mod = fetchModule(parts.getModuleName());
+    const record = mod.getRecord(parts.getEntryName());
+    const s = new Array<string>();
+    record.schema.forEach((attr: AttributeSpec, n: string) => {
+      let t = attr.type;
+      const enums = getEnumValues(attr);
+      if (enums) {
+        t = `one of the strings: ${[...enums].join(',')}`;
+      }
+      s.push(`"${n}": <${t}>`);
+    });
+    return `{${s.join(',\n')}}`;
+  } else {
+    throw new Error(`Failed to find module for ${fqName}`);
+  }
+}

package/src/runtime/modules/ai.ts

@@ -6,6 +6,7 @@ import {
   parseAndEvaluateStatement,
 } from '../interpreter.js';
 import {
+  asJSONSchema,
   fetchModule,
   Instance,
   instanceToObject,
@@ -129,6 +130,26 @@ export function registerAgentGlossary(
   AgentGlossary.set(makeFqName(moduleName, agentName), glossary);
 }
 
+const AgentResponseSchema = new Map<string, string>();
+
+export function registerAgentResponseSchema(
+  moduleName: string,
+  agentName: string,
+  responseSchema: string
+) {
+  AgentResponseSchema.set(makeFqName(moduleName, agentName), responseSchema);
+}
+
+const AgentScratchNames = new Map<string, Set<string>>();
+
+export function registerAgentScratchNames(
+  moduleName: string,
+  agentName: string,
+  scratch: string[]
+) {
+  AgentScratchNames.set(makeFqName(moduleName, agentName), new Set(scratch));
+}
+
 export class AgentInstance {
   llm: string = '';
   name: string = '';
@@ -145,6 +166,7 @@ export class AgentInstance {
   private toolsArray: string[] | undefined = undefined;
   private hasModuleTools = false;
   private withSession = true;
+  private fqName: string | undefined;
 
   private constructor() {}
 
@@ -241,7 +263,7 @@ export class AgentInstance {
     if (this.cachedInstruction) {
       return this.cachedInstruction;
     }
-    const fqName = makeFqName(this.moduleName, this.name);
+    const fqName = this.getFqName();
     this.cachedInstruction = `${this.instruction || ''} ${this.directivesAsString(fqName)}`;
     const gls = AgentGlossary.get(fqName);
     if (gls) {
@@ -262,14 +284,80 @@ export class AgentInstance {
       });
       this.cachedInstruction = `${this.cachedInstruction}\nHere are some example user requests and the corresponding responses you are supposed to produce:\n${scs.join('\n')}`;
     }
+    const responseSchema = AgentResponseSchema.get(fqName);
+    if (responseSchema) {
+      this.cachedInstruction = `${this.cachedInstruction}\nReturn your response in the following JSON schema:\n${asJSONSchema(responseSchema)}
+Only return a pure JSON object with no extra text, annotations etc.`;
+    }
     return this.cachedInstruction;
   }
 
+  maybeValidateJsonResponse(response: string | undefined): object | undefined {
+    if (response) {
+      const responseSchema = AgentResponseSchema.get(this.getFqName());
+      if (responseSchema) {
+        const attrs = JSON.parse(response);
+        const parts = splitFqName(responseSchema);
+        const moduleName = parts.getModuleName();
+        const entryName = parts.getEntryName();
+        const attrsMap = new Map(Object.entries(attrs));
+        const scm = fetchModule(moduleName).getRecord(entryName).schema;
+        const recAttrs = new Map<string, any>();
+        attrsMap.forEach((v: any, k: string) => {
+          if (scm.has(k)) {
+            recAttrs.set(k, v);
+          }
+        });
+        makeInstance(moduleName, entryName, recAttrs);
+        return attrs;
+      }
+    }
+    return undefined;
+  }
+
+  getFqName(): string {
+    if (this.fqName == undefined) {
+      this.fqName = makeFqName(this.moduleName, this.name);
+    }
+    return this.fqName;
+  }
+
   markAsFlowExecutor(): AgentInstance {
     this.type = 'flow-exec';
     return this;
   }
 
+  getScratchNames(): Set<string> | undefined {
+    return AgentScratchNames.get(this.getFqName());
+  }
+
+  maybeAddScratchData(env: Environment): AgentInstance {
+    const obj: any = env.getLastResult();
+    let r: Instance | Instance[] | undefined = undefined;
+    if (
+      obj instanceof Instance ||
+      (obj instanceof Array && obj.length > 0 && obj[0] instanceof Instance)
+    ) {
+      r = obj;
+    } else {
+      return this;
+    }
+    const scratchNames = this.getScratchNames();
+    let data: any = undefined;
+    let n = '';
+    if (r instanceof Array) {
+      data = r.map((inst: Instance) => {
+        return extractScratchData(scratchNames, inst);
+      });
+      n = r[0].getFqName();
+    } else {
+      data = extractScratchData(scratchNames, r);
+      n = r.getFqName();
+    }
+    if (data) env.addToScratchPad(n, data);
+    return this;
+  }
+
   async invoke(message: string, env: Environment) {
     const p = await findProviderForLLM(this.llm, env);
     const agentName = this.name;
@@ -411,6 +499,20 @@ export class AgentInstance {
   }
 }
 
+function extractScratchData(scratchNames: Set<string> | undefined, inst: Instance): any {
+  const data: any = {};
+  inst.attributes.forEach((v: any, k: string) => {
+    if (scratchNames) {
+      if (scratchNames.has(k)) {
+        data[k] = v;
+      }
+    } else {
+      data[k] = v;
+    }
+  });
+  return data;
+}
+
 async function parseHelper(stmt: string, env: Environment): Promise<any> {
   await parseAndEvaluateStatement(stmt, undefined, env);
   return env.getLastResult();

package/src/runtime/modules/auth.ts

@@ -332,6 +332,15 @@ workflow getUser {
 workflow getUserByEmail {
   await Auth.getUserInfoByEmail(getUserByEmail.email)
 }
+
+workflow inviteUser {
+  await Auth.inviteUser(inviteUser.email, inviteUser.firstName, inviteUser.lastName, inviteUser.userData)
+}
+
+
+workflow acceptInvitation {
+  await Auth.acceptInvitationUser(acceptInvitation.email, acceptInvitation.tempPassword, acceptInvitation.newPassword)
+}
 `;
 
 const evalEvent = makeEventEvaluator(CoreAuthModuleName);
@@ -1113,6 +1122,68 @@ export async function refreshUserToken(refreshToken: string, env: Environment):
   }
 }
 
+export async function inviteUser(
+  email: string,
+  firstName: string,
+  lastName: string,
+  userData: Map<string, any> | undefined,
+  env: Environment
+): Promise<object> {
+  const needCommit = env ? false : true;
+  env = env ? env : new Environment();
+  const f = async () => {
+    try {
+      let invitationInfo: any;
+      await fetchAuthImpl().inviteUser(email, firstName, lastName, userData, env, (info: any) => {
+        invitationInfo = info;
+      });
+
+      return {
+        email: invitationInfo.email,
+        firstName: invitationInfo.firstName,
+        lastName: invitationInfo.lastName,
+        invitationId: invitationInfo.invitationId,
+        message: 'User invitation sent successfully',
+      };
+    } catch (err: any) {
+      logger.error(`User invitation failed: ${err.message}`);
+      throw err;
+    }
+  };
+  if (needCommit) {
+    return await env.callInTransaction(f);
+  } else {
+    return await f();
+  }
+}
+
+export async function acceptInvitationUser(
+  email: string,
+  tempPassword: string,
+  newPassword: string,
+  env: Environment
+): Promise<object> {
+  const needCommit = env ? false : true;
+  env = env ? env : new Environment();
+  const f = async () => {
+    try {
+      await fetchAuthImpl().acceptInvitation(email, tempPassword, newPassword, env);
+      return {
+        email: email,
+        message: 'Invitation accepted successfully',
+      };
+    } catch (err: any) {
+      logger.error(`Accept invitation failed: ${err.message}`);
+      throw err;
+    }
+  };
+  if (needCommit) {
+    return await env.callInTransaction(f);
+  } else {
+    return await f();
+  }
+}
+
 export function requireAuth(moduleName: string, eventName: string): boolean {
   if (isAuthEnabled()) {
     const f =
@@ -1123,7 +1194,8 @@ export function requireAuth(moduleName: string, eventName: string): boolean {
         eventName == 'resendConfirmationCode' ||
         eventName == 'forgotPassword' ||
         eventName == 'confirmForgotPassword' ||
-        eventName == 'refreshToken');
+        eventName == 'refreshToken' ||
+        eventName == 'acceptInvitation');
     return !f;
   } else {
     return false;