agentlang 0.10.4 → 0.10.5

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 &&

package/src/runtime/monitor.ts

@@ -179,6 +179,7 @@ export class Monitor {
   private id: string;
   private eventInstance: Instance | undefined;
   private user: string | undefined;
+  private role: string | undefined;
   private entries: (MonitorEntry | Monitor)[] = new Array<MonitorEntry | Monitor>();
   private parent: Monitor | undefined = undefined;
   private lastEntry: MonitorEntry | undefined = undefined;
@@ -189,10 +190,15 @@ export class Monitor {
 
   private static MAX_REGISTRY_SIZE = 25;
 
-  constructor(eventInstance?: Instance | undefined, user?: string | undefined) {
+  constructor(
+    eventInstance?: Instance | undefined,
+    user?: string | undefined,
+    role?: string | undefined
+  ) {
     this.eventInstance = eventInstance;
     this.id = eventInstance ? eventInstance.getId() : crypto.randomUUID();
     this.user = user;
+    this.role = role;
     this.timestamp = Date.now();
     while (monitorRegistry.length >= Monitor.MAX_REGISTRY_SIZE) {
       monitorRegistry.shift();
@@ -405,6 +411,9 @@ export class Monitor {
     if (this.user) {
       r.user = this.user;
     }
+    if (this.role) {
+      r.role = this.role;
+    }
     r.timestamp = this.timestamp;
     if (this.flowResult !== undefined) {
       let fr = this.flowResult;