agentlang 0.10.3 → 0.10.5

package/src/runtime/modules/core.ts

@@ -2,6 +2,7 @@ import { default as ai, normalizeGeneratedCode } from './ai.js';
 import { default as auth } from './auth.js';
 import { default as files } from './files.js';
 import { default as mcp } from './mcp.js';
+import messaging, { initMessagingModule } from './messaging.js';
 import {
   DefaultModuleName,
   DefaultModules,
@@ -188,6 +189,7 @@ export function registerCoreModules() {
     { def: ai, name: makeCoreModuleName('ai') },
     { def: files, name: makeCoreModuleName('files') },
     { def: mcp, name: mcpn },
+    { def: messaging, name: makeCoreModuleName('messaging') },
   ];
 
   coreModuleInfo.forEach(({ def, name }) => {
@@ -639,6 +641,8 @@ async function internPersistentModules() {
 }
 
 export function initCoreModuleManager() {
+  initMessagingModule();
+
   const ModuleResolverName = 'agentlang/moduleResolver';
   const ModuleResolver = new GenericResolver(ModuleResolverName, {
     create: createModule,

package/src/runtime/modules/messaging.ts

@@ -0,0 +1,228 @@
+import { makeCoreModuleName } from '../util.js';
+import { Instance } from '../module.js';
+import { GenericResolver, Resolver } from '../resolvers/interface.js';
+import { registerResolver, setResolver } from '../resolvers/registry.js';
+import { logger } from '../logger.js';
+
+export const CoreMessagingModuleName = makeCoreModuleName('messaging');
+
+function getAgentManagerUrl(): string {
+  return (
+    (globalThis as any).__agentmanager_url ||
+    process.env.AGENTMANAGER_URL ||
+    'http://localhost:3001'
+  );
+}
+
+export async function pushNotification(_: Resolver, inst: Instance) {
+  const inbox = inst.lookup('inbox');
+  const subject = inst.lookup('subject');
+  const body = inst.lookup('body');
+  const fromKind = inst.lookup('fromKind') || 'employee';
+  const fromId = inst.lookup('fromId');
+
+  const url = `${getAgentManagerUrl()}/api/inboxes/${encodeURIComponent(inbox)}/messages`;
+  const payload = {
+    from: { kind: fromKind, id: fromId },
+    subject,
+    body,
+    kind: 'notification',
+  };
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      logger.error(
+        `Failed to push notification to inbox ${inbox}: HTTP ${response.status} — ${text}`
+      );
+    }
+    return inst;
+  } catch (err: any) {
+    logger.error(`Failed to push notification to inbox ${inbox}: ${err.message}`);
+    return inst;
+  }
+}
+
+export async function pushAction(_: Resolver, inst: Instance) {
+  const inbox = inst.lookup('inbox');
+  const subject = inst.lookup('subject');
+  const body = inst.lookup('body');
+  const fromKind = inst.lookup('fromKind') || 'employee';
+  const fromId = inst.lookup('fromId');
+  const responses: string[] = inst.lookup('responses') || [];
+  const continuationEvents: string[] = inst.lookup('continuationEvents') || [];
+  const inputPrompt: string | undefined = inst.lookup('inputPrompt');
+
+  // Zip responses and continuationEvents into a continuations map
+  const continuations: Record<string, { event: string }> = {};
+  for (let i = 0; i < responses.length; i++) {
+    const eventName = i < continuationEvents.length ? continuationEvents[i] : '';
+    if (eventName) {
+      continuations[responses[i]] = { event: eventName };
+    }
+  }
+
+  const url = `${getAgentManagerUrl()}/api/inboxes/${encodeURIComponent(inbox)}/messages`;
+  const payload: any = {
+    from: { kind: fromKind, id: fromId },
+    subject,
+    body,
+    kind: 'action',
+    action: {
+      responses,
+      continuations,
+      ...(inputPrompt ? { inputPrompt } : {}),
+    },
+  };
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      logger.error(`Failed to push action to inbox ${inbox}: HTTP ${response.status} — ${text}`);
+    }
+    return inst;
+  } catch (err: any) {
+    logger.error(`Failed to push action to inbox ${inbox}: ${err.message}`);
+    return inst;
+  }
+}
+
+export async function queryInbox(_: Resolver, inst: Instance, _queryAll: boolean) {
+  const inbox = inst.lookup('inbox');
+  const status: string | undefined = inst.lookup('status');
+  const kind: string | undefined = inst.lookup('kind');
+  const from: string | undefined = inst.lookup('from');
+
+  const params = new URLSearchParams();
+  if (status) params.set('status', status);
+  if (kind) params.set('kind', kind);
+  if (from) params.set('from', from);
+
+  const qs = params.toString();
+  const url = `${getAgentManagerUrl()}/api/inboxes/${encodeURIComponent(inbox)}/messages${qs ? '?' + qs : ''}`;
+
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      const text = await response.text();
+      logger.error(`Failed to query inbox ${inbox}: HTTP ${response.status} — ${text}`);
+      return [];
+    }
+    return await response.json();
+  } catch (err: any) {
+    logger.error(`Failed to query inbox ${inbox}: ${err.message}`);
+    return [];
+  }
+}
+
+export default `module ${CoreMessagingModuleName}
+
+record Notification {
+    inbox String,
+    subject String,
+    body String,
+    fromKind String @default("employee"),
+    fromId String
+}
+
+record Action {
+    inbox String,
+    subject String,
+    body String,
+    fromKind String @default("employee"),
+    fromId String,
+    responses String[],
+    continuationEvents String[] @optional,
+    inputPrompt String @optional
+}
+
+record InboxQuery {
+    inbox String,
+    status String @optional,
+    kind String @optional,
+    from String @optional
+}
+
+@public event SendNotification extends Notification {}
+workflow SendNotification {
+    {Notification {inbox SendNotification.inbox,
+                   subject SendNotification.subject,
+                   body SendNotification.body,
+                   fromKind SendNotification.fromKind,
+                   fromId SendNotification.fromId}}
+}
+
+@public event SendAction extends Action {}
+workflow SendAction {
+    {Action {inbox SendAction.inbox,
+             subject SendAction.subject,
+             body SendAction.body,
+             fromKind SendAction.fromKind,
+             fromId SendAction.fromId,
+             responses SendAction.responses,
+             continuationEvents SendAction.continuationEvents,
+             inputPrompt SendAction.inputPrompt}}
+}
+
+@public event QueryInbox extends InboxQuery {}
+workflow QueryInbox {
+    {InboxQuery {inbox? QueryInbox.inbox,
+                 status? QueryInbox.status,
+                 kind? QueryInbox.kind,
+                 from? QueryInbox.from}}
+}
+`;
+
+export function initMessagingModule() {
+  const resolverName = 'agentlang.messaging/messagingResolver';
+  const resolver = new GenericResolver(resolverName, {
+    create: pushNotification,
+    upsert: undefined,
+    update: undefined,
+    query: queryInbox,
+    delete: undefined,
+    startTransaction: undefined,
+    commitTransaction: undefined,
+    rollbackTransaction: undefined,
+  });
+  registerResolver(resolverName, () => resolver);
+  setResolver('agentlang.messaging/Notification', resolverName);
+
+  const actionResolverName = 'agentlang.messaging/actionResolver';
+  const actionResolver = new GenericResolver(actionResolverName, {
+    create: pushAction,
+    upsert: undefined,
+    update: undefined,
+    query: undefined,
+    delete: undefined,
+    startTransaction: undefined,
+    commitTransaction: undefined,
+    rollbackTransaction: undefined,
+  });
+  registerResolver(actionResolverName, () => actionResolver);
+  setResolver('agentlang.messaging/Action', actionResolverName);
+
+  const queryResolverName = 'agentlang.messaging/queryResolver';
+  const queryResolver = new GenericResolver(queryResolverName, {
+    create: undefined,
+    upsert: undefined,
+    update: undefined,
+    query: queryInbox,
+    delete: undefined,
+    startTransaction: undefined,
+    commitTransaction: undefined,
+    rollbackTransaction: undefined,
+  });
+  registerResolver(queryResolverName, () => queryResolver);
+  setResolver('agentlang.messaging/InboxQuery', queryResolverName);
+}

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;

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

