@memberjunction/ai-vector-dupe 5.42.0 → 5.44.0

package/dist/reasoning/DuplicateReasoningTypes.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Shared contract types for the duplicate-detection reasoning seam.
+ *
+ * These types are the pluggable boundary between the {@link DuplicateRecordDetector}
+ * pipeline and whichever {@link DuplicateReasoningProvider} (Prompt or Agent) actually
+ * reasons over a matched set. The input is a structural description of the entity plus
+ * the field-level deltas for one source record's candidate set; the output is a single
+ * structured verdict for that set. Both shipped providers emit the identical contract so
+ * promoting an entity from `Prompt` to `Agent` mode is a config change, not a rewrite.
+ *
+ * @module @memberjunction/ai-vector-dupe
+ */
+import { UserInfo, IMetadataProvider } from '@memberjunction/core';
+import { MJEntityDocumentEntity } from '@memberjunction/core-entities';
+/** One record's value for a single differing field, addressed by record id. */
+export interface ReasoningFieldValue {
+    /** The candidate/source record id (URL-segment composite key) this value belongs to. */
+    RecordID: string;
+    /** The field value held by that record (already stringified for the prompt; null when empty). */
+    Value: string | null;
+}
+/**
+ * The per-field delta passed to the reasoner. Only fields that differ across the set are
+ * included — identical fields are omitted so the reasoner focuses on what matters.
+ */
+export interface ReasoningFieldDelta {
+    /** The field name. */
+    FieldName: string;
+    /** Per-record values for this field. */
+    Values: ReasoningFieldValue[];
+}
+/** Description of the source record (the current default survivor) being reasoned over. */
+export interface ReasoningSourceRecord {
+    /** The source record id (URL-segment composite key). */
+    RecordID: string;
+    /** Human-readable label (name-field value, falling back to the key). */
+    Label: string;
+    /** Provenance hint (e.g. "Local"); free-form, surfaced in the instructions. */
+    Provenance: string;
+    /** Approximate count of dependent records, for the "cheapest to retain" heuristic. */
+    DependentCount: number;
+}
+/** Description of one vector-surfaced candidate match. */
+export interface ReasoningCandidate {
+    /** The candidate record id (URL-segment composite key). */
+    RecordID: string;
+    /** Human-readable label. */
+    Label: string;
+    /** The raw vector similarity score (0–1) that surfaced this candidate. */
+    VectorScore: number;
+    /** Provenance hint. */
+    Provenance: string;
+    /** Approximate dependent-record count. */
+    DependentCount: number;
+}
+/**
+ * The complete input to a single reasoning call — one source record's matched set.
+ * This is assembled once per set by the detector (after all filtering) and is identical
+ * regardless of which provider runs.
+ */
+export interface DuplicateReasoningInput {
+    /** Registered entity name (e.g. "Accounts"). */
+    EntityName: string;
+    /** Optional entity description for context. */
+    EntityDescription: string | null;
+    /** The entity document driving this run (carries the reasoning prompt/agent ids + mode). */
+    EntityDocument: MJEntityDocumentEntity;
+    /** The source record under review. */
+    SourceRecord: ReasoningSourceRecord;
+    /** The candidate matches for the source record. */
+    Candidates: ReasoningCandidate[];
+    /** The field-level deltas across the whole set (differing fields only). */
+    FieldDeltas: ReasoningFieldDelta[];
+}
+/** The recommendation verdict. */
+export type DuplicateReasoningRecommendation = 'Merge' | 'NotDuplicate' | 'Uncertain';
+/**
+ * The reasoner's verdict for ONE candidate, judged independently against the source. A matched
+ * set can mix true duplicates and false positives (vector search returns the top-K neighbors),
+ * so each candidate gets its own recommendation/confidence/reasoning — the detector stamps the
+ * per-candidate verdict onto that candidate's match row, never a blanket set-level verdict.
+ */
+export interface DuplicateReasoningCandidateVerdict {
+    /** The candidate record id (must match one of the input candidates' RecordID). */
+    RecordID: string;
+    /** This candidate's verdict vs. the source record. */
+    Recommendation: DuplicateReasoningRecommendation;
+    /** This candidate's confidence (0–1), or null when the reasoner didn't return one. */
+    Confidence: number | null;
+    /** Short rationale specific to THIS candidate. */
+    Reasoning: string;
+}
+/**
+ * One per-field survivor choice from the reasoner: keep this field's value from the
+ * record identified by {@link SourceRecordID}. Resolved to a literal `{FieldName, Value}`
+ * for `Metadata.MergeRecords` at merge time.
+ */
+export interface DuplicateReasoningFieldChoice {
+    /** The field whose surviving value is being chosen. */
+    FieldName: string;
+    /** The record id whose value should be kept for this field. */
+    SourceRecordID: string;
+}
+/**
+ * The structured verdict for a matched set. Persisted onto each match row's LLM* columns
+ * along with the run id of whichever provider ran.
+ */
+export interface DuplicateReasoningOutput {
+    /** Whether the reasoning call itself succeeded (not whether it recommended a merge). */
+    Success: boolean;
+    /** Populated when {@link Success} is false. */
+    ErrorMessage?: string;
+    /**
+     * The overall verdict for the set, **derived** from the per-candidate verdicts (Merge if any
+     * candidate is a Merge, else Uncertain if any is Uncertain, else NotDuplicate). Used for the
+     * group's dominant display and the auto-merge gate — NOT stamped on individual candidate rows.
+     */
+    Recommendation: DuplicateReasoningRecommendation;
+    /**
+     * Overall confidence (0–1), derived from the per-candidate verdicts. `null` means no candidate
+     * returned a usable confidence — callers must distinguish this from a real `0` (which reads as
+     * "confidently NOT a duplicate") and render/store it as "unknown".
+     */
+    Confidence: number | null;
+    /** Overall human-readable summary of the set decision. */
+    Reasoning: string;
+    /**
+     * Per-candidate verdicts — the authoritative, row-level result. Each entry is judged
+     * independently against the source so a false-positive candidate reads NotDuplicate even when
+     * another candidate in the same set is a confident Merge.
+     */
+    CandidateVerdicts: DuplicateReasoningCandidateVerdict[];
+    /** The record id the reasoner proposes should survive (null when NotDuplicate). */
+    SurvivorRecordID: string | null;
+    /** Per-field survivor choices (only fields whose value comes from a non-survivor). */
+    FieldChoices: DuplicateReasoningFieldChoice[];
+    /**
+     * The AI Prompt Run id, when a {@link DuplicateReasoningProvider} ran via a single-shot
+     * prompt. Mutually exclusive with {@link AIAgentRunID}.
+     */
+    AIPromptRunID?: string | null;
+    /**
+     * The AI Agent Run id, when a {@link DuplicateReasoningProvider} ran via an agent.
+     * Mutually exclusive with {@link AIPromptRunID}.
+     */
+    AIAgentRunID?: string | null;
+}
+/**
+ * Per-call context threaded from the detector into the reasoning provider so the provider
+ * runs on the same request-scoped provider/user as the rest of the pipeline (multi-provider
+ * safety) rather than reaching for the global default.
+ */
+export interface DuplicateReasoningContext {
+    /** The request-scoped metadata provider (server-side). */
+    Provider?: IMetadataProvider;
+    /** The context user for the run. */
+    ContextUser?: UserInfo;
+}
+//# sourceMappingURL=DuplicateReasoningTypes.d.ts.map

