@remnic/core 9.28.0 → 9.29.1

package/dist/{chunk-TKBDJTXG.js → chunk-GBJ4RDFR.js}

@@ -21,7 +21,10 @@ import {
 } from "./chunk-WLZYGLJ4.js";
 import {
   LocalLlmClient
-} from "./chunk-P2OZKKYP.js";
+} from "./chunk-PHWUFPCO.js";
+import {
+  applyExtractionSourceGrounding
+} from "./chunk-RPW2NOU6.js";
 import {
   classifyExtractionThrownError,
   classifyFallbackParseFailure
@@ -33,7 +36,7 @@ import {
   buildExtensionsFooterForSummary,
   formatDaySummaryMemories,
   loadDaySummaryPrompt
-} from "./chunk-FCCMFVS6.js";
+} from "./chunk-RPSYDM6C.js";
 import {
   applyWorkExtractionBoundary
 } from "./chunk-EI6V5UXY.js";
@@ -69,7 +72,7 @@ import {
   resolveMemoryLifecycleCapabilities,
   resolvePipelineProcessingCapabilities,
   resolveRecallAuxiliaryCapabilities
-} from "./chunk-RDQGLJRR.js";
+} from "./chunk-2XRE6FLM.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -471,7 +474,7 @@ var ExtractionEngine = class {
     const entityUpdates = (Array.isArray(result.entityUpdates) ? result.entityUpdates : []).map((entity) => this.normalizeEntityUpdate(entity)).filter((entity) => entity !== void 0 && entity.name.length > 0);
     return { items, profileUpdates, entityUpdates };
   }
