@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

package/dist/discovery/hyde.strategies.js

@@ -1,34 +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.
- */
-/** Default cache TTL for ephemeral HyDE documents (1 hour). */
-export const HYDE_DEFAULT_CACHE_TTL = 3600;
-/**
- * Prompt templates for HyDE document generation.
- * Keyed by target corpus — the lens label provides the semantic specificity.
- */
-export const HYDE_CORPUS_PROMPTS = {
-    profiles: (sourceText, lens) => `
-    Write a professional biography for someone who could fulfill this need: "${sourceText}".
-    Focus on the specific expertise, background, and role described by: ${lens}.
-
-    Write in first person. Include concrete skills, domain experience, and current professional focus that would make them a strong match.
-  `,
-    intents: (sourceText, lens) => `
-    Write a goal or aspiration statement for someone who is: ${lens}.
-    This person's needs would complement: "${sourceText}".
-
-    Write in first person as if stating their own goal.
-  `,
-    premises: (sourceText, lens) => `
-    Write a short self-description for someone whose identity, values, or worldview aligns with: "${sourceText}".
-    Reflect the character described by: ${lens}.
-
-    Write in first person as a stable statement of who this person is, not what they want.
-  `,
-};

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

@@ -1,78 +0,0 @@
-import type { BaseLanguageModelInput } from '@langchain/core/language_models/base';
-import { z } from 'zod';
-import type { HydeSourceFrame } from './hyde.frame.js';
-import type { HydeTargetCorpus } from './lens.inferrer.js';
-export interface HydeValidationDocument {
-    corpus: HydeTargetCorpus;
-    text: string;
-}
-export interface HydeValidationInput {
-    sourceText: string;
-    sourceFrame: HydeSourceFrame;
-    /** Generated documents keyed by opaque caller-supplied identifiers. */
-    documents: Record<string, HydeValidationDocument>;
-}
-export interface HydeValidationVerdict {
-    key: string;
-    valid: boolean;
-    unsupportedNamedEntities: string[];
-    unsupportedHardConstraints: string[];
-    reasoning: string;
-}
-export interface HydeValidationOutput {
-    verdicts: HydeValidationVerdict[];
-}
-/** Structured-output schema for a single batch validation response. */
-export declare const HydeValidationResponseSchema: z.ZodObject<{
-    verdicts: z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        valid: z.ZodBoolean;
-        unsupportedNamedEntities: z.ZodArray<z.ZodString, "many">;
-        unsupportedHardConstraints: z.ZodArray<z.ZodString, "many">;
-        reasoning: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        reasoning: string;
-        valid: boolean;
-        key: string;
-        unsupportedNamedEntities: string[];
-        unsupportedHardConstraints: string[];
-    }, {
-        reasoning: string;
-        valid: boolean;
-        key: string;
-        unsupportedNamedEntities: string[];
-        unsupportedHardConstraints: string[];
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    verdicts: {
-        reasoning: string;
-        valid: boolean;
-        key: string;
-        unsupportedNamedEntities: string[];
-        unsupportedHardConstraints: string[];
-    }[];
-}, {
-    verdicts: {
-        reasoning: string;
-        valid: boolean;
-        key: string;
-        unsupportedNamedEntities: string[];
-        unsupportedHardConstraints: string[];
-    }[];
-}>;
-/** Build a profile-free batch validation prompt. */
-export declare function buildHydeValidationPrompt(input: HydeValidationInput): string;
-/** Minimal structured model contract used for deterministic injection in tests. */
-export interface HydeValidatorStructuredModel {
-    invoke(input: BaseLanguageModelInput, config?: {
-        signal?: AbortSignal;
-    }): Promise<unknown>;
-}
-/** Production structured-model batch validator for frame-v1 HyDE documents. */
-export declare class HydeValidator {
-    private model?;
-    constructor(model?: HydeValidatorStructuredModel);
-    private getModel;
-    /** Validate all generated documents in one structured-model call. */
-    validate(input: HydeValidationInput): Promise<HydeValidationOutput>;
-}

package/dist/discovery/hyde.validator.js

