@indexnetwork/protocol 8.6.1-rc.429.1 → 8.7.0-rc.430.1

package/dist/capabilities/signals.facade.d.ts

@@ -15,5 +15,5 @@ export type { IntentIndexerOutput } from "../signals/application/intent.indexer.
 export { createIntentTools } from "../signals/application/intent.tools.js";
 export type { IntentToolDeps } from "./signals.tools.port.js";
 export { SignalIntakePackGenerator, normalizeIntakePack, type IntakePack, type IntakePackInput, type IntakePackQuestion, type IntakePackQuestionOption, } from "../signals/application/intake.pack.generator.js";
-export { SignalIntakeOrchestrator, answerLabel, FALLBACK_WHO_QUESTION, FALLBACK_BRING_QUESTION, type IntakeAnswer, type SynthesisInput, type SynthesisResult, } from "../signals/application/intake.orchestrator.js";
+export { SignalIntakeOrchestrator, answerLabel, FALLBACK_WHO_QUESTION, FALLBACK_BRING_QUESTION, type IntakeAnswer, type IntakeRound, type FollowUpPlan, type FollowUpPlanInput, type SynthesisInput, type SynthesisResult, } from "../signals/application/intake.orchestrator.js";
 export { normalizeIntentDescription } from "../signals/domain/intent.proposal.js";

package/dist/index.d.ts

@@ -69,7 +69,7 @@ export type { IntentIndexerOutput } from "./capabilities/signals.facade.js";
 export { SignalIntakePackGenerator, normalizeIntakePack } from "./capabilities/signals.facade.js";
 export type { IntakePack, IntakePackInput, IntakePackQuestion, IntakePackQuestionOption, } from "./capabilities/signals.facade.js";
 export { SignalIntakeOrchestrator, answerLabel, FALLBACK_WHO_QUESTION, FALLBACK_BRING_QUESTION, } from "./capabilities/signals.facade.js";
-export type { IntakeAnswer, SynthesisInput, SynthesisResult, } from "./capabilities/signals.facade.js";
+export type { IntakeAnswer, IntakeRound, FollowUpPlan, FollowUpPlanInput, SynthesisInput, SynthesisResult, } from "./capabilities/signals.facade.js";
 export { normalizeIntentDescription } from "./capabilities/signals.facade.js";
 export { LensInferrer } from "./capabilities/participant-context.facade.js";
 export { NegotiationInsightsGenerator } from "./capabilities/negotiation.facade.js";

package/dist/signals/application/index.d.ts

@@ -18,4 +18,4 @@ export { IntentReconciler, type IntentReconcilerOutput, type NormalizedIntentAct
 export { IntentIndexer, IntentIndexerOutputSchema, type IntentIndexerOutput } from "./intent.indexer.js";
 export { createIntentTools, describeIntentUpdateFailure } from "./intent.tools.js";
 export { SignalIntakePackGenerator, normalizeIntakePack, type IntakePack, type IntakePackInput, type IntakePackQuestion, type IntakePackQuestionOption, } from "./intake.pack.generator.js";
-export { SignalIntakeOrchestrator, answerLabel, FALLBACK_WHO_QUESTION, FALLBACK_BRING_QUESTION, type IntakeAnswer, type SynthesisInput, type SynthesisResult, } from "./intake.orchestrator.js";
+export { SignalIntakeOrchestrator, answerLabel, FALLBACK_WHO_QUESTION, FALLBACK_BRING_QUESTION, type IntakeAnswer, type IntakeRound, type FollowUpPlan, type FollowUpPlanInput, type SynthesisInput, type SynthesisResult, } from "./intake.orchestrator.js";

package/dist/signals/application/intake.orchestrator.d.ts

@@ -8,18 +8,23 @@
  */
 import type { BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import type { Runnable } from "@langchain/core/runnables";
+import { z } from "zod";
 import { type IntakePackQuestion } from "./intake.pack.generator.js";
 /** One answered intake round. */
 export interface IntakeAnswer {
     selectedOptions: string[];
     freeText?: string;
 }
+/** One answered intake round, in order (round 1 first). */
+export interface IntakeRound {
+    prompt: string;
+    answer: IntakeAnswer;
+}
 /** Everything synthesis needs to write the signal. */
 export interface SynthesisInput {
     brief: string;
-    whoAnswer: IntakeAnswer;
-    bringAnswer: IntakeAnswer;
-    /** Free-text place/community constraint from round 3. */
+    rounds: IntakeRound[];
+    /** Free-text place/community constraint from the where round. */
     whereText?: string;
     /**
      * Free-text correction the user typed against a draft they already saw.
@@ -28,12 +33,83 @@ export interface SynthesisInput {
      */
     feedback?: string;
 }
+/** Planning input for one follow-up generation call. */
+export interface FollowUpPlanInput {
+    brief: string;
+    /** Answered rounds in order (round 1 first). */
+    rounds: IntakeRound[];
+    /** Hard cap on questions returned by THIS call. */
+    maxFollowUps: number;
+    /** Locked interview plan on continuation calls; echoed unchanged. */
+    plannedFollowUpCount?: number;
+}
+/** The model's follow-up batch plus its total follow-up plan. */
+export interface FollowUpPlan {
+    questions: IntakePackQuestion[];
+    plannedFollowUpCount: number;
+}
 /** Synthesized signal text plus its summary fields. */
 export interface SynthesisResult {
     description: string;
     lookingFor: string;
     youBring: string;
 }
+declare const followUpPlanSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        prompt: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            description: string;
+        }, {
+            label: string;
+            description: string;
+        }>, "many">;
+        multiSelect: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    }, {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    }>, "many">;
+    plannedFollowUpCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    questions: {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    }[];
+    plannedFollowUpCount: number;
+}, {
+    questions: {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    }[];
+    plannedFollowUpCount: number;
+}>;
 /** Static round-1 question used only when pack generation fails outright. */
 export declare const FALLBACK_WHO_QUESTION: IntakePackQuestion;
 /** Static round-2 question used when live generation fails. */
