@indexnetwork/protocol 0.16.0-rc.39.1 → 0.17.0-rc.41.1

package/dist/opportunity/opportunity.graph.js

@@ -13,6 +13,7 @@
  */
 import { StateGraph, START, END } from '@langchain/langgraph';
 import { OpportunityGraphState, } from './opportunity.state.js';
+import { resolveInitialStatus } from './opportunity.state.js';
 import { OpportunityEvaluator, } from './opportunity.evaluator.js';
 import { IntentIndexer } from '../intent/intent.indexer.js';
 import { getModelName } from '../shared/agent/model.config.js';
@@ -1564,21 +1565,69 @@ export class OpportunityGraphFactory {
                         ? (await Promise.all(uniqueIndexIds.map((networkId) => this.agentDispatcher.hasPersonalAgent(discoveryUserId, { action: 'manage:negotiations', scopeType: 'network', scopeId: networkId }).catch(() => false)))).every(Boolean)
                         : false)
                     : false;
+                // Orchestrator (chat-driven a2h) fan-out uses a tight 60s park window —
+                // the user is watching the stream, so we cannot afford the 5-min ambient
+                // budget. Ambient keeps its heartbeat-aware long/short split.
+                const ORCHESTRATOR_PARK_WINDOW_MS = 60000;
+                const isOrchestrator = state.trigger === 'orchestrator';
                 const useLongTimeout = !isChatPath || hasPersonalAgent;
-                const timeoutMs = useLongTimeout ? AMBIENT_PARK_WINDOW_MS : 30000;
+                const timeoutMs = isOrchestrator
+                    ? ORCHESTRATOR_PARK_WINDOW_MS
+                    : useLongTimeout ? AMBIENT_PARK_WINDOW_MS : 30000;
                 logger.info('negotiateNode timeout decision', {
                     discoveryUserId,
+                    trigger: state.trigger,
                     isChatPath,
+                    isOrchestrator,
                     hasDispatcher: !!this.agentDispatcher,
                     hasPersonalAgent,
                     useLongTimeout,
                     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
+                // `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',
+                            opportunityId: candidate.opportunityId,
+                            opportunity: updated,
+                        });
+                    }
+                    : undefined;
                 const acceptedResults = await negotiateCandidates(this.negotiationGraph, sourceUser, candidates, { networkId: '', prompt: '' }, // base context, overridden per-candidate below
                 { maxTurns, traceEmitter: traceEmitter ?? undefined,
                     indexContextOverrides: indexContextMap,
-                    timeoutMs });
+                    timeoutMs,
+                    ...(onCandidateResolved && { onCandidateResolved }) });
                 // No filtering: every candidate's outcome (accept/reject/stalled) was applied to its
                 // opportunity row by the negotiation graph's finalize node via the opportunityId we
                 // passed. state.opportunities stays as it was at persist time; DB has the new statuses.
@@ -1874,9 +1923,11 @@ export class OpportunityGraphFactory {
         const persistNode = withNodeTrace("opportunity-persist", async (state) => {
             return timed("OpportunityGraph.persist", async () => {
                 const startTime = Date.now();
+                const initialStatus = resolveInitialStatus(state.trigger, state.options.initialStatus);
                 logger.verbose('[Graph:Persist] Starting persistence (dedup-v2)', {
                     opportunitiesToCreate: state.evaluatedOpportunities.length,
-                    initialStatus: state.options.initialStatus ?? 'pending',
+                    trigger: state.trigger,
+                    initialStatus,
                 });
                 if (state.evaluatedOpportunities.length === 0) {
                     logger.verbose('[Graph:Persist] No opportunities to persist');
@@ -1887,7 +1938,6 @@ export class OpportunityGraphFactory {
                     const reactivatedOpportunities = [];
                     const existingBetweenActors = [];
                     const now = new Date().toISOString();
-                    const initialStatus = state.options.initialStatus ?? 'pending';
                     // Only skip 'draft' (chat-only) opportunities during dedup.
                     // 'latent' must NOT be skipped — background discovery creates latent opportunities,
                     // and excluding them causes the same user pair to get duplicate opportunities
@@ -1896,6 +1946,41 @@ export class OpportunityGraphFactory {
                     const introducerUserForOnBehalf = state.onBehalfOfUserId
                         ? await this.database.getUser(state.userId)
                         : null;
+                    // Orchestrator-only: collect already-accepted pairs so Task 7's
+                    // create_opportunities tool can tell the LLM "these pairs are
+                    // already connected, surface the existing chat rather than
+                    // creating a new draft". Runs in parallel across unique
+                    // counterparties (a single evaluator pass can return multiple
+                    // opps per counterparty; we only hit the DB once per pair).
+                    // Failures are swallowed — the per-pair query is best-effort.
+                    const dedupAlreadyAccepted = [];
+                    if (state.trigger === 'orchestrator') {
+                        // Use the same viewer-resolution as evaluation/negotiate/persist
+                        // on-behalf branches so an introducer-driven orchestrator run
+                        // queries accepted opps between the *target* user and the
+                        // counterparty, not between the introducer and the counterparty.
+                        const dedupUserId = (state.onBehalfOfUserId ?? state.userId);
+                        const uniqueCounterparts = new Set();
+                        for (const evaluated of state.evaluatedOpportunities) {
+                            const candidateUserId = evaluated.actors.find(a => a.userId !== dedupUserId)?.userId;
+                            if (candidateUserId)
+                                uniqueCounterparts.add(candidateUserId);
+                        }
+                        const lookups = await Promise.all([...uniqueCounterparts].map(async (counterpartyUserId) => {
+                            const accepted = await this.database
+                                .getAcceptedOpportunitiesBetweenActors(dedupUserId, counterpartyUserId)
+                                .catch((err) => {
+                                logger.warn('[Graph:Persist] getAcceptedOpportunitiesBetweenActors failed', {
+                                    userId: dedupUserId,
+                                    counterpartyUserId,
+                                    error: err,
+                                });
+                                return [];
+                            });
+                            return accepted.map((opp) => ({ opportunityId: opp.id, counterpartyUserId }));
+                        }));
+                        dedupAlreadyAccepted.push(...lookups.flat());
+                    }
                     for (const evaluated of state.evaluatedOpportunities) {
                         const indexIdForActors = state.networkId ?? evaluated.actors[0]?.networkId;
                         let actors;
@@ -2176,13 +2261,15 @@ export class OpportunityGraphFactory {
                     return {
                         opportunities: allOpportunities,
                         existingBetweenActors,
+                        dedupAlreadyAccepted,
                         trace: [{
                                 node: "persist",
-                                detail: `Created ${createdList.length}, reactivated ${reactivatedOpportunities.length}, ${existingBetweenActors.length} existing skipped`,
+                                detail: `Created ${createdList.length}, reactivated ${reactivatedOpportunities.length}, ${existingBetweenActors.length} existing skipped, ${dedupAlreadyAccepted.length} already-accepted pair(s)`,
                                 data: {
                                     created: createdList.length,
                                     reactivated: reactivatedOpportunities.length,
                                     existingSkipped: existingBetweenActors.length,
+                                    alreadyAccepted: dedupAlreadyAccepted.length,
                                     totalOutput: allOpportunities.length,
                                     durationMs: Date.now() - startTime,
                                 },