@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

package/dist/intents/intake/intake.orchestrator.js

@@ -1,255 +0,0 @@
-/**
- * Deterministic signal-intake stage logic.
- *
- * The fast intake path is a fixed funnel, so stages are driven here rather than
- * by an agent loop: round 1 comes from the precomputed pack, round 2 is one
- * structured call, round 3 is a deterministic client-side picker, and synthesis
- * is one structured call. This module owns no I/O.
- */
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { z } from "zod";
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-import { normalizeIntakePack } from "./intake.pack.generator.js";
-const optionSchema = z.object({
-    label: z.string().min(1),
-    description: z.string(),
-});
-const answerFirstQuestionSchema = z.object({
-    missingAxis: z
-        .enum(["purpose", "desired_attributes", "exchange", "constraint"])
-        .describe("The unanswered decision axis selected only from the answered intake rounds."),
-    title: z.string(),
-    prompt: z.string().min(1),
-    answerGroundedOptions: z
-        .array(optionSchema)
-        .min(2)
-        .max(3)
-        .describe("Two or three distinct choices derived only from the answered intake rounds."),
-    multiSelect: z.boolean(),
-});
-const followUpPlanSchema = z.object({
-    questions: z.array(answerFirstQuestionSchema),
-    plannedFollowUpCount: z.number().int().min(0),
-});
-const profileBridgePlanSchema = z.object({
-    bridges: z.array(z.object({
-        questionIndex: z.number().int().min(0),
-        profileBridgeOption: optionSchema
-            .nullable()
-            .describe("One natural profile intersection, or null when the bridge would be forced."),
-    })),
-});
-const synthesisSchema = z.object({
-    description: z.string().min(1),
-    lookingFor: z.string().min(1),
-    youBring: z.string().min(1),
-});
-/** Static round-1 question used only when pack generation fails outright. */
-export const FALLBACK_WHO_QUESTION = {
-    title: "Question 1",
-    prompt: "Who do you want to meet right now?",
-    options: [
-        { label: "A collaborator", description: "Someone to build or work on something with" },
-        { label: "A customer or user", description: "Someone who has the problem you solve" },
-        { label: "An expert", description: "Someone who has done this before" },
-        { label: "A peer", description: "Someone at a similar stage to compare notes with" },
-    ],
-    multiSelect: false,
-};
-/** Static round-2 question used when live generation fails. */
-export const FALLBACK_BRING_QUESTION = {
-    title: "Question 2",
-    prompt: "What would you bring, and what gap should they fill?",
-    options: [
-        { label: "Hands-on expertise", description: "You can do the work with them" },
-        { label: "Introductions and reach", description: "You can open doors for them" },
-        { label: "Funding or resources", description: "You can back what they are doing" },
-        { label: "A mutual exchange", description: "You each cover the other's gap" },
-    ],
-    multiSelect: false,
-};
-const PLAN_SYSTEM_PROMPT = `You plan and write answer-first follow-up intake questions for a networking product.
-
-You receive ONLY the answered intake rounds. Use them to choose the next missing
-axis, write a standalone prompt that names the newly stated person or domain, and
-create 2-3 meaningfully distinct answerGroundedOptions. Choose the most useful
-unanswered axis from: purpose, desired_attributes, exchange, or constraint. Never
-re-ask an axis the rounds already answer. Do not infer a professional background,
-industry, capability, or commercial goal that the rounds do not state.
-
-Every answerGroundedOption must be visibly anchored to the stated person or domain
-in its label or description and represent a concrete, distinct path. Generic labels
-such as "Learn", "Share", "Collaborate", or "Networking" are invalid when they do
-not say what the user would learn, share, collaborate on, or network about.
-- Scuba divers: "Learn diving techniques", "Find dive buddies", "Share dive stories".
-- Climate founders: "Compare climate sectors", "Find climate peers", "Discuss adaptation".
-
-Each option needs a short label and a one-line description. Set multiSelect true
-only when several options can genuinely apply together. 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 PROFILE_BRIDGE_SYSTEM_PROMPT = `You may append one optional profile bridge to each already-written signal-intake question.
-
-The question, missing axis, and answer-grounded options are immutable. For each
-questionIndex, compare them with the profile brief and return either one genuinely
-useful profileBridgeOption or null. A bridge is useful only when it creates a
-natural additional path that is not already represented. Never rewrite, replace,
-remove, or reclassify a core option. Never return more than one bridge per question.
-When the profile theme is unrelated or the intersection would feel forced, return
-null. Running club + investor may support one sponsorship bridge; scuba divers +
-pianist should return null.`;
-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
-want to meet, what they bring or need, and any stated constraint. Write it in the
-person's own voice, first person, 1-3 sentences, concrete and free of hype. Also
-return short "lookingFor" and "youBring" summaries for the confirmation card.
-When revision feedback is present, it is the person correcting a draft they
-already read: apply it to the whole signal rather than treating it as a place or
-community constraint. Never invent facts beyond the brief and the answers.`;
-/**
- * Render an answer as a human-readable label.
- *
- * @param answer - Selected options plus optional free text
- * @returns Comma-joined non-empty parts
- */
-export function answerLabel(answer) {
-    return [...answer.selectedOptions, answer.freeText?.trim() ?? ""].filter(Boolean).join(", ");
-}
-function normalizeFollowUpQuestion(question, profileBridge, brief) {
-    const seen = new Set();
-    const normalizeOption = (option) => {
-        const label = option.label.trim();
-        const key = label.toLocaleLowerCase();
-        if (!label || seen.has(key))
-            return null;
-        seen.add(key);
-        return { label, description: option.description.trim() };
-    };
-    const answerGroundedOptions = question.answerGroundedOptions
-        .map(normalizeOption)
-        .filter((option) => option !== null)
-        .slice(0, 3);
-    if (answerGroundedOptions.length < 2) {
-        throw new Error("Follow-up question needs at least two answer-grounded options.");
-    }
-    const profileBridgeOption = profileBridge ? normalizeOption(profileBridge) : null;
-    return normalizeIntakePack({
-        brief,
-        question: {
-            title: question.title,
-            prompt: question.prompt,
-            options: [
-                ...answerGroundedOptions,
-                ...(profileBridgeOption ? [profileBridgeOption] : []),
-            ],
-            multiSelect: question.multiSelect,
-        },
-    }).question;
-}
-/** 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.plannerModel = models?.planner
-            ?? createStructuredModel("signalIntakePack", followUpPlanSchema);
-        this.profileBridgeModel = models?.profileBridge
-            ?? createStructuredModel("signalIntakePack", profileBridgePlanSchema, { name: "signal_intake_profile_bridges" });
-        this.synthesisModel = models?.synthesis
-            ?? createStructuredModel("signalIntakePack", synthesisSchema);
-    }
-    /**
-     * Plan and write follow-up questions from the brief and answered rounds.
-     *
-     * @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 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.plannerModel.invoke([
-                new SystemMessage(PLAN_SYSTEM_PROMPT),
-                new HumanMessage(`ANSWERED ROUNDS:\n${roundsText}\n\nWrite up to ${input.maxFollowUps} follow-up question(s).${lockedLine}`),
-            ]);
-            const coreQuestions = raw.questions.slice(0, input.maxFollowUps);
-            const bridgeByQuestion = new Map();
-            if (coreQuestions.length > 0 && input.brief.trim()) {
-                try {
-                    const bridgePlan = await this.profileBridgeModel.invoke([
-                        new SystemMessage(PROFILE_BRIDGE_SYSTEM_PROMPT),
-                        new HumanMessage(`ANSWERED ROUNDS:\n${roundsText}\n\nPROFILE BRIEF:\n${input.brief}\n\nIMMUTABLE CORE QUESTIONS:\n${JSON.stringify(coreQuestions, null, 2)}\n\nReturn one bridge decision for each questionIndex.`),
-                    ]);
-                    for (const bridge of bridgePlan.bridges) {
-                        if (bridge.questionIndex < coreQuestions.length
-                            && !bridgeByQuestion.has(bridge.questionIndex)) {
-                            bridgeByQuestion.set(bridge.questionIndex, bridge.profileBridgeOption);
-                        }
-                    }
-                }
-                catch {
-                    // Profile personalization is optional. A bridge-model failure must not
-                    // discard valid answer-grounded questions from the primary model.
-                }
-            }
-            const questions = coreQuestions.map((question, index) => normalizeFollowUpQuestion(question, bridgeByQuestion.get(index) ?? null, input.brief));
-            // 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 {
-            if (input.maxFollowUps <= 0)
-                return { questions: [], plannedFollowUpCount: 0 };
-            return {
-                questions: [FALLBACK_BRING_QUESTION],
-                plannedFollowUpCount: input.plannedFollowUpCount ?? 1,
-            };
-        }
-    }
-    /**
-     * Write the signal from every answered round, any where-constraint, and any
-     * revision 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()}`
-            : "";
-        const feedbackLine = input.feedback?.trim()
-            ? `\n\nRevision feedback on the previous draft: ${input.feedback.trim()}`
-            : "";
-        const result = await this.synthesisModel.invoke([
-            new SystemMessage(SYNTHESIS_SYSTEM_PROMPT),
-            new HumanMessage(`Brief:\n${input.brief}\n\n${roundsText}${whereLine}${feedbackLine}\n\nWrite the signal.`),
-        ]);
-        return {
-            description: result.description.trim(),
-            lookingFor: result.lookingFor.trim(),
-            youBring: result.youBring.trim(),
-        };
-    }
-}

package/dist/intents/intake/intake.pack.generator.d.ts

@@ -1,57 +0,0 @@
-/**
- * Signal intake pack generator.
- *
- * Produces the offline half of the fast intake path: a prose brief written for
- * the intake task and a ready round-1 question. Both are stored per user and
- * refreshed in the background, so `/i/new` can render round 1 with no model call.
- */
-import type { BaseLanguageModelInput } from "@langchain/core/language_models/base";
-import type { Runnable } from "@langchain/core/runnables";
-/** One selectable option on the round-1 question. */
-export interface IntakePackQuestionOption {
-    label: string;
-    description: string;
-}
-/** Round-1 question, shaped exactly like the frontend `QuestionPayload`. */
-export interface IntakePackQuestion {
-    title: string;
-    prompt: string;
-    options: IntakePackQuestionOption[];
-    multiSelect: boolean;
-}
-/** Everything the generator needs about a user. */
-export interface IntakePackInput {
-    premises: Array<{
-        text: string;
-    }>;
-    networkTitles: string[];
-    globalContext: string | null;
-}
-/** Stored artifact: the brief plus the ready round-1 question. */
-export interface IntakePack {
-    brief: string;
-    question: IntakePackQuestion;
-}
-/** Generates and normalizes the per-user intake pack. */
-export declare class SignalIntakePackGenerator {
-    private readonly model;
-    /**
-     * @param model - Optional injected structured model. Tests pass a stub.
-     */
-    constructor(model?: Runnable<BaseLanguageModelInput, IntakePack>);
-    /**
-     * Generate the intake pack for one user.
-     *
-     * @param input - Active premises, membership titles, and the global context paragraph
-     * @returns Normalized brief and round-1 question
-     */
-    generate(input: IntakePackInput): Promise<IntakePack>;
-}
-/**
- * Clamp a generated pack into the shape the frontend can render.
- *
- * @param pack - Raw model output
- * @returns Normalized pack
- * @throws When the question has fewer than 2 usable options
- */
-export declare function normalizeIntakePack(pack: IntakePack): IntakePack;

