@indexnetwork/protocol 6.12.1-rc.404.1 → 6.13.22-rc.405.1

package/dist/opportunity/application/opportunity.existing-negotiation.js

@@ -0,0 +1,109 @@
+import { resolveOpportunityActorIntent } from '../domain/opportunity.actor.js';
+const NEGOTIATION_INTENT_LIMIT = 5;
+/** Put an opportunity actor's exact intent first, then fill the bounded context without duplicates. */
+export function buildPrioritizedNegotiationIntents(activeIntents, exactIntentId, fallbackIntent) {
+    const exactId = typeof exactIntentId === 'string' && exactIntentId.trim().length > 0 ? exactIntentId : null;
+    const exactActive = exactId ? activeIntents.find((intent) => intent.id === exactId) : undefined;
+    const ordered = [
+        ...(exactActive ? [exactActive] : []),
+        ...(!exactActive && fallbackIntent?.id === exactId ? [fallbackIntent] : []),
+        ...activeIntents,
+    ];
+    const seen = new Set();
+    const intents = [];
+    for (const intent of ordered) {
+        if (typeof intent.id !== 'string' || intent.id.trim().length === 0 || seen.has(intent.id))
+            continue;
+        seen.add(intent.id);
+        intents.push({ id: intent.id, title: intent.summary ?? '', description: intent.payload ?? '', confidence: 1 });
+        if (intents.length === NEGOTIATION_INTENT_LIMIT)
+            break;
+    }
+    return intents;
+}
+/**
+ * Revalidates continuation actor bindings, builds exact intent-prioritized
+ * bilateral negotiation input, and notifies the non-introducer actors only
+ * after an accepted non-continuation negotiation.
+ */
+export async function negotiateExistingOpportunity(database, executeNegotiation, input, queueNotification, observer) {
+    const opportunity = await database.getOpportunity(input.opportunityId);
+    if (!opportunity)
+        return { kind: 'skipped', reason: 'not_found' };
+    const nonIntroducerActors = opportunity.actors.filter((actor) => actor.role !== 'introducer');
+    const continuation = input.continuation;
+    if (continuation) {
+        const recipientActor = nonIntroducerActors.find((actor) => actor.userId === input.actorUserId);
+        const counterpartyActor = nonIntroducerActors.find((actor) => actor.userId === continuation.counterpartyUserId);
+        if (!recipientActor
+            || resolveOpportunityActorIntent(recipientActor) !== continuation.recipientIntentId
+            || recipientActor.networkId !== continuation.networkId
+            || !counterpartyActor
+            || resolveOpportunityActorIntent(counterpartyActor) !== continuation.counterpartyIntentId
+            || counterpartyActor.networkId !== continuation.networkId)
+            return { kind: 'skipped', reason: 'stale_continuation' };
+    }
+    const sourceActor = nonIntroducerActors.find((actor) => actor.role === 'patient' || actor.role === 'party') ?? nonIntroducerActors[0];
+    if (!sourceActor)
+        return { kind: 'skipped', reason: 'no_source_actor' };
+    const candidateActor = nonIntroducerActors.find((actor) => actor.userId !== sourceActor.userId);
+    if (!candidateActor)
+        return { kind: 'skipped', reason: 'no_candidate_actor' };
+    const sourceIntentId = resolveOpportunityActorIntent(sourceActor);
+    const candidateIntentId = resolveOpportunityActorIntent(candidateActor);
+    const [sourceAccount, sourceProfile, sourceIntents, candidateAccount, candidateProfile, candidateIntents] = await Promise.all([
+        database.getUser(sourceActor.userId).catch(() => null),
+        database.getProfile(sourceActor.userId).catch(() => null),
+        database.getActiveIntents(sourceActor.userId).catch(() => []),
+        database.getUser(candidateActor.userId).catch(() => null),
+        database.getProfile(candidateActor.userId).catch(() => null),
+        database.getActiveIntents(candidateActor.userId).catch(() => []),
+    ]);
+    const [sourceFallbackIntent, candidateFallbackIntent] = await Promise.all([
+        sourceIntentId && !sourceIntents.some((intent) => intent.id === sourceIntentId) ? database.getIntent(sourceIntentId).catch(() => null) : null,
+        candidateIntentId && !candidateIntents.some((intent) => intent.id === candidateIntentId) ? database.getIntent(candidateIntentId).catch(() => null) : null,
+    ]);
+    const sourceUser = {
+        id: sourceActor.userId,
+        intents: buildPrioritizedNegotiationIntents(sourceIntents, sourceIntentId, sourceFallbackIntent?.userId === sourceActor.userId ? sourceFallbackIntent : null),
+        profile: {
+            name: sourceProfile?.identity?.name ?? sourceAccount?.name,
+            bio: sourceProfile?.identity?.bio ?? sourceAccount?.intro ?? undefined,
+            location: sourceProfile?.identity?.location ?? sourceAccount?.location ?? undefined,
+        },
+    };
+    const candidate = {
+        userId: candidateActor.userId,
+        ...(sourceIntentId ? { sourceIntentId } : {}),
+        ...(candidateIntentId ? { candidateIntentId } : {}),
+        opportunityId: opportunity.id,
+        opportunityStatus: opportunity.status,
+        opportunityUpdatedAt: opportunity.updatedAt,
+        reasoning: opportunity.interpretation?.reasoning ?? '',
+        valencyRole: candidateActor.role ?? 'peer',
+        networkId: candidateActor.networkId,
+        candidateUser: {
+            id: candidateActor.userId,
+            intents: buildPrioritizedNegotiationIntents(candidateIntents, candidateIntentId, candidateFallbackIntent?.userId === candidateActor.userId ? candidateFallbackIntent : null),
+            profile: {
+                name: candidateProfile?.identity?.name ?? candidateAccount?.name,
+                bio: candidateProfile?.identity?.bio ?? candidateAccount?.intro ?? undefined,
+                location: candidateProfile?.identity?.location ?? candidateAccount?.location ?? undefined,
+            },
+        },
+    };
+    const indexContextMap = new Map();
+    if (candidate.networkId) {
+        const context = await database.getNetworkMemberContext(candidate.networkId, sourceActor.userId).catch(() => null);
+        const prompt = [context?.indexPrompt, context?.memberPrompt].filter((value) => !!value?.trim()).join('\n\n');
+        if (prompt)
+            indexContextMap.set(candidate.networkId, prompt);
+    }
+    const execution = await executeNegotiation({ sourceUser, candidate, indexContextOverrides: indexContextMap, continuation });
+    if (execution.accepted && queueNotification && !continuation) {
+        for (const actor of nonIntroducerActors) {
+            await queueNotification(opportunity.id, actor.userId, 'high').catch((error) => observer?.onNotificationFailure?.({ actorId: actor.userId, error }));
+        }
+    }
+    return { kind: 'completed', opportunityId: opportunity.id, accepted: execution.accepted, continuationFence: continuation?.fence, ...(execution.receipt ? { receipt: execution.receipt } : {}) };
+}