@@ -45,34 +121,33 @@ export declare const FALLBACK_BRING_QUESTION: IntakePackQuestion;
  * @returns Comma-joined non-empty parts
  */
 export declare function answerLabel(answer: IntakeAnswer): string;
-/** Runs the two live stages of the fast intake funnel. */
+/** Runs the two live stages of the fast intake funnel: follow-up planning and synthesis. */
 export declare class SignalIntakeOrchestrator {
-    private readonly questionModel;
+    private readonly plannerModel;
     private readonly synthesisModel;
     /**
      * @param models - Optional injected structured models. Tests pass stubs.
      */
     constructor(models?: {
-        question?: Runnable<BaseLanguageModelInput, IntakePackQuestion>;
+        planner?: Runnable<BaseLanguageModelInput, z.infer<typeof followUpPlanSchema>>;
         synthesis?: Runnable<BaseLanguageModelInput, SynthesisResult>;
     });
     /**
-     * Generate round 2 from the brief and the round-1 answer.
+     * Plan and write follow-up questions from the brief and answered rounds.
      *
-     * @param input - Brief plus the answered round-1 question
-     * @returns A renderable question; the static fallback when generation fails
+     * @param input - Brief, answered rounds, per-call cap, and any locked plan
+     * @returns Up to `maxFollowUps` renderable questions plus the total plan;
+     * the static fallback question with count 1 when generation fails
      */
-    nextQuestion(input: {
-        brief: string;
-        whoAnswer: IntakeAnswer;
-    }): Promise<IntakePackQuestion>;
+    generateFollowUps(input: FollowUpPlanInput): Promise<FollowUpPlan>;
     /**
-     * Write the signal from both answers, any where-constraint, and any
+     * Write the signal from every answered round, any where-constraint, and any
      * revision feedback.
      *
-     * @param input - Brief, both answers, optional where constraint, optional feedback
+     * @param input - Brief, ordered rounds, optional where constraint, optional feedback
      * @returns Description plus card summary fields
      * @throws Propagates model failure so the caller can mark the run failed
      */
     synthesize(input: SynthesisInput): Promise<SynthesisResult>;
 }
+export {};

package/dist/signals/application/intake.orchestrator.js

@@ -16,6 +16,10 @@ const questionSchema = z.object({
     options: z.array(z.object({ label: z.string().min(1), description: z.string() })),
     multiSelect: z.boolean(),
 });