package/dist/reasoning/DuplicateReasoningTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DuplicateReasoningTypes.d.ts","sourceRoot":"","sources":["../../src/reasoning/DuplicateReasoningTypes.ts"],"names":[],"mappings":"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"}

package/dist/reasoning/DuplicateReasoningTypes.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Shared contract types for the duplicate-detection reasoning seam.
+ *
+ * These types are the pluggable boundary between the {@link DuplicateRecordDetector}
+ * pipeline and whichever {@link DuplicateReasoningProvider} (Prompt or Agent) actually
+ * reasons over a matched set. The input is a structural description of the entity plus
+ * the field-level deltas for one source record's candidate set; the output is a single
+ * structured verdict for that set. Both shipped providers emit the identical contract so
+ * promoting an entity from `Prompt` to `Agent` mode is a config change, not a rewrite.
+ *
+ * @module @memberjunction/ai-vector-dupe
+ */
+export {};
+//# sourceMappingURL=DuplicateReasoningTypes.js.map

package/dist/reasoning/DuplicateReasoningTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DuplicateReasoningTypes.js","sourceRoot":"","sources":["../../src/reasoning/DuplicateReasoningTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/reasoning/MatchedSetDeltaBuilder.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Projects a matched set's field-level comparison into the lean shape the
+ * reasoning template expects ({@link ReasoningFieldDelta}).
+ *
+ * The record loading + field selection + delta computation lives **once** in
+ * `RecordComparisonEngine` (`@memberjunction/record-comparison`) — a low-level package
+ * both this dupe package and the server/UI comparison path can depend on without a build
+ * cycle. This adapter is the thin dupe-specific projection over that single engine:
+ *
+ *   - it calls {@link RecordComparisonEngine.CompareRecordsForEntity} with the already-resolved
+ *     `EntityInfo` and the detector's request-scoped `RunView` (so no redundant metadata
+ *     lookup and no second RunView), then
+ *   - keeps only the **differing** fields (the reasoner wants signal, not noise — the engine
+ *     already drops fields that are empty across every record) and
+ *   - flattens each cell to `{ RecordID: <key string>, Value: <stringified> }`.
+ *
+ * @module @memberjunction/ai-vector-dupe
+ */
+import { RunView, CompositeKey, EntityInfo, UserInfo } from '@memberjunction/core';
+import { RecordComparisonResult, RecordFieldValue } from '@memberjunction/record-comparison';
+import { ReasoningFieldDelta } from './DuplicateReasoningTypes.js';
+/**
+ * The result of building a matched set's deltas: the differing-field deltas the reasoner
+ * consumes, plus a record-id → human label map (derived from the same loaded records) so the
+ * caller can give the source AND candidates real names instead of raw GUIDs in the prompt.
+ */
+export interface MatchedSetDelta {
+    /** Differing-field deltas (the reasoning payload). */
+    FieldDeltas: ReasoningFieldDelta[];
+    /** record-key string ({@link CompositeKey.Values}) → display label (name-field value, else key). */
+    Labels: Map<string, string>;
+}
+/**
+ * Builds the differing-field deltas for a matched set by delegating to the shared
+ * {@link RecordComparisonEngine} and projecting the result into {@link ReasoningFieldDelta}.
+ */
+export declare class MatchedSetDeltaBuilder {
+    private readonly runView;
+    /**
+     * @param runView a RunView bound to the detector's request-scoped provider; threaded
+     *   into the comparison engine so the load happens on the correct connection.
+     */
+    constructor(runView: RunView);
+    /**
+     * Build the field deltas for a matched set.
+     *
+     * @param entityInfo the entity being deduped (already resolved by the detector)
+     * @param keys the source key first, then each candidate key (order preserved)
+     * @param contextUser the run's context user
+     * @returns the differing-field deltas plus a record-id → label map; empty on load failure
+     */
+    Build(entityInfo: EntityInfo, keys: CompositeKey[], contextUser?: UserInfo): Promise<MatchedSetDelta>;
+    /**
+     * Map each loaded record's key string to its display label (the engine resolves the
+     * name-field value, falling back to the key). Lets the reasoner address records by name.
+     */
+    protected buildLabels(result: RecordComparisonResult): Map<string, string>;
+    /**
+     * Project the engine's rich delta matrix into the reasoning contract: differing fields
+     * only, each cell flattened to its record-key string + stringified value.
+     */
+    protected project(result: RecordComparisonResult): ReasoningFieldDelta[];
+    /** Stringify a loaded value for the prompt; null/undefined → null. */
+    protected toStringValue(value: RecordFieldValue): string | null;
+}
+//# sourceMappingURL=MatchedSetDeltaBuilder.d.ts.map

