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

package/dist/internal/opportunities/opportunity.cards.js

@@ -0,0 +1,165 @@
+/**
+ * Opportunity cards: presenter-texted cards for a viewer, as a list or one at
+ * a time. The list loads, filters, and dedupes the viewer's opportunities,
+ * serves cached cards, and presents the misses through OpportunityPresenter.
+ */
+import { protocolLogger } from '../shared/observability/protocol.logger.js';
+import { buildOpportunityCardCacheKey, gatherPresenterContext } from './opportunity.presentation.js';
+import { loadNegotiationContext } from './negotiation-context.loader.js';
+import { canUserSeeOpportunity, isActionableForViewer } from './opportunity.utils.js';
+import { getPrimaryActionLabel, SECONDARY_ACTION_LABEL } from './opportunity.labels.js';
+const logger = protocolLogger('OpportunityCards');
+const PRESENTATION_CONCURRENCY = 50;
+const CARD_CACHE_TTL = 24 * 60 * 60;
+const ROLE_PRIORITY = new Map([
+    ['patient', 0],
+    ['party', 1],
+    ['agent', 2],
+    ['peer', 3],
+]);
+/** Prefer direct counterpart roles, then a stable sort by user id. */
+function pickDisplayCounterpartActor(opportunity, viewerId) {
+    const candidates = opportunity.actors.filter((actor) => actor.userId !== viewerId);
+    return [...candidates].sort((a, b) => {
+        const aPriority = ROLE_PRIORITY.get(a.role) ?? 99;
+        const bPriority = ROLE_PRIORITY.get(b.role) ?? 99;
+        if (aPriority !== bPriority)
+            return aPriority - bPriority;
+        return a.userId.localeCompare(b.userId);
+    })[0] ?? null;
+}
+function counterpartUserIds(opportunity, viewerId) {
+    return new Set(opportunity.actors.map((a) => a.userId).filter((id) => id && id !== viewerId));
+}
+/**
+ * Present one opportunity as a card for the viewer.
+ *
+ * @param deps - Database, cache, and presenter.
+ * @param opportunity - The opportunity to present.
+ * @param viewerId - The viewing user.
+ * @param options - `intentId` focuses viewer context on one intent; `skeleton` skips the presenter.
+ * @returns The card, or null when the counterpart's name cannot be resolved.
+ * @throws When the presenter fails.
+ */
+export async function presentOpportunityCard(deps, opportunity, viewerId, options = {}) {
+    const { database } = deps;
+    const viewerRole = opportunity.actors.find((a) => a.userId === viewerId)?.role ?? 'party';
+    const counterpart = pickDisplayCounterpartActor(opportunity, viewerId);
+    if (!counterpart)
+        return null;
+    const user = await database.getUser(counterpart.userId).catch(() => null);
+    let name = user?.name?.trim();
+    if (!name) {
+        const profile = await database.getProfile(counterpart.userId).catch(() => null);
+        name = profile?.identity?.name?.trim();
+    }
+    if (!name)
+        return null;
+    const identity = {
+        opportunityId: opportunity.id,
+        createdAt: opportunity.createdAt.toISOString(),
+        status: opportunity.status,
+        userId: counterpart.userId,
+        name,
+        avatar: user?.avatar ?? null,
+        primaryActionLabel: getPrimaryActionLabel(viewerRole),
+        secondaryActionLabel: SECONDARY_ACTION_LABEL,
+        viewerRole,
+    };
+    if (options.skeleton) {
+        return { ...identity, mainText: '', cta: '', mutualIntentsLabel: 'Shared interests', presentationPending: true };
+    }
+    const [context, negotiationContext] = await Promise.all([
+        gatherPresenterContext(database, opportunity, viewerId, counterpart.userId, options.intentId),
+        loadNegotiationContext(database, opportunity.id, opportunity.status, viewerId),
+    ]);
+    const presentation = await deps.presenter.presentCard({
+        ...context,
+        opportunityStatus: opportunity.status,
+        ...(negotiationContext ? { negotiationContext } : {}),
+    });
+    return {
+        ...identity,
+        mainText: presentation.personalizedSummary,
+        cta: presentation.suggestedAction,
+        headline: presentation.headline,
+        mutualIntentsLabel: presentation.mutualIntentsLabel,
+        narratorChip: { name: 'Index', text: presentation.narratorRemark },
+    };
+}
+/**
+ * List the viewer's opportunities in the given statuses as presented cards,
+ * newest first, one card per counterpart. Cards whose presentation fails are
+ * dropped.
+ *
+ * @param deps - Database, cache, and presenter.
+ * @param input - Viewer, statuses, optional network/intent scope, limit, cache bypass, skeleton mode.
+ * @returns The cards and the number of opportunities selected.
+ */
+export async function listOpportunityCards(deps, input) {
+    const { viewerId, intentId } = input;
+    const raw = await deps.database.getOpportunitiesForUser(viewerId, {
+        limit: Math.min(150, Math.max(50, input.limit * 3)),
+        statuses: input.statuses,
+        ...(input.networkId ? { networkId: input.networkId } : {}),
+        ...(intentId ? { scopeType: 'intent', scopeId: intentId } : {}),
+    });
+    const requested = new Set(input.statuses);
+    const visible = raw
+        .filter((opp) => requested.has(opp.status) && canUserSeeOpportunity(opp.actors, opp.status, viewerId))
+        .filter((opp) => opp.status !== 'pending'
+        || isActionableForViewer(opp.actors, opp.status, viewerId, opp.committedActorIds ?? []))
+        .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const seen = new Set();
+    const opportunities = visible.filter((opp) => {
+        const ids = counterpartUserIds(opp, viewerId);
+        if ([...ids].some((id) => seen.has(id)))
+            return false;
+        for (const id of ids)
+            seen.add(id);
+        return true;
+    }).slice(0, input.limit);
+    const cacheable = (opp) => opp.status !== 'negotiating';
+    const keyFor = (opp) => buildOpportunityCardCacheKey(opp.id, opp.status, viewerId, intentId);
+    const cacheableOpps = input.noCache ? [] : opportunities.filter(cacheable);
+    const cached = new Map();
+    if (cacheableOpps.length > 0) {
+        try {
+            const hits = await deps.cache.mget(cacheableOpps.map(keyFor));
+            cacheableOpps.forEach((opp, i) => {
+                const hit = hits[i];
+                if (hit)
+                    cached.set(opp.id, { ...hit, status: opp.status });
+            });
+        }
+        catch (error) {
+            logger.warn('card cache read failed, presenting all', { error });
+        }
+    }
+    const cards = [];
+    for (let i = 0; i < opportunities.length; i += PRESENTATION_CONCURRENCY) {
+        const chunk = opportunities.slice(i, i + PRESENTATION_CONCURRENCY);
+        cards.push(...await Promise.all(chunk.map(async (opp) => {
+            const hit = cached.get(opp.id);
+            if (hit)
+                return hit;
+            try {
+                const card = await presentOpportunityCard(deps, opp, viewerId, { intentId, skeleton: input.skeleton });
+                if (card && !card.presentationPending && cacheable(opp)) {
+                    await deps.cache.set(keyFor(opp), card, { ttl: CARD_CACHE_TTL }).catch((error) => {
+                        logger.warn('card cache write failed', { opportunityId: opp.id, error });
+                    });
+                }
+                return card;
+            }
+            catch (error) {
+                logger.warn('presenter failed, dropping card', { opportunityId: opp.id, error });
+                return null;
+            }
+        })));
+    }
+    return {
+        cards: cards.filter((card) => card !== null),
+        totalOpportunities: opportunities.length,
+    };
+}

