@indexnetwork/protocol 0.33.0-rc.121.1 → 1.1.0-rc.123.1

package/dist/opportunity/opportunity.graph.js

@@ -22,6 +22,7 @@ import { persistOpportunities } from './opportunity.persist.js';
 import { INTRODUCER_DISCOVERY_SOURCE } from './opportunity.introducer.js';
 import { negotiateCandidates } from "../negotiation/negotiation.graph.js";
 import { AMBIENT_PARK_WINDOW_MS } from "../negotiation/negotiation.tools.js";
+import { buildDiscoverySummary, toDiscoveryNegotiation, } from "./negotiation-summary.builder.js";
 import { protocolLogger, withCallLogging } from '../shared/observability/protocol.logger.js';
 import { timed } from '../shared/observability/performance.js';
 import { requestContext } from "../shared/observability/request-context.js";
@@ -1621,56 +1622,79 @@ export class OpportunityGraphFactory {
                     timeoutMs,
                     candidateCount: candidates.length,
                 });
-                // Orchestrator-only: per-candidate streaming hook. Each accepted
-                // negotiation flips the opp from 'pending' (negotiation finalize's
-                // default) to 'draft' (chat-only surface) and pushes an
+                // Per-candidate hook — always-on. Accumulates negotiation resolutions
+                // for discovery question generation. Additionally, for the orchestrator
+                // trigger: flips the opp from 'pending' to 'draft' and pushes an
                 // `opportunity_draft_ready` event so the frontend can render it
                 // inline as soon as it resolves, rather than waiting for the full
                 // fan-out. Abort (e.g. user closed the chat) suppresses both the
                 // status flip and the event — the in-flight negotiation finishes
                 // naturally but its card never reaches the user.
-                const onCandidateResolved = isOrchestrator
-                    ? async ({ candidate, accepted }) => {
-                        const abortSignal = requestContext.getStore()?.abortSignal;
-                        if (abortSignal?.aborted)
-                            return;
-                        if (!accepted || !candidate.opportunityId)
-                            return;
-                        // Only emit after a successful status flip — the frontend keys
-                        // cards off `opportunity.status === 'draft'`, so emitting a row
-                        // with its pre-flip status would render inconsistently. If the
-                        // flip fails we log and drop the event; the negotiation result
-                        // is still captured in acceptedResults for the final summary.
-                        const updated = await this.database
-                            .updateOpportunityStatus(candidate.opportunityId, 'draft')
-                            .catch((err) => {
-                            logger.warn('[Graph:Negotiate] failed to flip opp to draft; suppressing draft-ready event', {
-                                opportunityId: candidate.opportunityId,
-                                error: err,
-                            });
-                            return null;
-                        });
-                        if (!updated || abortSignal?.aborted)
-                            return;
-                        traceEmitter?.({
-                            type: 'opportunity_draft_ready',
+                // Build a stable order index so that resolutions accumulated via the
+                // per-candidate async hook can be re-sorted to candidate-list order
+                // before being handed to buildQuestionPrompt. Without this the LLM
+                // sees negotiations in completion-time order (non-deterministic).
+                const candidateOrderById = new Map();
+                candidates.forEach((c, i) => candidateOrderById.set(c.userId, i));
+                const resolutions = [];
+                const onCandidateResolved = async ({ candidate, accepted, turns, outcome }) => {
+                    resolutions.push({
+                        __order: candidateOrderById.get(candidate.userId) ?? Number.MAX_SAFE_INTEGER,
+                        candidateUserId: candidate.userId,
+                        counterpartyHint: (() => {
+                            const bio = candidate.candidateUser.profile?.bio?.trim();
+                            if (bio)
+                                return bio;
+                            return (candidate.candidateUser.profile?.interests ?? []).join(", ");
+                        })(),
+                        indexContext: candidate.networkId
+                            ? indexContextMap.get(candidate.networkId) ?? ""
+                            : "",
+                        turns,
+                        outcome,
+                    });
+                    if (state.trigger !== 'orchestrator')
+                        return;
+                    // ─── orchestrator streaming body ───
+                    const abortSignal = requestContext.getStore()?.abortSignal;
+                    if (abortSignal?.aborted)
+                        return;
+                    if (!accepted || !candidate.opportunityId)
+                        return;
+                    // Only emit after a successful status flip — the frontend keys
+                    // cards off `opportunity.status === 'draft'`, so emitting a row
+                    // with its pre-flip status would render inconsistently. If the
+                    // flip fails we log and drop the event; the negotiation result
+                    // is still captured in acceptedResults for the final summary.
+                    const updated = await this.database
+                        .updateOpportunityStatus(candidate.opportunityId, 'draft')
+                        .catch((err) => {
+                        logger.warn('[Graph:Negotiate] failed to flip opp to draft; suppressing draft-ready event', {
                             opportunityId: candidate.opportunityId,
-                            opportunity: updated,
-                            counterparty: {
-                                userId: candidate.candidateUser.id,
-                                ...(candidate.candidateUser.profile?.name
-                                    ? { name: candidate.candidateUser.profile.name }
-                                    : {}),
-                            },
+                            error: err,
                         });
-                    }
-                    : undefined;
+                        return null;
+                    });
+                    if (!updated || abortSignal?.aborted)
+                        return;
+                    traceEmitter?.({
+                        type: 'opportunity_draft_ready',
+                        opportunityId: candidate.opportunityId,
+                        opportunity: updated,
+                        counterparty: {
+                            userId: candidate.candidateUser.id,
+                            ...(candidate.candidateUser.profile?.name
+                                ? { name: candidate.candidateUser.profile.name }
+                                : {}),
+                        },
+                    });
+                };
                 const negotiationWork = negotiateCandidates(this.negotiationGraph, sourceUser, candidates, { networkId: '', prompt: '' }, // base context, overridden per-candidate below
                 { maxTurns, traceEmitter: traceEmitter ?? undefined,
                     indexContextOverrides: indexContextMap,
                     timeoutMs,
                     trigger: state.trigger === 'orchestrator' ? 'orchestrator' : 'ambient',
-                    ...(onCandidateResolved && { onCandidateResolved }) });
+                    onCandidateResolved });
                 // MCP-only: race the whole negotiate phase against a budget. When the
                 // timer wins we return early with a `timed_out` trace; the unresolved
                 // promise keeps running in the Bun event loop and each candidate's