package/dist/reasoning/MatchedSetDeltaBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatchedSetDeltaBuilder.d.ts","sourceRoot":"","sources":["../../src/reasoning/MatchedSetDeltaBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAEH,sBAAsB,EACtB,gBAAgB,EACnB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,sDAAsD;IACtD,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACnC,oGAAoG;IACpG,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC;;;OAGG;gBACS,OAAO,EAAE,OAAO;IAI5B;;;;;;;OAOG;IACU,KAAK,CACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,YAAY,EAAE,EACpB,WAAW,CAAC,EAAE,QAAQ,GACvB,OAAO,CAAC,eAAe,CAAC;IAc3B;;;OAGG;IACH,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,sBAAsB,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAQ1E;;;OAGG;IACH,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,sBAAsB,GAAG,mBAAmB,EAAE;IAqBxE,sEAAsE;IACtE,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI;CAMlE"}

package/dist/reasoning/MatchedSetDeltaBuilder.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Projects a matched set's field-level comparison into the lean shape the
+ * reasoning template expects ({@link ReasoningFieldDelta}).
+ *
+ * The record loading + field selection + delta computation lives **once** in
+ * `RecordComparisonEngine` (`@memberjunction/record-comparison`) — a low-level package
+ * both this dupe package and the server/UI comparison path can depend on without a build
+ * cycle. This adapter is the thin dupe-specific projection over that single engine:
+ *
+ *   - it calls {@link RecordComparisonEngine.CompareRecordsForEntity} with the already-resolved
+ *     `EntityInfo` and the detector's request-scoped `RunView` (so no redundant metadata
+ *     lookup and no second RunView), then
+ *   - keeps only the **differing** fields (the reasoner wants signal, not noise — the engine
+ *     already drops fields that are empty across every record) and
+ *   - flattens each cell to `{ RecordID: <key string>, Value: <stringified> }`.
+ *
+ * @module @memberjunction/ai-vector-dupe
+ */
+import { RecordComparisonEngine, } from '@memberjunction/record-comparison';
+/**
+ * Builds the differing-field deltas for a matched set by delegating to the shared
+ * {@link RecordComparisonEngine} and projecting the result into {@link ReasoningFieldDelta}.
+ */
+export class MatchedSetDeltaBuilder {
+    /**
+     * @param runView a RunView bound to the detector's request-scoped provider; threaded
+     *   into the comparison engine so the load happens on the correct connection.
+     */
+    constructor(runView) {
+        this.runView = runView;
+    }
+    /**
+     * Build the field deltas for a matched set.
+     *
+     * @param entityInfo the entity being deduped (already resolved by the detector)
+     * @param keys the source key first, then each candidate key (order preserved)
+     * @param contextUser the run's context user
+     * @returns the differing-field deltas plus a record-id → label map; empty on load failure
+     */
+    async Build(entityInfo, keys, contextUser) {
+        if (keys.length === 0) {
+            return { FieldDeltas: [], Labels: new Map() };
+        }
+        const engine = new RecordComparisonEngine();
+        const result = await engine.CompareRecordsForEntity(entityInfo, keys, contextUser, {
+            RunViewInstance: this.runView,
+        });
+        if (!result.Success) {
+            return { FieldDeltas: [], Labels: new Map() };
+        }
+        return { FieldDeltas: this.project(result), Labels: this.buildLabels(result) };
+    }
+    /**
+     * Map each loaded record's key string to its display label (the engine resolves the
+     * name-field value, falling back to the key). Lets the reasoner address records by name.
+     */
+    buildLabels(result) {
+        const labels = new Map();
+        for (const record of result.Records) {
+            labels.set(record.Key.Values(), record.Label);
+        }
+        return labels;
+    }
+    /**
+     * Project the engine's rich delta matrix into the reasoning contract: differing fields
+     * only, each cell flattened to its record-key string + stringified value.
+     */
+    project(result) {
+        // Column index → record-key string. This is the same addressing the reasoner uses to
+        // refer back to records (CompositeKey.Values()), so field choices resolve cleanly.
+        const recordIdByColumn = result.Records.map(r => r.Key.Values());
+        const deltas = [];
+        for (const field of result.Fields) {
+            if (!field.Differs) {
+                continue;
+            }
+            deltas.push({
+                FieldName: field.FieldName,
+                Values: field.Cells.map(cell => ({
+                    RecordID: recordIdByColumn[cell.ColumnIndex],
+                    Value: this.toStringValue(cell.Value),
+                })),
+            });
+        }
+        return deltas;
+    }
+    /** Stringify a loaded value for the prompt; null/undefined → null. */
+    toStringValue(value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        return String(value);
+    }
+}
+//# sourceMappingURL=MatchedSetDeltaBuilder.js.map