package/dist/opportunity/application/opportunity.feed-selection.d.ts

@@ -0,0 +1,30 @@
+import type { DeliveryLedger } from '../../shared/interfaces/delivery-ledger.interface.js';
+import type { ChatGraphCompositeDatabase, Opportunity } from '../../shared/interfaces/database.interface.js';
+export interface OpportunityFeedSelectionInput {
+    reader: Pick<ChatGraphCompositeDatabase, 'getOpportunitiesForUser'>;
+    deliveryLedger?: Pick<DeliveryLedger, 'getDeliveredOpportunities'>;
+    viewerId: string;
+    networkId?: string;
+    intentScope: {
+        scopeType?: 'intent';
+        scopeId?: string;
+    };
+    isMcp: boolean;
+    includeDigestMarkers?: boolean;
+    displayLimit: number;
+    warn: (message: string, data: Record<string, unknown>) => void;
+}
+export interface OpportunityFeedSelection {
+    opportunities: Opportunity[];
+    dedupedCount: number;
+    skippedIds: string[];
+    redeliveryIds: Set<string>;
+    fetchedCount: number;
+    isDigestMode: boolean;
+}
+/**
+ * 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 digest suppression, selection, or downstream profile/presentation reads.
+ */
+export declare function selectOpportunityFeed(args: OpportunityFeedSelectionInput): Promise<OpportunityFeedSelection>;