package/dist/intents/intake/intake.pack.generator.js

@@ -1,90 +0,0 @@
-/**
- * Signal intake pack generator.
- *
- * Produces the offline half of the fast intake path: a prose brief written for
- * the intake task and a ready round-1 question. Both are stored per user and
- * refreshed in the background, so `/i/new` can render round 1 with no model call.
- */
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { z } from "zod";
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-const packSchema = z.object({
-    brief: z.string().min(1),
-    question: z.object({
-        title: z.string(),
-        prompt: z.string().min(1),
-        options: z.array(z.object({ label: z.string().min(1), description: z.string() })),
-        multiSelect: z.boolean(),
-    }),
-});
-const SYSTEM_PROMPT = `You prepare a person's signal-intake pack for a networking product.
-
-Produce two things:
-
-1. "brief": 4-8 sentences of prose, third person, written specifically to help a
-   small model run an intake interview with this person. Cover who they are, what
-   they plausibly need from a connection, what they can offer in return, and which
-   communities they belong to. Be concrete. Never invent facts beyond the input.
-
-2. "question": the opening intake question asking who they want to meet right now.
-   Give 3-4 concrete, distinct recipient profiles grounded in the person's actual
-   background (for example a design partner, a technical co-founder, an early
-   customer, a specific expertise gap) — never generic choices like "anyone".
-   Each option needs a short label and a one-line description. Set multiSelect false.
-
-Never expose raw JSON, IDs, or internal vocabulary in either field.`;
-/** Generates and normalizes the per-user intake pack. */
-export class SignalIntakePackGenerator {
-    /**
-     * @param model - Optional injected structured model. Tests pass a stub.
-     */
-    constructor(model) {
-        this.model = model ?? createStructuredModel("signalIntakePack", packSchema);
-    }
-    /**
-     * Generate the intake pack for one user.
-     *
-     * @param input - Active premises, membership titles, and the global context paragraph
-     * @returns Normalized brief and round-1 question
-     */
-    async generate(input) {
-        const premiseBlock = input.premises.map((p) => `- ${p.text}`).join("\n");
-        const networkBlock = input.networkTitles.length > 0
-            ? input.networkTitles.join(", ")
-            : "none";
-        const contextBlock = input.globalContext?.trim() ? input.globalContext.trim() : "none";
-        const raw = await this.model.invoke([
-            new SystemMessage(SYSTEM_PROMPT),
-            new HumanMessage(`Communities: ${networkBlock}\n\nGlobal context:\n${contextBlock}\n\nPremises:\n${premiseBlock}\n\nWrite the intake pack.`),
-        ]);
-        return normalizeIntakePack(raw);
-    }
-}
-/**
- * Clamp a generated pack into the shape the frontend can render.
- *
- * @param pack - Raw model output
- * @returns Normalized pack
- * @throws When the question has fewer than 2 usable options
- */
-export function normalizeIntakePack(pack) {
-    const options = pack.question.options
-        .filter((option) => option.label.trim().length > 0)
-        .slice(0, 4)
-        .map((option) => ({
-        label: option.label.trim().slice(0, 120),
-        description: option.description.trim().slice(0, 280),
-    }));
-    if (options.length < 2) {
-        throw new Error("Intake pack question needs at least 2 options.");
-    }
-    return {
-        brief: pack.brief.trim(),
-        question: {
-            title: pack.question.title.trim() || "Question 1",
-            prompt: pack.question.prompt.trim().slice(0, 400),
-            options,
-            multiSelect: pack.question.multiSelect,
-        },
-    };
-}

