@indexnetwork/protocol 6.14.0-rc.406.1 → 8.0.1-rc.417.1

package/dist/signals/application/intent.graph.js

@@ -3,6 +3,7 @@ import { IntentGraphState } from "../domain/intent.state.js";
 import { ExplicitIntentInferrer } from "./intent.inferrer.js";
 import { SemanticVerifier } from "./intent.verifier.js";
 import { DEFAULT_SPECIFICITY_WARNING } from "../domain/signal.specificity.js";
+import { normalizeIntentDescription } from "../domain/intent.proposal.js";
 import { IntentReconciler } from "./intent.reconciler.js";
 import { getAbortSignalConfig } from "../../shared/agent/model-signal.js";
 import { protocolLogger } from "../../shared/observability/protocol.logger.js";
@@ -497,18 +498,6 @@ export class IntentGraphFactory {
                 };
             });
         };
-        /** Strip URLs and "More details at [url]" from intent payloads before persisting. */
-        const sanitizePayload = (payload) => {
-            if (!payload || typeof payload !== "string")
-                return payload;
-            const out = payload
-                .replace(/\s*More details at\s*:?\s*https?:\/\/[^\s"'<>)\]]+/gi, "")
-                .replace(/\s*See\s+https?:\/\/[^\s"'<>)\]]+\s+for\s+more[^.]*\.?/gi, "")
-                .replace(/https?:\/\/[^\s"'<>)\]]+/g, "")
-                .replace(/\s{2,}/g, " ")
-                .trim();
-            return out.replace(/[.,;]\s*$/, "").trim() || payload;
-        };
         /**
          * Generate a flat embedding for an intent payload, swallowing failures so
          * persistence can continue without an embedding. `intentId` is logging-only
@@ -554,14 +543,14 @@ export class IntentGraphFactory {
                 const verifiedIntentByPayload = new Map();
                 for (const verifiedIntent of state.verifiedIntents) {
                     verifiedIntentByPayload.set(verifiedIntent.description, verifiedIntent);
-                    verifiedIntentByPayload.set(sanitizePayload(verifiedIntent.description), verifiedIntent);
+                    verifiedIntentByPayload.set(normalizeIntentDescription(verifiedIntent.description), verifiedIntent);
                 }
                 for (const action of actions) {
                     const actionType = action.type.toLowerCase();
                     try {
                         if (actionType === 'create') {
                             const createAction = action;
-                            const sanitizedPayload = sanitizePayload(createAction.payload);
+                            const sanitizedPayload = normalizeIntentDescription(createAction.payload);
                             const matchedVerifiedIntent = verifiedIntentByPayload.get(createAction.payload) ||
                                 verifiedIntentByPayload.get(sanitizedPayload);
                             // Generate embedding for the intent payload
@@ -610,7 +599,7 @@ export class IntentGraphFactory {
                         }
                         else if (actionType === 'update') {
                             const updateAction = action;
-                            const sanitizedPayload = sanitizePayload(updateAction.payload);
+                            const sanitizedPayload = normalizeIntentDescription(updateAction.payload);
                             const matchedVerifiedIntent = verifiedIntentByPayload.get(updateAction.payload) ||
                                 verifiedIntentByPayload.get(sanitizedPayload);
                             // Regenerate embedding for the updated payload

package/dist/signals/application/intent.tools.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { IntentClarifier } from "./intent.clarifier.js";
 import { DEFAULT_SPECIFICITY_WARNING } from "../domain/signal.specificity.js";
+import { normalizeIntentDescription } from "../domain/intent.proposal.js";
 import { protocolLogger } from "../../shared/observability/protocol.logger.js";
 import { traceGraph } from "../../shared/observability/trace.js";
 import { success, error, UUID_REGEX } from "../../shared/agent/tool.helpers.js";
@@ -265,11 +266,11 @@ export function createIntentTools(defineTool, deps) {
             "**What to pass:** A clear, concept-based description of what the user is looking for (e.g. 'Looking for an AI/ML co-founder in Berlin', " +
             "'Need a designer for a mobile app project'). If the user provided a URL, scrape it with scrape_url first and synthesize the content into a description.\n\n" +
             "**What happens:** The system runs inference (extracting structured intents), verification (checking specificity and speech-act type), " +
-            "and returns a proposal widget. The proposal is NOT yet persisted — the user must approve it first.\n\n" +
+            "and durably stores an owner-scoped proposal containing the exact normalized description, optional network scope, and complete verifier output before returning a proposal widget. The intent itself is NOT yet persisted — the user must approve the proposal first.\n\n" +
             "**Returns:** An intent_proposal code block that MUST be included verbatim in the response. The frontend renders it as an interactive " +
             "card the user can approve or skip. On approval, the intent is persisted, indexed, and discovery begins.\n\n" +
-            "**Next steps after approval:** The intent is automatically linked to relevant indexes. Call discover_opportunities(searchQuery) to explicitly trigger discovery, " +
-            "or wait for background processing to find matches.\n\n" +
+            "**Next steps after approval:** The intent is automatically linked to relevant indexes and becomes eligible for background matching. " +
+            "Background processing creates opportunities when matches are found; use list_opportunities only to review persisted results.\n\n" +
             "**Specificity gate.** Before calling this tool, judge whether the description is concrete enough to be " +
             "useful for matching. If the user says \"find a job\", \"meet people\", or \"learn something\", that's too " +
             "vague — FIRST call read_user_contexts() + read_intents() to understand their context, THEN propose a " +
@@ -419,13 +420,32 @@ export function createIntentTools(defineTool, deps) {
                 });
             }
             // ── Proposal path (for web chat with interactive cards) ──
-            // Build intent_proposal code fences for each verified intent
-            const proposalBlocks = verified.map((v) => {
+            // Persist complete verifier output before emitting any usable card.
+            if (!deps.intentProposalStore) {
+                return error("Verified intent proposals are unavailable because durable proposal storage is not configured.");
+            }
+            const proposals = [];
+            const proposalBlocks = [];
+            for (const v of verified) {
+                if (!v.verification) {
+                    return error("Intent verification produced no authoritative analysis; no proposal was created.", debugSteps);
+                }
                 const proposalId = crypto.randomUUID();
+                const normalizedDescription = normalizeIntentDescription(v.description);
                 const isBroad = isBroadAttributiveIntent(v);
+                proposals.push({
+                    proposalId,
+                    userId: context.userId,
+                    description: normalizedDescription,
+                    ...(effectiveIndexId ? { networkId: effectiveIndexId } : {}),
+                    analysis: {
+                        verifierOutput: v.verification,
+                        combinedScore: v.score ?? null,
+                    },
+                });
                 const data = {
                     proposalId,
-                    description: v.description,
+                    description: normalizedDescription,
                     ...(effectiveIndexId ? { networkId: effectiveIndexId } : {}),
                     confidence: v.score != null ? Math.round(v.score * 100) / 100 : null,
                     speechActType: v.verification?.classification ?? null,
@@ -434,10 +454,11 @@ export function createIntentTools(defineTool, deps) {
                     missingSelectionalConstraints: v.verification?.missing_selectional_constraints ?? [],
                     specificityWarning: isBroad ? specificityWarningFor(v) : normalizeSpecificityWarning(v.verification?.specificity_warning),
                 };
-                return ("```intent_proposal\n" +
+                proposalBlocks.push("```intent_proposal\n" +
                     sanitizeJsonForCodeFence(JSON.stringify(data)) +
                     "\n```");
-            });
+            }
+            await deps.intentProposalStore.createProposals(proposals);
             const blocksText = proposalBlocks.join("\n\n");
             return success({
                 proposed: true,
@@ -453,8 +474,8 @@ export function createIntentTools(defineTool, deps) {
     });
     const updateIntent = defineTool({
         name: "update_intent",
-        description: "Updates an existing intent's description. After updating, the system re-processes the intent through inference and verification, " +
-            "re-evaluates its index assignments, and triggers fresh opportunity discovery with the new description.\n\n" +
+        description: "Updates an existing intent's description. After updating, the system re-processes it through inference and verification, " +
+            "re-evaluates its index assignments, and makes the approved signal eligible for background matching.\n\n" +
             "**When to use:** When the user wants to refine or change what they're looking for — e.g. narrowing scope, adding specificity, " +
             "or pivoting to a different need. Prefer updating over delete+create to preserve the intent's history and existing index links.\n\n" +
             "**Returns:** Updated `intentId` and `description`, plus a confirmation message. The intent's embeddings and index relevancy scores are recalculated automatically.",
@@ -585,7 +606,7 @@ export function createIntentTools(defineTool, deps) {
     // ─────────────────────────────────────────────────────────────────────────────
     const createIntentIndex = defineTool({
         name: "create_intent_index",
-        description: "Manually links an intent to a network (community), making it visible to other members and eligible for opportunity discovery within that index. " +
+        description: "Manually links an intent to a network (community), making the approved signal eligible for background matching within that index. " +
             "Normally intents are auto-assigned to relevant indexes on creation, but use this to explicitly add an intent to an additional index.\n\n" +
             "**When to use:** When the user wants to share an existing intent with a specific community they belong to, " +
             "or when auto-assignment missed a network the user considers relevant.\n\n" +
@@ -713,7 +734,7 @@ export function createIntentTools(defineTool, deps) {
     const deleteIntentIndex = defineTool({
         name: "delete_intent_index",
         description: "Removes the link between an intent and a network. The intent itself is NOT deleted — it just stops being visible in that community " +
-            "and no longer participates in opportunity discovery within that index. The intent may still be linked to other indexes.\n\n" +
+            "and is no longer eligible for background matching within that index. The intent may still be linked to other indexes.\n\n" +
             "**When to use:** When the user wants to withdraw an intent from a specific community without archiving it entirely. " +
             "Use read_intent_indexes first to verify the link exists.\n\n" +
             "**Returns:** Confirmation that the link was removed. To fully remove an intent, use delete_intent instead.",
@@ -766,8 +787,7 @@ export function createIntentTools(defineTool, deps) {
         description: "Text-searches the authenticated user's own active signals by description. Case-insensitive substring " +
             "match over the signal's payload and summary. Use when the user references a past signal they wrote " +
             '("find my signal about React mentorship") or wants to audit what they\'ve posted.\n\n' +
-            "For discovery of OTHER users' signals that match a query, use discover_opportunities(searchQuery=...) " +
-            "instead — that runs semantic matching across the user's networks.\n\n" +
+            "Approved signals are matched in the background. Use list_opportunities only to review persisted opportunities after background matching has produced them.\n\n" +
             "**Returns:** `intents: [{ id, payload, summary, createdAt }]`, most recent first, up to `limit` (default 25).",
         querySchema: z.object({
             query: z.string().min(1).describe("Text to match against payload and summary (case-insensitive)."),

package/dist/signals/domain/intent.proposal.d.ts

@@ -0,0 +1,35 @@
+/** Verifier output retained verbatim across the host persistence boundary. */
+export interface IntentProposalVerifierOutput {
+    reasoning: string;
+    classification: "COMMISSIVE" | "DIRECTIVE" | "ASSERTIVE" | "EXPRESSIVE" | "DECLARATION" | "UNKNOWN";
+    felicity_scores: {
+        clarity: number;
+        authority: number;
+        sincerity: number;
+    };
+    semantic_entropy: number;
+    referential_anchor: string | null;
+    referential_breadth: "narrow" | "moderate" | "broad";
+    missing_selectional_constraints: Array<"role" | "outcome" | "location" | "timeframe" | "domain" | "concrete_need">;
+    specificity_warning: string | null;
+    flags: string[];
+}
+/** Complete server-authoritative analysis captured for a verified intent proposal. */
+export interface IntentProposalAnalysis {
+    verifierOutput: IntentProposalVerifierOutput;
+    combinedScore: number | null;
+}
+/** One proposal persisted by the host before its display card is emitted. */
+export interface PersistableIntentProposal {
+    proposalId: string;
+    userId: string;
+    description: string;
+    networkId?: string;
+    analysis: IntentProposalAnalysis;
+}
+/** Host persistence boundary for durable, owner-scoped intent proposals. */
+export interface IntentProposalStore {
+    createProposals(proposals: PersistableIntentProposal[]): Promise<void>;
+}
+/** Normalize intent text exactly as the direct graph write path does. */
+export declare function normalizeIntentDescription(description: string): string;

package/dist/signals/domain/intent.proposal.js

@@ -0,0 +1,12 @@
+/** Normalize intent text exactly as the direct graph write path does. */
+export function normalizeIntentDescription(description) {
+    if (!description || typeof description !== "string")
+        return description;
+    const normalized = description
+        .replace(/\s*More details at\s*:?\s*https?:\/\/[^\s"'<>)\]]+/gi, "")
+        .replace(/\s*See\s+https?:\/\/[^\s"'<>)\]]+\s+for\s+more[^.]*\.?/gi, "")
+        .replace(/https?:\/\/[^\s"'<>)\]]+/g, "")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    return normalized.replace(/[.,;]\s*$/, "").trim() || description;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "6.14.0-rc.406.1",
+  "version": "8.0.1-rc.417.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -40,19 +40,20 @@
     "eval:opportunity": "bun --env-file=../../.env.test ./eval/opportunity/opportunity.eval.ts",
     "eval:clarification": "bun --env-file=../../.env.test ./eval/clarification/clarification.eval.ts",
     "eval:canary": "bun --env-file=../../.env.test ./eval/canary/canary.eval.ts",
+    "eval:stance": "bun --env-file=../../.env.test ./eval/stance/stance.eval.ts",
     "eval:view": "bun ./eval/viewer/viewer.eval.ts",
     "eval:verify": "bun ./eval/verify.ts"
   },
   "dependencies": {
-    "@langchain/core": "^1.1.17",
-    "@langchain/langgraph": "^1.1.2",
-    "@langchain/openai": "^1.2.3",
-    "@modelcontextprotocol/server": "^2.0.0-alpha.2",
-    "zod": "^3.22.4"
+    "@langchain/core": "1.1.48",
+    "@langchain/langgraph": "1.3.2",
+    "@langchain/openai": "1.4.7",
+    "@modelcontextprotocol/server": "2.0.0",
+    "zod": "3.25.76"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
-    "dotenv": "^16.3.1",
-    "typescript": "^5.0.0"
+    "@types/node": "25.9.1",
+    "dotenv": "16.6.1",
+    "typescript": "5.9.3"
   }
 }

package/dist/opportunity/application/opportunity.discover.d.ts

@@ -1,215 +0,0 @@
-/**
- * Run discovery from an ad-hoc query (e.g. chat "find me a mentor", "who needs a React developer").
- *
- * Invokes the opportunity graph with the query as sourceText. The HyDE graph's
- * LensInferrer automatically infers search lenses from the query, replacing the
- * old hardcoded strategy selection. Returns formatted candidates (enriched with
- * profile name/bio) for chat display.
- *
- * Used by the discover_opportunities chat tool.
- */
-import type { ChatGraphCompositeDatabase, UserRecord } from "../../shared/interfaces/database.interface.js";
-import type { Cache } from "../../shared/interfaces/cache.interface.js";
-import type { QuestionerEnqueueFn } from "../../capabilities/questions.enqueue.facade.js";
-import type { ToolScopeType } from "../../shared/agent/tool.scope.js";
-import { OpportunityPresenter, type OpportunityPresentationResult, type HomeCardPresentationResult } from "./opportunity.presenter.js";
-import type { ChatSummaryReader } from "../../shared/interfaces/chat-summary.interface.js";
-import type { QuestionGeneratorReader } from "../../shared/interfaces/question-generator.interface.js";
-import type { NegotiationSummaryReader } from "../../shared/interfaces/negotiation-summary.interface.js";
-import type { Question, QuestionStrategy } from "../../shared/schemas/question.schema.js";
-import type { DiscoverDebugStep } from '../domain/opportunity.discovery.contracts.js';
-/** Compiled opportunity graph (from OpportunityGraphFactory.createGraph()). */
-export type CompiledOpportunityGraph = ReturnType<import("./opportunity.graph.js").OpportunityGraphFactory["createGraph"]>;
-export interface DiscoverInput {
-    /** Compiled opportunity graph (already has DB, embedder, cache, HyDE graph). */
-    opportunityGraph: CompiledOpportunityGraph;
-    /** Database for enriching candidates with profile (getProfile). */
-    database: ChatGraphCompositeDatabase;
-    userId: string;
-    query: string;
-    indexScope: string[];
-    limit?: number;
-    /** Optional intent to use as discovery source and for triggeredBy (e.g. from opportunity queue). */
-    triggerIntentId?: string;
-    /** When set, filter discovery candidates to this specific user only (direct connection). */
-    targetUserId?: string;
-    /** When set, discover on behalf of this user (introducer flow). The caller (userId) becomes the introducer. */
-    onBehalfOfUserId?: string;
-    /** When provided, each opportunity is enriched with personalized presentation (headline, personalizedSummary, suggestedAction). */
-    presenter?: OpportunityPresenter;
-    /**
-     * When true, use the full home card presentation format (with narratorRemark, action labels, mutualIntentsLabel).
-     * This enables rendering the same rich opportunity cards in chat as on the home page.
-     */
-    useHomeCardFormat?: boolean;
-    /**
-     * When true, skip the LLM presenter and return minimal card data only (faster for chat).
-     * Sets homeCardPresentation and narratorChip from static labels and match reason.
-     */
-    minimalForChat?: boolean;
-    /** When set (e.g. from chat), create opportunities as draft with context.conversationId = chatSessionId. */
-    chatSessionId?: string;
-    /** Redis cache for discovery pagination. When provided, remaining candidates are cached for continuation. */
-    cache?: Cache;
-    /**
-     * Which flow is invoking discovery. Drives the graph's trigger-aware branches
-     * in persist (initial status) and negotiate (park window + streaming). When
-     * omitted, the graph defaults to 'ambient'. Pass 'orchestrator' from the
-     * chat `discover_opportunities` tool so users see drafts stream in and the
-     * accepted-pair lookup surfaces existing connections.
-     */
-    trigger?: 'ambient' | 'orchestrator';
-    /**
-     * MCP-only. When set, the opportunity graph's negotiate phase is capped at
-     * this many milliseconds; on timeout the caller gets whichever candidates
-     * finished, the rest stay in `negotiating` and finalize in the background.
-     * Chat, ambient queue, and all other callers omit this — existing behavior.
-     */
-    negotiateTimeoutMs?: number;
-    /** Optional read-through chat-session digest reader. Required for chatContext enrichment. */
-    chatSummary?: ChatSummaryReader;
-    /**
-     * Optional negotiation summarizer. When provided, each post-negotiation digest
-     * replaces the raw negotiation in the decision-question generator's input,
-     * keeping that prompt small and predictable regardless of candidate count.
-     * When omitted, a deterministic fallback digest is built per negotiation.
-     */
-    negotiationSummary?: NegotiationSummaryReader;
-    /** Optional decision-question generator. When omitted, no questions are produced. */
-    questionGenerator?: QuestionGeneratorReader;
-    /**
-     * Master switch for decision-question generation. When false, this code path
-     * is skipped entirely regardless of trigger. The composition root passes
-     * `isDiscoveryQuestionsEnabled()` (QUESTIONER_ENABLED + QUESTIONER_DISCOVERY_ENABLED).
-     */
-    enableQuestions?: boolean;
-    /**
-     * Optional async question enqueue callback. When provided, question generation
-     * is dispatched asynchronously to the QuestionerQueue instead of running inline
-     * via the `questionGenerator`. The callback receives an enqueue payload and
-     * returns a promise that resolves when the job is enqueued (not when generation
-     * completes).
-     */
-    questionerEnqueue?: QuestionerEnqueueFn;
-    /** Focused request scope type for generated discovery questions. */
-    scopeType?: ToolScopeType;
-    /** Focused request scope id. When `scopeType === 'network'`, persisted as actor networkId. */
-    scopeId?: string;
-}
-/** One formatted opportunity for chat (candidate-facing). */
-export interface FormattedDiscoveryCandidate {
-    opportunityId: string;
-    userId: string;
-    name?: string;
-    avatar?: string | null;
-    bio?: string;
-    matchReason: string;
-    score: number;
-    status?: string;
-    /** Present when DiscoverInput.presenter was provided (basic presentation). */
-    presentation?: OpportunityPresentationResult;
-    /** Present when DiscoverInput.useHomeCardFormat is true (full home card contract). */
-    homeCardPresentation?: HomeCardPresentationResult;
-    /** Viewer's role in this opportunity. */
-    viewerRole?: string;
-    /** Whether the viewer (as introducer) has approved the introduction. */
-    viewerApproved?: boolean;
-    /** Timestamp set once this viewer has already acted on the opportunity. */
-    viewerActedAt?: string | null;
-    /** Full user record for the candidate (needed for socials / Telegram fallback). */
-    candidateUser?: UserRecord | null;
-    /** Whether the counterpart is a ghost (not yet onboarded) user. */
-    isGhost?: boolean;
-    /** Narrator chip for home card display (name + remark, with optional avatar/userId for introducer). */
-    narratorChip?: {
-        name: string;
-        text: string;
-        avatar?: string | null;
-        userId?: string;
-    };
-    /** Second party in introducer arrow layout (candidate -> secondParty). Present when viewer is introducer. */
-    secondParty?: {
-        name: string;
-        avatar?: string | null;
-        userId?: string;
-    };
-}
-/** One step for debug visibility (subgraph/subtask). */
-export type { DiscoverDebugStep } from '../domain/opportunity.discovery.contracts.js';
-/** One existing connection (no new opportunity created; user already has one with this person). */
-export interface ExistingConnection {
-    userId: string;
-    name: string;
-    status?: string;
-    opportunityId?: string;
-}
-export interface DiscoverResult {
-    found: boolean;
-    count: number;
-    message?: string;
-    opportunities?: FormattedDiscoveryCandidate[];
-    /** Existing connections eligible for card display (draft, latent, or pending). Others are mention-only. */
-    existingConnections?: ExistingConnection[];
-    /** All existing connections for mention text (e.g. "You already have a connection with: X (pending), Y (draft)."). */
-    existingConnectionsForMention?: ExistingConnection[];
-    /**
-     * Orchestrator-only: accepted opportunities the persist step found between the
-     * discoverer and a candidate counterparty (status='accepted'). Populated from
-     * OpportunityGraphState.dedupAlreadyAccepted. Used by the discover_opportunities
-     * tool to tell the LLM "this pair is already connected — open the existing
-     * chat rather than creating a new draft". Empty for the ambient trigger.
-     */
-    alreadyAcceptedPairs?: Array<{
-        opportunityId: string;
-        counterpartyUserId: string;
-    }>;
-    /** When true, the chat agent should call create_intent(suggestedIntentDescription) and retry discovery. */
-    createIntentSuggested?: boolean;
-    /** Description to pass to create_intent when createIntentSuggested is true. */
-    suggestedIntentDescription?: string;
-    /** Internal steps for copy-debug (select_strategies, opportunity_graph, enrich, etc.). */
-    debugSteps?: DiscoverDebugStep[];
-    /** Pagination metadata -- present when there are more unevaluated candidates. */
-    pagination?: {
-        discoveryId: string;
-        evaluated: number;
-        remaining: number;
-    };
-    /** 0–3 decision questions produced by the orchestrator path. Omitted when none. */
-    questions?: Question[];
-    /** Debug metadata for `debugMeta.discoveryQuestions` plumbing. */
-    discoveryQuestionsDebug?: {
-        inputMode: "transcripts" | "insights";
-        finalCount: number;
-        strategies: QuestionStrategy[];
-        durationMs: number;
-    };
-}
-/**
- * Run discovery from an ad-hoc query (e.g. "find me a mentor", "who needs a React developer").
- * The HyDE graph's LensInferrer automatically infers search lenses from the query.
- * Invokes the opportunity graph and returns formatted candidates suitable for chat display.
- */
-export declare function runDiscoverFromQuery(input: DiscoverInput): Promise<DiscoverResult>;
-/**
- * Continue a paginated discovery by evaluating the next batch of cached candidates.
- * Loads candidates from Redis, invokes the opportunity graph in continue_discovery mode,
- * then enriches and returns the results with updated pagination metadata.
- *
- * @param input - Continuation context (graph, database, cache, discoveryId, etc.).
- * @returns Discovery result with enriched opportunities and pagination state.
- */
-export declare function continueDiscovery(input: {
-    opportunityGraph: CompiledOpportunityGraph;
-    database: ChatGraphCompositeDatabase;
-    cache: Cache;
-    userId: string;
-    discoveryId: string;
-    /** If provided, validates the cached session's indexScope contains this network. */
-    expectedIndexId?: string;
-    limit?: number;
-    chatSessionId?: string;
-    minimalForChat?: boolean;
-    presenter?: OpportunityPresenter;
-    useHomeCardFormat?: boolean;
-}): Promise<DiscoverResult>;