@@ -1710,6 +1734,11 @@ export class OpportunityGraphFactory {
                             negotiateTimeoutMs: budgetMs,
                         });
                         traceEmitter?.({ type: "graph_end", name: "Negotiation graph", durationMs: Date.now() - graphStart });
+                        const orderedResolutionsPartial = [...resolutions]
+                            .sort((a, b) => a.__order - b.__order)
+                            .map(({ __order: _o, ...r }) => r);
+                        const discoveryNegotiationsPartial = orderedResolutionsPartial.map(toDiscoveryNegotiation);
+                        const discoverySummaryPartial = buildDiscoverySummary(orderedResolutionsPartial);
                         return {
                             trace: [{
                                     node: 'negotiate',
@@ -1720,6 +1749,8 @@ export class OpportunityGraphFactory {
                                         durationMs: Date.now() - graphStart,
                                     },
                                 }],
+                            discoveryNegotiations: discoveryNegotiationsPartial,
+                            discoverySummary: discoverySummaryPartial,
                         };
                     }
                     acceptedResults = raced;
@@ -1765,7 +1796,16 @@ export class OpportunityGraphFactory {
                     ...candidateTraceEntries,
                 ];
                 traceEmitter?.({ type: "graph_end", name: "Negotiation graph", durationMs: Date.now() - graphStart });
-                return { trace: negotiateTrace };
+                const orderedResolutions = [...resolutions]
+                    .sort((a, b) => a.__order - b.__order)
+                    .map(({ __order: _o, ...r }) => r);
+                const discoveryNegotiations = orderedResolutions.map(toDiscoveryNegotiation);
+                const discoverySummary = buildDiscoverySummary(orderedResolutions);
+                return {
+                    trace: negotiateTrace,
+                    discoveryNegotiations,
+                    discoverySummary,
+                };
             }
             catch (err) {
                 logger.error("[Graph:Negotiate] Negotiation stage failed", { error: err });
@@ -1776,6 +1816,8 @@ export class OpportunityGraphFactory {
                             detail: 'Negotiation failed',
                             data: { durationMs: Date.now() - graphStart, error: true },
                         }],
+                    discoveryNegotiations: [],
+                    discoverySummary: buildDiscoverySummary([]),
                 };
             }
         };
@@ -2067,9 +2109,9 @@ export class OpportunityGraphFactory {
                         }
                         const lookups = await Promise.all([...uniqueCounterparts].map(async (counterpartyUserId) => {
                             const accepted = await this.database
-                                .getAcceptedOpportunitiesBetweenActors(dedupUserId, counterpartyUserId)
+                                .findOpportunitiesByActors([dedupUserId, counterpartyUserId], { includeIntroducers: true, statuses: ['accepted'] })
                                 .catch((err) => {
-                                logger.warn('[Graph:Persist] getAcceptedOpportunitiesBetweenActors failed', {
+                                logger.warn('[Graph:Persist] findOpportunitiesByActors (sibling-accept) failed', {
                                     userId: dedupUserId,
                                     counterpartyUserId,
                                     error: err,
@@ -2164,7 +2206,7 @@ export class OpportunityGraphFactory {
                                 ];
                             const candidateUserId = evaluated.actors.find((a) => a.userId !== state.onBehalfOfUserId)?.userId;
                             const overlapping = candidateUserId
-                                ? await this.database.findOverlappingOpportunities([state.onBehalfOfUserId, candidateUserId], { excludeStatuses: DEDUP_SKIP_STATUSES })
+                                ? await this.database.findOpportunitiesByActors([state.onBehalfOfUserId, candidateUserId], { excludeStatuses: DEDUP_SKIP_STATUSES })
                                 : [];
                             if (overlapping.length > 0) {
                                 const existing = overlapping[0];
@@ -2283,9 +2325,9 @@ export class OpportunityGraphFactory {
                                 evaluatedActors: evaluated.actors.map(a => ({ userId: a.userId, role: a.role })),
                             });
                             const overlapping = candidateUserId
-                                ? await this.database.findOverlappingOpportunities([state.userId, candidateUserId], { excludeStatuses: DEDUP_SKIP_STATUSES })
+                                ? await this.database.findOpportunitiesByActors([state.userId, candidateUserId], { excludeStatuses: DEDUP_SKIP_STATUSES })
                                 : [];
-                            logger.verbose('[Graph:Persist:Dedup] findOverlappingOpportunities result', {
+                            logger.verbose('[Graph:Persist:Dedup] findOpportunitiesByActors result', {
                                 count: overlapping.length,
                                 results: overlapping.map(o => ({ id: o.id, status: o.status, actors: o.actors?.map((a) => ({ userId: a.userId, role: a.role })) })),
                             });