package/dist/intents/intent.clarifier.d.ts

@@ -1,51 +0,0 @@
-import { z } from "zod";
-declare const clarificationSchema: z.ZodDiscriminatedUnion<"needsClarification", [z.ZodObject<{
-    needsClarification: z.ZodLiteral<false>;
-    reason: z.ZodString;
-    suggestedDescription: z.ZodNullable<z.ZodString>;
-    clarificationMessage: z.ZodNullable<z.ZodString>;
-    underspecificationType: z.ZodNull;
-}, "strip", z.ZodTypeAny, {
-    reason: string;
-    underspecificationType: null;
-    needsClarification: false;
-    suggestedDescription: string | null;
-    clarificationMessage: string | null;
-}, {
-    reason: string;
-    underspecificationType: null;
-    needsClarification: false;
-    suggestedDescription: string | null;
-    clarificationMessage: string | null;
-}>, z.ZodObject<{
-    needsClarification: z.ZodLiteral<true>;
-    reason: z.ZodString;
-    suggestedDescription: z.ZodString;
-    clarificationMessage: z.ZodString;
-    underspecificationType: z.ZodEnum<["missing_constituent", "missing_constraint", "open_alternative_set"]>;
-}, "strip", z.ZodTypeAny, {
-    reason: string;
-    underspecificationType: "missing_constituent" | "missing_constraint" | "open_alternative_set";
-    needsClarification: true;
-    suggestedDescription: string;
-    clarificationMessage: string;
-}, {
-    reason: string;
-    underspecificationType: "missing_constituent" | "missing_constraint" | "open_alternative_set";
-    needsClarification: true;
-    suggestedDescription: string;
-    clarificationMessage: string;
-}>]>;
-export type IntentClarifierOutput = z.infer<typeof clarificationSchema>;
-export declare class IntentClarifier {
-    private readonly model;
-    private readonly suggestionModel;
-    private readonly clarificationDraftModel;
-    constructor();
-    /** Build the shared user prompt with intent, profile, and active-intent context. */
-    private buildPrompt;
-    invoke(description: string, profileContext: string, activeIntentsContext: string): Promise<IntentClarifierOutput>;
-    private generateSuggestion;
-    private generateClarificationDraft;
-}
-export {};

