@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/discovery/hyde.graph.js

@@ -1,482 +0,0 @@
-/**
- * HyDE Graph: cache-aware hypothetical document generation with lens inference.
- *
- * Legacy flow: infer_lenses → check_cache → generate_missing? → embed → cache_results.
- * Frame-v1 flow adds one batch validate_generated node before embed.
- */
-import { createHash } from 'crypto';
-import { END, START, StateGraph } from '@langchain/langgraph';
-import { getAbortSignalConfig } from '../shared/agent/model-signal.js';
-import { protocolLogger } from '../shared/observability/protocol.logger.js';
-import { timed } from '../shared/observability/performance.js';
-import { requestContext } from "../shared/observability/request-context.js";
-import { computeHydeSourceTextHash } from './hyde.documents.js';
-import { getHydeGenerationMode, HYDE_FRAME_GENERATION_VERSION } from './hyde.env.js';
-import { sanitizeHydeSourceFrame } from './hyde.frame.js';
-import { HydeGraphState } from './hyde.state.js';
-import { HYDE_DEFAULT_CACHE_TTL } from './hyde.strategies.js';
-import { HydeValidator } from './hyde.validator.js';
-const logger = protocolLogger("HyDEGraphFactory");
-let lastGenerationTimestamp = 0;
-function nextGenerationMarker() {
-    lastGenerationTimestamp = Math.max(Date.now(), lastGenerationTimestamp + 1);
-    return new Date(lastGenerationTimestamp).toISOString();
-}
-/** Hash a lens label (+ optional corpus) to a short key for cache/DB indexing. */
-function lensHash(label, corpus) {
-    const input = corpus
-        ? `${label.toLowerCase().trim()}:${corpus}`
-        : label.toLowerCase().trim();
-    return createHash('sha256').update(input).digest('hex').slice(0, 16);
-}
-function entityCacheKey(sourceId, sourceText) {
-    return sourceId ?? `q:${createHash('sha256').update(sourceText).digest('hex').slice(0, 16)}`;
-}
-function sortedFrame(frame) {
-    const sort = (items) => [...items].sort((left, right) => {
-        const leftJson = JSON.stringify(left);
-        const rightJson = JSON.stringify(right);
-        return leftJson < rightJson ? -1 : leftJson > rightJson ? 1 : 0;
-    });
-    return {
-        sourceRoles: sort(frame.sourceRoles),
-        counterpartRoles: sort(frame.counterpartRoles),
-        hardConstraints: sort(frame.hardConstraints),
-        namedEntities: sort(frame.namedEntities),
-        domainVocabulary: sort(frame.domainVocabulary),
-    };
-}
-/** Deterministic identity for the source content and sanitized frame. */
-function computeHydeFrameFingerprint(sourceText, sourceFrame) {
-    return createHash('sha256')
-        .update(sourceText)
-        .update('\0')
-        .update(JSON.stringify(sortedFrame(sourceFrame)))
-        .digest('hex');
-}
-function requireFrameFingerprint(frameFingerprint) {
-    if (!frameFingerprint)
-        throw new Error('frame-v1 HyDE requires a frame fingerprint');
-    return frameFingerprint;
-}
-/** Preserve the exact legacy Redis key and isolate frame-v1 data by namespace. */
-function cacheKey(mode, sourceType, sourceId, sourceText, lens, corpus, frameFingerprint) {
-    const entityKey = entityCacheKey(sourceId, sourceText);
-    if (mode === 'legacy')
-        return `hyde:${sourceType}:${entityKey}:${lensHash(lens, corpus)}`;
-    return `hyde:${HYDE_FRAME_GENERATION_VERSION}:${sourceType}:${entityKey}:${requireFrameFingerprint(frameFingerprint)}:${lensHash(lens, corpus)}`;
-}
-/** Preserve legacy identity and use a stable frame-v1 identity per lens/corpus. */
-function dbStrategy(mode, label, corpus) {
-    const hash = lensHash(label, corpus);
-    return mode === 'legacy' ? hash : `${HYDE_FRAME_GENERATION_VERSION}:${hash}`;
-}
-function isValidGenerationMarker(value) {
-    return typeof value === 'string' && Number.isFinite(Date.parse(value));
-}
-function isFrameCacheDocument(doc, lensLabel, frameFingerprint, sourceTextHash) {
-    return doc.hydeGenerationVersion === HYDE_FRAME_GENERATION_VERSION
-        && doc.validationStatus === 'valid'
-        && doc.lens === lensLabel
-        && doc.frameFingerprint === frameFingerprint
-        && doc.sourceTextHash === sourceTextHash
-        && isValidGenerationMarker(doc.generatedAt);
-}
-function isFrameDbContext(context, lensLabel, frameFingerprint, sourceTextHash) {
-    return context?.hydeGenerationVersion === HYDE_FRAME_GENERATION_VERSION
-        && context.lensLabel === lensLabel
-        && context.validationStatus === 'valid'
-        && context.frameFingerprint === frameFingerprint
-        && context.sourceTextHash === sourceTextHash
-        && isValidGenerationMarker(context.generatedAt);
-}
-function emptyFrame() {
-    return {
-        sourceRoles: [],
-        counterpartRoles: [],
-        hardConstraints: [],
-        namedEntities: [],
-        domainVocabulary: [],
-    };
-}
-function opaqueDocumentKey(doc) {
-    return `d-${createHash('sha256')
-        .update(`${doc.lens}\0${doc.targetCorpus}\0${doc.hydeText}`)
-        .digest('hex')
-        .slice(0, 16)}`;
-}
-function isRuntimeVerdict(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const verdict = value;
-    return typeof verdict.key === 'string'
-        && typeof verdict.valid === 'boolean'
-        && Array.isArray(verdict.unsupportedNamedEntities)
-        && verdict.unsupportedNamedEntities.every((item) => typeof item === 'string')
-        && Array.isArray(verdict.unsupportedHardConstraints)
-        && verdict.unsupportedHardConstraints.every((item) => typeof item === 'string')
-        && typeof verdict.reasoning === 'string';
-}
-/** Factory for the HyDE generation graph. Existing five-argument calls remain valid. */
-export class HydeGraphFactory {
-    constructor(database, embedder, cache, inferrer, generator, options = {}) {
-        const mode = options.mode ?? getHydeGenerationMode();
-        this.deps = {
-            database, embedder, cache, inferrer, generator, options, mode,
-            ...(mode === HYDE_FRAME_GENERATION_VERSION
-                ? { validator: options.validator ?? new HydeValidator() }
-                : {}),
-        };
-    }
-    createGraph() {
-        const deps = this.deps;
-        const mode = deps.mode;
-        const workflow = new StateGraph(HydeGraphState)
-            .addNode('infer_lenses', (state) => inferLensesNode(state, deps))
-            .addNode('check_cache', (state) => checkCacheNode(state, deps))
-            .addNode('generate_missing', (state) => generateMissingNode(state, deps))
-            .addNode('embed', (state) => embedNode(state, deps))
-            .addNode('cache_results', (state) => cacheResultsNode(state, deps))
-            .addEdge(START, 'infer_lenses')
-            .addEdge('infer_lenses', 'check_cache')
-            .addConditionalEdges('check_cache', shouldGenerate, {
-            generate: 'generate_missing',
-            skip: 'embed',
-        });
-        if (mode === HYDE_FRAME_GENERATION_VERSION) {
-            workflow
-                .addNode('validate_generated', (state) => validateGeneratedNode(state, deps))
-                .addEdge('generate_missing', 'validate_generated')
-                .addEdge('validate_generated', 'embed');
-        }
-        else {
-            workflow.addEdge('generate_missing', 'embed');
-        }
-        workflow
-            .addEdge('embed', 'cache_results')
-            .addEdge('cache_results', END);
-        return workflow.compile();
-        return workflow.compile();
-    }
-}
-/** Node 1: Infer lenses from source text + optional profile context. */
-export async function inferLensesNode(state, deps) {
-    return timed("HydeGraph.inferLenses", async () => {
-        const { sourceText, profileContext, maxLenses } = state;
-        const agentTimingsAccum = [];
-        try {
-            const traceEmitter = requestContext.getStore()?.traceEmitter;
-            const inferrerStart = Date.now();
-            traceEmitter?.({ type: "agent_start", name: "lens-inferrer" });
-            const result = await deps.inferrer.infer({
-                sourceText,
-                profileContext,
-                maxLenses,
-                ...(deps.mode === HYDE_FRAME_GENERATION_VERSION ? { frameConstrained: true } : {}),
-            });
-            const durationMs = Date.now() - inferrerStart;
-            agentTimingsAccum.push({ name: 'lens.inferrer', durationMs });
-            traceEmitter?.({ type: "agent_end", name: "lens-inferrer", durationMs, summary: result.lenses.length > 0 ? `Inferred ${result.lenses.length} lens(es)` : "lens-inferrer completed" });
-            if (deps.mode === HYDE_FRAME_GENERATION_VERSION) {
-                const sourceFrame = sanitizeHydeSourceFrame(sourceText, result.sourceFrame ?? emptyFrame());
-                return {
-                    lenses: result.lenses,
-                    sourceFrame,
-                    frameFingerprint: computeHydeFrameFingerprint(sourceText, sourceFrame),
-                    sourceTextHash: computeHydeSourceTextHash(sourceText),
-                    generatedAt: nextGenerationMarker(),
-                    agentTimings: agentTimingsAccum,
-                };
-            }
-            return { lenses: result.lenses, agentTimings: agentTimingsAccum };
-        }
-        catch (error) {
-            logger.error('Lens inference failed in graph node', { error });
-            if (deps.mode === HYDE_FRAME_GENERATION_VERSION) {
-                const sourceFrame = emptyFrame();
-                return {
-                    lenses: [],
-                    sourceFrame,
-                    frameFingerprint: computeHydeFrameFingerprint(sourceText, sourceFrame),
-                    sourceTextHash: computeHydeSourceTextHash(sourceText),
-                    generatedAt: nextGenerationMarker(),
-                    agentTimings: agentTimingsAccum,
-                };
-            }
-            return { lenses: [], agentTimings: agentTimingsAccum };
-        }
-    });
-}
-/** Node 2: Check the mode-isolated cache/DB for matching documents. */
-export async function checkCacheNode(state, deps) {
-    return timed("HydeGraph.checkCache", async () => {
-        const { sourceType, sourceId, sourceText, lenses, forceRegenerate } = state;
-        if (forceRegenerate)
-            return { hydeDocuments: {} };
-        const frameFingerprint = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? requireFrameFingerprint(state.frameFingerprint)
-            : undefined;
-        const sourceTextHash = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? state.sourceTextHash ?? computeHydeSourceTextHash(sourceText)
-            : undefined;
-        const cached = {};
-        for (const lens of lenses) {
-            const key = cacheKey(deps.mode, sourceType, sourceId ?? undefined, sourceText, lens.label, lens.corpus, frameFingerprint);
-            const fromCache = await deps.cache.get(key);
-            const cacheAccepted = fromCache?.hydeText
-                && fromCache.hydeEmbedding?.length
-                && (deps.mode === 'legacy' || isFrameCacheDocument(fromCache, lens.label, frameFingerprint, sourceTextHash));
-            if (cacheAccepted && fromCache) {
-                cached[lens.label] = {
-                    ...fromCache,
-                    ...(deps.mode === HYDE_FRAME_GENERATION_VERSION ? { origin: 'cache' } : {}),
-                };
-                continue;
-            }
-            if (sourceId) {
-                const fromDb = await deps.database.getHydeDocument(sourceType, sourceId, dbStrategy(deps.mode, lens.label, lens.corpus));
-                const frameDbContext = deps.mode === HYDE_FRAME_GENERATION_VERSION && fromDb
-                    ? fromDb.context
-                    : null;
-                if (fromDb && (deps.mode === 'legacy' || isFrameDbContext(frameDbContext, lens.label, frameFingerprint, sourceTextHash))) {
-                    cached[lens.label] = {
-                        lens: lens.label,
-                        targetCorpus: fromDb.targetCorpus,
-                        hydeText: fromDb.hydeText,
-                        hydeEmbedding: fromDb.hydeEmbedding,
-                        ...(deps.mode === HYDE_FRAME_GENERATION_VERSION
-                            ? {
-                                origin: 'db',
-                                validationStatus: 'valid',
-                                hydeGenerationVersion: HYDE_FRAME_GENERATION_VERSION,
-                                frameFingerprint,
-                                sourceTextHash,
-                                generatedAt: frameDbContext.generatedAt,
-                            }
-                            : {}),
-                    };
-                }
-            }
-        }
-        if (deps.mode === HYDE_FRAME_GENERATION_VERSION) {
-            const newestTimestamp = Math.max(...Object.values(cached).map((doc) => Date.parse(doc.generatedAt ?? '')));
-            if (Number.isFinite(newestTimestamp)) {
-                return {
-                    hydeDocuments: Object.fromEntries(Object.entries(cached).filter(([, doc]) => Date.parse(doc.generatedAt ?? '') === newestTimestamp)),
-                };
-            }
-        }
-        return { hydeDocuments: cached };
-    });
-}
-/** Node 3: Generate all missing documents and return a complete snapshot. */
-export async function generateMissingNode(state, deps) {
-    return timed("HydeGraph.generateMissing", async () => {
-        const { sourceText, sourceFrame, lenses, hydeDocuments } = state;
-        const missing = lenses.filter((lens) => !hydeDocuments[lens.label]);
-        const agentTimingsAccum = [];
-        const generated = {};
-        const sourceTextHash = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? state.sourceTextHash ?? computeHydeSourceTextHash(sourceText)
-            : undefined;
-        const generatedAt = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? state.generatedAt ?? nextGenerationMarker()
-            : undefined;
-        await Promise.all(missing.map(async (lens) => {
-            const traceEmitter = requestContext.getStore()?.traceEmitter;
-            const generatorStart = Date.now();
-            traceEmitter?.({ type: "agent_start", name: "hyde-generator" });
-            const out = await deps.generator.generate({
-                sourceText,
-                lens: lens.label,
-                corpus: lens.corpus,
-                ...(deps.mode === HYDE_FRAME_GENERATION_VERSION && sourceFrame ? { sourceFrame } : {}),
-            });
-            const durationMs = Date.now() - generatorStart;
-            agentTimingsAccum.push({ name: 'hyde.generator', durationMs });
-            traceEmitter?.({ type: "agent_end", name: "hyde-generator", durationMs, summary: `Generated: ${lens.label}` });
-            generated[lens.label] = {
-                lens: lens.label,
-                targetCorpus: lens.corpus,
-                hydeText: out.text,
-                hydeEmbedding: [],
-                ...(deps.mode === HYDE_FRAME_GENERATION_VERSION
-                    ? {
-                        origin: 'generated',
-                        frameFingerprint: requireFrameFingerprint(state.frameFingerprint),
-                        sourceTextHash,
-                        generatedAt,
-                    }
-                    : {}),
-            };
-        }));
-        const retained = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? Object.fromEntries(Object.entries(hydeDocuments).map(([label, doc]) => [
-                label,
-                {
-                    ...doc,
-                    frameFingerprint: requireFrameFingerprint(state.frameFingerprint),
-                    sourceTextHash,
-                    generatedAt,
-                },
-            ]))
-            : hydeDocuments;
-        return { hydeDocuments: { ...retained, ...generated }, agentTimings: agentTimingsAccum };
-    });
-}
-/** Frame-v1 only: validate newly generated docs in one batch. */
-export async function validateGeneratedNode(state, deps) {
-    return timed("HydeGraph.validateGenerated", async () => {
-        const generated = Object.values(state.hydeDocuments).filter((doc) => doc.origin === 'generated');
-        if (generated.length === 0 || !deps.validator)
-            return { hydeDocuments: state.hydeDocuments };
-        const frame = sanitizeHydeSourceFrame(state.sourceText, state.sourceFrame ?? emptyFrame());
-        const documents = {};
-        const lensByDocumentKey = new Map();
-        for (const doc of generated) {
-            const key = opaqueDocumentKey(doc);
-            documents[key] = { corpus: doc.targetCorpus, text: doc.hydeText };
-            lensByDocumentKey.set(key, doc.lens);
-        }
-        const updated = { ...state.hydeDocuments };
-        const agentTimingsAccum = [];
-        const traceEmitter = requestContext.getStore()?.traceEmitter;
-        const validatorStart = Date.now();
-        let validCount = 0;
-        let rejectedCount = 0;
-        let failedOpenCount = 0;
-        traceEmitter?.({ type: 'agent_start', name: 'hyde-validator' });
-        try {
-            const output = await deps.validator.validate({
-                sourceText: state.sourceText,
-                sourceFrame: frame,
-                documents,
-            });
-            const rawVerdicts = Array.isArray(output.verdicts)
-                ? output.verdicts
-                : [];
-            for (const key of Object.keys(documents)) {
-                const lensLabel = lensByDocumentKey.get(key);
-                if (!lensLabel)
-                    continue;
-                const matching = rawVerdicts.filter((value) => !!value && typeof value === 'object' && value.key === key);
-                const doc = updated[lensLabel];
-                if (!doc)
-                    continue;
-                if (matching.length !== 1 || !isRuntimeVerdict(matching[0])) {
-                    failedOpenCount += 1;
-                    updated[lensLabel] = { ...doc, validationStatus: 'failed_open', hydeGenerationVersion: HYDE_FRAME_GENERATION_VERSION };
-                    continue;
-                }
-                const verdict = matching[0];
-                const hasUnsupportedGrounding = verdict.unsupportedNamedEntities.length > 0
-                    || verdict.unsupportedHardConstraints.length > 0;
-                const contradictory = verdict.valid === hasUnsupportedGrounding;
-                if (contradictory) {
-                    failedOpenCount += 1;
-                    updated[lensLabel] = { ...doc, validationStatus: 'failed_open', hydeGenerationVersion: HYDE_FRAME_GENERATION_VERSION };
-                }
-                else if (!verdict.valid) {
-                    rejectedCount += 1;
-                    delete updated[lensLabel];
-                }
-                else {
-                    validCount += 1;
-                    updated[lensLabel] = { ...doc, validationStatus: 'valid', hydeGenerationVersion: HYDE_FRAME_GENERATION_VERSION };
-                }
-            }
-        }
-        catch (error) {
-            logger.error('HyDE validation failed open', { error });
-            validCount = 0;
-            rejectedCount = 0;
-            failedOpenCount = generated.length;
-            for (const doc of generated) {
-                updated[doc.lens] = { ...doc, validationStatus: 'failed_open', hydeGenerationVersion: HYDE_FRAME_GENERATION_VERSION };
-            }
-        }
-        finally {
-            const durationMs = Date.now() - validatorStart;
-            agentTimingsAccum.push({ name: 'hyde.validator', durationMs });
-            traceEmitter?.({
-                type: 'agent_end',
-                name: 'hyde-validator',
-                durationMs,
-                summary: `${validCount} valid, ${rejectedCount} rejected, ${failedOpenCount} failed open`,
-            });
-        }
-        return { hydeDocuments: updated, agentTimings: agentTimingsAccum };
-    });
-}
-/** Embed all accepted/cached documents that do not have embeddings. */
-export async function embedNode(state, deps) {
-    return timed("HydeGraph.embed", async () => {
-        const toEmbed = [];
-        const updated = {};
-        const hydeEmbeddings = {};
-        for (const [label, doc] of Object.entries(state.hydeDocuments)) {
-            if (doc.hydeEmbedding?.length) {
-                updated[label] = doc;
-                hydeEmbeddings[label] = doc.hydeEmbedding;
-            }
-            else {
-                toEmbed.push({ label, doc });
-            }
-        }
-        if (toEmbed.length > 0) {
-            const embeddings = await deps.embedder.generate(toEmbed.map((item) => item.doc.hydeText), undefined, getAbortSignalConfig());
-            const embeddingArray = Array.isArray(embeddings[0]) ? embeddings : [embeddings];
-            for (let i = 0; i < toEmbed.length; i++) {
-                const { label, doc } = toEmbed[i];
-                const embedding = embeddingArray[i] ?? [];
-                updated[label] = { ...doc, hydeEmbedding: embedding };
-                hydeEmbeddings[label] = embedding;
-            }
-        }
-        return { hydeDocuments: updated, hydeEmbeddings };
-    });
-}
-/** Cache/persist only legacy docs or successfully validated frame-v1 docs. */
-export async function cacheResultsNode(state, deps) {
-    return timed("HydeGraph.cacheResults", async () => {
-        const { sourceType, sourceId, sourceText, hydeDocuments } = state;
-        const frameFingerprint = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? requireFrameFingerprint(state.frameFingerprint)
-            : undefined;
-        const sourceTextHash = deps.mode === HYDE_FRAME_GENERATION_VERSION
-            ? state.sourceTextHash ?? computeHydeSourceTextHash(sourceText)
-            : undefined;
-        for (const [label, doc] of Object.entries(hydeDocuments)) {
-            if (deps.mode === HYDE_FRAME_GENERATION_VERSION
-                && !isFrameCacheDocument(doc, label, frameFingerprint, sourceTextHash))
-                continue;
-            const key = cacheKey(deps.mode, sourceType, sourceId ?? undefined, sourceText, label, doc.targetCorpus, frameFingerprint);
-            await deps.cache.set(key, doc, { ttl: HYDE_DEFAULT_CACHE_TTL });
-            if (sourceId) {
-                await deps.database.saveHydeDocument({
-                    sourceType,
-                    sourceId,
-                    strategy: dbStrategy(deps.mode, label, doc.targetCorpus),
-                    targetCorpus: doc.targetCorpus,
-                    hydeText: doc.hydeText,
-                    hydeEmbedding: doc.hydeEmbedding,
-                    ...(deps.mode === HYDE_FRAME_GENERATION_VERSION ? {
-                        context: {
-                            hydeGenerationVersion: HYDE_FRAME_GENERATION_VERSION,
-                            lensLabel: label,
-                            validationStatus: 'valid',
-                            frameFingerprint: doc.frameFingerprint,
-                            sourceTextHash: doc.sourceTextHash,
-                            generatedAt: doc.generatedAt,
-                        },
-                    } : {}),
-                });
-            }
-        }
-        return {};
-    });
-}
-/** After the cache check: generate the missing documents, or skip straight to embedding. */
-export function shouldGenerate(state) {
-    return state.lenses.some((lens) => !state.hydeDocuments[lens.label]) ? 'generate' : 'skip';
-}