package/dist/reasoning/MatchedSetDeltaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatchedSetDeltaBuilder.js","sourceRoot":"","sources":["../../src/reasoning/MatchedSetDeltaBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EACH,sBAAsB,GAGzB,MAAM,mCAAmC,CAAC;AAe3C;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IAG/B;;;OAGG;IACH,YAAY,OAAgB;QACxB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAC3B,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,KAAK,CACd,UAAsB,EACtB,IAAoB,EACpB,WAAsB;QAEtB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpB,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;QAClD,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,sBAAsB,EAAE,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,uBAAuB,CAAC,UAAU,EAAE,IAAI,EAAE,WAAW,EAAE;YAC/E,eAAe,EAAE,IAAI,CAAC,OAAO;SAChC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;QAClD,CAAC;QACD,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;IACnF,CAAC;IAED;;;OAGG;IACO,WAAW,CAAC,MAA8B;QAChD,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;QACzC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YAClC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;OAGG;IACO,OAAO,CAAC,MAA8B;QAC5C,qFAAqF;QACrF,mFAAmF;QACnF,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;QAEjE,MAAM,MAAM,GAA0B,EAAE,CAAC;QACzC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAChC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;gBACjB,SAAS;YACb,CAAC;YACD,MAAM,CAAC,IAAI,CAAC;gBACR,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBAC7B,QAAQ,EAAE,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC;oBAC5C,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;iBACxC,CAAC,CAAC;aACN,CAAC,CAAC;QACP,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,sEAAsE;IAC5D,aAAa,CAAC,KAAuB;QAC3C,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxC,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;CACJ"}