@@ -1,48 +0,0 @@
-import { HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { z } from 'zod';
-import { createStructuredModel } from '../shared/agent/model.config.js';
-import { invokeWithAbortSignal } from '../shared/agent/model-signal.js';
-/** Structured-output schema for a single batch validation response. */
-export const HydeValidationResponseSchema = z.object({
-    verdicts: z.array(z.object({
-        key: z.string().min(1),
-        valid: z.boolean(),
-        unsupportedNamedEntities: z.array(z.string()),
-        unsupportedHardConstraints: z.array(z.string()),
-        reasoning: z.string().min(1).describe('Concise explanation of the verdict'),
-    })),
-});
-const VALIDATOR_SYSTEM_PROMPT = `You validate hypothetical retrieval documents against a sanitized source-grounded frame.
-
-A document is invalid only when it invents unsupported proper nouns/named entities or unsupported HARD constraints (location, time, numeric, credential, organization, or exclusivity constraints).
-
-Explicitly allowed and not grounds for rejection:
-- first-person target voice;
-- generic role or domain elaboration;
-- reciprocal or complementary inversion of source and target roles.
-
-Return exactly one verdict for each opaque key. Copy each key exactly. Mark valid=false when either unsupported list is non-empty. Keep reasoning concise.`;
-/** Build a profile-free batch validation prompt. */
-export function buildHydeValidationPrompt(input) {
-    return `Source text:\n${input.sourceText}\n\nSanitized source frame:\n${JSON.stringify(input.sourceFrame)}\n\nGenerated documents:\n${JSON.stringify(input.documents)}`;
-}
-/** Production structured-model batch validator for frame-v1 HyDE documents. */
-export class HydeValidator {
-    constructor(model) {
-        this.model = model;
-    }
-    getModel() {
-        this.model ?? (this.model = createStructuredModel('hydeValidator', HydeValidationResponseSchema, {
-            name: 'hyde_validator',
-        }));
-        return this.model;
-    }
-    /** Validate all generated documents in one structured-model call. */
-    async validate(input) {
-        const result = await invokeWithAbortSignal(this.getModel(), [
-            new SystemMessage(VALIDATOR_SYSTEM_PROMPT),
-            new HumanMessage(buildHydeValidationPrompt(input)),
-        ]);
-        return HydeValidationResponseSchema.parse(result);
-    }
-}

package/dist/discovery/index.d.ts

@@ -1,26 +0,0 @@
-/**
- * discovery — the capability's sole cross-capability surface.
- *
- * HyDE (Hypothetical Document Embeddings) is discovery machinery, not shared
- * infrastructure: it owns a graph, a generator, a lens inferrer, and a
- * validator. It lived under shared/ because two capabilities needed it, which
- * made shared/ the default home for anything with more than one consumer.
- *
- * Anything outside this capability imports from here and nowhere else.
- */
-export { computeHydeSourceTextHash, selectHydeDocumentsForGeneration, } from "./hyde.documents.js";
-export { HYDE_FRAME_GENERATION_VERSION, getHydeGenerationMode, } from "./hyde.env.js";
-export type { HydeGenerationMode, } from "./hyde.env.js";
-export { HYDE_HARD_CONSTRAINT_TYPES, HYDE_NAMED_ENTITY_TYPES, HydeSourceFrameSchema, } from "./hyde.frame.js";
-export type { HydeFrameHardConstraint, HydeFrameNamedEntity, HydeFrameRole, HydeFrameVocabulary, HydeSourceFrame, } from "./hyde.frame.js";
-export { HydeGenerator, } from "./hyde.generator.js";
-export type { HydeGenerateInput, HydeGeneratorOutput, } from "./hyde.generator.js";
-export { HydeGraphFactory, } from "./hyde.graph.js";
-export type { HydeGeneratorLike, HydeGraphOptions, HydeLensInferrerLike, HydeValidatorLike, } from "./hyde.graph.js";
-export { HydeGraphState, } from "./hyde.state.js";
-export type { HydeDocumentOrigin, HydeDocumentState, HydeValidationStatus, } from "./hyde.state.js";
-export { HYDE_CORPUS_PROMPTS, HYDE_DEFAULT_CACHE_TTL, } from "./hyde.strategies.js";
-export { HydeValidationResponseSchema, HydeValidator, buildHydeValidationPrompt, } from "./hyde.validator.js";
-export type { HydeValidationDocument, HydeValidationInput, HydeValidationOutput, HydeValidationVerdict, } from "./hyde.validator.js";
-export { FRAME_SYSTEM_PROMPT, FrameResponseSchema, LensInferrer, } from "./lens.inferrer.js";
-export type { HydeTargetCorpus, Lens, LensInferenceInput, LensInferenceOutput, } from "./lens.inferrer.js";

package/dist/discovery/index.js

@@ -1,19 +0,0 @@
-/**
- * discovery — the capability's sole cross-capability surface.
- *
- * HyDE (Hypothetical Document Embeddings) is discovery machinery, not shared
- * infrastructure: it owns a graph, a generator, a lens inferrer, and a
- * validator. It lived under shared/ because two capabilities needed it, which
- * made shared/ the default home for anything with more than one consumer.
- *
- * Anything outside this capability imports from here and nowhere else.
- */
-export { computeHydeSourceTextHash, selectHydeDocumentsForGeneration, } from "./hyde.documents.js";
-export { HYDE_FRAME_GENERATION_VERSION, getHydeGenerationMode, } from "./hyde.env.js";
-export { HYDE_HARD_CONSTRAINT_TYPES, HYDE_NAMED_ENTITY_TYPES, HydeSourceFrameSchema, } from "./hyde.frame.js";
-export { HydeGenerator, } from "./hyde.generator.js";
-export { HydeGraphFactory, } from "./hyde.graph.js";
-export { HydeGraphState, } from "./hyde.state.js";
-export { HYDE_CORPUS_PROMPTS, HYDE_DEFAULT_CACHE_TTL, } from "./hyde.strategies.js";
-export { HydeValidationResponseSchema, HydeValidator, buildHydeValidationPrompt, } from "./hyde.validator.js";
-export { FRAME_SYSTEM_PROMPT, FrameResponseSchema, LensInferrer, } from "./lens.inferrer.js";

package/dist/discovery/lens.inferrer.d.ts

@@ -1,214 +0,0 @@
-/**
- * Lens Inferrer Agent: analyzes source text (intent or query) with optional
- * profile context and infers 1-N search lenses, each tagged with a target corpus.
- * Replaces the hardcoded HydeStrategy enum and regex-based selectStrategiesFromQuery.
- */
-import type { BaseLanguageModelInput } from '@langchain/core/language_models/base';
-import { z } from 'zod';
-import { type HydeSourceFrame } from './hyde.frame.js';
-export type HydeTargetCorpus = 'profiles' | 'intents' | 'premises';
-/** A single inferred lens — a search perspective the LLM decided is relevant. */
-export interface Lens {
-    /** Free-text description (e.g. "crypto infrastructure VC"). */
-    label: string;
-    /** Which vector index to search: user profiles or user intents. */
-    corpus: HydeTargetCorpus;
-    /** Why this perspective is relevant (for logging/trace). */
-    reasoning: string;
-}
-export interface LensInferenceInput {
-    /** Intent payload or search query. */
-    sourceText: string;
-    /** User's profile summary for domain context (optional). */
-    profileContext?: string;
-    /** Maximum number of lenses to infer (default 3). */
-    maxLenses?: number;
-    /** Use the source-grounded frame-v1 inference path. */
-    frameConstrained?: boolean;
-}
-export interface LensInferenceOutput {
-    lenses: Lens[];
-    /** Sanitized source frame, present only for frame-constrained inference. */
-    sourceFrame?: HydeSourceFrame;
-}
-/** Source-grounded system prompt used only by frame extraction. */
-export declare const FRAME_SYSTEM_PROMPT = "You extract a source-grounded frame for semantic retrieval from sourceText alone.\n\nSource-frame rules:\n- Extract evidence ONLY from sourceText.\n- Every frame element must include an evidence field copied as an exact substring of sourceText.\n- sourceRoles describe roles held or offered by the source side.\n- sourceRoles and counterpartRoles MUST use generic lower-case role labels only (for example, \"founder\", \"investor\", or \"technical advisor\"). Never put a person, organization, product, location, time, number, credential, or exclusivity detail in a role label.\n- counterpartRoles describe reciprocal or complementary target roles. A generic role may be inferred, but its evidence must be an exact sourceText span that supports the inference.\n- hardConstraints contain only explicit constraints and classify each as location, time, numeric, credential, organization, exclusivity, or other.\n- namedEntities contain only proper names explicitly present in sourceText and classify each as person, organization, product, location, event, or other.\n- domainVocabulary contains source domain terms worth preserving.";
-/** Structured-output schema used only by source-frame extraction. */
-export declare const FrameResponseSchema: z.ZodObject<{
-    sourceFrame: z.ZodObject<{
-        sourceRoles: z.ZodArray<z.ZodObject<{
-            role: z.ZodString;
-            evidence: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            role: string;
-            evidence: string;
-        }, {
-            role: string;
-            evidence: string;
-        }>, "many">;
-        counterpartRoles: z.ZodArray<z.ZodObject<{
-            role: z.ZodString;
-            evidence: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            role: string;
-            evidence: string;
-        }, {
-            role: string;
-            evidence: string;
-        }>, "many">;
-        hardConstraints: z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<["location", "time", "numeric", "credential", "organization", "exclusivity", "other"]>;
-            value: z.ZodString;
-            evidence: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            value: string;
-            type: "location" | "time" | "numeric" | "credential" | "organization" | "exclusivity" | "other";
-            evidence: string;
-        }, {
-            value: string;
-            type: "location" | "time" | "numeric" | "credential" | "organization" | "exclusivity" | "other";
-            evidence: string;
-        }>, "many">;
-        namedEntities: z.ZodArray<z.ZodObject<{
-            type: z.ZodEnum<["person", "organization", "product", "location", "event", "other"]>;
-            name: z.ZodString;
-            evidence: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            name: string;
-            type: "location" | "event" | "organization" | "other" | "person" | "product";
-            evidence: string;
-        }, {
-            name: string;
-            type: "location" | "event" | "organization" | "other" | "person" | "product";
-            evidence: string;
-        }>, "many">;
-        domainVocabulary: z.ZodArray<z.ZodObject<{
-            term: z.ZodString;
-            evidence: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            evidence: string;
-            term: string;
-        }, {
-            evidence: string;
-            term: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        sourceRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        counterpartRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        hardConstraints: {
-            value: string;
-            type: "location" | "time" | "numeric" | "credential" | "organization" | "exclusivity" | "other";
-            evidence: string;
-        }[];
-        namedEntities: {
-            name: string;
-            type: "location" | "event" | "organization" | "other" | "person" | "product";
-            evidence: string;
-        }[];
-        domainVocabulary: {
-            evidence: string;
-            term: string;
-        }[];
-    }, {
-        sourceRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        counterpartRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        hardConstraints: {
-            value: string;
-            type: "location" | "time" | "numeric" | "credential" | "organization" | "exclusivity" | "other";
-            evidence: string;
-        }[];
-        namedEntities: {
-            name: string;
-            type: "location" | "event" | "organization" | "other" | "person" | "product";
-            evidence: string;
-        }[];
-        domainVocabulary: {
-            evidence: string;
-            term: string;
-        }[];
-    }>;
-}, "strip", z.ZodTypeAny, {
-    sourceFrame: {
-        sourceRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        counterpartRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        hardConstraints: {
-            value: string;
-            type: "location" | "time" | "numeric" | "credential" | "organization" | "exclusivity" | "other";
-            evidence: string;
-        }[];
-        namedEntities: {
-            name: string;
-            type: "location" | "event" | "organization" | "other" | "person" | "product";
-            evidence: string;
-        }[];
-        domainVocabulary: {
-            evidence: string;
-            term: string;
-        }[];
-    };
-}, {
-    sourceFrame: {
-        sourceRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        counterpartRoles: {
-            role: string;
-            evidence: string;
-        }[];
-        hardConstraints: {
-            value: string;
-            type: "location" | "time" | "numeric" | "credential" | "organization" | "exclusivity" | "other";
-            evidence: string;
-        }[];
-        namedEntities: {
-            name: string;
-            type: "location" | "event" | "organization" | "other" | "person" | "product";
-            evidence: string;
-        }[];
-        domainVocabulary: {
-            evidence: string;
-            term: string;
-        }[];
-    };
-}>;
-type ModelInput = BaseLanguageModelInput;
-/** Minimal structured model contract used for deterministic injection in tests. */
-export interface LensStructuredModel {
-    invoke(input: ModelInput, config?: {
-        signal?: AbortSignal;
-    }): Promise<unknown>;
-}
-export interface LensInferrerOptions {
-    legacyModel?: LensStructuredModel;
-    frameModel?: LensStructuredModel;
-}
-/** Infers search lenses from source text and optional profile context. */
-export declare class LensInferrer {
-    private legacyModel?;
-    private frameModel?;
-    constructor(options?: LensInferrerOptions);
-    private getLegacyModel;
-    private getFrameModel;
-    /** Infer search lenses while preserving the legacy path unless explicitly enabled. */
-    infer(input: LensInferenceInput): Promise<LensInferenceOutput>;
-}
-export {};

package/dist/discovery/lens.inferrer.js

@@ -1,152 +0,0 @@
-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;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { z } from 'zod';
-import { createStructuredModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-import { protocolLogger } from '../shared/observability/protocol.logger.js';
-import { Timed } from "../shared/observability/performance.js";
-import { HydeSourceFrameSchema, sanitizeHydeSourceFrame } from './hyde.frame.js';
-const SYSTEM_PROMPT = `You analyze goals and search queries to identify the most relevant perspectives for finding matching people in a professional network.
-
-For each perspective you identify, specify:
-1. A clear, specific description of who or what to search for
-2. Whether to search "profiles" (user bios, expertise, backgrounds), "intents" (stated goals, needs, aspirations), or "premises" (identity assertions, values, worldview)
-3. A brief reason why this perspective is relevant
-
-Guidelines:
-- Be specific and domain-aware. "early-stage crypto infrastructure investor" is better than "investor".
-- Consider both sides: who can help the person AND whose goals complement theirs.
-- When user context is provided, tailor perspectives to their domain (e.g. a DePIN founder searching for "investors" needs crypto-native infra investors specifically).
-- Generate only perspectives that add distinct search value — don't repeat similar angles.
-- Use "profiles" when looking for a type of person (expert, advisor, leader). Use "intents" when looking for a complementary goal or need (someone raising, someone hiring, someone seeking collaboration). Use "premises" when looking for someone whose identity, values, or worldview aligns — stable traits rather than transient goals.
-- Always include at least one "profiles" perspective when the source describes a need that a specific type of professional could fulfill. Most intents benefit from profile-based discovery.
-- LOCATION AWARENESS: When the source text or user context mentions a specific location (city, region, country), incorporate it into lens descriptions. For example, "investors in San Francisco" should produce a lens like "SF-based early-stage investor" rather than just "early-stage investor". This helps the hypothetical document generator produce location-specific search documents, improving retrieval quality.`;
-/** Source-grounded system prompt used only by frame extraction. */
-export const FRAME_SYSTEM_PROMPT = `You extract a source-grounded frame for semantic retrieval from sourceText alone.
-
-Source-frame rules:
-- Extract evidence ONLY from sourceText.
-- Every frame element must include an evidence field copied as an exact substring of sourceText.
-- sourceRoles describe roles held or offered by the source side.
-- sourceRoles and counterpartRoles MUST use generic lower-case role labels only (for example, "founder", "investor", or "technical advisor"). Never put a person, organization, product, location, time, number, credential, or exclusivity detail in a role label.
-- counterpartRoles describe reciprocal or complementary target roles. A generic role may be inferred, but its evidence must be an exact sourceText span that supports the inference.
-- hardConstraints contain only explicit constraints and classify each as location, time, numeric, credential, organization, exclusivity, or other.
-- namedEntities contain only proper names explicitly present in sourceText and classify each as person, organization, product, location, event, or other.
-- domainVocabulary contains source domain terms worth preserving.`;
-const lensSchema = z.object({
-    label: z.string().describe('Specific description of the search perspective'),
-    corpus: z.enum(['profiles', 'intents', 'premises']).describe('Search user profiles, user intents, or user premises (identity/values)'),
-    reasoning: z.string().describe('Why this perspective is relevant'),
-});
-const responseFormat = z.object({
-    lenses: z.array(lensSchema).min(1).max(5).describe('Inferred search lenses'),
-});
-/** Structured-output schema used only by source-frame extraction. */
-export const FrameResponseSchema = z.object({
-    sourceFrame: HydeSourceFrameSchema,
-});
-const logger = protocolLogger("LensInferrer");
-/** Infers search lenses from source text and optional profile context. */
-export class LensInferrer {
-    constructor(options = {}) {
-        // Preserve legacy construction behavior in production. Frame-only model
-        // injection deliberately avoids constructing a provider-backed legacy model.
-        this.legacyModel = options.legacyModel
-            ?? (options.frameModel ? undefined : createStructuredModel("lensInferrer", responseFormat, { name: "lens_inferrer" }));
-        this.frameModel = options.frameModel;
-    }
-    getLegacyModel() {
-        this.legacyModel ?? (this.legacyModel = createStructuredModel("lensInferrer", responseFormat, {
-            name: "lens_inferrer",
-        }));
-        return this.legacyModel;
-    }
-    getFrameModel() {
-        this.frameModel ?? (this.frameModel = createStructuredModel("lensInferrer", FrameResponseSchema, {
-            name: "lens_inferrer_frame_v1",
-        }));
-        return this.frameModel;
-    }
-    /** Infer search lenses while preserving the legacy path unless explicitly enabled. */
-    async infer(input) {
-        const { sourceText, profileContext, maxLenses = 3, frameConstrained = false } = input;
-        logger.verbose('Inferring lenses', {
-            sourceTextLength: sourceText.length,
-            hasProfileContext: !!profileContext,
-            maxLenses,
-            frameConstrained,
-        });
-        let humanPrompt = `Identify up to ${maxLenses} search perspectives for finding relevant matches.\n\nSource: "${sourceText}"`;
-        if (profileContext) {
-            humanPrompt += `\n\nUser context: ${profileContext}`;
-        }
-        const messages = [
-            new SystemMessage(SYSTEM_PROMPT),
-            new HumanMessage(humanPrompt),
-        ];
-        if (!frameConstrained) {
-            try {
-                const result = await invokeWithAbortSignal(this.getLegacyModel(), messages);
-                const parsed = responseFormat.parse(result);
-                const lenses = parsed.lenses.slice(0, maxLenses);
-                logger.verbose('Lenses inferred', {
-                    count: lenses.length,
-                    lenses: lenses.map(l => ({ label: l.label, corpus: l.corpus })),
-                });
-                return { lenses };
-            }
-            catch (error) {
-                logger.error('Lens inference failed', { error });
-                return { lenses: [] };
-            }
-        }
-        const frameMessages = [
-            new SystemMessage(FRAME_SYSTEM_PROMPT),
-            new HumanMessage(`Extract the source frame.\n\nSource: "${sourceText}"`),
-        ];
-        const lensPromise = (async () => {
-            const result = await invokeWithAbortSignal(this.getLegacyModel(), messages);
-            return responseFormat.parse(result).lenses.slice(0, maxLenses);
-        })();
-        const framePromise = (async () => {
-            const result = await invokeWithAbortSignal(this.getFrameModel(), frameMessages);
-            const parsed = FrameResponseSchema.parse(result);
-            return sanitizeHydeSourceFrame(sourceText, parsed.sourceFrame);
-        })();
-        const [lensResult, frameResult] = await Promise.allSettled([lensPromise, framePromise]);
-        if (lensResult.status === 'rejected') {
-            logger.error('Lens inference failed', { error: lensResult.reason });
-            return { lenses: [] };
-        }
-        const lenses = lensResult.value;
-        logger.verbose('Frame-constrained lenses inferred', { count: lenses.length });
-        if (frameResult.status === 'rejected') {
-            logger.error('Source frame extraction failed', { error: frameResult.reason });
-            return {
-                lenses,
-                sourceFrame: {
-                    sourceRoles: [],
-                    counterpartRoles: [],
-                    hardConstraints: [],
-                    namedEntities: [],
-                    domainVocabulary: [],
-                },
-            };
-        }
-        return { lenses, sourceFrame: frameResult.value };
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], LensInferrer.prototype, "infer", null);

package/dist/enrichment/enrichment.generator.d.ts

@@ -1,68 +0,0 @@
-import { z } from "zod/v4";
-declare const responseFormat: z.ZodObject<{
-    identity: z.ZodObject<{
-        name: z.ZodString;
-        bio: z.ZodString;
-        location: z.ZodString;
-    }, z.core.$strip>;
-    narrative: z.ZodObject<{
-        context: z.ZodString;
-    }, z.core.$strip>;
-    attributes: z.ZodObject<{
-        interests: z.ZodArray<z.ZodString>;
-        skills: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-type Profile = z.infer<typeof responseFormat>;
-export type GeneratedProfile = Profile & {
-    userId: string;
-};
-export declare class EnrichmentGenerator {
-    private static sharedModel;
-    private model;
-    constructor();
-    private toString;
-    invoke(input: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<{
-        output: {
-            identity: {
-                name: string;
-                bio: string;
-                location: string;
-            };
-            narrative: {
-                context: string;
-            };
-            attributes: {
-                interests: string[];
-                skills: string[];
-            };
-        };
-        textToEmbed: string;
-    }>;
-    static asTool(): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
-        input: z.ZodString;
-    }, z.core.$strip>, {
-        input: string;
-    }, {
-        input: string;
-    }, {
-        output: {
-            identity: {
-                name: string;
-                bio: string;
-                location: string;
-            };
-            narrative: {
-                context: string;
-            };
-            attributes: {
-                interests: string[];
-                skills: string[];
-            };
-        };
-        textToEmbed: string;
-    }, unknown, "profileGenerator">;
-}
-export {};