package/dist/discovery/hyde.state.d.ts

@@ -1,70 +0,0 @@
-/**
- * HyDE Graph state: cache-aware hypothetical document generation.
- * Used by the HyDE graph for infer_lenses → check_cache → generate_missing → embed → cache_results.
- */
-import type { Id } from '../shared/interfaces/database.interface.js';
-import type { Lens, HydeTargetCorpus } from './lens.inferrer.js';
-import type { HydeSourceFrame } from './hyde.frame.js';
-import type { DebugMetaAgent } from '../agents/agent.module.js';
-export type HydeDocumentOrigin = 'cache' | 'db' | 'generated';
-export type HydeValidationStatus = 'valid' | 'invalid' | 'failed_open';
-/** Single HyDE document (text + embedding) for one lens. */
-export interface HydeDocumentState {
-    lens: string;
-    targetCorpus: HydeTargetCorpus;
-    hydeText: string;
-    hydeEmbedding: number[];
-    origin?: HydeDocumentOrigin;
-    validationStatus?: HydeValidationStatus;
-    hydeGenerationVersion?: 'frame-v1';
-    frameFingerprint?: string;
-    sourceTextHash?: string;
-    generatedAt?: string;
-}
-/** State for the HyDE generation graph. */
-export declare const HydeGraphState: import("@langchain/langgraph").AnnotationRoot<{
-    /** Source type: intent, profile, user context, or ad-hoc query. */
-    sourceType: {
-        (annotation: import("@langchain/langgraph").SingleReducer<"intent" | "context" | "query", "intent" | "context" | "query">): import("@langchain/langgraph").BaseChannel<"intent" | "context" | "query", "intent" | "context" | "query" | import("@langchain/langgraph").OverwriteValue<"intent" | "context" | "query">, unknown>;
-        (): import("@langchain/langgraph").LastValue<"intent" | "context" | "query">;
-        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
-    };
-    /** Source entity ID (e.g. intent ID, user ID). Omitted for ad-hoc query. */
-    sourceId: import("@langchain/langgraph").BaseChannel<Id<"users"> | Id<"intents"> | undefined, Id<"users"> | Id<"intents"> | import("@langchain/langgraph").OverwriteValue<Id<"users"> | Id<"intents"> | undefined> | undefined, unknown>;
-    /** Source text to generate HyDE from (intent payload, profile summary, or query). */
-    sourceText: {
-        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
-        (): import("@langchain/langgraph").LastValue<string>;
-        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
-    };
-    /** Optional profile context for lens inference (user's profile summary). */
-    profileContext: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /** Maximum number of lenses to infer (default 3). */
-    maxLenses: import("@langchain/langgraph").BaseChannel<number, number | import("@langchain/langgraph").OverwriteValue<number>, unknown>;
-    /** When true, skip cache/DB and regenerate all lenses. */
-    forceRegenerate: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
-    /** Inferred lenses from the LensInferrer agent. */
-    lenses: import("@langchain/langgraph").BaseChannel<Lens[], Lens[] | import("@langchain/langgraph").OverwriteValue<Lens[]>, unknown>;
-    /** Sanitized source-grounded frame produced by frame-v1 inference. */
-    sourceFrame: import("@langchain/langgraph").BaseChannel<HydeSourceFrame | undefined, HydeSourceFrame | import("@langchain/langgraph").OverwriteValue<HydeSourceFrame | undefined> | undefined, unknown>;
-    /** Exact sourceText + sanitized sourceFrame identity for frame-v1 reuse. */
-    frameFingerprint: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /** Hash of the exact source text for persisted frame-v1 freshness checks. */
-    sourceTextHash: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /** Shared cohort marker assigned when this run generates any missing document. */
-    generatedAt: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /**
-     * Complete HyDE document snapshot keyed by lens label. Writers replace the
-     * snapshot so rejected documents can be removed before embedding.
-     */
-    hydeDocuments: import("@langchain/langgraph").BaseChannel<Record<string, HydeDocumentState>, Record<string, HydeDocumentState> | import("@langchain/langgraph").OverwriteValue<Record<string, HydeDocumentState>>, unknown>;
-    /**
-     * Final embeddings per lens (convenience output for search).
-     * Populated by embed node; used by opportunity graph.
-     */
-    hydeEmbeddings: import("@langchain/langgraph").BaseChannel<Record<string, number[]>, Record<string, number[]> | import("@langchain/langgraph").OverwriteValue<Record<string, number[]>>, unknown>;
-    /** Non-fatal error message. */
-    error: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /** Timing records for each agent invocation within this graph run. */
-    agentTimings: import("@langchain/langgraph").BaseChannel<DebugMetaAgent[], DebugMetaAgent[] | import("@langchain/langgraph").OverwriteValue<DebugMetaAgent[]>, unknown>;
-}>;

