@indexnetwork/protocol 66.0.0-rc.608.1 → 66.0.0-rc.609.1

package/dist/internal/opportunities/radar/radar.graph.js

@@ -1,506 +0,0 @@
-/**
- * Radar Graph: Build the opportunity radar view — a flat, presenter-texted
- * list of opportunity cards for a viewer, optionally scoped to one intent.
- *
- * Flow:
- * loadOpportunities → checkPresenterCache → [generateCardText if misses]
- * → cachePresenterResults → normalizeItems
- *
- * Uses OpportunityPresenter for card text and caches presenter results via
- * OpportunityCache. Responses are a flat `items` array; clients bucket by
- * lifecycle status themselves.
- */
-import { StateGraph, START, END } from '@langchain/langgraph';
-import { RadarGraphState } from './radar.state.js';
-import { OpportunityPresenter, gatherPresenterContext } from '../opportunity.presentation.js';
-import { loadNegotiationContext } from '../negotiation-context.loader.js';
-import { canUserSeeOpportunity, isActionableForViewer, selectByComposition } from '../opportunity.utils.js';
-import { getPrimaryActionLabel, SECONDARY_ACTION_LABEL } from '../opportunity.labels.js';
-import { buildRadarCardPresentationCacheKey } from '../opportunity.presentation.js';
-import { protocolLogger } from '../../shared/observability/protocol.logger.js';
-import { timed } from '../../shared/observability/performance.js';
-import { requestContext } from "../../shared/observability/request-context.js";
-const logger = protocolLogger('RadarGraph');
-const checkPresenterCacheLog = protocolLogger('RadarGraph:checkPresenterCache');
-const cachePresenterResultsLog = protocolLogger('RadarGraph:cachePresenterResults');
-const generateCardTextLog = protocolLogger('RadarGraph:generateCardText');
-const normalizeItemsLog = protocolLogger('RadarGraph:normalizeItems');
-/** Default radar statuses: the lifecycle stages a viewer can act on today. */
-export const DEFAULT_RADAR_STATUSES = ['pending'];
-// Exhaustive registry — keys must cover every OpportunityStatus union member.
-// Adding a new status to OpportunityStatus without adding a key here is a TS error,
-// which is the whole point: prevents ALL_OPPORTUNITY_STATUSES from silently drifting.
-const OPPORTUNITY_STATUS_REGISTRY = {
-    negotiating: true,
-    pending: true,
-    accepted: true,
-    rejected: true,
-    expired: true,
-};
-/** Full status enumeration. Pass this to `RadarGraphInvokeInput.statuses` to restore pre-Issue-3 (unfiltered) behavior. */
-export const ALL_OPPORTUNITY_STATUSES = Object.keys(OPPORTUNITY_STATUS_REGISTRY);
-const PRESENTATION_CONCURRENCY = 50;
-const RADAR_CACHE_TTL = 24 * 60 * 60; // 24 hours in seconds
-/** Pure cache policy for presenter cards. */
-export function isRadarPresentationCacheable(card, status) {
-    return Boolean(status &&
-        status !== 'negotiating' &&
-        !card.presentationPending &&
-        card.name &&
-        card.name !== 'Unknown');
-}
-/**
- * Strip leading narrator name from remark when the UI already prepends "Name: " to the chip.
- * Avoids duplication like "Yankı Ekin Yüksel: Yankı Ekin Yüksel introduced you two..."
- * Repeats until no leading name (handles "Name: Name rest").
- */
-export function stripLeadingNarratorName(remark, narratorName) {
-    let t = remark.trim();
-    if (!t || !narratorName.trim())
-        return remark;
-    const name = narratorName.trim();
-    const nameLower = name.toLowerCase();
-    for (;;) {
-        const lower = t.toLowerCase();
-        if (!lower.startsWith(nameLower))
-            break;
-        const rest = t.slice(name.length).replace(/^\s*[:,\-–—]\s*/i, '').trim();
-        if (rest.length === 0 || rest === t)
-            break;
-        t = rest;
-    }
-    return t;
-}
-/** Normalize timestamp for sorting; returns numeric ms or 0 for invalid/missing. */
-const safeParseDate = (value) => {
-    if (value == null)
-        return 0;
-    if (value instanceof Date) {
-        const t = value.getTime();
-        return Number.isFinite(t) ? t : 0;
-    }
-    if (typeof value === 'number' && Number.isFinite(value))
-        return value;
-    if (typeof value === 'string') {
-        const t = new Date(value).getTime();
-        if (!Number.isNaN(t))
-            return t;
-    }
-    return 0;
-};
-/** Confidence score for sorting (interpretation.confidence or opportunity.confidence). */
-const getRawConfidence = (opp) => {
-    const fromInterp = opp.interpretation?.confidence;
-    if (typeof fromInterp === 'number' && !Number.isNaN(fromInterp))
-        return fromInterp;
-    if (typeof fromInterp === 'string') {
-        const n = parseFloat(fromInterp);
-        if (!Number.isNaN(n))
-            return n;
-    }
-    const fromRow = opp.confidence;
-    if (typeof fromRow === 'number' && !Number.isNaN(fromRow))
-        return fromRow;
-    if (typeof fromRow === 'string') {
-        const n = parseFloat(fromRow);
-        if (!Number.isNaN(n))
-            return n;
-    }
-    return 0;
-};
-/** Unique non-viewer userIds for an opportunity (actors can repeat). */
-const getUniqueCounterpartUserIds = (opp, viewerId) => {
-    const ids = new Set();
-    for (const a of opp.actors) {
-        if (a.userId !== viewerId && a.userId) {
-            ids.add(a.userId);
-        }
-    }
-    return ids;
-};
-const pickDisplayCounterpartActor = (opportunity, viewerId) => {
-    const candidates = opportunity.actors.filter((actor) => actor.userId !== viewerId);
-    if (candidates.length === 0) {
-        return null;
-    }
-    // Prefer direct counterpart roles when available, then stable sort by user id.
-    const rolePriority = new Map([
-        ['patient', 0],
-        ['party', 1],
-        ['agent', 2],
-        ['peer', 3],
-    ]);
-    const sorted = [...candidates].sort((a, b) => {
-        const aPriority = rolePriority.get(a.role) ?? 99;
-        const bPriority = rolePriority.get(b.role) ?? 99;
-        if (aPriority !== bPriority)
-            return aPriority - bPriority;
-        return a.userId.localeCompare(b.userId);
-    });
-    return sorted[0] ?? null;
-};
-export class RadarGraphFactory {
-    constructor(database, cache) {
-        this.deps = { database, cache, presenter: new OpportunityPresenter() };
-    }
-    createGraph() {
-        const deps = this.deps;
-        const graph = new StateGraph(RadarGraphState)
-            .addNode('loadOpportunities', (state) => loadOpportunitiesNode(state, deps))
-            .addNode('checkPresenterCache', (state) => checkPresenterCacheNode(state, deps))
-            .addNode('generateCardText', (state) => generateCardTextNode(state, deps))
-            .addNode('cachePresenterResults', (state) => cachePresenterResultsNode(state, deps))
-            .addNode('normalizeItems', normalizeItemsNode)
-            .addEdge(START, 'loadOpportunities')
-            .addEdge('loadOpportunities', 'checkPresenterCache')
-            .addConditionalEdges('checkPresenterCache', (state) => shouldGenerateCards(state, deps), {
-            generate: 'generateCardText',
-            skip: 'cachePresenterResults',
-        })
-            .addEdge('generateCardText', 'cachePresenterResults')
-            .addEdge('cachePresenterResults', 'normalizeItems')
-            .addEdge('normalizeItems', END);
-        return graph.compile();
-    }
-}
-export async function loadOpportunitiesNode(state, deps) {
-    return timed("RadarGraph.loadOpportunities", async () => {
-        if (!state.userId) {
-            return { error: 'userId is required' };
-        }
-        try {
-            // Minimum of 50 ensures enough candidates across all radar categories
-            // (connection, expired) for selectByComposition to fill
-            // its soft targets, even after visibility filtering and dedup.
-            const fetchLimit = Math.min(150, Math.max(50, state.limit * 3));
-            const statuses = state.statuses ?? DEFAULT_RADAR_STATUSES;
-            const options = {
-                limit: fetchLimit,
-                statuses,
-            };
-            if (state.networkId)
-                options.networkId = state.networkId;
-            if (state.scopeType === 'intent' && state.scopeId) {
-                options.scopeType = 'intent';
-                options.scopeId = state.scopeId;
-            }
-            // Do not pass conversationId: radar view excludes draft opportunities (chat-only drafts).
-            const raw = await deps.database.getOpportunitiesForUser(state.userId, options);
-            const visible = raw.filter((opp) => canUserSeeOpportunity(opp.actors, opp.status, state.userId));
-            // Actionability only gates the live statuses a viewer could act on:
-            // latent/pending cards the viewer cannot act on are noise, but
-            // terminal/internal statuses (accepted, rejected, expired, negotiating,
-            // draft) are deliberate history — when a caller explicitly
-            // requests them via `statuses`, they must pass through (they are never
-            // actionable by rule 5, so filtering them here would return nothing).
-            // The requested-status membership check is defense-in-depth: rows
-            // outside the requested set are dropped even if the adapter drifts.
-            const requestedStatuses = new Set(statuses);
-            const visibleForRadar = visible.filter((opp) => {
-                if (!requestedStatuses.has(opp.status))
-                    return false;
-                if (opp.status === 'pending') {
-                    return isActionableForViewer(opp.actors, opp.status, state.userId, opp.committedActorIds ?? []);
-                }
-                return true;
-            });
-            const explicitStatuses = (state.statuses?.length ?? 0) > 0;
-            if (explicitStatuses) {
-                // Lifecycle view (e.g. intent radar): newest-created first so status
-                // transitions do not reorder cards merely by touching updatedAt.
-                // Counterpart dedup still keeps each person's newest opportunity; no
-                // composition capping because the caller wants the full pipeline.
-                const newestFirst = [...visibleForRadar].sort((a, b) => safeParseDate(b.createdAt) - safeParseDate(a.createdAt));
-                const seenIds = new Set();
-                const dedupedByCounterpart = newestFirst.filter((opp) => {
-                    const counterpartIds = getUniqueCounterpartUserIds(opp, state.userId);
-                    const hasOverlap = [...counterpartIds].some((id) => seenIds.has(id));
-                    if (hasOverlap)
-                        return false;
-                    for (const id of counterpartIds)
-                        seenIds.add(id);
-                    return true;
-                });
-                return { opportunities: dedupedByCounterpart.slice(0, state.limit) };
-            }
-            const sorted = [...visibleForRadar].sort((a, b) => {
-                const confA = getRawConfidence(a);
-                const confB = getRawConfidence(b);
-                if (confB !== confA)
-                    return confB - confA;
-                const aTime = safeParseDate(a.updatedAt);
-                const bTime = safeParseDate(b.updatedAt);
-                return bTime - aTime;
-            });
-            const seenUserIds = new Set();
-            const deduped = sorted.filter((opp) => {
-                const counterpartIds = getUniqueCounterpartUserIds(opp, state.userId);
-                const hasOverlap = [...counterpartIds].some((id) => seenUserIds.has(id));
-                if (hasOverlap)
-                    return false;
-                for (const id of counterpartIds)
-                    seenUserIds.add(id);
-                return true;
-            });
-            const opportunities = selectByComposition(deduped, state.userId);
-            return { opportunities };
-        }
-        catch (e) {
-            logger.error('RadarGraph loadOpportunities failed', { error: e });
-            return { error: 'Failed to load opportunities', opportunities: [] };
-        }
-    });
-}
-export async function checkPresenterCacheNode(state, deps) {
-    return timed("RadarGraph.checkPresenterCache", async () => {
-        const { opportunities, userId, scopeId } = state;
-        if (opportunities.length === 0) {
-            return { cachedCards: new Map(), uncachedOpportunities: [] };
-        }
-        if (state.noCache) {
-            checkPresenterCacheLog.verbose('noCache=true, skipping cache');
-            return { cachedCards: new Map(), uncachedOpportunities: opportunities };
-        }
-        try {
-            // Negotiating cards are templated (no LLM call) and their text
-            // depends on the live turn count, which changes between requests
-            // without changing the opportunity status. Skip cache entirely
-            // for them so each render reflects the current turn.
-            //
-            // For all other statuses, include status in the key so status
-            // transitions (e.g. negotiating → pending) don't serve stale cards.
-            const cacheable = opportunities.filter((opp) => opp.status !== 'negotiating');
-            const liveNegotiating = opportunities.filter((opp) => opp.status === 'negotiating');
-            const keys = cacheable.map((opp) => buildRadarCardPresentationCacheKey(opp.id, opp.status, userId, scopeId));
-            const results = keys.length > 0 ? await deps.cache.mget(keys) : [];
-            const cachedCards = new Map();
-            const uncachedOpportunities = [...liveNegotiating];
-            for (let i = 0; i < cacheable.length; i++) {
-                const cached = results[i];
-                if (cached) {
-                    const originalIndex = opportunities.indexOf(cacheable[i]);
-                    // Stamp the live status: pre-status cache entries lack the field,
-                    // and the key already guarantees it matches the current status.
-                    cachedCards.set(cacheable[i].id, {
-                        ...cached,
-                        status: cacheable[i].status,
-                        _cardIndex: originalIndex,
-                    });
-                }
-                else {
-                    uncachedOpportunities.push(cacheable[i]);
-                }
-            }
-            checkPresenterCacheLog.verbose('', {
-                total: opportunities.length,
-                cacheHits: cachedCards.size,
-                cacheMisses: uncachedOpportunities.length,
-            });
-            return { cachedCards, uncachedOpportunities };
-        }
-        catch (e) {
-            checkPresenterCacheLog.warn('cache unavailable, skipping', { error: e });
-            return { cachedCards: new Map(), uncachedOpportunities: opportunities };
-        }
-    });
-}
-export function shouldGenerateCards(state, _deps) {
-    if (state.uncachedOpportunities.length > 0) {
-        return 'generate';
-    }
-    logger.verbose('All presenter results cached, skipping generation');
-    return 'skip';
-}
-export async function generateCardTextNode(state, deps) {
-    return timed("RadarGraph.generateCardText", async () => {
-        const opportunities = state.uncachedOpportunities.length > 0
-            ? state.uncachedOpportunities
-            : state.opportunities;
-        generateCardTextLog.verbose('entry', { opportunitiesLength: opportunities.length, userId: state.userId });
-        if (opportunities.length === 0) {
-            generateCardTextLog.verbose('exit', { totalOpportunities: 0 });
-            return { cards: [], agentTimings: [], meta: { totalOpportunities: 0 } };
-        }
-        const db = deps.database;
-        const cards = [];
-        const relevantActorIds = new Set();
-        for (const opp of opportunities) {
-            for (const a of opp.actors) {
-                if (a.userId)
-                    relevantActorIds.add(a.userId);
-            }
-        }
-        const userEntries = await Promise.all(Array.from(relevantActorIds).map(async (userId) => {
-            try {
-                const user = await deps.database.getUser(userId);
-                return [userId, user ?? null];
-            }
-            catch {
-                return [userId, null];
-            }
-        }));
-        const userMap = new Map(userEntries);
-        const oppIndexMap = new Map(state.opportunities.map((opp, idx) => [opp.id, idx]));
-        const agentTimingsAccum = [];
-        for (let i = 0; i < opportunities.length; i += PRESENTATION_CONCURRENCY) {
-            const chunk = opportunities.slice(i, i + PRESENTATION_CONCURRENCY);
-            const chunkCards = await Promise.all(chunk.map(async (opportunity, offset) => {
-                const cardIndex = oppIndexMap.get(opportunity.id) ?? (i + offset);
-                const viewerActor = opportunity.actors.find((a) => a.userId === state.userId);
-                const viewerRole = viewerActor?.role ?? 'party';
-                const preferredActor = pickDisplayCounterpartActor(opportunity, state.userId)
-                    ?? opportunity.actors.find((a) => a.userId !== state.userId);
-                const actorWithProfile = opportunity.actors.find((a) => a.userId !== state.userId && !!userMap.get(a.userId));
-                const otherActor = (preferredActor && userMap.get(preferredActor.userId))
-                    ? preferredActor
-                    : (actorWithProfile ?? preferredActor);
-                const otherUser = otherActor ? userMap.get(otherActor.userId) ?? null : null;
-                let userName = otherUser?.name ?? 'Unknown';
-                // Fallback to profile identity name when users.name is missing (e.g. profile has display name, users row does not)
-                if ((userName === 'Unknown' || !userName?.trim()) && otherActor?.userId && db.getProfile) {
-                    const profile = await db.getProfile(otherActor.userId).catch((err) => {
-                        logger.debug('getProfile fallback failed', { otherActorUserId: otherActor.userId, error: err });
-                        return null;
-                    });
-                    const profileName = profile?.identity?.name?.trim();
-                    if (profileName)
-                        userName = profileName;
-                }
-                // Unresolvable display counterpart (deleted user: no users row, no
-                // profile fallback). Drop the card entirely instead of rendering an
-                // "Unknown" placeholder: such cards are unusable, excluded from the
-                // deps.presenter cache (see cachePresenterResults), and would otherwise
-                // trigger a fresh deps.presenter LLM call on every request — a permanent
-                // cache miss that keeps the whole radar slow (~9s per load).
-                if (userName === 'Unknown' || !userName?.trim()) {
-                    logger.verbose('[RadarGraph:generateCardText] dropping card with unresolvable counterpart', {
-                        opportunityId: opportunity.id,
-                        otherActorUserId: otherActor?.userId,
-                    });
-                    return null;
-                }
-                const userAvatar = otherUser?.avatar ?? null;
-                // Skeleton presentation: return an identity-only card without the
-                // deps.presenter LLM or negotiation-context load. Name resolution and
-                // the unresolvable-counterpart drop above still apply, so the card
-                // set matches what the follow-up full request will return.
-                if (state.presentation === 'skeleton') {
-                    return {
-                        opportunityId: opportunity.id,
-                        status: opportunity.status,
-                        userId: otherActor?.userId ?? '',
-                        name: userName,
-                        avatar: userAvatar,
-                        mainText: '',
-                        cta: '',
-                        primaryActionLabel: getPrimaryActionLabel(viewerRole),
-                        secondaryActionLabel: SECONDARY_ACTION_LABEL,
-                        mutualIntentsLabel: 'Shared interests',
-                        viewerRole,
-                        presentationPending: true,
-                        _cardIndex: cardIndex,
-                    };
-                }
-                try {
-                    const [ctx, negotiationContext] = await Promise.all([
-                        gatherPresenterContext(db, opportunity, state.userId, otherActor?.userId, state.scopeId),
-                        loadNegotiationContext(db, opportunity.id, opportunity.status, state.userId),
-                    ]);
-                    const presenterInput = {
-                        ...ctx,
-                        mutualIntentCount: undefined,
-                        opportunityStatus: opportunity.status,
-                        ...(negotiationContext ? { negotiationContext } : {}),
-                    };
-                    const _traceEmitterPresenter = requestContext.getStore()?.traceEmitter;
-                    const presenterStart = Date.now();
-                    _traceEmitterPresenter?.({ type: "agent_start", name: "opportunity-presenter" });
-                    const presentation = await deps.presenter.presentCard(presenterInput);
-                    const _presenterDuration = Date.now() - presenterStart;
-                    agentTimingsAccum.push({ name: 'opportunity.presenter', durationMs: _presenterDuration });
-                    _traceEmitterPresenter?.({ type: "agent_end", name: "opportunity-presenter", durationMs: _presenterDuration, summary: `Presented: ${userName}` });
-                    // Every card is system-discovered now: one narrator.
-                    const narratorChip = { name: 'Index', text: presentation.narratorRemark };
-                    return {
-                        opportunityId: opportunity.id,
-                        status: opportunity.status,
-                        userId: otherActor?.userId ?? '',
-                        name: userName,
-                        avatar: userAvatar,
-                        mainText: presentation.personalizedSummary,
-                        cta: presentation.suggestedAction,
-                        headline: presentation.headline,
-                        primaryActionLabel: getPrimaryActionLabel(viewerRole),
-                        secondaryActionLabel: SECONDARY_ACTION_LABEL,
-                        mutualIntentsLabel: presentation.mutualIntentsLabel,
-                        narratorChip,
-                        viewerRole,
-                        _cardIndex: cardIndex,
-                    };
-                }
-                catch (e) {
-                    logger.warn('RadarGraph presenter failed for opportunity', { opportunityId: opportunity.id, error: e });
-                    return null;
-                }
-            }));
-            cards.push(...chunkCards.filter((c) => c !== null));
-        }
-        generateCardTextLog.verbose('exit', { totalOpportunities: state.opportunities.length });
-        return {
-            cards,
-            agentTimings: agentTimingsAccum,
-            meta: { totalOpportunities: state.opportunities.length },
-        };
-    });
-}
-export async function cachePresenterResultsNode(state, deps) {
-    return timed("RadarGraph.cachePresenterResults", async () => {
-        const { cards, cachedCards, userId, opportunities, scopeId } = state;
-        // Only cache cards that weren't already from cache
-        const newCards = cards.filter((card) => !cachedCards.has(card.opportunityId));
-        const statusById = new Map(opportunities.map((opp) => [opp.id, opp.status]));
-        try {
-            await Promise.all(newCards.map((card) => {
-                const status = statusById.get(card.opportunityId);
-                // Negotiating, skeleton, and unresolved-name cards are
-                // safe for the current response but must not become 24h entries.
-                if (!status || !isRadarPresentationCacheable(card, status))
-                    return Promise.resolve();
-                return deps.cache.set(buildRadarCardPresentationCacheKey(card.opportunityId, status, userId, scopeId), card, { ttl: RADAR_CACHE_TTL });
-            }));
-        }
-        catch (e) {
-            cachePresenterResultsLog.warn('cache write failed, continuing', { error: e });
-        }
-        // Merge cached cards into full card list
-        const allCards = [...cards];
-        for (const [oppId, cachedCard] of cachedCards) {
-            if (!cards.some((card) => card.opportunityId === oppId)) {
-                allCards.push(cachedCard);
-            }
-        }
-        // Re-sort by _cardIndex to maintain original ordering
-        allCards.sort((a, b) => a._cardIndex - b._cardIndex);
-        cachePresenterResultsLog.verbose('', {
-            newlyCached: newCards.length,
-            totalCards: allCards.length,
-        });
-        return {
-            cards: allCards,
-            meta: { totalOpportunities: state.opportunities.length },
-        };
-    });
-}
-export async function normalizeItemsNode(state) {
-    return timed("RadarGraph.normalizeItems", async () => {
-        normalizeItemsLog.verbose('entry', { cardsLength: state.cards.length });
-        const createdAtById = new Map(state.opportunities.map((opportunity) => [opportunity.id, opportunity.createdAt.toISOString()]));
-        const items = state.cards.map((card) => {
-            const { _cardIndex, ...rest } = card;
-            return { ...rest, createdAt: createdAtById.get(card.opportunityId) };
-        });
-        const meta = { totalOpportunities: state.opportunities.length };
-        normalizeItemsLog.verbose('exit', { totalOpportunities: meta.totalOpportunities, totalItems: items.length });
-        return { items, meta };
-    });
-}