-  async applyProactiveQuestionPass(conversation, base) {
+  async applyProactiveQuestionPass(conversation, base, groundingSource, assertionSource, messageTimestamp, roleAssertionSources) {
     if (!resolvePipelineProcessingCapabilities(this.config).proactiveExtraction) return base;
     const maxAdditional = Math.max(0, Math.floor(this.config.maxProactiveQuestionsPerExtraction));
     if (!shouldRunProactivePass(this.config, maxAdditional, this.shouldUseLocalLlm, this.localLlm)) return base;
@@ -484,8 +487,16 @@ var ExtractionEngine = class {
         proactive,
         maxAdditional
       );
-      if (!this.hasExtractionOutputs(proactiveAdditions)) return base;
-      return this.mergeProactiveExtractionPass(base, proactiveAdditions, maxAdditional);
+      const sanitizedAdditions = this.sanitizeExtractionResult(proactiveAdditions, messageTimestamp);
+      const groundedAdditions = this.applySourceGrounding(
+        sanitizedAdditions,
+        groundingSource,
+        assertionSource,
+        roleAssertionSources,
+        messageTimestamp
+      );
+      if (!this.hasExtractionOutputs(groundedAdditions)) return base;
+      return this.mergeProactiveExtractionPass(base, groundedAdditions, maxAdditional);
     } catch (err) {
       log.debug(`proactive extraction question pass failed (ignored): ${err}`);
       return base;
@@ -641,7 +652,7 @@ var ExtractionEngine = class {
         if (localResponse?.content) {
           const parsed = this.parseProactiveExtractionResultFromText(localResponse.content.trim());
           if (parsed) {
-            return this.sanitizeExtractionResult(parsed);
+            return parsed;
           }
         }
         if (!this.config.localLlmFallback) {
@@ -671,12 +682,10 @@ var ExtractionEngine = class {
     if (!fallbackResult) {
       return { facts: [], profileUpdates: [], entities: [], questions: [] };
     }
-    return this.sanitizeExtractionResult(
-      this.normalizeExtractionResultPayload({
-        ...fallbackResult,
-        questions: []
-      })
-    );
+    return this.normalizeExtractionResultPayload({
+      ...fallbackResult,
+      questions: []
+    });
   }
   mergeProactiveExtractionPass(base, proactive, maxAdditional) {
     const allowlist = this.config.proactiveExtractionCategoryAllowlist;
@@ -857,6 +866,23 @@ var ExtractionEngine = class {
     });
     return { ...result, facts };
   }
+  applySourceGrounding(result, sourceText, assertionSourceText = sourceText, roleAssertionSources, messageTimestamp) {
+    const capabilities = resolvePipelineProcessingCapabilities(this.config);
+    return applyExtractionSourceGrounding(
+      result,
+      sourceText,
+      assertionSourceText,
+      roleAssertionSources,
+      messageTimestamp,
+      {
+        sourceGrounding: capabilities.sourceGrounding,
+        anchorTemporalExpressions: capabilities.delinearize
+      }
+    );
+  }
+  finalizeExtractionResult(result, turns) {
+    return this.attachProvenanceToResult(result, turns);
+  }
   async extract(turns, existingEntities) {
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
     const substantiveTurns = turns.filter((t) => t.content.trim().length > 0);
@@ -872,6 +898,12 @@ var ExtractionEngine = class {
       const roleLabel = t.extractionContextOnly === true ? `context ${t.role}` : t.role;
       return `[${roleLabel}] ${t.content}`;
     }).join("\n\n");
+    const groundingSource = boundedTurns.map((turn) => turn.content).join("\n\n");
+    const assertionSource = boundedTurns.filter((turn) => turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n");
+    const roleAssertionSources = {
+      profile: boundedTurns.filter((turn) => turn.role === "user" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n"),
+      identity: boundedTurns.filter((turn) => turn.role === "assistant" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n")
+    };
     if (conversation.trim().length === 0) {
       log.debug("extraction skipped \u2014 conversation only contained non-memory work-layer context");
       return { facts: [], profileUpdates: [], entities: [], questions: [] };
@@ -912,8 +944,22 @@ var ExtractionEngine = class {
             this.emit({ kind: "llm_end", traceId, model: this.config.localLlmModel, operation: "extraction", durationMs });
             log.debug(`extraction: used local LLM \u2014 ${localResult.facts.length} facts, ${localResult.entities.length} entities`);
             const sanitized = this.sanitizeExtractionResult(localResult, messageTimestamp);
-            const finalResult = await this.applyProactiveQuestionPass(conversation, sanitized);
-            return this.attachProvenanceToResult(finalResult, boundedTurns);
+            const grounded = this.applySourceGrounding(
+              sanitized,
+              groundingSource,
+              assertionSource,
+              roleAssertionSources,
+              messageTimestamp
+            );
+            const finalResult = await this.applyProactiveQuestionPass(
+              conversation,
+              grounded,
+              groundingSource,
+              assertionSource,
+              messageTimestamp,
+              roleAssertionSources
+            );
+            return this.finalizeExtractionResult(finalResult, boundedTurns);
           }
           if (!this.config.localLlmFallback) {
             log.warn("extraction: local LLM failed and fallback disabled");
@@ -958,8 +1004,22 @@ var ExtractionEngine = class {
             this.emit({ kind: "llm_end", traceId, model: this.config.model, operation: "extraction", durationMs });
             log.debug(`extraction: used direct client (${this.config.model}) \u2014 ${directResult.facts.length} facts, ${directResult.entities.length} entities`);
             const sanitized = this.sanitizeExtractionResult(directResult, messageTimestamp);
-            const finalResult = await this.applyProactiveQuestionPass(conversation, sanitized);
-            return this.attachProvenanceToResult(finalResult, boundedTurns);
+            const grounded = this.applySourceGrounding(
+              sanitized,
+              groundingSource,
+              assertionSource,
+              roleAssertionSources,
+              messageTimestamp
+            );
+            const finalResult = await this.applyProactiveQuestionPass(
+              conversation,
+              grounded,
+              groundingSource,
+              assertionSource,
+              messageTimestamp,
+              roleAssertionSources
+            );
+            return this.finalizeExtractionResult(finalResult, boundedTurns);
           }
           try {
             this.emit({
@@ -1049,8 +1109,22 @@ var ExtractionEngine = class {
           );
           const normalized = this.normalizeExtractionResultPayload(result);
           const sanitized = this.sanitizeExtractionResult(normalized, messageTimestamp);
-          const finalResult = await this.applyProactiveQuestionPass(conversation, sanitized);
-          return this.attachProvenanceToResult(finalResult, boundedTurns);
+          const grounded = this.applySourceGrounding(
+            sanitized,
+            groundingSource,
+            assertionSource,
+            roleAssertionSources,
+            messageTimestamp
+          );
+          const finalResult = await this.applyProactiveQuestionPass(
+            conversation,
+            grounded,
+            groundingSource,
+            assertionSource,
+            messageTimestamp,
+            roleAssertionSources
+          );
+          return this.finalizeExtractionResult(finalResult, boundedTurns);
         }
         this.emit({
           kind: "llm_error",
@@ -2433,4 +2507,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-TKBDJTXG.js.map
+//# sourceMappingURL=chunk-GBJ4RDFR.js.map