freshcontext-mcp 0.3.20 → 0.3.21

package/dist/core/provenanceReadiness.js

@@ -0,0 +1,220 @@
+import { calculateHaPriV2, canonicalizeHaPriContent, sha256Hex } from "./provenance.js";
+import { SIGNAL_CONTRACT_VERSION, normalizeSignal } from "./signal.js";
+const UNUSABLE_SOURCE_VALUES = new Set([
+    "unknown",
+    "n/a",
+    "na",
+    "none",
+    "null",
+    "undefined",
+    "not provided",
+    "tbd",
+]);
+const WEAK_SOURCE_TYPES = new Set(["", "default", "unknown", "custom"]);
+const DERIVED_SOURCE_TYPES = new Set([
+    "copy",
+    "copied",
+    "derived",
+    "excerpt",
+    "local",
+    "local_custom",
+    "local_file",
+    "local_handoff",
+    "secondary",
+    "summary",
+]);
+function cleanString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function isNormalizedSignal(input) {
+    return input.contract_version === SIGNAL_CONTRACT_VERSION;
+}
+function coerceInput(input) {
+    const value = input;
+    return {
+        ...value,
+        source: cleanString(value.source) ?? "",
+    };
+}
+function metadataString(signal, keys) {
+    for (const key of keys) {
+        const value = signal.metadata[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return null;
+}
+function metadataBoolean(signal, keys) {
+    return keys.some((key) => signal.metadata[key] === true);
+}
+function hasStringField(input, field) {
+    return cleanString(input[field]) !== null;
+}
+function sourceIdentityCompleteness(source) {
+    if (!source)
+        return "missing";
+    const lower = source.toLowerCase();
+    if (UNUSABLE_SOURCE_VALUES.has(lower))
+        return "unusable";
+    if (source.length < 4)
+        return "weak";
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(source))
+        return "complete";
+    if (/^[a-z][a-z0-9+.-]*:/i.test(source))
+        return "complete";
+    if (/^[a-z]:\\/i.test(source) || source.startsWith("/") || source.startsWith("\\\\"))
+        return "complete";
+    if (source.includes("/") || source.includes("\\") || source.includes("."))
+        return "complete";
+    return source.length >= 12 ? "complete" : "weak";
+}
+function isDerivedContext(signal) {
+    const sourceType = signal.source_type.toLowerCase();
+    if (DERIVED_SOURCE_TYPES.has(sourceType))
+        return true;
+    if (metadataBoolean(signal, ["is_derived", "derived", "copied", "is_secondary"]))
+        return true;
+    return metadataString(signal, [
+        "derived_from",
+        "copied_from",
+        "original_source",
+        "origin_source",
+        "source_chain",
+    ]) !== null;
+}
+function timingCompleteness(signal, retrievedAtWasProvided) {
+    if (signal.status === "failed")
+        return "unknown";
+    if (!signal.published_at && !signal.retrieved_at)
+        return "missing";
+    if (!signal.published_at || signal.date_confidence === "unknown" || retrievedAtWasProvided === false) {
+        return "partial";
+    }
+    return "complete";
+}
+function readinessState(input) {
+    if (input.signal.status === "failed" || input.sourceCompleteness === "unusable")
+        return "unknown";
+    if (input.derived)
+        return "derived";
+    if (input.sourceCompleteness === "missing" || !input.hasCanonicalHash)
+        return "incomplete";
+    if (input.sourceCompleteness === "complete"
+        && input.timingCompleteness === "complete"
+        && !input.sourceTypeWeak) {
+        return "complete";
+    }
+    return "partial";
+}
+function canonicalContentHash(signal) {
+    return signal.content === undefined ? null : sha256Hex(canonicalizeHaPriContent(signal.content));
+}
+function prepareHaPriV2(input) {
+    if (input.signal.status === "failed") {
+        input.reasons.push("Ha-Pri v2 identity material was not prepared for failed context");
+        return null;
+    }
+    if (!input.signal.content) {
+        input.reasons.push("Ha-Pri v2 identity material needs content");
+        return null;
+    }
+    if (!input.resultId) {
+        input.reasons.push("Ha-Pri v2 identity material needs a result id or stable source identity");
+        return null;
+    }
+    if (!input.engineVersion) {
+        input.reasons.push("Ha-Pri v2 identity material needs an explicit engine version");
+        return null;
+    }
+    input.reasons.push("Ha-Pri v2 identity material prepared from caller-provided context");
+    return calculateHaPriV2({
+        resultId: input.resultId,
+        rawContent: input.signal.content,
+        semanticFingerprint: input.semanticFingerprint,
+        adapter: input.signal.source_type,
+        publishedAt: input.signal.published_at,
+        retrievedAt: input.signal.retrieved_at,
+        engineVersion: input.engineVersion,
+    });
+}
+export function prepareProvenanceReadiness(input, options = {}) {
+    const normalizedInput = isNormalizedSignal(input);
+    const signal = normalizedInput ? input : normalizeSignal(coerceInput(input), options);
+    const warnings = [];
+    const reasons = [...signal.reasons];
+    const source = cleanString(signal.source);
+    const sourceCompleteness = sourceIdentityCompleteness(source);
+    const sourceType = cleanString(signal.source_type);
+    const sourceTypeWeak = !sourceType || WEAK_SOURCE_TYPES.has(sourceType.toLowerCase());
+    const retrievedAtWasProvided = normalizedInput ? null : hasStringField(input, "retrieved_at");
+    const timeCompleteness = timingCompleteness(signal, retrievedAtWasProvided);
+    const canonicalHash = canonicalContentHash(signal);
+    const semanticFingerprint = cleanString(options.semanticFingerprint)
+        ?? metadataString(signal, ["semantic_fingerprint", "semanticFingerprint"]);
+    const semanticFingerprintHash = semanticFingerprint ? sha256Hex(semanticFingerprint) : null;
+    const resultId = cleanString(options.resultId)
+        ?? cleanString(signal.id)
+        ?? metadataString(signal, ["result_id", "resultId", "source_id", "sourceId"])
+        ?? (sourceCompleteness === "complete" ? source : null);
+    const engineVersion = cleanString(options.engineVersion);
+    const derived = isDerivedContext(signal);
+    if (sourceCompleteness === "missing")
+        warnings.push("source identity is missing");
+    if (sourceCompleteness === "weak")
+        warnings.push("source identity is weak");
+    if (sourceCompleteness === "unusable")
+        warnings.push("source identity is unusable");
+    if (sourceTypeWeak)
+        warnings.push("source_type is missing or generic");
+    if (!signal.published_at)
+        warnings.push("published_at is missing or unusable");
+    if (retrievedAtWasProvided === false)
+        warnings.push("retrieved_at was missing; normalization time was used");
+    if (signal.date_confidence === "unknown")
+        warnings.push("timing confidence is unknown");
+    if (!canonicalHash)
+        warnings.push("content is missing; canonical content hash is unavailable");
+    if (!semanticFingerprintHash)
+        reasons.push("semantic fingerprint was not provided");
+    if (derived)
+        warnings.push("context appears copied, local, secondary, or derived; preserve the upstream source chain");
+    if (signal.status === "failed")
+        warnings.push("failed context has unknown provenance readiness");
+    const haPriV2 = prepareHaPriV2({
+        signal,
+        resultId,
+        semanticFingerprint,
+        engineVersion,
+        reasons,
+    });
+    const state = readinessState({
+        signal,
+        sourceCompleteness,
+        timingCompleteness: timeCompleteness,
+        sourceTypeWeak,
+        hasCanonicalHash: canonicalHash !== null,
+        derived,
+    });
+    return {
+        state,
+        source_identity: {
+            source,
+            source_type: sourceType,
+            result_id: resultId,
+            completeness: sourceCompleteness,
+        },
+        source_type: sourceType,
+        published_at: signal.published_at,
+        retrieved_at: signal.retrieved_at,
+        timing_confidence: signal.date_confidence,
+        timing_completeness: timeCompleteness,
+        canonical_content_sha256: canonicalHash,
+        semantic_fingerprint_sha256: semanticFingerprintHash,
+        ha_pri_v2: haPriV2,
+        warnings: unique(warnings),
+        reasons: unique(reasons),
+    };
+}

package/dist/core/rank.d.ts

@@ -0,0 +1,4 @@
+import type { FreshSignal, RankOptions, RankedSignal } from "./types.js";
+export declare function clampScore(value: number): number;
+export declare function rankSignal(signal: FreshSignal, options?: RankOptions): RankedSignal;
+export declare function rankSignals(signals: FreshSignal[], options?: RankOptions): RankedSignal[];

package/dist/core/readable.d.ts

@@ -0,0 +1,2 @@
+import type { ContextDecisionResult, CoreSignalEvaluationResult, HumanReadableContextResult } from "./types.js";
+export declare function toReadableContextResult(evaluation: CoreSignalEvaluationResult, decision: ContextDecisionResult): HumanReadableContextResult;

package/dist/core/readable.js

@@ -0,0 +1,75 @@
+const MAX_READABLE_REASONS = 5;
+const HANDOFF_SAFE_REASON = "Decision and complete provenance support agent handoff.";
+const HANDOFF_UNSAFE_DECISION_REASON = "Decision does not support agent handoff.";
+const HANDOFF_UNSAFE_PROVENANCE_REASON = "Provenance is not complete enough for agent handoff.";
+const HANDOFF_SAFE_DECISIONS = new Set([
+    "use_first",
+    "cite_as_primary",
+    "cite_as_supporting",
+    "use_as_background",
+]);
+const READER_LABELS = {
+    use_first: "Use first",
+    cite_as_primary: "Primary source",
+    cite_as_supporting: "Supporting source",
+    use_as_background: "Background only",
+    needs_verification: "Needs verification",
+    needs_refresh: "Needs refresh",
+    watch_only: "Watch only",
+    exclude: "Excluded",
+};
+const SUMMARIES = {
+    use_first: "This source is strong enough to use early in the context bundle.",
+    cite_as_primary: "This source is strong enough to use as main evidence.",
+    cite_as_supporting: "This source is useful as supporting evidence.",
+    use_as_background: "This source is useful as background, but should not carry the main claim.",
+    needs_verification: "This source may be relevant, but timing, origin, or confidence needs checking.",
+    needs_refresh: "This source may be outdated for the current task and should be refreshed.",
+    watch_only: "This source may be related, but is too weak to rely on directly.",
+    exclude: "This source should not be included as trusted context.",
+};
+const ACTIONS = {
+    use_first: "Use this near the front of the selected context while preserving provenance.",
+    cite_as_primary: "Use this as main evidence while preserving citation and provenance.",
+    cite_as_supporting: "Use this to support or qualify the answer, not as the only source.",
+    use_as_background: "Keep this as background context only.",
+    needs_verification: "Do not use this as primary evidence until it is checked.",
+    needs_refresh: "Look for a newer source before using this as current evidence.",
+    watch_only: "Do not rely on this directly; keep it for monitoring or review.",
+    exclude: "Keep this out of the final model context unless a human reviews it.",
+};
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function handoffFor(evaluation, decision) {
+    if (!HANDOFF_SAFE_DECISIONS.has(decision.decision)) {
+        return {
+            safe_for_agent_handoff: false,
+            reason: HANDOFF_UNSAFE_DECISION_REASON,
+        };
+    }
+    if (evaluation.provenance_readiness.state !== "complete") {
+        return {
+            safe_for_agent_handoff: false,
+            reason: HANDOFF_UNSAFE_PROVENANCE_REASON,
+        };
+    }
+    return {
+        safe_for_agent_handoff: true,
+        reason: HANDOFF_SAFE_REASON,
+    };
+}
+export function toReadableContextResult(evaluation, decision) {
+    const why = unique([
+        ...decision.reasons,
+        evaluation.explanation,
+    ]).slice(0, MAX_READABLE_REASONS);
+    return {
+        label: READER_LABELS[decision.decision],
+        summary: SUMMARIES[decision.decision],
+        why,
+        action: ACTIONS[decision.decision],
+        warnings: [...decision.warnings],
+        handoff: handoffFor(evaluation, decision),
+    };
+}

package/dist/core/signal.d.ts

@@ -0,0 +1,3 @@
+import type { FreshContextSignal, FreshContextSignalInput, SignalNormalizeOptions } from "./types.js";
+export declare const SIGNAL_CONTRACT_VERSION: "freshcontext.signal.v1";
+export declare function normalizeSignal(input: FreshContextSignalInput, options?: SignalNormalizeOptions): FreshContextSignal;

package/dist/core/sourceProfiles.d.ts

@@ -0,0 +1,4 @@
+import type { SourceProfile, SourceProfileId } from "./types.js";
+export declare const BUILT_IN_SOURCE_PROFILES: Readonly<Record<SourceProfileId, SourceProfile>>;
+export declare function listSourceProfiles(): SourceProfile[];
+export declare function getSourceProfile(profileId: string): SourceProfile | undefined;

package/dist/core/types.d.ts

@@ -0,0 +1,239 @@
+export interface FreshContext {
+    content: string;
+    source_url: string;
+    content_date: string | null;
+    retrieved_at: string;
+    freshness_confidence: "high" | "medium" | "low";
+    freshness_score: number | null;
+    adapter: string;
+}
+export interface ExtractOptions {
+    url: string;
+    prompt?: string;
+    maxLength?: number;
+    location?: string;
+    remoteOnly?: boolean;
+    maxAgeDays?: number;
+    keywords?: string[];
+}
+export interface AdapterResult {
+    raw: string;
+    content_date: string | null;
+    freshness_confidence: "high" | "medium" | "low";
+}
+export interface EnvelopeFormatOptions {
+    unknownDateText?: string;
+    publishedLabel?: string;
+}
+export type SignalConfidence = "high" | "medium" | "low";
+export type SignalDateConfidence = SignalConfidence | "unknown";
+export type SignalContractVersion = "freshcontext.signal.v1";
+export type SourceAuthorityHint = "high" | "medium" | "low";
+export type SourceDatePolicy = "strict" | "balanced" | "lenient";
+export type SourceFailurePolicy = "exclude" | "downgrade" | "warn";
+export type SourceSurface = "mcp" | "rest" | "sdk" | "cli" | "operator";
+export type SourceProfileId = "official_docs" | "code_activity" | "social_pulse" | "academic_research" | "market_finance" | "jobs_opportunities" | "government_regulatory" | "company_intel" | "composite_landscape" | "local_custom";
+export type ContextDecision = "use_first" | "cite_as_primary" | "cite_as_supporting" | "use_as_background" | "needs_verification" | "needs_refresh" | "watch_only" | "exclude";
+export type IntentProfileId = "citation_check" | "student_research" | "developer_adoption" | "job_search" | "market_watch" | "business_due_diligence" | "medical_literature_triage";
+export type ContextUtilityStatus = "success" | "partial" | "stale" | "failed" | "unknown";
+export interface SignalNormalizeOptions {
+    defaultSourceType?: string;
+    now?: Date | string;
+}
+export interface SourceProfile {
+    profile_id: SourceProfileId;
+    source_types: string[];
+    purpose: string;
+    default_decay_lambda: number;
+    half_life_hours: number;
+    authority_hint: SourceAuthorityHint;
+    date_policy: SourceDatePolicy;
+    failure_policy: SourceFailurePolicy;
+    recommended_surfaces: SourceSurface[];
+}
+export interface ContextDecisionOptions {
+    sourceProfile?: SourceProfile | SourceProfileId;
+    intentProfile?: IntentProfileId;
+}
+export interface ContextDecisionResult {
+    decision: ContextDecision;
+    label: string;
+    meaning: string;
+    action: string;
+    reasons: string[];
+    warnings: string[];
+}
+export interface HumanReadableHandoffResult {
+    safe_for_agent_handoff: boolean;
+    reason: string;
+}
+export interface HumanReadableContextResult {
+    label: string;
+    summary: string;
+    why: string[];
+    action: string;
+    warnings: string[];
+    handoff: HumanReadableHandoffResult;
+}
+export interface FreshContextSignalInput {
+    id?: string;
+    source: string;
+    source_type?: string;
+    title?: string;
+    content?: string;
+    published_at?: string | null;
+    content_date?: string | null;
+    retrieved_at?: string | null;
+    semantic_score?: number;
+    date_confidence?: SignalDateConfidence;
+    freshness_confidence?: SignalConfidence;
+    status?: ContextUtilityStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface FreshContextSignal {
+    contract_version: SignalContractVersion;
+    id?: string;
+    source: string;
+    source_type: string;
+    title?: string;
+    content?: string;
+    published_at: string | null;
+    retrieved_at: string;
+    semantic_score: number;
+    date_confidence: SignalDateConfidence;
+    status: ContextUtilityStatus;
+    metadata: Record<string, unknown>;
+    reasons: string[];
+}
+export interface FreshSignal {
+    id?: string;
+    source: string;
+    source_type?: string;
+    title?: string;
+    content?: string;
+    published_at?: string | null;
+    content_date?: string | null;
+    retrieved_at?: string | null;
+    semantic_score: number;
+    date_confidence?: SignalDateConfidence;
+    freshness_confidence?: SignalConfidence;
+    status?: ContextUtilityStatus;
+    metadata?: Record<string, unknown>;
+}
+export interface RankedSignal extends FreshSignal {
+    freshness_score: number | null;
+    final_score: number;
+    confidence: SignalConfidence;
+    reason: string;
+}
+export interface RankOptions {
+    semanticWeight?: number;
+    freshnessWeight?: number;
+    defaultSourceType?: string;
+    now?: Date | string;
+}
+export interface ContextUtilityInput {
+    contextualRelevance: number;
+    lambda: number;
+    ageHours: number;
+    dateConfidence?: SignalConfidence | "unknown";
+    status?: ContextUtilityStatus;
+}
+export interface ContextUtilityResult {
+    score: number;
+    contextualRelevance: number;
+    decayFactor: number;
+    dateConfidenceFactor: number;
+    statusFactor: number;
+    lambda: number;
+    ageHours: number;
+    status: ContextUtilityStatus;
+    reasons: string[];
+}
+export interface HaPriV2Input {
+    resultId: string;
+    rawContent: string;
+    semanticFingerprint?: string | null;
+    adapter: string;
+    publishedAt?: string | null;
+    retrievedAt?: string | null;
+    engineVersion: string;
+}
+export interface HaPriV2Material {
+    version: "FRESHCONTEXT_HA_PRI_V2";
+    resultId: string;
+    canonicalContentSha256: string;
+    semanticFingerprintSha256: string;
+    adapter: string;
+    publishedAt: string;
+    retrievedAt: string;
+    engineVersion: string;
+    signingPayload: string;
+}
+export interface HaPriV2Result extends HaPriV2Material {
+    haPriSigV2: string;
+}
+export type HaPriVerificationStatus = "valid" | "invalid" | "unknown";
+export interface HaPriV2VerificationResult {
+    status: HaPriVerificationStatus;
+    expected: string | null;
+    actual: string | null;
+    reasons: string[];
+}
+export type ProvenanceReadinessState = "complete" | "partial" | "incomplete" | "unknown" | "derived";
+export type ProvenanceSourceIdentityCompleteness = "complete" | "weak" | "missing" | "unusable";
+export type ProvenanceTimingCompleteness = "complete" | "partial" | "missing" | "unknown";
+export type ProvenanceReadinessInput = Partial<FreshContextSignalInput> | FreshContextSignal;
+export interface ProvenanceReadinessOptions extends SignalNormalizeOptions {
+    resultId?: string;
+    semanticFingerprint?: string | null;
+    engineVersion?: string;
+}
+export interface ProvenanceSourceIdentityResult {
+    source: string | null;
+    source_type: string | null;
+    result_id: string | null;
+    completeness: ProvenanceSourceIdentityCompleteness;
+}
+export interface ProvenanceReadinessResult {
+    state: ProvenanceReadinessState;
+    source_identity: ProvenanceSourceIdentityResult;
+    source_type: string | null;
+    published_at: string | null;
+    retrieved_at: string | null;
+    timing_confidence: SignalDateConfidence;
+    timing_completeness: ProvenanceTimingCompleteness;
+    canonical_content_sha256: string | null;
+    semantic_fingerprint_sha256: string | null;
+    ha_pri_v2: HaPriV2Result | null;
+    warnings: string[];
+    reasons: string[];
+}
+export interface CoreSignalProvenanceOptions {
+    resultId?: string;
+    semanticFingerprint?: string | null;
+    engineVersion?: string;
+}
+export interface CoreSignalEnvelopeResult {
+    context: FreshContext;
+    text: string;
+    structured: object;
+}
+export interface CoreSignalEvaluationOptions extends SignalNormalizeOptions, RankOptions {
+    includeEnvelope?: boolean;
+    envelopeMaxLength?: number;
+    envelopeFormat?: EnvelopeFormatOptions;
+    includeProvenance?: boolean;
+    provenance?: CoreSignalProvenanceOptions;
+}
+export interface CoreSignalEvaluationResult {
+    signal: FreshContextSignal;
+    freshness_score: number | null;
+    utility: ContextUtilityResult;
+    ranked: RankedSignal;
+    explanation: string;
+    envelope?: CoreSignalEnvelopeResult;
+    provenance?: HaPriV2Result;
+    provenance_readiness: ProvenanceReadinessResult;
+    reasons: string[];
+}

package/dist/core/utility.d.ts

@@ -0,0 +1,2 @@
+import type { ContextUtilityInput, ContextUtilityResult } from "./types.js";
+export declare function calculateContextUtility(input: ContextUtilityInput): ContextUtilityResult;

package/dist/rest/handler.d.ts

@@ -0,0 +1 @@
+export declare function handleRestRequest(request: Request): Promise<Response>;

package/dist/security.d.ts

@@ -0,0 +1,15 @@
+/**
+ * freshcontext-mcp security module
+ * Input sanitization, domain allowlists, and request validation
+ */
+export declare const ALLOWED_DOMAINS: Record<string, string[]>;
+export declare const MAX_URL_LENGTH = 500;
+export declare const MAX_QUERY_LENGTH = 200;
+export declare const MAX_PACKAGES_LENGTH = 300;
+export declare class SecurityError extends Error {
+    constructor(message: string);
+}
+export declare function validateUrl(rawUrl: string, adapterName: keyof typeof ALLOWED_DOMAINS): string;
+export declare function sanitizeQuery(query: string, maxLength?: number): string;
+export declare function sanitizePackages(input: string): string;
+export declare function formatSecurityError(err: unknown): string;

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server.js

@@ -23,7 +23,7 @@ import { EvaluateContextInputError, evaluateContextInput, formatEvaluateContextR
 import { formatSecurityError } from "./security.js";
 const server = new McpServer({
     name: "freshcontext-mcp",
-    version: "0.3.20",
+    version: "0.3.21",
 });
 const signalInputSchema = z.object({
     id: z.string().optional(),

package/dist/tools/evaluateContext.d.ts

@@ -0,0 +1,21 @@
+import type { ContextDecisionResult, CoreSignalEvaluationResult, IntentProfileId, SourceProfile } from "../core/index.js";
+export declare class EvaluateContextInputError extends Error {
+    constructor(message: string);
+}
+export interface EvaluateContextInput {
+    profile: string;
+    intent: string;
+    signals: unknown;
+    now?: string;
+}
+export interface EvaluateContextItem {
+    evaluation: CoreSignalEvaluationResult;
+    decision: ContextDecisionResult;
+}
+export interface EvaluateContextResult {
+    profile: SourceProfile;
+    intent: IntentProfileId;
+    items: EvaluateContextItem[];
+}
+export declare function evaluateContextInput(input: EvaluateContextInput): EvaluateContextResult;
+export declare function formatEvaluateContextResult(result: EvaluateContextResult): string;

package/dist/tools/evaluateContext.js

@@ -1,4 +1,4 @@
-import { evaluateSignals, getSourceProfile, interpretEvaluations, } from "../core/index.js";
+import { evaluateSignals, getSourceProfile, interpretEvaluations, toReadableContextResult, } from "../core/index.js";
 const SUPPORTED_INTENTS = [
     "citation_check",
     "student_research",
@@ -139,6 +139,8 @@ export function formatEvaluateContextResult(result) {
             utility_score: item.evaluation.utility.score,
             confidence: item.evaluation.ranked.confidence,
             why: item.evaluation.explanation,
+            provenance_readiness: item.evaluation.provenance_readiness,
+            readable: toReadableContextResult(item.evaluation, item.decision),
         })),
     };
     lines.push("[FRESHCONTEXT_EVALUATION_JSON]", JSON.stringify(structured, null, 2), "[/FRESHCONTEXT_EVALUATION_JSON]");

package/dist/tools/freshnessStamp.d.ts

@@ -0,0 +1 @@
+export { LAMBDA, stampFreshness, toStructuredJSON, formatForLLM, } from "../core/index.js";

package/dist/types.d.ts

@@ -0,0 +1 @@
+export type { FreshContext, ExtractOptions, AdapterResult } from "./core/types.js";