@utaba/deep-memory 0.15.0 → 0.16.0

package/dist/index.cjs

@@ -894,10 +894,15 @@ var EntityManager = class {
         attempt++;
         if (attempt > maxRetries) {
           const errorMsg = err instanceof Error ? err.message : String(err);
+          const failureMessage = `embedBatch failed after ${maxRetries} retries: ${errorMsg}`;
+          const failed = entries.map(([id]) => ({ entityId: id, error: failureMessage }));
+          for (const { entityId, error } of failed) {
+            await options?.onItemFailed?.(entityId, error);
+          }
           return {
             processed: 0,
             failed: entries.length,
-            errors: entries.map(([id]) => ({ entityId: id, error: `embedBatch failed after ${maxRetries} retries: ${errorMsg}` })),
+            errors: failed,
             modelId: this.embedding.modelId(),
             dimensions: this.embedding.dimensions()
           };
@@ -920,7 +925,9 @@ var EntityManager = class {
         });
         processed++;
       } catch (err) {
-        errors.push({ entityId: id, error: err instanceof Error ? err.message : String(err) });
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        errors.push({ entityId: id, error: errorMessage });
+        await options?.onItemFailed?.(id, errorMessage);
       }
     }
     return {
@@ -963,7 +970,8 @@ var EntityManager = class {
       if (page.items.length === 0) break;
       const ids = page.items.map((e) => e.id);
       const result = await this.reembedEntities(ids, {
-        maxRetries: options?.maxRetries
+        maxRetries: options?.maxRetries,
+        onItemFailed: options?.onItemFailed
       });
       totalProcessed += result.processed;
       totalFailed += result.failed;
@@ -2392,6 +2400,9 @@ var MemoryRepository = class {
       signal: options?.signal,
       onProgress: async (processed, total, failed) => {
         await options?.onProgress?.({ processed, totalEntities: total, failed });
+      },
+      onItemFailed: async (entityId, error) => {
+        await options?.onItemFailed?.({ entityId, error });
       }
     });
     await this.storage.updateRepository(this.repositoryId, {
@@ -3514,7 +3525,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.15.0" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.16.0" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -3868,12 +3879,14 @@ var RepositoryImporter = class {
   storage;
   actorId;
   onProgress;
+  onItemFailed;
   signal;
   migrationEngine = new MigrationEngine();
   constructor(config) {
     this.storage = config.storage;
     this.actorId = config.actorId;
     this.onProgress = config.onProgress;
+    this.onItemFailed = config.onItemFailed;
     this.signal = config.signal;
   }
   throwIfAborted() {
@@ -3970,6 +3983,8 @@ var RepositoryImporter = class {
           message: `Failed to import ${e.item}: ${e.error}`,
           id: e.item
         });
+        const itemType = chunk.entities?.some((x) => x.id === e.item) ? "entity" : chunk.relationships?.some((x) => x.id === e.item) ? "relationship" : "entity";
+        await this.onItemFailed?.({ itemId: e.item, itemType, error: e.error });
       }
       await this.onProgress?.({
         repositoryId: target.repositoryId,
@@ -4106,11 +4121,13 @@ var RepositoryImporter = class {
             const targetExists = await this.storage.getEntity(repositoryId, rel.targetEntityId);
             if (!sourceExists || !targetExists) {
               relationshipsSkipped++;
+              const errorMsg = `source or target entity missing`;
               warnings.push({
                 code: "relationship_orphaned",
-                message: `Relationship "${rel.id}" skipped \u2014 source or target entity missing`,
+                message: `Relationship "${rel.id}" skipped \u2014 ${errorMsg}`,
                 relationshipId: rel.id
               });
+              await this.onItemFailed?.({ itemId: rel.id, itemType: "relationship", error: errorMsg });
             } else {
               try {
                 await this.storage.createRelationship(repositoryId, rel);
@@ -4457,6 +4474,12 @@ var DeepMemory = class {
       storage: this.storage,
       actorId: this.provenance.getContext().actorId,
       onProgress: (progress) => this.globalEventBus.emit("import:progress", progress),
+      onItemFailed: (failure) => this.globalEventBus.emit("import:item-failed", {
+        repositoryId: options.target.repositoryId,
+        itemId: failure.itemId,
+        itemType: failure.itemType,
+        error: failure.error
+      }),
       signal: options.signal
     });
     try {
@@ -4550,6 +4573,12 @@ var DeepMemory = class {
       storage: this.storage,
       actorId: this.provenance.getContext().actorId,
       onProgress: (progress) => this.globalEventBus.emit("import:progress", progress),
+      onItemFailed: (failure) => this.globalEventBus.emit("import:item-failed", {
+        repositoryId: options.target.repositoryId,
+        itemId: failure.itemId,
+        itemType: failure.itemType,
+        error: failure.error
+      }),
       signal: options.signal
     });
     await this.globalEventBus.emit("import:started", { repositoryId: options.target.repositoryId });
@@ -4604,6 +4633,11 @@ var DeepMemory = class {
           processed: progress.processed,
           totalEntities: progress.totalEntities,
           failed: progress.failed
+        }),
+        onItemFailed: (failure) => this.globalEventBus.emit("reembed:item-failed", {
+          repositoryId,
+          entityId: failure.entityId,
+          error: failure.error
         })
       });
       await this.globalEventBus.emit("reembed:completed", {