package/dist/reasoning/PromptReasoningProvider.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Default ('Prompt' mode) reasoning provider.
+ *
+ * Runs the shared "Duplicate Resolution" instruction set as a single-shot
+ * `AIPromptRunner.ExecutePrompt` call — cheap, fast, no per-set agent run. Resolves the
+ * prompt from the Entity Document's `ReasoningPromptID` (falling back to the seeded
+ * "Duplicate Resolution" prompt by name), feeds it the shared template data, and persists
+ * the resulting `AIPromptRunID`.
+ *
+ * @module @memberjunction/ai-vector-dupe
+ */
+import type { MJAIPromptEntityExtended } from '@memberjunction/ai-core-plus';
+import { DuplicateReasoningProvider } from './DuplicateReasoningProvider.js';
+import { DuplicateReasoningInput, DuplicateReasoningOutput, DuplicateReasoningContext } from './DuplicateReasoningTypes.js';
+/**
+ * Single-shot prompt reasoning provider (the default). Registered under the 'Prompt'
+ * `ReasoningMode`.
+ */
+export declare class PromptReasoningProvider extends DuplicateReasoningProvider {
+    /**
+     * Reason over a matched set via a single-shot prompt.
+     */
+    Reason(input: DuplicateReasoningInput, context: DuplicateReasoningContext): Promise<DuplicateReasoningOutput>;
+    /**
+     * Resolve the prompt from `ReasoningPromptID`, falling back to the seeded
+     * "Duplicate Resolution" prompt by name. Uses the AIEngine cache (no DB query).
+     */
+    protected resolvePrompt(input: DuplicateReasoningInput): MJAIPromptEntityExtended | null;
+    /** Build the params, execute, and translate the result into the reasoning contract. */
+    protected runPrompt(prompt: MJAIPromptEntityExtended, input: DuplicateReasoningInput, context: DuplicateReasoningContext): Promise<DuplicateReasoningOutput>;
+}
+//# sourceMappingURL=PromptReasoningProvider.d.ts.map