package/dist/internal/opportunities/opportunity.presentation.d.ts

@@ -20,7 +20,7 @@ export interface UserInfo {
 }
 /** Cache namespace for opportunity presentation copy. Bump to invalidate copy safety changes. */
 export declare const OPPORTUNITY_PRESENTATION_CACHE_VERSION = "v2";
-export declare function buildRadarCardPresentationCacheKey(opportunityId: string, status: string, viewerId: string, focusedViewerIntentId?: string): string;
+export declare function buildOpportunityCardCacheKey(opportunityId: string, status: string, viewerId: string, focusedViewerIntentId?: string): string;
 export declare function buildApiChatCardPresentationCacheKey(opportunityId: string, viewerId: string): string;
 /**
  * Opportunity Presenter Agent
@@ -159,7 +159,7 @@ export declare function summarizeSignalsForPresenter(signals: Opportunity['inter
  * Gather all context needed for the presenter from the database.
  * Fetches viewer profile, viewer intents, other party profile(s), and network in parallel.
  *
- * @param displayCounterpartUserId - When set (e.g. for a radar card), only this counterpart is included in otherPartyContext so the presenter writes about the person on the card.
+ * @param displayCounterpartUserId - When set (e.g. for an opportunity card), only this counterpart is included in otherPartyContext so the presenter writes about the person on the card.
  * @param focusedViewerIntentId - When set, include only that active intent in viewer context.
  */
 export declare function gatherPresenterContext(database: PresenterDatabase, opportunity: Opportunity, viewerId: string, displayCounterpartUserId?: string, focusedViewerIntentId?: string): Promise<PresenterInput>;

