agentlang 0.10.3 → 0.10.5

package/src/runtime/interpreter.ts

@@ -182,7 +182,7 @@ export class Environment extends Instance {
   private agentMode: 'chat' | 'planner' | undefined = undefined;
   private agentChatId: string | undefined = undefined;
   private monitor: Monitor | undefined = undefined;
-  private escalatedRole: string | undefined;
+  private assumedRole: string | undefined;
   private activeChatId: string | undefined;
 
   private activeUserData: any = undefined;
@@ -210,7 +210,7 @@ export class Environment extends Instance {
       this.eventExecutor = parent.eventExecutor;
       this.agentChatId = parent.agentChatId;
       this.monitor = parent.monitor;
-      this.escalatedRole = parent.escalatedRole;
+      this.assumedRole = parent.assumedRole;
       this.activeChatId = parent.activeChatId;
     } else {
       this.activeModule = DefaultModuleName;
@@ -308,17 +308,17 @@ export class Environment extends Instance {
     return this;
   }
 
-  setEscalatedRole(s: string): Environment {
-    this.escalatedRole = s;
+  setAssumedRole(s: string): Environment {
+    this.assumedRole = s;
     return this;
   }
 
-  getEscalatedRole(): string | undefined {
-    return this.escalatedRole;
+  getAssumedRole(): string | undefined {
+    return this.assumedRole;
   }
 
-  resetEscalatedRole(): Environment {
-    this.escalatedRole = undefined;
+  resetAssumedRole(): Environment {
+    this.assumedRole = undefined;
     return this;
   }
 
@@ -856,7 +856,7 @@ export class Environment extends Instance {
       if (this.activeEventInstance && isCoreModule(this.activeEventInstance.moduleName)) {
         return this;
       }
-      this.monitor = new Monitor(this.activeEventInstance, this.activeUser);
+      this.monitor = new Monitor(this.activeEventInstance, this.activeUser, this.assumedRole);
     }
     this.monitor.addEntry(new MonitorEntry(stmt));
     return this;
@@ -971,7 +971,7 @@ export let evaluate = async function (
         env = new Environment(eventInstance.name + '.env', activeEnv);
         env.setActiveEvent(eventInstance);
         const er = wf.getRoleEscalation();
-        if (er) env.setEscalatedRole(er);
+        if (er) env.setAssumedRole(er);
         if (kernelCall) {
           env.setInKernelMode(true);
         }
@@ -1012,7 +1012,7 @@ export let evaluate = async function (
       throw err;
     }
   } finally {
-    env?.resetEscalatedRole();
+    env?.resetAssumedRole();
     if (!txnRolledBack && env !== undefined && activeEnv === undefined) {
       await env.commitAllTransactions();
     }
@@ -1578,7 +1578,11 @@ async function maybeValidateOneOfRefs(inst: Instance, env: Environment) {
   }
 }
 
-function maybeSetQueryClauses(inst: Instance, qopts: ExtractedQueryOptions) {
+async function maybeSetQueryClauses(
+  inst: Instance,
+  qopts: ExtractedQueryOptions,
+  env: Environment
+) {
   if (qopts.groupByClause) {
     inst.setGroupBy(qopts.groupByClause.colNames);
   }
@@ -1586,10 +1590,18 @@ function maybeSetQueryClauses(inst: Instance, qopts: ExtractedQueryOptions) {
     inst.setOrderBy(qopts.orderByClause.colNames, qopts.orderByClause.order === '@desc');
   }
   if (qopts.limitClause) {
-    inst.setLimit(qopts.limitClause.value);
+    await evaluateExpression(qopts.limitClause.value, env);
+    const v = env.getLastResult();
+    if (typeof v === 'number') {
+      inst.setLimit(v);
+    }
   }
   if (qopts.offsetClause) {
-    inst.setOffset(qopts.offsetClause.value);
+    await evaluateExpression(qopts.offsetClause.value, env);
+    const v = env.getLastResult();
+    if (typeof v === 'number') {
+      inst.setOffset(v);
+    }
   }
 }
 
@@ -1608,7 +1620,7 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
   const onlyAggregates = inst.aggregates !== undefined && qattrs === undefined;
   const isQueryAll = onlyAggregates || crud.name.endsWith(QuerySuffix);
   const distinct: boolean = qopts.distinct !== undefined;
-  maybeSetQueryClauses(inst, qopts);
+  await maybeSetQueryClauses(inst, qopts, env);
   if (attrs.size > 0) {
     await maybeValidateOneOfRefs(inst, env);
   }
@@ -2171,8 +2183,8 @@ const MAX_PLANNER_RETRIES = 3;
 async function agentInvoke(agent: AgentInstance, msg: string, env: Environment): Promise<void> {
   // log invocation details
   let invokeDebugMsg = `\nInvoking agent ${agent.name}:`;
-  if (agent.role) {
-    invokeDebugMsg = `${invokeDebugMsg} Role=${agent.role}`;
+  if (agent.goal) {
+    invokeDebugMsg = `${invokeDebugMsg} Goal=${agent.goal}`;
   }
   console.debug(invokeDebugMsg);
   invokeDebugMsg = `\nMessage=${msg}`;
@@ -2299,6 +2311,9 @@ export async function handleAgentInvocation(
   env: Environment
 ): Promise<void> {
   const agent: AgentInstance = await findAgentByName(agentEventInst.name, env);
+  if (agent.role) {
+    env.setAssumedRole(agent.role);
+  }
   const chatId = agentEventInst.lookup('chatId');
   if (chatId) {
     env.setActiveChatId(chatId);

package/src/runtime/loader.ts

@@ -832,7 +832,14 @@ async function addAgentDefinition(
       }
       const ov = v;
       if (apdef.value.id || apdef.value.ref || apdef.value.array) {
-        if (!(apdef.name === 'instruction' || apdef.name === 'role' || apdef.name === 'llm'))
+        if (
+          !(
+            apdef.name === 'instruction' ||
+            apdef.name === 'goal' ||
+            apdef.name === 'role' ||
+            apdef.name === 'llm'
+          )
+        )
           v = `"${v}"`;
       } else if (apdef.value.str) {
         v = `"${escapeSpecialChars(v)}"`;
@@ -867,9 +874,10 @@ async function addAgentDefinition(
   }
   if (attrs.get('type') === 'planner' || attrs.get('tools')) {
     const llmn = llmName || attrs.get('llm');
+    const agentRole = attrs.get('role') || 'admin';
     wf = `${wf}; {${CoreAIModuleName}/${AgentEntityName}
         {name "${name}_${AgentLearnerType}", moduleName "${moduleName}", llm "${llmn}",
-         type "${AgentLearnerType}", role "You are an agent that summarizes user-provided scenarios."}, @upsert}`;
+         type "${AgentLearnerType}", role "${agentRole}", goal "You are an agent that summarizes user-provided scenarios."}, @upsert}`;
   }
   (await parseWorkflow(`workflow A {${wf}}`)).statements.forEach((stmt: Statement) => {
     addStandaloneStatement(stmt, moduleName, false);

package/src/runtime/logger.ts

@@ -36,17 +36,6 @@ export function initializeLogger() {
       maxFiles: '7d',
     });
 
-    // Add console transport for visibility
-    const consoleTransport = new winston.transports.Console({
-      level: logLevel,
-      format: winston.format.combine(
-        winston.format.colorize(),
-        winston.format.printf(({ level, message }: any) => {
-          return `${level}: ${message}`;
-        })
-      ),
-    });
-
     logger = winston.createLogger({
       level: logLevel,
       format: winston.format.combine(
@@ -55,7 +44,7 @@ export function initializeLogger() {
           return `[${timestamp}] ${level}: ${message}`;
         })
       ),
-      transports: [fileTransport, consoleTransport],
+      transports: [fileTransport],
     });
   } else {
     function mkLogger(tag: string): Function {

package/src/runtime/module.ts

@@ -2859,46 +2859,6 @@ export function resolveDocumentAliases(names: string[]): string[] {
   return names.map((name: string) => DocumentAliasMap.get(name) ?? name);
 }
 
-// TopicRegistry: maps topic name → list of document titles belonging to that topic
-const TopicRegistry: Map<string, string[]> = new Map();
-
-export function registerTopic(name: string, documents?: string): void {
-  if (!name) return;
-  const docs = documents
-    ? documents
-        .split(',')
-        .map(d => d.trim())
-        .filter(Boolean)
-    : [];
-  TopicRegistry.set(name, docs);
-}
-
-export function getTopicDocuments(topicName: string): string[] {
-  return TopicRegistry.get(topicName) ?? [];
-}
-
-export function resolveTopicNames(topicsCsv: string): string[] {
-  return topicsCsv
-    .split(',')
-    .map(t => t.trim())
-    .filter(Boolean);
-}
-
-export function getTopicContainerTags(topicNames: string[]): string[] {
-  return topicNames.filter(name => TopicRegistry.has(name));
-}
-
-export function getAllDocumentsForTopics(topicNames: string[]): string[] {
-  const docs: string[] = [];
-  for (const name of topicNames) {
-    const topicDocs = TopicRegistry.get(name);
-    if (topicDocs) {
-      docs.push(...topicDocs);
-    }
-  }
-  return [...new Set(docs)];
-}
-
 export function addGlobalRetry(r: Retry): Retry {
   if (GlobalRetries === undefined) {
     GlobalRetries = new Array<Retry>();
@@ -2995,19 +2955,6 @@ export function fetchModuleEntry(entryName: string, moduleName: string): ModuleE
   const module: Module = fetchModule(moduleName);
   return module.getEntry(entryName);
 }
-// UUID regex pattern
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-
-// containerTag format: alphanumeric with dashes/underscores, no spaces
-const CONTAINER_TAG_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-
-export function isTopicReference(value: any): boolean {
-  if (!isString(value)) {
-    return false;
-  }
-  // Topic can be a UUID or a containerTag format
-  return UUID_REGEX.test(value) || CONTAINER_TAG_REGEX.test(value);
-}
 
 const builtInChecks = new Map([
   ['String', isString],
@@ -3036,7 +2983,6 @@ const builtInChecks = new Map([
       return true;
     },
   ],
-  ['Topic', isTopicReference],
 ]);
 
 export const builtInTypes = new Set(Array.from(builtInChecks.keys()));
@@ -3060,16 +3006,7 @@ export const propertyNames = new Set([
   '@comment',
 ]);
 
-const TextualTypes = new Set([
-  'String',
-  'Email',
-  'UUID',
-  'DateTime',
-  'Date',
-  'Time',
-  'Path',
-  'Topic',
-]);
+const TextualTypes = new Set(['String', 'Email', 'UUID', 'DateTime', 'Date', 'Time', 'Path']);
 
 function isTextualType(type: string): boolean {
   return TextualTypes.has(type);

package/src/runtime/modules/ai.ts

@@ -26,7 +26,6 @@ import {
   asJSONSchema,
   Decision,
   fetchModule,
-  getAllDocumentsForTopics,
   getDecision,
   getGlobalRetry,
   Instance,
@@ -38,9 +37,7 @@ import {
   newInstanceAttributes,
   objectToInstanceAttributes,
   Record,
-  registerTopic as registerTopicInRegistry,
   resolveDocumentAliases,
-  resolveTopicNames,
   Retry,
 } from '../module.js';
 import { provider } from '../agents/registry.js';
@@ -74,10 +71,9 @@ import {
 import { logger } from '../logger.js';
 import { FlowStep } from '../agents/flows.js';
 import { Statement } from '../../language/generated/ast.js';
-import { getKnowledgeGraphConfig, isMonitoringEnabled, TtlCache } from '../state.js';
+import { isMonitoringEnabled, TtlCache } from '../state.js';
 import { isNodeEnv } from '../../utils/runtime.js';
 import { getFileSystem } from '../../utils/fs-utils.js';
-import { getDocumentRetriever } from '../document-retriever.js';
 
 export const CoreAIModuleName = makeCoreModuleName('ai');
 export const AgentEntityName = 'Agent';
@@ -148,10 +144,10 @@ entity ${AgentEntityName} {
     stateless Boolean @default(false),
     instruction String @optional,
     tools String @optional, // comma-separated list of tool names
-    documents String @optional, // list of document names
-    topics String @optional, // list of topic names
+    documents String @optional, // comma-separated list of document names
     channels String @optional, // comma-separated list of channel names
-    role String @optional,
+    goal String @optional,
+    role String,
     flows String @optional,
     validate String @optional,
     retry String @optional,
@@ -196,15 +192,6 @@ workflow processDoc {
   await ai.fetchAndCreateDocument(doc.title, doc.url, doc.retrievalConfig, doc.embeddingConfig)
 }
 
-event topic {
-  name String,
-  documents String @optional // comma-separated or array of document titles
-}
-
-workflow processTopic {
-  await ai.registerTopic(topic.name, topic.documents)
-}
-
 entity Directive {
   id UUID @id @default(uuid()),
   agentFqName String @indexed,
@@ -297,7 +284,7 @@ type AgentInstructionActivator = {
   provider: AgentServiceProvider;
   userMessage: string;
   agentInstruction: string;
-  agentRole: string | undefined;
+  agentGoal: string | undefined;
 };
 
 const MAX_USER_DEFINED_GLOSSARY = 20;
@@ -387,10 +374,10 @@ export class AgentInstance {
   type: string = 'chat';
   tools: string | undefined;
   documents: string | undefined;
-  topics: string | undefined;
   channels: string | undefined;
   runWorkflows: boolean = true;
-  role: string | undefined;
+  goal: string | undefined;
+  role: string = '';
   flows: string | undefined;
   validate: string | undefined;
   retry: string | undefined;
@@ -661,7 +648,7 @@ export class AgentInstance {
     activator: AgentInstructionActivator
   ): Promise<string> {
     const fqName = this.getFqName();
-    const ins = this.role ? `${this.role}\n${this.instruction || ''}` : this.instruction || '';
+    const ins = this.goal ? `${this.goal}\n${this.instruction || ''}` : this.instruction || '';
     let finalInstruction = `${ins} ${await this.directivesAsString(fqName, activator)}`;
     const staticGls = getAgentGlossary(fqName) || [];
     let userGls = await this.getUserDefinedAgentGlossary(fqName);
@@ -925,7 +912,7 @@ Only return a pure JSON object with no extra text, annotations etc.`;
       provider: p,
       userMessage: message,
       agentInstruction: this.instruction,
-      agentRole: this.role,
+      agentGoal: this.goal,
     };
     if (sess) {
       msgs = sess.lookup('messages');
@@ -1142,139 +1129,93 @@ Only return a pure JSON object with no extra text, annotations etc.`;
     return result;
   }
 
-  private async maybeAddRelevantDocuments(message: string, _env: Environment): Promise<string> {
-    const hasDocuments = this.documents && this.documents.length > 0;
-    const hasTopics = this.topics && this.topics.length > 0;
-
-    if (!hasDocuments && !hasTopics) {
-      return message;
-    }
-
-    try {
-      let containerTags: string[] = [];
-      let topicDocumentTitles: string[] = [];
-
-      if (hasTopics) {
-        const topicNames = resolveTopicNames(this.topics!);
-        containerTags = topicNames;
-        topicDocumentTitles = getAllDocumentsForTopics(topicNames);
-      }
-
-      if (containerTags.length === 0) {
-        containerTags = [this.getFqName()];
-      }
-
-      let documentTitles: string[] = [];
-      let documentRefs: string[] = [];
-
-      if (hasDocuments) {
-        const documentEntries = this.documents!.split(',')
-          .map(d => d.trim())
-          .filter(Boolean);
-        documentTitles = resolveDocumentAliases(documentEntries);
-        documentRefs = documentEntries.filter(d => d.startsWith('document-service://'));
-      }
+  private async maybeAddRelevantDocuments(message: string, env: Environment): Promise<string> {
+    if (this.documents && this.documents.length > 0) {
+      try {
+        const docNames = this.documents.split(',').map(d => d.trim());
+        const docTitles = resolveDocumentAliases(docNames);
 
-      const allDocumentTitles = [...new Set([...topicDocumentTitles, ...documentTitles])];
+        const searchQuery = message;
 
-      const kgConfig = getKnowledgeGraphConfig();
-      const serviceUrl = kgConfig?.serviceUrl?.trim() || process.env.KNOWLEDGE_SERVICE_URL || null;
+        try {
+          const semanticResult: any[] = await parseHelper(
+            `{${CoreAIModuleName}/Document {content? "${searchQuery.replace(/"/g, '\\"')}"}}`,
+            env
+          );
 
-      if (serviceUrl) {
-        return await this.queryRemoteKnowledgeService(
-          message,
-          serviceUrl,
-          containerTags,
-          allDocumentTitles,
-          documentRefs
-        );
-      }
+          if (semanticResult && semanticResult.length > 0) {
+            const docs: Instance[] = [];
+            for (const doc of semanticResult) {
+              const docTitle = doc.lookup ? doc.lookup('title') : doc.title;
+              if (AgentInstance.docTitlesMatch(docTitle, docTitles)) {
+                docs.push(
+                  doc instanceof Instance
+                    ? doc
+                    : Instance.newWithAttributes(doc, new Map(Object.entries(doc)))
+                );
+              }
+            }
 
-      // Local mode: embed documents into pgvector/lancedb and query
-      const retriever = getDocumentRetriever();
-      const aiModule = isModule(DefaultModuleName + '.ai')
-        ? fetchModule(DefaultModuleName + '.ai')
-        : null;
-      if (aiModule) {
-        for (const title of allDocumentTitles) {
-          const url = aiModule.getDocument(title);
-          if (url) {
-            await retriever.processDocument(title, url);
+            if (docs.length > 0) {
+              return message.concat('\n\nRelevant context from documents:\n').concat(
+                docs
+                  .map((v: Instance) => {
+                    return `Document: ${v.lookup('title')}\n${v.lookup('content') as string}`;
+                  })
+                  .join('\n\n---\n\n')
+              );
+            }
           }
+        } catch (semanticErr) {
+          logger.debug(
+            `Semantic search is not available, falling back to title-based filtering: ${semanticErr}`
+          );
         }
-      }
 
-      const contextString = await retriever.query(
-        message,
-        allDocumentTitles.length > 0 ? allDocumentTitles : undefined,
-        10
-      );
+        const result: any[] = await parseHelper(`{${CoreAIModuleName}/Document? {}}`, env);
+        if (result && result.length > 0) {
+          const docs: Instance[] = [];
+          for (let i = 0; i < result.length; ++i) {
+            const v: any = result[i];
+            const docTitle: string | undefined = AgentInstance.getDocumentTitle(v);
+
+            if (docTitle && docTitles.includes(docTitle)) {
+              if (v instanceof Instance) {
+                docs.push(v);
+              }
+            }
+          }
 
-      if (contextString.trim().length > 0) {
-        return message.concat('\n\nRelevant context from documents:\n').concat(contextString);
+          if (docs.length > 0) {
+            return message.concat('\n\nRelevant context from documents:\n').concat(
+              docs
+                .map((v: Instance) => {
+                  return v.lookup('content') as string;
+                })
+                .join('\n\n')
+            );
+          }
+        }
+      } catch (err) {
+        logger.debug(`Error retrieving documents: ${err}`);
       }
-    } catch (err) {
-      logger.debug(`[KNOWLEDGE] Knowledge retrieval failed: ${err}`);
     }
-
     return message;
   }
 
-  private async queryRemoteKnowledgeService(
-    message: string,
-    serviceUrl: string,
-    containerTags: string[],
-    documentTitles: string[],
-    documentRefs: string[]
-  ): Promise<string> {
-    const options = {
-      chunkLimit: 10,
-      entityLimit: 20,
-      includeChunks: true,
-      includeEntities: true,
-      includeEdges: true,
-      documentTitles: documentTitles.length > 0 ? documentTitles : undefined,
-      documentRefs: documentRefs.length > 0 ? documentRefs : undefined,
-    };
-
-    let response = await fetch(`${serviceUrl}/api/knowledge/query`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ query: message, containerTags, ...options }),
-    });
-
-    if (!response.ok) {
-      response = await fetch(`${serviceUrl}/knowledge.core/ApiKnowledgeQuery`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          queryText: message,
-          containerTagsJson: JSON.stringify(containerTags),
-          documentTitlesJson: JSON.stringify(options.documentTitles || []),
-          documentRefsJson: JSON.stringify(options.documentRefs || []),
-          optionsJson: JSON.stringify({
-            includeChunks: options.includeChunks,
-            includeEntities: options.includeEntities,
-            includeEdges: options.includeEdges,
-            chunkLimit: options.chunkLimit,
-            entityLimit: options.entityLimit,
-          }),
-        }),
-      });
-    }
+  private static docTitlesMatch(title: string | undefined, docNames: string[]): boolean {
+    return title !== undefined && docNames.includes(title);
+  }
 
-    if (response.ok) {
-      const rawPayload: any = await response.json();
-      const first = Array.isArray(rawPayload) ? rawPayload[0] : rawPayload;
-      const payload =
-        first && typeof first === 'object' && first.KnowledgeQuery ? first.KnowledgeQuery : first;
-      const contextString = payload?.contextString || '';
-      if (contextString.trim().length > 0) {
-        return message.concat('\n\nRelevant context from documents:\n').concat(contextString);
-      }
+  private static getDocumentTitle(doc: any): string | undefined {
+    if (typeof doc.lookup === 'function') {
+      return doc.lookup('title') as string | undefined;
+    } else if (doc.attributes) {
+      return doc.attributes.get('title') as string | undefined;
+    } else if (doc.title) {
+      return doc.title;
     }
-
-    return message;
+    return undefined;
   }
 
   private static ToolsCache = new Map<string, string>();
@@ -1734,72 +1675,6 @@ export async function loadFlowStep(chatId: string, step: string): Promise<Instan
   }
 }
 
-export async function registerTopic(
-  name: string,
-  documents: string | undefined,
-  _env: Environment
-): Promise<any> {
-  // Register in local registry
-  registerTopicInRegistry(name, documents ?? undefined);
-
-  // Sync to knowledge service if configured
-  const kgConfig = getKnowledgeGraphConfig();
-  const serviceUrl = kgConfig?.serviceUrl?.trim() || process.env.KNOWLEDGE_SERVICE_URL || null;
-
-  if (serviceUrl) {
-    try {
-      // Parse document list
-      const docList = documents
-        ? documents
-            .split(',')
-            .map(d => d.trim())
-            .filter(Boolean)
-        : [];
-
-      // Create or update topic in knowledge service
-      let response = await fetch(`${serviceUrl}/api/knowledge/topics`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          name,
-          description: `Topic ${name} with ${docList.length} documents`,
-          documentTitles: docList,
-        }),
-      });
-
-      if (!response.ok) {
-        // Fallback to Agentlang entity path for deployed knowledge-service
-        response = await fetch(`${serviceUrl}/knowledge.core/Topic`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            name,
-            description: `Topic ${name} with ${docList.length} documents`,
-            type: 'manual',
-            documentCount: docList.length,
-          }),
-        });
-      }
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        logger.debug(`[KNOWLEDGE] Failed to sync topic to service: ${errorText}`);
-      } else {
-        logger.debug(`[KNOWLEDGE] Synced topic "${name}" to knowledge service`);
-      }
-    } catch (err) {
-      // Don't fail topic registration if service sync fails
-      logger.debug(`[KNOWLEDGE] Error syncing topic to service: ${err}`);
-    }
-  }
-
-  return { topic: { name, documents: documents ?? '' } };
-}
-
 export async function fetchAndCreateDocument(
   title: string,
   url: string,

package/src/runtime/modules/auth.ts

@@ -960,10 +960,12 @@ export async function userHasPermissions(
     UserRoleCache.set(userId, userRoles);
   }
   let tempRoles = userRoles;
-  const escalatedRole = env.getEscalatedRole();
-  if (escalatedRole) {
-    tempRoles = userRoles.slice();
-    tempRoles.push(escalatedRole);
+  const assumedRole = env.getAssumedRole();
+  if (assumedRole) {
+    tempRoles = [assumedRole];
+    if (!RolePermissionsCache.get(assumedRole)) {
+      await updatePermissionCacheForRole(assumedRole, env);
+    }
   }
   if (
     tempRoles &&