+const followUpPlanSchema = z.object({
+    questions: z.array(questionSchema),
+    plannedFollowUpCount: z.number().int().min(0),
+});
 const synthesisSchema = z.object({
     description: z.string().min(1),
     lookingFor: z.string().min(1),
@@ -45,13 +49,18 @@ export const FALLBACK_BRING_QUESTION = {
     ],
     multiSelect: false,
 };
-const QUESTION_SYSTEM_PROMPT = `You write one intake question for a networking product.
+const PLAN_SYSTEM_PROMPT = `You plan and write follow-up intake questions for a networking product.
 
-Given a brief about the person and who they said they want to meet, ask what they
-would bring to that connection and what gap the other side should fill. Give 3-4
-concrete options grounded in the brief, each with a short label and a one-line
-description. Include an option for mutual exchange when both sides matter. Set
-multiSelect false. Never expose raw JSON, IDs, or internal vocabulary.`;
+Given a brief about the person and the intake rounds they already answered, decide
+how many further questions (up to the stated maximum) would make their signal
+specific enough to match on, and write them. Each question is one concise prompt
+with 3-4 concrete options grounded in the brief and the previous answers; each
+option has a short label and a one-line description. Set multiSelect true only
+when several options can genuinely apply together. Never re-ask a dimension that
+is already answered; skip a dimension the brief already covers. Never expose raw
+JSON, IDs, or internal vocabulary. plannedFollowUpCount is the TOTAL number of
+follow-up questions the interview should contain, including any returned now;
+when the input already fixes it, echo that value unchanged.`;
 const SYNTHESIS_SYSTEM_PROMPT = `You write one clear signal for a networking product.
 
 Combine the brief and the person's answers into a specific description of who they
@@ -70,44 +79,74 @@ community constraint. Never invent facts beyond the brief and the answers.`;
 export function answerLabel(answer) {
     return [...answer.selectedOptions, answer.freeText?.trim() ?? ""].filter(Boolean).join(", ");
 }
-/** Runs the two live stages of the fast intake funnel. */
+/** Runs the two live stages of the fast intake funnel: follow-up planning and synthesis. */
 export class SignalIntakeOrchestrator {
     /**
      * @param models - Optional injected structured models. Tests pass stubs.
      */
     constructor(models) {
-        this.questionModel = models?.question
-            ?? createStructuredModel("signalIntakePack", questionSchema);
+        this.plannerModel = models?.planner
+            ?? createStructuredModel("signalIntakePack", followUpPlanSchema);
         this.synthesisModel = models?.synthesis
             ?? createStructuredModel("signalIntakePack", synthesisSchema);
     }
     /**
-     * Generate round 2 from the brief and the round-1 answer.
+     * Plan and write follow-up questions from the brief and answered rounds.
      *
-     * @param input - Brief plus the answered round-1 question
-     * @returns A renderable question; the static fallback when generation fails
+     * @param input - Brief, answered rounds, per-call cap, and any locked plan
+     * @returns Up to `maxFollowUps` renderable questions plus the total plan;
+     * the static fallback question with count 1 when generation fails
      */
-    async nextQuestion(input) {
+    async generateFollowUps(input) {
+        const roundsText = input.rounds
+            .map((round, index) => `Round ${index + 1} — Q: ${round.prompt}\nA: ${answerLabel(round.answer)}`)
+            .join("\n\n");
+        const lockedLine = input.plannedFollowUpCount !== undefined
+            ? `\n\nThe interview plan is fixed at ${input.plannedFollowUpCount} follow-up question(s) in total; ${input.rounds.length - 1} already asked. Echo that count unchanged.`
+            : "";
         try {
-            const raw = await this.questionModel.invoke([
-                new SystemMessage(QUESTION_SYSTEM_PROMPT),
-                new HumanMessage(`Brief:\n${input.brief}\n\nThey want to meet: ${answerLabel(input.whoAnswer)}\n\nWrite the question.`),
+            const raw = await this.plannerModel.invoke([
+                new SystemMessage(PLAN_SYSTEM_PROMPT),
+                new HumanMessage(`Brief:\n${input.brief}\n\n${roundsText}\n\nWrite up to ${input.maxFollowUps} follow-up question(s).${lockedLine}`),
             ]);
-            return normalizeIntakePack({ brief: input.brief, question: raw }).question;
+            const questions = raw.questions
+                .slice(0, input.maxFollowUps)
+                .map((q) => normalizeIntakePack({ brief: input.brief, question: q }).question);
+            // Backstop: while budget remains, a successful empty plan must not
+            // silently shrink the interview; serve the static fallback instead.
+            if (questions.length === 0 && input.maxFollowUps > 0) {
+                return {
+                    questions: [FALLBACK_BRING_QUESTION],
+                    plannedFollowUpCount: input.plannedFollowUpCount ?? 1,
+                };
+            }
+            return {
+                questions,
+                plannedFollowUpCount: input.plannedFollowUpCount
+                    ?? Math.max(raw.plannedFollowUpCount, questions.length),
+            };
         }
         catch {
-            return FALLBACK_BRING_QUESTION;
+            if (input.maxFollowUps <= 0)
+                return { questions: [], plannedFollowUpCount: 0 };
+            return {
+                questions: [FALLBACK_BRING_QUESTION],
+                plannedFollowUpCount: input.plannedFollowUpCount ?? 1,
+            };
         }
     }
     /**
-     * Write the signal from both answers, any where-constraint, and any
+     * Write the signal from every answered round, any where-constraint, and any
      * revision feedback.
      *
-     * @param input - Brief, both answers, optional where constraint, optional feedback
+     * @param input - Brief, ordered rounds, optional where constraint, optional feedback
      * @returns Description plus card summary fields
      * @throws Propagates model failure so the caller can mark the run failed
      */
     async synthesize(input) {
+        const roundsText = input.rounds
+            .map((round) => `Q: ${round.prompt}\nA: ${answerLabel(round.answer)}`)
+            .join("\n\n");
         const whereLine = input.whereText?.trim()
             ? `\n\nWhere constraint: ${input.whereText.trim()}`
             : "";
@@ -116,7 +155,7 @@ export class SignalIntakeOrchestrator {
             : "";
         const result = await this.synthesisModel.invoke([
             new SystemMessage(SYNTHESIS_SYSTEM_PROMPT),
-            new HumanMessage(`Brief:\n${input.brief}\n\nThey want to meet: ${answerLabel(input.whoAnswer)}\n\nThey bring: ${answerLabel(input.bringAnswer)}${whereLine}${feedbackLine}\n\nWrite the signal.`),
+            new HumanMessage(`Brief:\n${input.brief}\n\n${roundsText}${whereLine}${feedbackLine}\n\nWrite the signal.`),
         ]);
         return {
             description: result.description.trim(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "8.6.1-rc.429.1",
+  "version": "8.7.0-rc.430.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",