package/dist/internal/opportunities/opportunity.presentation.js

@@ -27,9 +27,9 @@ import { createStructuredModel } from "../shared/agent/model.config.js";
 // ──────────────────────────────────────────────────────────────────────
 /** Cache namespace for opportunity presentation copy. Bump to invalidate copy safety changes. */
 export const OPPORTUNITY_PRESENTATION_CACHE_VERSION = "v2";
-export function buildRadarCardPresentationCacheKey(opportunityId, status, viewerId, focusedViewerIntentId) {
+export function buildOpportunityCardCacheKey(opportunityId, status, viewerId, focusedViewerIntentId) {
     const scope = focusedViewerIntentId ? `:intent:${focusedViewerIntentId}` : "";
-    return `radar:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:card:${opportunityId}:${status}:${viewerId}${scope}`;
+    return `card:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:${opportunityId}:${status}:${viewerId}${scope}`;
 }
 export function buildApiChatCardPresentationCacheKey(opportunityId, viewerId) {
     return `chat:${OPPORTUNITY_PRESENTATION_CACHE_VERSION}:card:${opportunityId}:${viewerId}`;
@@ -387,7 +387,7 @@ export function summarizeSignalsForPresenter(signals) {
  * Gather all context needed for the presenter from the database.
  * Fetches viewer profile, viewer intents, other party profile(s), and network in parallel.
  *
- * @param displayCounterpartUserId - When set (e.g. for a radar card), only this counterpart is included in otherPartyContext so the presenter writes about the person on the card.
+ * @param displayCounterpartUserId - When set (e.g. for an opportunity card), only this counterpart is included in otherPartyContext so the presenter writes about the person on the card.
  * @param focusedViewerIntentId - When set, include only that active intent in viewer context.
  */
 export async function gatherPresenterContext(database, opportunity, viewerId, displayCounterpartUserId, focusedViewerIntentId) {

package/dist/internal/opportunities/opportunity.utils.d.ts

@@ -46,11 +46,6 @@ export declare function isActionableForViewer(actors: Array<{
 }>, status: string, viewerId: string, committedActorIds?: readonly string[]): boolean;
 /** Feed category for home composition. */
 export type FeedCategory = 'connection' | 'expired';
-/** Soft targets for radar composition. */
-export declare const RADAR_SOFT_TARGETS: {
-    readonly connection: 5;
-    readonly expired: 2;
-};
 /**
  * Classify an actionable opportunity into a feed category.
  * Assumes the opportunity already passed isActionableForViewer or is expired.
@@ -66,40 +61,3 @@ export declare function classifyOpportunity(opp: {
     }>;
     status: string;
 }, _viewerId: string): FeedCategory;
-/**
- * Select opportunities for the radar using soft composition targets.
- * Fills each category up to its target, then redistributes unused slots
- * to categories that have more items available. Preserves input order.
- *
- * @param opportunities - Pre-sorted opportunities (by confidence/recency)
- * @param viewerId - The viewing user's ID
- * @returns Composition-balanced subset
- */
-export declare function selectByComposition<T extends {
-    actors: Array<{
-        userId: string;
-        role: string;
-    }>;
-    status: string;
-}>(opportunities: T[], viewerId: string): T[];
-/**
- * Deduplicate opportunities so each counterpart appears at most once.
- * Keeps the opportunity with the highest interpretation.confidence per
- * counterpart userId. On ties, the first encountered wins (stable).
- *
- * Counterpart = first actor whose userId !== viewerId.
- * Opportunities without a derivable counterpart pass through undeduped.
- *
- * @param opportunities - Pre-sorted opportunities (e.g. by confidence/recency)
- * @param viewerId - The viewing user's ID
- * @returns Deduped subset preserving original input order among winners
- */
-export declare function deduplicateByPerson<T extends {
-    actors: Array<{
-        userId: string;
-        role: string;
-    }>;
-    interpretation?: {
-        confidence?: number;
-    } | null;
-}>(opportunities: T[], viewerId: string): T[];

package/dist/internal/opportunities/opportunity.utils.js

@@ -1,6 +1,3 @@
-import { log } from '../shared/observability/log.js';
-const logger = log.graph.from('SelectByComposition');
-const dedupeByPersonLog = log.graph.from('DeduplicateByPerson');
 /**
  * Validates opportunity actors.
  *
@@ -51,14 +48,6 @@ export function isActionableForViewer(actors, status, viewerId, committedActorId
         return false;
     return !committedActorIds.includes(viewerId);
 }
-/** Soft targets for radar composition. */
-export const RADAR_SOFT_TARGETS = {
-    // 3 + 2 in a second category before that category was removed. The slots move to
-    // connections rather than shrinking the feed: the total a radar can hold is
-    // unchanged, and connections are the only kind of card left.
-    connection: 5,
-    expired: 2,
-};
 /**
  * Classify an actionable opportunity into a feed category.
  * Assumes the opportunity already passed isActionableForViewer or is expired.
@@ -72,94 +61,3 @@ export function classifyOpportunity(opp, _viewerId) {
         return 'expired';
     return 'connection';
 }
-/**
- * Select opportunities for the radar using soft composition targets.
- * Fills each category up to its target, then redistributes unused slots
- * to categories that have more items available. Preserves input order.
- *
- * @param opportunities - Pre-sorted opportunities (by confidence/recency)
- * @param viewerId - The viewing user's ID
- * @returns Composition-balanced subset
- */
-export function selectByComposition(opportunities, viewerId) {
-    const buckets = { connection: [], expired: [] };
-    for (const opp of opportunities) {
-        buckets[classifyOpportunity(opp, viewerId)].push(opp);
-    }
-    const targets = {
-        connection: RADAR_SOFT_TARGETS.connection,
-        expired: RADAR_SOFT_TARGETS.expired,
-    };
-    // First pass: fill each category up to its target.
-    const selected = {
-        connection: buckets.connection.slice(0, targets.connection),
-        expired: buckets.expired.slice(0, targets.expired),
-    };
-    // Second pass: redistribute unused slots, connection before expired.
-    let unusedSlots = (targets.connection + targets.expired)
-        - (selected.connection.length + selected.expired.length);
-    for (const category of ['connection', 'expired']) {
-        if (unusedSlots <= 0)
-            break;
-        const remaining = buckets[category].slice(selected[category].length);
-        const take = Math.min(remaining.length, unusedSlots);
-        selected[category].push(...remaining.slice(0, take));
-        unusedSlots -= take;
-    }
-    // Within each category, preserve original input order.
-    const indexMap = new Map(opportunities.map((opp, i) => [opp, i]));
-    const sortByOriginal = (a, b) => (indexMap.get(a) ?? 0) - (indexMap.get(b) ?? 0);
-    selected.connection.sort(sortByOriginal);
-    selected.expired.sort(sortByOriginal);
-    logger.info('Selected opportunities by composition', {
-        input: opportunities.length,
-        buckets: { connection: buckets.connection.length, expired: buckets.expired.length },
-        selected: { connection: selected.connection.length, expired: selected.expired.length },
-    });
-    return [...selected.connection, ...selected.expired];
-}
-/**
- * Deduplicate opportunities so each counterpart appears at most once.
- * Keeps the opportunity with the highest interpretation.confidence per
- * counterpart userId. On ties, the first encountered wins (stable).
- *
- * Counterpart = first actor whose userId !== viewerId.
- * Opportunities without a derivable counterpart pass through undeduped.
- *
- * @param opportunities - Pre-sorted opportunities (e.g. by confidence/recency)
- * @param viewerId - The viewing user's ID
- * @returns Deduped subset preserving original input order among winners
- */
-export function deduplicateByPerson(opportunities, viewerId) {
-    const bestByCounterpart = new Map();
-    const noCounterpart = [];
-    for (let i = 0; i < opportunities.length; i++) {
-        const opp = opportunities[i];
-        const counterpart = opp.actors.find((a) => a.userId !== viewerId);
-        if (!counterpart) {
-            noCounterpart.push({ opp, index: i });
-            continue;
-        }
-        const key = counterpart.userId;
-        const existing = bestByCounterpart.get(key);
-        if (!existing) {
-            bestByCounterpart.set(key, { opp, index: i });
-            continue;
-        }
-        const newConf = opp.interpretation?.confidence ?? -1;
-        const oldConf = existing.opp.interpretation?.confidence ?? -1;
-        if (newConf > oldConf) {
-            bestByCounterpart.set(key, { opp, index: i });
-        }
-    }
-    const all = [...bestByCounterpart.values(), ...noCounterpart];
-    all.sort((a, b) => a.index - b.index);
-    const result = all.map((entry) => entry.opp);
-    if (result.length < opportunities.length) {
-        dedupeByPersonLog.info('Deduped opportunities by person', {
-            input: opportunities.length,
-            output: result.length,
-        });
-    }
-    return result;
-}

package/dist/internal/shared/agent/decision.client.d.ts

@@ -0,0 +1,42 @@
+export type DecisionQuestion = {
+    type: "noul";
+    instructions: string;
+    criteria?: {
+        true: string;
+        false: string;
+    };
+} | {
+    type: "choice";
+    instructions: string;
+    criteria: Record<string, string>;
+} | {
+    type: "score";
+    instructions: string;
+    criteria: string[];
+};
+export type DecisionAnswer = {
+    type: "noul";
+    noul: number;
+} | {
+    type: "choice";
+    choice: string;
+} | {
+    type: "score";
+    score: number;
+};
+/**
+ * Jev, through OpenRouter's Decisions API. It returns typed answers, not text.
+ * A missing key, a bad response, or a timeout throws. Callers keep their own fallback.
+ */
+export declare class DecisionClient {
+    private readonly apiKey?;
+    private readonly timeout;
+    constructor(apiKey?: string | undefined, timeout?: number);
+    /**
+     * @param state - The draft and whatever else the questions refer to.
+     * @param questions - Named noul, choice, or score questions.
+     * @param signal - Cancels this call. A request-scoped signal is used when this is omitted.
+     * @returns One answer per question key.
+     */
+    decide(state: unknown, questions: Record<string, DecisionQuestion>, signal?: AbortSignal): Promise<Record<string, DecisionAnswer>>;
+}

package/dist/internal/shared/agent/decision.client.js

@@ -0,0 +1,61 @@
+import { getAbortSignalConfig } from "./model-signal.js";
+const DECISIONS_URL = "https://openrouter.ai/api/alpha/decisions";
+const JEV_MODEL = "typesafe/jev-1.13";
+const TIMEOUT_MS = 60000;
+/**
+ * Jev, through OpenRouter's Decisions API. It returns typed answers, not text.
+ * A missing key, a bad response, or a timeout throws. Callers keep their own fallback.
+ */
+export class DecisionClient {
+    constructor(apiKey, timeout = TIMEOUT_MS) {
+        this.apiKey = apiKey;
+        this.timeout = timeout;
+    }
+    /**
+     * @param state - The draft and whatever else the questions refer to.
+     * @param questions - Named noul, choice, or score questions.
+     * @param signal - Cancels this call. A request-scoped signal is used when this is omitted.
+     * @returns One answer per question key.
+     */
+    async decide(state, questions, signal) {
+        const apiKey = this.apiKey ?? process.env.OPENROUTER_API_KEY;
+        if (!apiKey?.trim())
+            throw new Error("DecisionClient: OPENROUTER_API_KEY is required.");
+        const caller = signal ?? getAbortSignalConfig()?.signal;
+        const deadline = AbortSignal.timeout(this.timeout);
+        const stop = caller ? AbortSignal.any([caller, deadline]) : deadline;
+        const response = await fetch(DECISIONS_URL, {
+            method: "POST",
+            signal: stop,
+            headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ model: JEV_MODEL, state, questions }),
+        });
+        const body = await response.text();
+        let data = {};
+        try {
+            data = JSON.parse(body);
+        }
+        catch {
+            if (response.ok)
+                throw new Error(`Jev returned a non-JSON response: ${body.slice(0, 500)}`);
+        }
+        if (!response.ok || data.error || !data.answers) {
+            throw new Error(`Jev request failed (${response.status}): ${(data.error?.message ?? body).slice(0, 500)}`);
+        }
+        return readAnswers(data.answers);
+    }
+}
+function readAnswers(raw) {
+    const answers = {};
+    for (const [key, answer] of Object.entries(raw)) {
+        if (answer?.type === "noul" && typeof answer.noul === "number")
+            answers[key] = { type: "noul", noul: answer.noul };
+        else if (answer?.type === "choice" && typeof answer.choice === "string")
+            answers[key] = { type: "choice", choice: answer.choice };
+        else if (answer?.type === "score" && typeof answer.score === "number")
+            answers[key] = { type: "score", score: answer.score };
+        else
+            throw new Error(`Jev answer "${key}" was unusable`);
+    }
+    return answers;
+}

package/dist/platform/database/capabilities.d.ts

@@ -51,9 +51,9 @@ export type IntentNetworkGraphDatabase = Pick<Database, 'getIntentForIndexing' |
  */
 export type NetworkMembershipGraphDatabase = Pick<Database, 'isNetworkMember' | 'isNetworkOwner' | 'getNetworkWithPermissions' | 'addMemberToNetwork' | 'removeMemberFromNetwork' | 'getNetworkMembersForMember'>;
 /**
- * Database interface for Radar Graph (opportunity radar view).
+ * Database interface for opportunity cards.
  * Load opportunities, enrich with profile/network, and support presenter context.
  *
  * Access layer: UserDatabase (own opportunities and profile)
  */
-export type RadarGraphDatabase = Pick<Database, 'getOpportunitiesForUser' | 'getOpportunity' | 'getProfile' | 'getActiveIntents' | 'getNetwork' | 'getUser'> & NegotiationContextDatabase;
+export type OpportunityCardsDatabase = Pick<Database, 'getOpportunitiesForUser' | 'getOpportunity' | 'getProfile' | 'getActiveIntents' | 'getNetwork' | 'getUser'> & NegotiationContextDatabase;

package/dist/platform/database/entities.d.ts

@@ -485,6 +485,6 @@ export interface OpportunityQueryOptions {
     actorUserId?: string;
     limit?: number;
     offset?: number;
-    /** When set, include draft opportunities for this chat session. When unset, exclude all draft opportunities (e.g. radar view, API). */
+    /** When set, include draft opportunities for this chat session. When unset, exclude all draft opportunities (e.g. opportunity cards, API). */
     conversationId?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "66.0.0-rc.608.1",
+  "version": "66.0.0-rc.610.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/internal/opportunities/opportunity.feed-selection.d.ts

@@ -1,24 +0,0 @@
-import type { CompositeDatabase, Opportunity } from '../../platform/database.js';
-export interface OpportunityFeedSelectionInput {
-    reader: Pick<CompositeDatabase, 'getOpportunitiesForUser'>;
-    viewerId: string;
-    networkId?: string;
-    intentScope: {
-        scopeType?: 'intent';
-        scopeId?: string;
-    };
-    displayLimit: number;
-    warn: (message: string, data: Record<string, unknown>) => void;
-}
-export interface OpportunityFeedSelection {
-    opportunities: Opportunity[];
-    dedupedCount: number;
-    skippedIds: string[];
-    fetchedCount: number;
-}
-/**
- * Selects actionable opportunities for the chat/feed surface. The caller actor
- * check is deliberately the first post-read filter so non-actor rows cannot
- * affect selection or downstream profile/presentation reads.
- */
-export declare function selectOpportunityFeed(args: OpportunityFeedSelectionInput): Promise<OpportunityFeedSelection>;

package/dist/internal/opportunities/opportunity.feed-selection.js

@@ -1,40 +0,0 @@
-import { deduplicateByPerson, selectByComposition } from './opportunity.utils.js';
-const ACTIONABLE_FEED_STATUSES = ['pending'];
-const FEED_FETCH_LIMIT = 30;
-/**
- * Selects actionable opportunities for the chat/feed surface. The caller actor
- * check is deliberately the first post-read filter so non-actor rows cannot
- * affect selection or downstream profile/presentation reads.
- */
-export async function selectOpportunityFeed(args) {
-    const fetched = await args.reader.getOpportunitiesForUser(args.viewerId, {
-        networkId: args.networkId,
-        ...args.intentScope,
-        statuses: ACTIONABLE_FEED_STATUSES,
-        limit: FEED_FETCH_LIMIT,
-    });
-    const skippedIds = [];
-    const callerScoped = fetched.filter((opportunity) => {
-        if (opportunity.actors.some((actor) => actor.userId === args.viewerId))
-            return true;
-        args.warn('Opportunity feed: skipping opportunity where caller is not an actor', {
-            opportunityId: opportunity.id,
-            viewerId: args.viewerId,
-            actorUserIds: opportunity.actors
-                .map((actor) => actor.userId)
-                .filter((userId) => typeof userId === 'string'),
-        });
-        skippedIds.push(opportunity.id);
-        return false;
-    });
-    const deduped = deduplicateByPerson(callerScoped, args.viewerId);
-    const selected = deduped.length > 0
-        ? selectByComposition(deduped, args.viewerId)
-        : deduped;
-    return {
-        opportunities: selected.slice(0, args.displayLimit),
-        dedupedCount: deduped.length,
-        skippedIds,
-        fetchedCount: fetched.length,
-    };
-}