package/dist/reasoning/PromptReasoningProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromptReasoningProvider.d.ts","sourceRoot":"","sources":["../../src/reasoning/PromptReasoningProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,EACH,0BAA0B,EAE7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACH,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EAC5B,MAAM,2BAA2B,CAAC;AAKnC;;;GAGG;AACH,qBACa,uBAAwB,SAAQ,0BAA0B;IACnE;;OAEG;IACU,MAAM,CACf,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE,yBAAyB,GACnC,OAAO,CAAC,wBAAwB,CAAC;IAqBpC;;;OAGG;IACH,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,uBAAuB,GAAG,wBAAwB,GAAG,IAAI;IAYxF,uFAAuF;cACvE,SAAS,CACrB,MAAM,EAAE,wBAAwB,EAChC,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE,yBAAyB,GACnC,OAAO,CAAC,wBAAwB,CAAC;CAyBvC"}

package/dist/reasoning/PromptReasoningProvider.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Default ('Prompt' mode) reasoning provider.
+ *
+ * Runs the shared "Duplicate Resolution" instruction set as a single-shot
+ * `AIPromptRunner.ExecutePrompt` call — cheap, fast, no per-set agent run. Resolves the
+ * prompt from the Entity Document's `ReasoningPromptID` (falling back to the seeded
+ * "Duplicate Resolution" prompt by name), feeds it the shared template data, and persists
+ * the resulting `AIPromptRunID`.
+ *
+ * @module @memberjunction/ai-vector-dupe
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LogError } from '@memberjunction/core';
+import { RegisterClass, UUIDsEqual } from '@memberjunction/global';
+import { AIEngine } from '@memberjunction/aiengine';
+import { AIPromptRunner } from '@memberjunction/ai-prompts';
+import { AIPromptParams } from '@memberjunction/ai-core-plus';
+import { DuplicateReasoningProvider, PROMPT_REASONING_PROVIDER_KEY } from './DuplicateReasoningProvider.js';
+/** The name of the seeded prompt used when an Entity Document doesn't specify one. */
+const DEFAULT_REASONING_PROMPT_NAME = 'Duplicate Resolution';
+/**
+ * Single-shot prompt reasoning provider (the default). Registered under the 'Prompt'
+ * `ReasoningMode`.
+ */
+let PromptReasoningProvider = class PromptReasoningProvider extends DuplicateReasoningProvider {
+    /**
+     * Reason over a matched set via a single-shot prompt.
+     */
+    async Reason(input, context) {
+        try {
+            await AIEngine.Instance.Config(false, context.ContextUser, context.Provider);
+            const prompt = this.resolvePrompt(input);
+            if (!prompt) {
+                return this.failedOutput(`No reasoning prompt resolved (ReasoningPromptID=${input.EntityDocument.ReasoningPromptID ?? 'null'}, fallback="${DEFAULT_REASONING_PROMPT_NAME}")`);
+            }
+            const result = await this.runPrompt(prompt, input, context);
+            if (!result.Success) {
+                return result;
+            }
+            return result;
+        }
+        catch (e) {
+            LogError(e);
+            return this.failedOutput(e instanceof Error ? e.message : String(e));
+        }
+    }
+    /**
+     * Resolve the prompt from `ReasoningPromptID`, falling back to the seeded
+     * "Duplicate Resolution" prompt by name. Uses the AIEngine cache (no DB query).
+     */
+    resolvePrompt(input) {
+        const prompts = AIEngine.Instance.Prompts;
+        const promptId = input.EntityDocument.ReasoningPromptID;
+        if (promptId) {
+            const byId = prompts.find(p => UUIDsEqual(p.ID, promptId));
+            if (byId) {
+                return byId;
+            }
+        }
+        return prompts.find(p => p.Name === DEFAULT_REASONING_PROMPT_NAME) ?? null;
+    }
+    /** Build the params, execute, and translate the result into the reasoning contract. */
+    async runPrompt(prompt, input, context) {
+        const params = new AIPromptParams();
+        params.prompt = prompt;
+        params.data = this.buildPromptData(input);
+        params.contextUser = context.ContextUser;
+        // Cheap LLM-based JSON-repair pass before AIPromptRunner falls back to a full
+        // re-run (the prompt's Strict ValidationBehavior + MaxRetries). Small reasoning
+        // models occasionally emit malformed JSON; this recovers most of those without
+        // re-spending a whole generation.
+        params.attemptJSONRepair = true;
+        const runner = new AIPromptRunner();
+        const runResult = await runner.ExecutePrompt(params);
+        const promptRunID = runResult.promptRun?.ID ?? null;
+        if (!runResult.success) {
+            const failed = this.failedOutput(runResult.errorMessage ?? 'Prompt execution failed');
+            failed.AIPromptRunID = promptRunID;
+            return failed;
+        }
+        const output = this.parseRawOutput(runResult.result ?? runResult.rawResult);
+        output.AIPromptRunID = promptRunID;
+        return output;
+    }
+};
+PromptReasoningProvider = __decorate([
+    RegisterClass(DuplicateReasoningProvider, PROMPT_REASONING_PROVIDER_KEY)
+], PromptReasoningProvider);
+export { PromptReasoningProvider };
+//# sourceMappingURL=PromptReasoningProvider.js.map