package/dist/internal/opportunities/radar/radar.state.d.ts

@@ -1,86 +0,0 @@
-import type { Opportunity, OpportunityStatus } from '../../../platform/database.js';
-import type { DebugMetaAgent } from "../../../protocol/core.js";
-/**
- * Radar card item: one opportunity with full presenter-driven display contract.
- */
-export interface RadarCardItem {
-    opportunityId: string;
-    createdAt?: string;
-    /** Lifecycle status of the underlying opportunity at render time (client bucketing, e.g. intent radar). */
-    status?: OpportunityStatus;
-    userId: string;
-    name: string;
-    avatar: string | null;
-    mainText: string;
-    cta: string;
-    headline?: string;
-    /** Presenter-generated; primary button (accept) and secondary button (dismiss). */
-    primaryActionLabel: string;
-    secondaryActionLabel: string;
-    /** Presenter-generated subtitle under the other party name (e.g. "1 mutual intent"). */
-    mutualIntentsLabel: string;
-    /** Narrator chip for human-introduced opportunities; avatar set when narrator is a user */
-    narratorChip?: {
-        name: string;
-        text: string;
-        avatar?: string | null;
-        userId?: string;
-    };
-    /** Viewer's role in this opportunity (e.g. 'party', 'agent', 'patient', 'peer'). */
-    viewerRole?: string;
-    /**
-     * True when this card was produced by a skeleton-presentation run: identity
-     * fields (name/avatar/status) are real but mainText/cta are empty because the
-     * presenter LLM was skipped. Clients render a shimmer body and re-fetch the
-     * full view. Skeleton cards are never written to the presenter cache.
-     */
-    presentationPending?: boolean;
-    /** Internal: original position in the loaded opportunity list, for stable ordering. */
-    _cardIndex: number;
-}
-/** Card item as returned in API responses (no internal fields). */
-export type RadarResponseItem = Omit<RadarCardItem, '_cardIndex'>;
-/**
- * Radar Graph State (Annotation-based).
- * Flow: loadOpportunities → checkPresenterCache → [generateCardText if misses]
- * → cachePresenterResults → normalizeItems.
- */
-export declare const RadarGraphState: import("@langchain/langgraph").AnnotationRoot<{
-    userId: import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
-    networkId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    scopeType: import("@langchain/langgraph").BaseChannel<"intent" | undefined, "intent" | import("@langchain/langgraph").OverwriteValue<"intent" | undefined> | undefined, unknown>;
-    scopeId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    limit: import("@langchain/langgraph").BaseChannel<number, number | import("@langchain/langgraph").OverwriteValue<number>, unknown>;
-    /** When true, bypass the presenter Redis cache. */
-    noCache: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
-    /**
-     * Presentation depth. 'full' (default) runs the presenter LLM for cache
-     * misses. 'skeleton' skips it: uncached cards come back with resolved
-     * identity (name/avatar/status) and `presentationPending: true`, cached
-     * cards come back complete.
-     */
-    presentation: import("@langchain/langgraph").BaseChannel<"full" | "skeleton", "full" | "skeleton" | import("@langchain/langgraph").OverwriteValue<"full" | "skeleton">, unknown>;
-    /** Optional status filter. When undefined, the graph uses `DEFAULT_RADAR_STATUSES`. */
-    statuses: import("@langchain/langgraph").BaseChannel<OpportunityStatus[] | undefined, OpportunityStatus[] | import("@langchain/langgraph").OverwriteValue<OpportunityStatus[] | undefined> | undefined, unknown>;
-    /** Raw opportunities visible to the viewer (after visibility filter). */
-    opportunities: import("@langchain/langgraph").BaseChannel<Opportunity[], Opportunity[] | import("@langchain/langgraph").OverwriteValue<Opportunity[]>, unknown>;
-    /** Cards with presenter output and narrator chip. */
-    cards: import("@langchain/langgraph").BaseChannel<RadarCardItem[], RadarCardItem[] | import("@langchain/langgraph").OverwriteValue<RadarCardItem[]>, unknown>;
-    /** Final items for response (internal fields stripped). */
-    items: import("@langchain/langgraph").BaseChannel<RadarResponseItem[], RadarResponseItem[] | import("@langchain/langgraph").OverwriteValue<RadarResponseItem[]>, unknown>;
-    /** Presenter results retrieved from cache (opportunityId → RadarCardItem). */
-    cachedCards: import("@langchain/langgraph").BaseChannel<Map<string, RadarCardItem>, Map<string, RadarCardItem> | import("@langchain/langgraph").OverwriteValue<Map<string, RadarCardItem>>, unknown>;
-    /** Opportunities that had no cache hit and need presenter generation. */
-    uncachedOpportunities: import("@langchain/langgraph").BaseChannel<Opportunity[], Opportunity[] | import("@langchain/langgraph").OverwriteValue<Opportunity[]>, unknown>;
-    error: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /** Meta for response (e.g. totalOpportunities). */
-    meta: import("@langchain/langgraph").BaseChannel<{
-        totalOpportunities: number;
-    }, {
-        totalOpportunities: number;
-    } | import("@langchain/langgraph").OverwriteValue<{
-        totalOpportunities: number;
-    }>, unknown>;
-    /** Timing records for each agent invocation within this graph run. */
-    agentTimings: import("@langchain/langgraph").BaseChannel<DebugMetaAgent[], DebugMetaAgent[] | import("@langchain/langgraph").OverwriteValue<DebugMetaAgent[]>, unknown>;
-}>;