agentlang 0.10.1 → 0.10.3

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

@@ -101,6 +101,10 @@ export class EmbeddingService {
     return await this.provider.embedText(query);
   }
 
+  async embedTexts(texts: string[]): Promise<number[][]> {
+    return await this.provider.embedTexts(texts);
+  }
+
   private averageEmbeddings(embeddings: number[][]): number[] {
     if (embeddings.length === 0) return [];
     const dimension = embeddings[0].length;
@@ -402,6 +406,8 @@ export class SqlDbResolver extends Resolver {
       joinClauses: undefined,
       intoSpec: undefined,
       whereClauses: undefined,
+      limit: inst.limit,
+      offset: inst.offset,
     };
     const readOnlyAttrs = inst.record.getWriteOnlyAttributes();
     const rslt: any =
@@ -480,16 +486,17 @@ export class SqlDbResolver extends Resolver {
   public override async queryConnectedInstances(
     relationship: Relationship,
     connectedInstance: Instance,
-    inst: Instance
+    inst: Instance,
+    connectedAlias?: string
   ): Promise<Instance[]> {
     let result = SqlDbResolver.EmptyResultSet;
     if (relationship.isOneToOne()) {
-      const col = relationship.getAliasFor(connectedInstance);
+      const col = relationship.getAliasForConnected(connectedInstance, connectedAlias);
       inst.addQuery(col, '=', connectedInstance.lookup(PathAttributeName));
       return await this.queryInstances(inst, false);
     } else {
-      const from = relationship.getAliasFor(connectedInstance);
-      const to = relationship.getInverseAliasFor(connectedInstance);
+      const from = relationship.getAliasForConnected(connectedInstance, connectedAlias);
+      const to = relationship.getInverseAliasForConnected(connectedInstance, connectedAlias);
       await getAllConnected(
         asTableReference(inst.moduleName, inst.name),
         inst.queryAttributesAsObject(),
@@ -566,6 +573,8 @@ export class SqlDbResolver extends Resolver {
       joinClauses,
       whereClauses,
       intoSpec,
+      limit: inst.limit,
+      offset: inst.offset,
     };
     const rslt: any = await getManyByJoin(tableName, qspec, this.getDbContext(inst.getFqName()));
     return rslt;
@@ -797,9 +806,18 @@ function ensureOneToOneAttributes(inst: Instance) {
   const betRels = getAllBetweenRelationships();
   getAllOneToOneRelationshipsForEntity(inst.moduleName, inst.name, betRels).forEach(
     (re: Relationship) => {
-      const n = re.getInverseAliasFor(inst);
-      if (!inst.attributes.has(n)) {
-        inst.attributes.set(n, crypto.randomUUID());
+      if (re.isSelfReferencing()) {
+        // Self-referencing one-to-one: ensure both alias columns have placeholder values
+        [re.node1.alias, re.node2.alias].forEach((n: string) => {
+          if (!inst.attributes.has(n)) {
+            inst.attributes.set(n, crypto.randomUUID());
+          }
+        });
+      } else {
+        const n = re.getInverseAliasFor(inst);
+        if (!inst.attributes.has(n)) {
+          inst.attributes.set(n, crypto.randomUUID());
+        }
       }
     }
   );

package/src/runtime/resolvers/vector/lancedb-store.ts

@@ -0,0 +1,187 @@
+import * as lancedb from '@lancedb/lancedb';
+import { Schema, Field, Float32, Utf8, FixedSizeList } from 'apache-arrow';
+import { logger } from '../../logger.js';
+import { VectorStore, VectorRecord, SearchResult, VectorStoreConfig } from './types.js';
+
+export class LanceDBVectorStore implements VectorStore {
+  private db: lancedb.Connection | null = null;
+  private table: lancedb.Table | null = null;
+  private config: VectorStoreConfig;
+
+  constructor(config: VectorStoreConfig) {
+    this.config = config;
+  }
+
+  async init(): Promise<void> {
+    try {
+      const dbPath = this.config.inMemory
+        ? 'memory://'
+        : this.config.dbname || `./data/vector-store/${this.config.moduleName}.lance`;
+
+      this.db = await lancedb.connect(dbPath);
+
+      const tableName = 'embeddings';
+      const tableNames = await this.db.tableNames();
+
+      if (tableNames.includes(tableName)) {
+        this.table = await this.db.openTable(tableName);
+        logger.info(`LanceDB table ${tableName} opened`);
+      } else {
+        const schema = new Schema([
+          new Field('id', new Utf8(), false),
+          new Field(
+            'embedding',
+            new FixedSizeList(this.config.vectorDimension, new Field('item', new Float32())),
+            false
+          ),
+          new Field('tenantId', new Utf8(), true),
+          new Field('agentId', new Utf8(), true),
+          new Field('documentId', new Utf8(), true),
+        ]);
+
+        this.table = await this.db.createEmptyTable(tableName, schema);
+        logger.info(`LanceDB table ${tableName} created`);
+      }
+    } catch (error) {
+      logger.error('Failed to initialize LanceDB vector store:', error);
+      throw error;
+    }
+  }
+
+  async addEmbedding(record: VectorRecord): Promise<void> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      await this.table.add([
+        {
+          id: record.id,
+          embedding: record.embedding,
+          tenantId: record.tenantId || null,
+          agentId: record.agentId || null,
+          documentId: record.documentId || null,
+        },
+      ]);
+    } catch (error) {
+      logger.error(`Failed to add embedding ${record.id}:`, error);
+      throw error;
+    }
+  }
+
+  async addEmbeddings(records: VectorRecord[]): Promise<void> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      const data = records.map(record => ({
+        id: record.id,
+        embedding: record.embedding,
+        tenantId: record.tenantId || null,
+        agentId: record.agentId || null,
+        documentId: record.documentId || null,
+      }));
+
+      await this.table.add(data);
+    } catch (error) {
+      logger.error(`Failed to add ${records.length} embeddings:`, error);
+      throw error;
+    }
+  }
+
+  async search(
+    embedding: number[],
+    tenantId?: string,
+    agentId?: string,
+    limit: number = 10
+  ): Promise<SearchResult[]> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      let query = this.table.vectorSearch(embedding).limit(limit);
+
+      // Build filter conditions for agent-level isolation
+      const filters: string[] = [];
+
+      if (tenantId) {
+        // Use parameterized filtering to prevent SQL injection
+        const escapedTenantId = tenantId.replace(/'/g, "''");
+        filters.push(`tenantId = '${escapedTenantId}'`);
+      }
+
+      if (agentId) {
+        // Add agent-level filtering for strict agent isolation
+        const escapedAgentId = agentId.replace(/'/g, "''");
+        filters.push(`agentId = '${escapedAgentId}'`);
+      }
+
+      if (filters.length > 0) {
+        query = query.where(filters.join(' AND '));
+      }
+
+      const results = await query.toArray();
+
+      return results.map((row: any) => ({
+        id: row.id,
+        distance: row._distance || 0,
+        tenantId: row.tenantId,
+        agentId: row.agentId,
+        documentId: row.documentId,
+      }));
+    } catch (error) {
+      logger.error('Failed to search embeddings:', error);
+      throw error;
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      await this.table.delete(`id = '${id}'`);
+    } catch (error) {
+      logger.error(`Failed to delete embedding ${id}:`, error);
+      throw error;
+    }
+  }
+
+  async exists(id: string): Promise<boolean> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      const results = await this.table.query().where(`id = '${id}'`).limit(1).toArray();
+      return results.length > 0;
+    } catch (error) {
+      logger.error(`Failed to check existence of ${id}:`, error);
+      throw error;
+    }
+  }
+
+  async close(): Promise<void> {
+    try {
+      if (this.table) {
+        // LanceDB tables don't have explicit close method
+        this.table = null;
+      }
+      if (this.db) {
+        // Note: LanceDB connection doesn't have explicit close method
+        this.db = null;
+      }
+      logger.info('LanceDB vector store closed');
+    } catch (error) {
+      logger.error('Failed to close LanceDB vector store:', error);
+      throw error;
+    }
+  }
+}
+
+export function createLanceDBStore(config: VectorStoreConfig): VectorStore {
+  return new LanceDBVectorStore(config);
+}

package/src/runtime/resolvers/vector/types.ts

@@ -0,0 +1,39 @@
+export interface VectorRecord {
+  id: string;
+  embedding: number[];
+  tenantId?: string;
+  agentId?: string;
+  documentId?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface SearchResult {
+  id: string;
+  distance: number;
+  tenantId?: string;
+  agentId?: string;
+  documentId?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface VectorStore {
+  init(): Promise<void>;
+  addEmbedding(record: VectorRecord): Promise<void>;
+  addEmbeddings(records: VectorRecord[]): Promise<void>;
+  search(
+    embedding: number[],
+    tenantId?: string,
+    agentId?: string,
+    limit?: number
+  ): Promise<SearchResult[]>;
+  delete(id: string): Promise<void>;
+  exists(id: string): Promise<boolean>;
+  close(): Promise<void>;
+}
+
+export interface VectorStoreConfig {
+  dbname?: string;
+  moduleName: string;
+  vectorDimension: number;
+  inMemory?: boolean;
+}

package/src/runtime/services/documentFetcher.ts

@@ -68,6 +68,7 @@ class DocumentFetcherService {
 
   async fetchDocument(config: DocumentConfig): Promise<FetchedDocument | null> {
     this.ensureNodeEnv();
+    logger.info(`[DOC-FETCH] Starting fetch for: ${config.title}`);
     const cacheKey = `${config.title}:${config.url || config.documentServiceId}`;
     const cached = this.documentCache.get(cacheKey);
 
@@ -79,6 +80,7 @@ class DocumentFetcherService {
     try {
       let content: string;
       let sourceUrl: string;
+      logger.info(`[DOC-FETCH] Fetching from URL: ${config.url}`);
 
       if (config.url?.startsWith('document-service://')) {
         if (!config.retrievalConfig || config.retrievalConfig.provider !== 'document-service') {
@@ -144,8 +146,10 @@ class DocumentFetcherService {
         content = await this.fetchFromUrl(config.url);
         sourceUrl = config.url;
       } else if (config.url) {
+        logger.info(`[DOC-FETCH] Fetching from local file: ${config.url}`);
         content = await this.fetchFromLocal(config.url);
         sourceUrl = config.url;
+        logger.info(`[DOC-FETCH] Local file fetched successfully: ${content.length} chars`);
       } else {
         if (this.documentServiceConfig) {
           const docId = await this.lookupDocumentByTitle(config.title);
@@ -171,7 +175,9 @@ class DocumentFetcherService {
 
       this.documentCache.set(cacheKey, document);
 
+      logger.info(`[DOC-FETCH] Creating Document entity for: ${config.title}`);
       await this.createDocumentEntity(document);
+      logger.info(`[DOC-FETCH] Document entity created successfully for: ${config.title}`);
 
       return document;
     } catch (error) {
@@ -443,11 +449,14 @@ class DocumentFetcherService {
 
   private async fetchFromLocal(filePath: string): Promise<string> {
     try {
+      logger.info(`[DOC-FETCH] Reading local file: ${filePath}`);
       const content = await readFile(filePath);
+      logger.info(`[DOC-FETCH] File read successfully: ${content.length} chars`);
       const lowerPath = filePath.toLowerCase();
       const isMarkdown = lowerPath.endsWith('.md') || lowerPath.endsWith('.markdown');
 
       if (isMarkdown) {
+        logger.info(`[DOC-FETCH] Parsing markdown...`);
         return this.parseMarkdownText(content);
       }
 
@@ -547,10 +556,11 @@ class DocumentFetcherService {
     // Lazy load PDF parser
     if (!this.pdfParser) {
       try {
-        const pdfParse = await import('pdf-parse');
-        // Handle both ESM and CSM module formats
-        const parser = (pdfParse as any).default || pdfParse;
-        this.pdfParser = parser;
+        const { PDFParse } = await import('pdf-parse');
+        if (!PDFParse) {
+          throw new Error('pdf-parse does not export PDFParse');
+        }
+        this.pdfParser = PDFParse;
       } catch (error) {
         logger.error('Failed to load PDF parser', { error });
         throw new Error(
@@ -560,11 +570,16 @@ class DocumentFetcherService {
     }
 
     try {
-      const result = await this.pdfParser(buffer);
+      const parser = new this.pdfParser({ data: buffer });
+      const result = await parser.getText();
+      if (typeof parser.destroy === 'function') {
+        await parser.destroy();
+      }
       return result.text || '';
     } catch (error) {
       logger.error('PDF parsing failed', { error });
-      throw new Error(`Failed to parse PDF: ${error}`);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to parse PDF: ${message}`);
     }
   }
 

package/src/runtime/state.ts

@@ -35,6 +35,21 @@ export const ConfigSchema = z.object({
         type: z.literal('sqlite'),
         dbname: z.string().optional(),
       }),
+      z.object({
+        type: z.literal('lancedb'),
+        path: z.string().optional(),
+      }),
+    ])
+    .optional(),
+  vectorStore: z
+    .discriminatedUnion('type', [
+      z.object({
+        type: z.literal('pgvector'),
+      }),
+      z.object({
+        type: z.literal('lancedb'),
+        dbname: z.string().optional(),
+      }),
     ])
     .optional(),
   integrations: z
@@ -42,7 +57,17 @@ export const ConfigSchema = z.object({
       host: z.string(),
       username: z.string().optional(),
       password: z.string().optional(),
-      connections: z.record(z.string(), z.string()),
+      connections: z.record(
+        z.string(),
+        z.union([
+          z.string(),
+          z.object({
+            config: z.string(),
+            resolvers: z.array(z.string()),
+          }),
+        ])
+      ),
+      oauth: z.boolean().default(false),
     })
     .optional(),
   graphql: z
@@ -71,6 +96,11 @@ export const ConfigSchema = z.object({
       enabled: z.boolean().default(false),
     })
     .optional(),
+  knowledgeGraph: z
+    .object({
+      serviceUrl: z.string().default('#js process.env.KNOWLEDGE_SERVICE_URL || ""'),
+    })
+    .optional(),
   authentication: z
     .discriminatedUnion('service', [
       z.object({
@@ -155,6 +185,15 @@ export function isMonitoringEnabled(): boolean {
   return internalMonitoringEnabled || AppConfig?.monitoring?.enabled === true;
 }
 
+export function isKnowledgeGraphEnabled(): boolean {
+  const url = AppConfig?.knowledgeGraph?.serviceUrl?.trim();
+  return !!(url && url.length > 0) || !!process.env.KNOWLEDGE_SERVICE_URL;
+}
+
+export function getKnowledgeGraphConfig(): Config['knowledgeGraph'] | undefined {
+  return AppConfig?.knowledgeGraph;
+}
+
 type TtlCacheEntry<T> = {
   value: T;
   expireTime: number;

package/src/runtime/util.ts

@@ -2,6 +2,7 @@ import { isNodeEnv, path } from '../utils/runtime.js';
 import {
   AliasSpec,
   CatchSpec,
+  EmptySpec,
   ExtendsClause,
   isLiteral,
   MapEntry,
@@ -441,6 +442,18 @@ export function firstCatchSpec(stmt: Statement): CatchSpec | undefined {
   return undefined;
 }
 
+export function firstEmptySpec(stmt: Statement): EmptySpec | undefined {
+  if (stmt.hints) {
+    for (let i = 0; i < stmt.hints.length; ++i) {
+      const rh = stmt.hints[i];
+      if (rh.emptySpec) {
+        return rh.emptySpec;
+      }
+    }
+  }
+  return undefined;
+}
+
 function maybeExtractEntryName(n: string): string {
   const i = n.indexOf('$');
   if (i > 0) {
@@ -671,7 +684,11 @@ export type ExtractedText = {
 };
 
 // extract all data between a given xml tag from within an arbitray text.
-export function extractAndRemoveAllXmlTaggedText(text: string, tagName: string): ExtractedText {
+export function extractAndRemoveAllXmlTaggedText(
+  text: string,
+  tagName: string,
+  replaceWith: string = ''
+): ExtractedText {
   const pattern = `<${tagName}\\b[^>]*>([\\s\\S]*?)</${tagName}>`;
   const regex = new RegExp(pattern, 'gi');
 
@@ -683,7 +700,7 @@ export function extractAndRemoveAllXmlTaggedText(text: string, tagName: string):
     extracted.push(match[1]);
   }
 
-  updatedText = text.replace(regex, '');
+  updatedText = text.replace(regex, replaceWith);
 
   return { extracted, updatedText };
 }

package/src/syntaxes/agentlang.monarch.ts

@@ -1,7 +1,7 @@
 // Monarch syntax highlighting for the agentlang language.
 export default {
     keywords: [
-        '@actions','@after','@as','@asc','@async','@before','@catch','@desc','@distinct','@enum','@expr','@from','@full_join','@groupBy','@inner_join','@into','@join','@left_join','@meta','@oneof','@orderBy','@public','@rbac','@ref','@right_join','@then','@upsert','@where','@withRole','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','eval','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
+        '@actions','@after','@as','@asc','@async','@before','@catch','@desc','@distinct','@empty','@enum','@expr','@from','@full_join','@groupBy','@inner_join','@into','@join','@left_join','@limit','@meta','@offset','@oneof','@orderBy','@public','@rbac','@ref','@right_join','@then','@upsert','@where','@withRole','@with_unique','agent','agentlang/retry','allow','and','attempts','await','backoff','between','case','commitTransaction','contains','create','decision','delete','directive','else','entity','error','eval','event','extends','false','flow','for','glossaryEntry','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','rollbackTransaction','scenario','startTransaction','subscribe','throw','true','update','upsert','where','workflow'
     ],
     operators: [
         '!=','*','+',',','-','-->','.','/',':',';','<','<=','<>','=','==','>','>=','?','@'