@@ -46,8 +46,6 @@ import { saveMigration } from '../../modules/core.js';
 import { getAppSpec } from '../../loader.js';
 import { WhereClause } from '../interface.js';
 import { AppConfig } from '../../state.js';
-import { createLanceDBStore } from '../vector/lancedb-store.js';
-import type { VectorStore } from '../vector/types.js';
 
 export let defaultDataSource: DataSource | undefined;
 
@@ -60,8 +58,57 @@ function isBrowser(): boolean {
   );
 }
 
-// LanceDB vector store cache - keyed by module name
-const lanceDBStores: Map<string, VectorStore> = new Map();
+// SQLite WASM with built-in sqlite-vec for browsers
+// Loaded from CDN - this has sqlite-vec statically compiled in
+let sqliteVecWasmModule: any = null;
+
+async function loadSqliteVecWasm(): Promise<any> {
+  if (sqliteVecWasmModule) {
+    return sqliteVecWasmModule;
+  }
+
+  try {
+    // Use dynamic import with string to prevent bundlers from analyzing
+    const cdnUrl = 'https://cdn.jsdelivr.net/npm/sqlite-vec-wasm-demo@latest/sqlite3.mjs';
+    const module = await import(/* @vite-ignore */ cdnUrl);
+    sqliteVecWasmModule = await module.default();
+    return sqliteVecWasmModule;
+  } catch (err) {
+    logger.warn('Failed to load sqlite-vec WASM:', err);
+    return null;
+  }
+}
+
+// Helper to load sqlite-vec based on environment
+async function loadSqliteVec(): Promise<any> {
+  // In browser, use WASM version with built-in sqlite-vec
+  // In Node.js, use the npm package
+  if (isBrowser()) {
+    const wasmModule = await loadSqliteVecWasm();
+    if (wasmModule) {
+      // WASM version has sqlite-vec built-in, no need to call load()
+      // Return a compatible interface
+      return {
+        load: () => {
+          // No-op: sqlite-vec is already loaded in WASM version
+          logger.info('sqlite-vec WASM loaded (built-in)');
+        },
+        // Expose the WASM module for direct use if needed
+        _wasmModule: wasmModule,
+      };
+    }
+    return null;
+  }
+
+  // Node.js: use npm package
+  try {
+    // Use variable to prevent bundlers from statically analyzing this import
+    const moduleName = 'sqlite-vec';
+    return await import(/* @vite-ignore */ moduleName);
+  } catch {
+    return null;
+  }
+}
 
 export class DbContext {
   txnId: string | undefined;
@@ -259,27 +306,17 @@ function makeSqliteDataSource(
   ds.initialize = async () => {
     const res = await originalInit();
     try {
+      const sqliteVec = await loadSqliteVec();
       const driver = ds.driver as any;
       const db = driver.databaseConnection || driver.nativeDatabase;
-      // Enable WAL mode and additional pragmas for better write performance
-      if (db?.pragma) {
-        db.pragma('journal_mode = WAL');
-
-        const syncMode = process.env.SQLITE_SYNC_MODE || 'NORMAL';
-        const busyTimeout = process.env.SQLITE_BUSY_TIMEOUT || '5000';
-        const cacheSize = process.env.SQLITE_CACHE_SIZE || '-20000';
-
-        db.pragma(`synchronous = ${syncMode}`);
-        db.pragma(`busy_timeout = ${busyTimeout}`);
-        db.pragma(`cache_size = ${cacheSize}`);
-        db.pragma('temp_store = MEMORY');
-
-        logger.info(
-          `SQLite pragmas enabled: WAL mode, synchronous=${syncMode}, busy_timeout=${busyTimeout}, cache_size=${cacheSize}, temp_store=MEMORY`
-        );
+      if (db && sqliteVec?.load) {
+        sqliteVec.load(db);
+        logger.info('sqlite-vec extension loaded successfully');
       }
     } catch (err: any) {
-      logger.warn(`Failed to enable SQLite pragmas: ${err.message}.`);
+      logger.warn(
+        `Failed to load sqlite-vec extension: ${err.message}. Vector operations may not be available.`
+      );
     }
     return res;
   };
@@ -375,20 +412,6 @@ function forceGetDbType(config: DatabaseConfig | undefined): string {
 
 let DbType: string | undefined;
 
-function getVectorStoreType(): string {
-  // Check explicit vectorStore config first
-  const vectorStoreConfig = AppConfig?.vectorStore;
-  if (vectorStoreConfig?.type) {
-    if (vectorStoreConfig.type === 'pgvector') return 'postgres';
-    if (vectorStoreConfig.type === 'lancedb') return 'lancedb';
-  }
-
-  // Fallback to main store type
-  const dbType = getDbType(AppConfig?.store);
-  if (dbType === 'postgres') return 'postgres';
-  return 'lancedb';
-}
-
 function getDbType(config: DatabaseConfig | undefined): string {
   if (DbType === undefined) DbType = forceGetDbType(config);
   return DbType;
@@ -422,9 +445,12 @@ export function isUsingSqljs(): boolean {
 }
 
 export async function isVectorStoreSupported(): Promise<boolean> {
-  const vectorStoreType = getVectorStoreType();
-  if (vectorStoreType === 'postgres') return true;
-  if (vectorStoreType === 'lancedb') return true;
+  const dbType = getDbType(AppConfig?.store);
+  if (dbType === 'postgres') return true;
+  if (dbType === 'sqlite') {
+    const sqliteVecModule = await loadSqliteVec();
+    return !!sqliteVecModule;
+  }
   return false;
 }
 
@@ -483,14 +509,9 @@ async function insertRowsHelper(
   ctx: DbContext,
   doUpsert: boolean
 ): Promise<void> {
-  const ds = getDatasourceForTransaction(ctx.txnId);
-  const repo = ds.getRepository(tableName);
-
-  if (doUpsert) {
-    await repo.save(rows);
-  } else {
-    await repo.insert(rows);
-  }
+  const repo = getDatasourceForTransaction(ctx.txnId).getRepository(tableName);
+  if (doUpsert) await repo.save(rows);
+  else await repo.insert(rows);
 }
 
 export async function addRowForFullTextSearch(
@@ -499,45 +520,28 @@ export async function addRowForFullTextSearch(
   vect: number[],
   ctx: DbContext
 ) {
-  if (!(await isVectorStoreSupported())) {
-    logger.warn(`[VECTOR] Vector store not supported, skipping save for ${id}`);
-    return;
-  }
+  if (!(await isVectorStoreSupported())) return;
   try {
     const vecTableName = tableName + VectorSuffix;
-    logger.info(
-      `[VECTOR] Saving embedding to ${vecTableName} for ${id} (${vect.length} dimensions)`
-    );
-    const dbType = getVectorStoreType();
+    const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
     const tenantId = await ctx.getTenantId();
-
-    if (dbType === 'lancedb') {
-      let store = lanceDBStores.get(tableName);
-      if (!store) {
-        store = createLanceDBStore({
-          moduleName: tableName,
-          vectorDimension: vect.length,
-        });
-        await store.init();
-        lanceDBStores.set(tableName, store);
-      }
-      await store.addEmbedding({
-        id,
-        embedding: Array.from(vect),
-        tenantId,
-      });
-    } else if (dbType === 'postgres') {
-      const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
+    const dbType = getDbType(AppConfig?.store);
+    if (dbType === 'postgres') {
       const { default: pgvector } = await import('pgvector');
       await qb
         .insert()
         .into(vecTableName)
-        .values([{ id: id, embedding: pgvector.toSql(vect), agentId: tenantId }])
+        .values([{ id: id, embedding: pgvector.toSql(vect), __tenant__: tenantId }])
+        .execute();
+    } else {
+      await qb
+        .insert()
+        .into(vecTableName)
+        .values([{ id: id, embedding: new Float32Array(vect) }])
         .execute();
     }
-    logger.info(`[VECTOR] Successfully saved embedding to ${vecTableName} for ${id}`);
   } catch (err: any) {
-    logger.error(`[VECTOR] Failed to add row to vector store - ${err}`);
+    logger.error(`Failed to add row to vector store - ${err}`);
   }
 }
 
@@ -546,21 +550,11 @@ export async function initVectorStore(tableNames: string[], ctx: DbContext) {
     logger.info(`Vector store not supported for ${getDbType(AppConfig?.store)}, skipping init...`);
     return;
   }
-  const dbType = getVectorStoreType();
+  const dbType = getDbType(AppConfig?.store);
   let notInited = true;
   for (const vecTableName of tableNames) {
-    if (dbType === 'lancedb') {
-      if (!lanceDBStores.has(vecTableName)) {
-        const store = createLanceDBStore({
-          moduleName: vecTableName,
-          vectorDimension: DefaultVectorDimension,
-        });
-        await store.init();
-        lanceDBStores.set(vecTableName, store);
-        logger.info(`[VECTOR] Initialized LanceDB store for ${vecTableName}`);
-      }
-    } else if (dbType === 'postgres') {
-      const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
+    const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
+    if (dbType === 'postgres') {
       if (notInited) {
         let failure = false;
         try {
@@ -574,11 +568,18 @@ export async function initVectorStore(tableNames: string[], ctx: DbContext) {
       }
       await vecRepo.query(
         `CREATE TABLE IF NOT EXISTS ${vecTableName} (
-          id varchar PRIMARY KEY,
-          embedding vector(${DefaultVectorDimension}),
-          ${TenantAttributeName} varchar,
-          __is_deleted__ boolean default false
-        )`
+            id varchar PRIMARY KEY,
+            embedding vector(${DefaultVectorDimension}),
+            ${TenantAttributeName} varchar,
+            __is_deleted__ boolean default false
+          )`
+      );
+    } else {
+      // sqlite-vec - vec0 doesn't support type declarations for metadata columns
+      await vecRepo.query(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${vecTableName} USING vec0(
+            id TEXT PRIMARY KEY,
+            embedding FLOAT[${DefaultVectorDimension}])`
       );
     }
   }
@@ -595,21 +596,6 @@ export async function vectorStoreSearch(
     return [];
   }
   try {
-    const dbType = getVectorStoreType();
-    const tenantId = await ctx.getTenantId();
-
-    if (dbType === 'lancedb') {
-      const store = lanceDBStores.get(tableName);
-      if (!store) {
-        logger.warn(`[VECTOR] LanceDB store not found for ${tableName}`);
-        return [];
-      }
-      // Extract agentId from resourceFqName for agent-level filtering
-      const agentId = ctx.resourceFqName || undefined;
-      const results = await store.search(searchVec, tenantId, agentId, limit);
-      return results.map(r => ({ id: r.id }));
-    }
-
     let hasGlobalPerms = ctx.isPermitted();
     if (!hasGlobalPerms) {
       const userId = ctx.getUserId();
@@ -619,6 +605,8 @@ export async function vectorStoreSearch(
     }
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
+    const dbType = getDbType(AppConfig?.store);
+    const tenantId = await ctx.getTenantId();
     let ownersJoinCond: string = '';
     if (!hasGlobalPerms) {
       const ot = ownersTable(tableName);
@@ -631,6 +619,16 @@ export async function vectorStoreSearch(
       const sql = `select ${vecTableName}.id from ${vecTableName} ${ownersJoinCond} order by embedding <-> $1 LIMIT ${limit}`;
       const args = pgvector.toSql(searchVec);
       return await qb.query(sql, [args]);
+    } else {
+      // sqlite-vec - join with main table to filter by tenant
+      const alias = tableName.toLowerCase();
+      const sql = `SELECT ${vecTableName}.id FROM ${vecTableName}
+        INNER JOIN ${tableName} ${alias} ON ${alias}.${PathAttributeName} = ${vecTableName}.id
+        ${ownersJoinCond}
+        WHERE ${alias}.${TenantAttributeName} = '${tenantId}' AND ${alias}.${DeletedFlagAttributeName} = false AND ${vecTableName}.embedding MATCH $1
+        LIMIT ${limit}`;
+      const args = new Float32Array(searchVec);
+      return await qb.query(sql, [args]);
     }
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
@@ -645,19 +643,9 @@ export async function vectorStoreSearchEntryExists(
 ): Promise<boolean> {
   if (!(await isVectorStoreSupported())) return false;
   try {
-    const dbType = getVectorStoreType();
-
-    if (dbType === 'lancedb') {
-      const store = lanceDBStores.get(tableName);
-      if (!store) {
-        logger.warn(`[VECTOR] LanceDB store not found for ${tableName}`);
-        return false;
-      }
-      return await store.exists(id);
-    }
-
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
 
     if (dbType === 'postgres') {
@@ -666,6 +654,16 @@ export async function vectorStoreSearchEntryExists(
         [id]
       );
       return result !== null && result.length > 0;
+    } else {
+      // sqlite-vec - join with main table to verify tenant
+      const alias = tableName.toLowerCase();
+      const result: any[] = await qb.query(
+        `SELECT ${vecTableName}.id FROM ${vecTableName}
+         INNER JOIN ${tableName} ${alias} ON ${alias}.${PathAttributeName} = ${vecTableName}.id
+         WHERE ${vecTableName}.id = $1 AND ${alias}.${TenantAttributeName} = '${tenantId}'`,
+        [id]
+      );
+      return result !== null && result.length > 0;
     }
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
@@ -676,20 +674,9 @@ export async function vectorStoreSearchEntryExists(
 export async function deleteFullTextSearchEntry(tableName: string, id: string, ctx: DbContext) {
   if (!(await isVectorStoreSupported())) return;
   try {
-    const dbType = getVectorStoreType();
-
-    if (dbType === 'lancedb') {
-      const store = lanceDBStores.get(tableName);
-      if (!store) {
-        logger.warn(`[VECTOR] LanceDB store not found for ${tableName}`);
-        return;
-      }
-      await store.delete(id);
-      return;
-    }
-
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
 
     if (dbType === 'postgres') {
@@ -697,6 +684,9 @@ export async function deleteFullTextSearchEntry(tableName: string, id: string, c
         `delete from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
         [id]
       );
+    } else {
+      // sqlite-vec - delete just by id (ownership verified by caller)
+      await qb.query(`delete from ${vecTableName} where id = $1`, [id]);
     }
   } catch (err: any) {
     logger.error(`Vector store delete failed - ${err}`);
@@ -872,7 +862,7 @@ async function createLimitedOwnership(
       r: perms.has(RbacPermissionFlag.READ),
       d: perms.has(RbacPermissionFlag.DELETE),
       u: perms.has(RbacPermissionFlag.UPDATE),
-      agentId: tenantId,
+      __tenant__: tenantId,
     });
   });
   const tname = ownersTable(tableName);
@@ -1374,16 +1364,14 @@ async function endTransaction(txnId: string, commit: boolean): Promise<void> {
   const qr: QueryRunner | undefined = transactionsDb.get(txnId);
   if (qr && qr.isTransactionActive) {
     try {
-      if (commit) {
-        await qr.commitTransaction();
-      } else {
-        await qr.rollbackTransaction();
-      }
-    } catch (err: any) {
-      logger.error(
-        `Failed to ${commit ? 'commit' : 'rollback'} transaction ${txnId}: ${err.message}`
-      );
-      throw err;
+      if (commit)
+        await qr.commitTransaction().catch((reason: any) => {
+          logger.error(`failed to commit transaction ${txnId} - ${reason}`);
+        });
+      else
+        await qr.rollbackTransaction().catch((reason: any) => {
+          logger.error(`failed to rollback transaction ${txnId} - ${reason}`);
+        });
     } finally {
       await qr.release();
       transactionsDb.delete(txnId);