package/dist/intents/intent.clarifier.js

@@ -1,201 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { z } from "zod";
-import { createStructuredModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-import { Timed } from "../shared/observability/performance.js";
-import { UnderspecificationTypeSchema } from "../shared/schemas/underspecification.schema.js";
-const logger = protocolLogger("IntentClarifier");
-const clarificationSchema = z.discriminatedUnion("needsClarification", [
-    z.object({
-        needsClarification: z.literal(false),
-        reason: z.string(),
-        suggestedDescription: z.string().nullable(),
-        clarificationMessage: z.string().nullable(),
-        underspecificationType: z.null(),
-    }),
-    z.object({
-        needsClarification: z.literal(true),
-        reason: z.string(),
-        suggestedDescription: z.string().trim().min(1),
-        clarificationMessage: z.string().trim().min(1),
-        underspecificationType: UnderspecificationTypeSchema,
-    }),
-]);
-const suggestionSchema = z.object({
-    suggestedDescription: z.string(),
-});
-const clarificationDraftSchema = z.object({
-    suggestedDescription: z.string(),
-    clarificationMessage: z.string(),
-});
-const systemPrompt = `
-You evaluate whether one focused clarification would materially improve an intent before discovery.
-
-Set needsClarification=true only when the intent has a consequential unresolved Question Under Discussion (QUD): the answer would materially change which people or opportunities should surface. Do not ask for merely nice-to-have detail, procedural confirmation, or information already inferable from the user profile or active intents.
-
-Classify the single highest-impact QUD repair in underspecificationType:
-- missing_constituent: an absent core participant, entity, or outcome (who/what). Example: "I need help with something" does not identify what help or outcome is sought.
-- missing_constraint: the core target exists, but an explicitly unresolved or discovery-blocking ranking boundary is missing (where/when/how/how much). Example: a concrete hiring target whose location, timing, or engagement boundary is explicitly undecided.
-- open_alternative_set: an unresolved choice among materially different interpretations or scopes. Example: seeking either a technical co-founder or a sales channel partner, which would surface different people.
-
-An intent does NOT need every possible constraint. A concrete target with enough boundaries to run a useful search is specific even if it omits optional preferences such as compensation, budget, exact seniority, or secondary skills. For example, "a senior ML engineer in Berlin for a full-time role building production LLM evaluation systems this quarter" requires no clarification; do not invent a missing budget or other unstated requirement.
-
-Set needsClarification=false when the intent already fixes its core target and enough material ranking boundaries for actionable discovery, or when remaining omissions are optional. When false, underspecificationType MUST be null. When true, it MUST be exactly one category above.
-
-Rules when needsClarification=true:
-- Ask about the selected QUD category rather than proposing an arbitrary refinement.
-- User Profile is the primary source for a grounded suggestedDescription; Active Intents are secondary.
-- You MUST provide a concrete suggestedDescription and short clarificationMessage.
-- Do not include JSON in clarificationMessage.
-`;
-const suggestionPrompt = `
-You generate one concrete, specific intent rewrite.
-
-Rules:
-- Output only a concise intent sentence in suggestedDescription.
-- Use profile as primary source of personalization.
-- Use active intents as secondary context for consistency.
-- Keep user intent meaning, but make it actionable and specific.
-- Never return an empty suggestion.
-`;
-const clarificationDraftPrompt = `
-You draft one concise clarification response for an underspecified intent.
-
-Return both:
-1) suggestedDescription: one concrete rewrite representing a plausible interpretation.
-2) clarificationMessage: one direct question that resolves the supplied QUD category.
-
-Question rules by category:
-- missing_constituent: ask which participant, entity, or outcome the user means.
-- missing_constraint: ask for the unresolved ranking boundary (where/when/how/how much).
-- open_alternative_set: name the materially different alternatives and ask the user to choose; never collapse them into a generic yes/no confirmation.
-
-The question may mention suggestedDescription when useful, but do not force every category into "Did you mean...?". Keep it short. No bullet lists. No JSON.
-`;
-export class IntentClarifier {
-    constructor() {
-        this.model = createStructuredModel("intentClarifier", clarificationSchema, {
-            name: "intent_clarifier",
-        });
-        this.suggestionModel = createStructuredModel("intentClarifier", suggestionSchema, {
-            name: "intent_clarifier_suggestion",
-        });
-        this.clarificationDraftModel = createStructuredModel("intentClarifier", clarificationDraftSchema, { name: "intent_clarifier_message" });
-    }
-    /** Build the shared user prompt with intent, profile, and active-intent context. */
-    buildPrompt(description, profileContext, activeIntentsContext) {
-        return `
-# User Input Intent
-${description}
-
-# User Profile
-${profileContext || "none"}
-
-# Active Intents
-${activeIntentsContext || "none"}
-`;
-    }
-    async invoke(description, profileContext, activeIntentsContext) {
-        try {
-            const prompt = this.buildPrompt(description, profileContext, activeIntentsContext);
-            const result = await invokeWithAbortSignal(this.model, [
-                new SystemMessage(systemPrompt),
-                new HumanMessage(prompt),
-            ]);
-            const parsed = clarificationSchema.parse(result);
-            if (parsed.needsClarification) {
-                // Always prefer a dedicated rewrite pass for vague inputs so we avoid generic follow-up text.
-                const draft = await this.generateClarificationDraft(description, profileContext, activeIntentsContext, parsed.underspecificationType);
-                if (draft) {
-                    return {
-                        ...parsed,
-                        suggestedDescription: draft.suggestedDescription,
-                        clarificationMessage: draft.clarificationMessage,
-                    };
-                }
-            }
-            return parsed;
-        }
-        catch (error) {
-            logger.warn("invoke: clarification failed", { error });
-            return {
-                needsClarification: false,
-                reason: "fallback_on_model_error",
-                suggestedDescription: null,
-                clarificationMessage: null,
-                underspecificationType: null,
-            };
-        }
-    }
-    async generateSuggestion(description, profileContext, activeIntentsContext) {
-        try {
-            const prompt = this.buildPrompt(description, profileContext, activeIntentsContext);
-            const output = await invokeWithAbortSignal(this.suggestionModel, [
-                new SystemMessage(suggestionPrompt),
-                new HumanMessage(prompt),
-            ]);
-            const parsed = suggestionSchema.parse(output);
-            const suggestion = parsed.suggestedDescription.trim();
-            return suggestion.length > 0 ? suggestion : null;
-        }
-        catch (error) {
-            logger.warn("generateSuggestion: failed", { error });
-            return null;
-        }
-    }
-    async generateClarificationDraft(description, profileContext, activeIntentsContext, underspecificationType) {
-        try {
-            const prompt = [
-                this.buildPrompt(description, profileContext, activeIntentsContext),
-                "# QUD Repair Category",
-                underspecificationType,
-            ].join("\n");
-            const output = await invokeWithAbortSignal(this.clarificationDraftModel, [
-                new SystemMessage(clarificationDraftPrompt),
-                new HumanMessage(prompt),
-            ]);
-            const parsed = clarificationDraftSchema.parse(output);
-            const suggestedDescription = parsed.suggestedDescription.trim();
-            const clarificationMessage = parsed.clarificationMessage.trim();
-            if (!suggestedDescription || !clarificationMessage)
-                return null;
-            return { suggestedDescription, clarificationMessage };
-        }
-        catch (error) {
-            logger.warn("generateClarificationDraft: failed", { error });
-            const suggestion = await this.generateSuggestion(description, profileContext, activeIntentsContext);
-            if (!suggestion)
-                return null;
-            const clarificationMessage = (() => {
-                switch (underspecificationType) {
-                    case "missing_constituent":
-                        return "Who or what should this intent focus on?";
-                    case "missing_constraint":
-                        return "Which location, timing, format, or range should constrain this intent?";
-                    case "open_alternative_set":
-                        return `Your intent names different alternatives — "${description}". Which one should take priority?`;
-                }
-            })();
-            return {
-                suggestedDescription: suggestion,
-                clarificationMessage,
-            };
-        }
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String]),
-    __metadata("design:returntype", Promise)
-], IntentClarifier.prototype, "invoke", null);