package/dist/opportunity/application/opportunity.feed-selection.js

@@ -0,0 +1,96 @@
+import { deduplicateByPerson, selectByComposition, selectDigestCandidates } from '../domain/opportunity.utils.js';
+const ACTIONABLE_FEED_STATUSES = ['draft', 'pending', 'latent'];
+const FEED_FETCH_LIMIT = 30;
+const ACCEPTED_SUPPRESSION_FETCH_LIMIT = 200;
+/**
+ * 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 digest suppression, 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('list_opportunities: 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 visible = callerScoped.filter((opportunity) => {
+        if (opportunity.status !== 'latent')
+            return true;
+        return opportunity.actors.find((actor) => actor.userId === args.viewerId)?.role === 'introducer';
+    });
+    const deduped = deduplicateByPerson(visible, args.viewerId);
+    const isDigestMode = args.isMcp === true && args.includeDigestMarkers === true;
+    let digestPool = deduped;
+    let redeliveryIds = new Set();
+    if (isDigestMode && deduped.length > 0) {
+        const acceptedCounterpartIds = new Set();
+        try {
+            const acceptedOpportunities = await args.reader.getOpportunitiesForUser(args.viewerId, {
+                ...(args.networkId ? { networkId: args.networkId } : {}),
+                ...args.intentScope,
+                statuses: ['accepted'],
+                limit: ACCEPTED_SUPPRESSION_FETCH_LIMIT,
+            });
+            for (const opportunity of acceptedOpportunities) {
+                for (const actor of opportunity.actors) {
+                    if (actor.userId && actor.userId !== args.viewerId && actor.role !== 'introducer') {
+                        acceptedCounterpartIds.add(actor.userId);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            args.warn('digest suppression: failed to fetch accepted opportunities, skipping counterpart suppression', { err });
+        }
+        let deliveredRows = [];
+        if (args.deliveryLedger?.getDeliveredOpportunities) {
+            try {
+                const rows = await args.deliveryLedger.getDeliveredOpportunities({
+                    userId: args.viewerId,
+                    opportunityIds: deduped.map((opportunity) => opportunity.id),
+                });
+                deliveredRows = rows.map((row) => ({
+                    opportunityId: row.opportunityId,
+                    deliveredAtStatus: row.deliveredAtStatus,
+                    deliveredAt: row.deliveredAt instanceof Date ? row.deliveredAt : new Date(row.deliveredAt),
+                }));
+            }
+            catch (err) {
+                args.warn('digest suppression: failed to read delivery ledger, skipping shown-opportunity dedup', { err });
+            }
+        }
+        const digestSelection = selectDigestCandidates(deduped, {
+            viewerId: args.viewerId,
+            acceptedCounterpartIds,
+            deliveredRows,
+        });
+        digestPool = digestSelection.pool;
+        redeliveryIds = digestSelection.redeliveryIds;
+    }
+    const selected = digestPool.length > 0
+        ? selectByComposition(digestPool, args.viewerId)
+        : digestPool;
+    return {
+        opportunities: selected.slice(0, args.displayLimit),
+        dedupedCount: deduped.length,
+        skippedIds,
+        redeliveryIds,
+        fetchedCount: fetched.length,
+        isDigestMode,
+    };
+}