package/dist/reasoning/PromptReasoningProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromptReasoningProvider.js","sourceRoot":"","sources":["../../src/reasoning/PromptReasoningProvider.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memberjunction/ai-vector-dupe",
   "type": "module",
-  "version": "5.42.0",
+  "version": "5.44.0",
   "description": "MemberJunction: AI Vector/Entity Sync Package - Handles synchronization between Vector DB and MJ CDP Data",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,15 +17,18 @@
   "author": "MemberJunction.com",
   "license": "ISC",
   "dependencies": {
-    "@memberjunction/ai": "5.42.0",
-    "@memberjunction/ai-vectordb": "5.42.0",
-    "@memberjunction/ai-vectors": "5.42.0",
-    "@memberjunction/templates": "5.42.0",
-    "@memberjunction/ai-vector-sync": "5.42.0",
-    "@memberjunction/aiengine": "5.42.0",
-    "@memberjunction/core": "5.42.0",
-    "@memberjunction/global": "5.42.0",
-    "@memberjunction/core-entities": "5.42.0",
+    "@memberjunction/ai": "5.44.0",
+    "@memberjunction/ai-vectordb": "5.44.0",
+    "@memberjunction/ai-core-plus": "5.44.0",
+    "@memberjunction/ai-prompts": "5.44.0",
+    "@memberjunction/ai-vectors": "5.44.0",
+    "@memberjunction/templates": "5.44.0",
+    "@memberjunction/ai-vector-sync": "5.44.0",
+    "@memberjunction/aiengine": "5.44.0",
+    "@memberjunction/core": "5.44.0",
+    "@memberjunction/global": "5.44.0",
+    "@memberjunction/core-entities": "5.44.0",
+    "@memberjunction/record-comparison": "5.44.0",
     "dotenv": "^17.2.4"
   },
   "devDependencies": {