@indexnetwork/protocol 0.17.0-rc.43.1 → 0.18.0-rc.45.1

package/dist/opportunity/opportunity.graph.js

@@ -73,7 +73,13 @@ export class OpportunityGraphFactory {
      * agent (long timeout) or fall back to the system agent immediately
      * (short timeout). Without it, the chat path always uses a short timeout.
      */
-    agentDispatcher) {
+    agentDispatcher, 
+    /**
+     * Callback to enqueue a negotiate_existing job for an opportunity.
+     * When provided, negotiate_existing mode uses this to queue follow-up
+     * negotiations after introducer approval.
+     */
+    queueNegotiateExisting) {
         this.database = database;
         this.embedder = embedder;
         this.hydeGenerator = hydeGenerator;
@@ -81,6 +87,7 @@ export class OpportunityGraphFactory {
         this.queueNotification = queueNotification;
         this.negotiationGraph = negotiationGraph;
         this.agentDispatcher = agentDispatcher;
+        this.queueNegotiateExisting = queueNegotiateExisting;
     }
     createGraph() {
         const evaluatorAgent = this.optionalEvaluator ?? new OpportunityEvaluator();
@@ -1480,6 +1487,11 @@ export class OpportunityGraphFactory {
                 // so the negotiation graph's finalize node can update its status from the outcome.
                 const candidateEntries = state.opportunities
                     .map(opp => {
+                    // Skip opportunities where any introducer exists but has not yet approved.
+                    const introducerActors = opp.actors
+                        .filter(a => a.role === 'introducer');
+                    if (introducerActors.length > 0 && !introducerActors.every(a => a.approved === true))
+                        return null;
                     const candidateActor = opp.actors
                         .find(a => a.userId !== discoveryUserId);
                     if (!candidateActor)
@@ -2018,7 +2030,7 @@ export class OpportunityGraphFactory {
                                 ? evaluatorActors
                                 : [
                                     ...evaluatorActors,
-                                    { networkId: indexIdForActors, userId: state.userId, role: 'introducer' },
+                                    { networkId: indexIdForActors, userId: state.userId, role: 'introducer', approved: false },
                                 ];
                             data = {
                                 detection: {
@@ -2068,7 +2080,7 @@ export class OpportunityGraphFactory {
                                 ? evaluatorActors
                                 : [
                                     ...evaluatorActors,
-                                    { networkId: indexIdForActors, userId: state.userId, role: 'introducer' },
+                                    { networkId: indexIdForActors, userId: state.userId, role: 'introducer', approved: false },
                                 ];
                             const candidateUserId = evaluated.actors.find((a) => a.userId !== state.onBehalfOfUserId)?.userId;
                             const overlapping = candidateUserId
@@ -2577,6 +2589,158 @@ export class OpportunityGraphFactory {
                 }
             });
         };
+        /**
+         * Negotiate Existing Node: Load an existing opportunity by ID and run bilateral negotiation.
+         * Used after introducer approval to trigger the normal negotiation flow for a latent opportunity.
+         */
+        const negotiateExistingNode = async (state) => {
+            if (!state.opportunityId)
+                return {};
+            if (!this.negotiationGraph) {
+                logger.warn('[Graph:NegotiateExisting] No negotiationGraph wired; skipping', {
+                    opportunityId: state.opportunityId,
+                });
+                return {};
+            }
+            try {
+                const opp = await this.database.getOpportunity(state.opportunityId);
+                if (!opp) {
+                    logger.warn('[Graph:NegotiateExisting] Opportunity not found', { opportunityId: state.opportunityId });
+                    return {};
+                }
+                const actors = opp.actors;
+                const nonIntroducerActors = actors.filter(a => a.role !== 'introducer');
+                // Find the sourceActor: non-introducer with role patient or party, fallback to first non-introducer
+                const sourceActor = nonIntroducerActors.find(a => a.role === 'patient' || a.role === 'party')
+                    ?? nonIntroducerActors[0];
+                if (!sourceActor) {
+                    logger.warn('[Graph:NegotiateExisting] No source actor found', { opportunityId: state.opportunityId });
+                    return {};
+                }
+                // Find the candidateActor: non-introducer that is NOT the sourceActor
+                const candidateActor = nonIntroducerActors.find(a => a.userId !== sourceActor.userId);
+                if (!candidateActor) {
+                    logger.warn('[Graph:NegotiateExisting] No candidate actor found', { opportunityId: state.opportunityId });
+                    return {};
+                }
+                // Load user data for both actors in parallel
+                const [sourceUserAccount, sourceProfile, sourceIntents, candidateAccount, candidateProfile, candidateIntents] = await Promise.all([
+                    this.database.getUser(sourceActor.userId).catch(() => null),
+                    this.database.getProfile(sourceActor.userId).catch(() => null),
+                    this.database.getActiveIntents(sourceActor.userId).catch(() => []),
+                    this.database.getUser(candidateActor.userId).catch(() => null),
+                    this.database.getProfile(candidateActor.userId).catch(() => null),
+                    this.database.getActiveIntents(candidateActor.userId).catch(() => []),
+                ]);
+                const toNegIntent = (ai) => ({
+                    id: ai.id,
+                    title: ai.summary ?? '',
+                    description: ai.payload ?? '',
+                    confidence: 1,
+                });
+                const sourceUser = {
+                    id: sourceActor.userId,
+                    intents: sourceIntents.slice(0, 5).map(toNegIntent),
+                    profile: {
+                        name: sourceProfile?.identity?.name ?? sourceUserAccount?.name,
+                        bio: sourceProfile?.identity?.bio ?? sourceUserAccount?.intro ?? undefined,
+                        location: sourceProfile?.identity?.location ?? sourceUserAccount?.location ?? undefined,
+                        skills: sourceProfile?.attributes?.skills,
+                        interests: sourceProfile?.attributes?.interests,
+                    },
+                };
+                const candidateIntentsForNeg = candidateIntents.slice(0, 5).map(toNegIntent);
+                const candidate = {
+                    userId: candidateActor.userId,
+                    opportunityId: opp.id,
+                    reasoning: opp.interpretation?.reasoning ?? '',
+                    valencyRole: candidateActor.role ?? 'peer',
+                    networkId: candidateActor.networkId,
+                    candidateUser: {
+                        id: candidateActor.userId,
+                        intents: candidateIntentsForNeg,
+                        profile: {
+                            name: candidateProfile?.identity?.name ?? candidateAccount?.name,
+                            bio: candidateProfile?.identity?.bio ?? candidateAccount?.intro ?? undefined,
+                            location: candidateProfile?.identity?.location ?? candidateAccount?.location ?? undefined,
+                            skills: candidateProfile?.attributes?.skills,
+                            interests: candidateProfile?.attributes?.interests,
+                        },
+                    },
+                };
+                // Load index context for the candidate's network
+                const indexContextMap = new Map();
+                if (candidate.networkId) {
+                    const ctx = await this.database.getNetworkMemberContext(candidate.networkId, sourceActor.userId).catch(() => null);
+                    const prompt = [ctx?.indexPrompt, ctx?.memberPrompt]
+                        .filter((v) => !!v?.trim())
+                        .join('\n\n');
+                    if (prompt)
+                        indexContextMap.set(candidate.networkId, prompt);
+                }
+                const acceptedResults = await negotiateCandidates(this.negotiationGraph, sourceUser, [candidate], { networkId: '', prompt: '' }, {
+                    maxTurns: 6,
+                    indexContextOverrides: indexContextMap,
+                    timeoutMs: AMBIENT_PARK_WINDOW_MS,
+                    trigger: 'ambient',
+                });
+                // Send notifications to non-introducer actors if negotiation was accepted
+                if (acceptedResults.length > 0 && this.queueNotification) {
+                    for (const actor of nonIntroducerActors) {
+                        await this.queueNotification(opp.id, actor.userId, 'high').catch((err) => {
+                            logger.warn('[Graph:NegotiateExisting] Failed to queue notification', { actorId: actor.userId, error: err });
+                        });
+                    }
+                }
+                logger.info('[Graph:NegotiateExisting] Negotiation complete', {
+                    opportunityId: opp.id,
+                    accepted: acceptedResults.length > 0,
+                });
+            }
+            catch (err) {
+                logger.error('[Graph:NegotiateExisting] Failed', { opportunityId: state.opportunityId, error: err });
+                return { error: `Failed to load opportunity: ${err instanceof Error ? err.message : String(err)}` };
+            }
+            return {};
+        };
+        /**
+         * Node: Approve Introduction
+         * Called by the introducer to approve a latent introducer-pattern opportunity.
+         * Sets approved=true on the introducer actor (status stays latent), then
+         * enqueues a negotiate_existing job so the parties negotiate normally.
+         */
+        const approveIntroductionNode = async (state) => {
+            const { opportunityId, userId } = state;
+            if (!opportunityId) {
+                return { mutationResult: { success: false, error: 'opportunityId required for approve_introduction' } };
+            }
+            let opp;
+            try {
+                opp = await this.database.getOpportunity(opportunityId);
+            }
+            catch (err) {
+                return { mutationResult: { success: false, error: `Failed to load opportunity: ${err instanceof Error ? err.message : String(err)}` } };
+            }
+            if (!opp) {
+                return { mutationResult: { success: false, error: 'Opportunity not found' } };
+            }
+            const introducerActor = opp.actors
+                .find(a => a.role === 'introducer' && a.userId === userId);
+            if (!introducerActor) {
+                return { mutationResult: { success: false, error: 'You are not the introducer for this opportunity' } };
+            }
+            if (introducerActor.approved === true) {
+                return { mutationResult: { success: false, error: 'Introduction already approved' } };
+            }
+            const updated = await this.database.updateOpportunityActorApproval(opportunityId, userId, true);
+            if (!updated) {
+                return { mutationResult: { success: false, error: 'Failed to update approval' } };
+            }
+            if (this.queueNegotiateExisting) {
+                await this.queueNegotiateExisting(opportunityId, userId);
+            }
+            return { mutationResult: { success: true, opportunityId } };
+        };
         // ═══════════════════════════════════════════════════════════════
         // CONDITIONAL ROUTING FUNCTIONS
         // ═══════════════════════════════════════════════════════════════
@@ -2595,6 +2759,10 @@ export class OpportunityGraphFactory {
                 return 'send';
             if (mode === 'create_introduction')
                 return 'intro_validation';
+            if (mode === 'negotiate_existing')
+                return 'negotiate_existing';
+            if (mode === 'approve_introduction')
+                return 'approve_introduction';
             // 'create' is the default discovery pipeline
             return 'prep';
         };
@@ -2667,6 +2835,8 @@ export class OpportunityGraphFactory {
             .addNode('update', updateNode)
             .addNode('delete_opp', deleteNode)
             .addNode('send', sendNode)
+            .addNode('negotiate_existing', negotiateExistingNode)
+            .addNode('approve_introduction', approveIntroductionNode)
             // Route by operation mode from START
             .addConditionalEdges(START, routeByMode, {
             prep: 'prep',
@@ -2675,6 +2845,8 @@ export class OpportunityGraphFactory {
             update: 'update',
             delete_opp: 'delete_opp',
             send: 'send',
+            negotiate_existing: 'negotiate_existing',
+            approve_introduction: 'approve_introduction',
         })
             // Introduction path: validation -> evaluation -> persist (or END on validation error)
             .addConditionalEdges('intro_validation', routeAfterIntroValidation, {
@@ -2687,6 +2859,8 @@ export class OpportunityGraphFactory {
             .addEdge('update', END)
             .addEdge('delete_opp', END)
             .addEdge('send', END)
+            .addEdge('negotiate_existing', END)
+            .addEdge('approve_introduction', END)
             // Conditional routing: early exit if no indexed intents
             .addConditionalEdges('prep', shouldContinueAfterPrep, {
             scope: 'scope',