package/dist/discovery/hyde.state.js

@@ -1,85 +0,0 @@
-/**
- * HyDE Graph state: cache-aware hypothetical document generation.
- * Used by the HyDE graph for infer_lenses → check_cache → generate_missing → embed → cache_results.
- */
-import { Annotation } from '@langchain/langgraph';
-/** State for the HyDE generation graph. */
-export const HydeGraphState = Annotation.Root({
-    // ─── Inputs ─────────────────────────────────────────────────────────────
-    /** Source type: intent, profile, user context, or ad-hoc query. */
-    sourceType: (Annotation),
-    /** Source entity ID (e.g. intent ID, user ID). Omitted for ad-hoc query. */
-    sourceId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Source text to generate HyDE from (intent payload, profile summary, or query). */
-    sourceText: (Annotation),
-    /** Optional profile context for lens inference (user's profile summary). */
-    profileContext: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Maximum number of lenses to infer (default 3). */
-    maxLenses: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => 3,
-    }),
-    /** When true, skip cache/DB and regenerate all lenses. */
-    forceRegenerate: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => false,
-    }),
-    // ─── Intermediate / output ─────────────────────────────────────────────
-    /** Inferred lenses from the LensInferrer agent. */
-    lenses: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => [],
-    }),
-    /** Sanitized source-grounded frame produced by frame-v1 inference. */
-    sourceFrame: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Exact sourceText + sanitized sourceFrame identity for frame-v1 reuse. */
-    frameFingerprint: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Hash of the exact source text for persisted frame-v1 freshness checks. */
-    sourceTextHash: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Shared cohort marker assigned when this run generates any missing document. */
-    generatedAt: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /**
-     * Complete HyDE document snapshot keyed by lens label. Writers replace the
-     * snapshot so rejected documents can be removed before embedding.
-     */
-    hydeDocuments: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => ({}),
-    }),
-    /**
-     * Final embeddings per lens (convenience output for search).
-     * Populated by embed node; used by opportunity graph.
-     */
-    hydeEmbeddings: Annotation({
-        reducer: (curr, next) => (next ? { ...curr, ...next } : curr),
-        default: () => ({}),
-    }),
-    /** Non-fatal error message. */
-    error: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Timing records for each agent invocation within this graph run. */
-    agentTimings: Annotation({
-        reducer: (acc, val) => [...acc, ...val],
-        default: () => [],
-    }),
-});

package/dist/discovery/hyde.strategies.d.ts

@@ -1,17 +0,0 @@
-/**
- * HyDE (Hypothetical Document Embeddings) type definitions.
- *
- * The system is now role-agnostic: instead of hardcoded strategy names
- * (mirror, reciprocal, mentor, investor, collaborator, hiree), an LLM
- * infers free-text "lenses" dynamically. This file re-exports the lens
- * types and provides constants for the HyDE pipeline.
- */
-import type { HydeTargetCorpus } from './lens.inferrer.js';
-export type { Lens, HydeTargetCorpus, LensInferenceInput, LensInferenceOutput } from './lens.inferrer.js';
-/** Default cache TTL for ephemeral HyDE documents (1 hour). */
-export declare const HYDE_DEFAULT_CACHE_TTL = 3600;
-/**
- * Prompt templates for HyDE document generation.
- * Keyed by target corpus — the lens label provides the semantic specificity.
- */
-export declare const HYDE_CORPUS_PROMPTS: Record<HydeTargetCorpus, (sourceText: string, lens: string) => string>;