@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/negotiations/negotiation.state.js

@@ -1,286 +0,0 @@
-import { Annotation } from "@langchain/langgraph";
-import { z } from "zod";
-import { AskUserPayloadSchema, NEGOTIATION_ACTIONS } from "../shared/schemas/negotiation-state.schema.js";
-/**
- * Zod schema for a single negotiation turn (DataPart payload in A2A message).
- * Accepts the full v1+v2 action union — which subset is valid for a given turn
- * is enforced by the seat-scoped schemas in `negotiation.protocol.ts`.
- */
-export const NegotiationTurnSchema = z.object({
-    action: z.enum(NEGOTIATION_ACTIONS),
-    assessment: z.object({
-        reasoning: z.string(),
-        suggestedRoles: z.object({
-            ownUser: z.enum(["agent", "patient", "peer"]),
-            otherUser: z.enum(["agent", "patient", "peer"]),
-        }),
-    }),
-    message: z.string().nullable().optional(),
-    /** Present when action is `ask_user` (v2, P3.2). */
-    askUser: AskUserPayloadSchema.nullable().optional(),
-});
-/** Restricted v1 turn schema for the system agent (no question action). */
-export const SystemNegotiationTurnSchema = z.object({
-    action: z.enum(["propose", "accept", "reject", "counter"]),
-    assessment: z.object({
-        reasoning: z.string(),
-        suggestedRoles: z.object({
-            ownUser: z.enum(["agent", "patient", "peer"]),
-            otherUser: z.enum(["agent", "patient", "peer"]),
-        }),
-    }),
-    message: z.string().nullable().optional(),
-});
-/** v1 turn schema for system agent's final allowed turn (must decide). */
-export const FinalNegotiationTurnSchema = z.object({
-    action: z.enum(["accept", "reject"]),
-    assessment: z.object({
-        reasoning: z.string(),
-        suggestedRoles: z.object({
-            ownUser: z.enum(["agent", "patient", "peer"]),
-            otherUser: z.enum(["agent", "patient", "peer"]),
-        }),
-    }),
-    message: z.string().nullable().optional(),
-});
-/** Zod schema for the negotiation outcome (Artifact payload on COMPLETED task). */
-export const NegotiationOutcomeSchema = z.object({
-    hasOpportunity: z.boolean(),
-    agreedRoles: z.array(z.object({
-        userId: z.string(),
-        role: z.enum(["agent", "patient", "peer"]),
-    })),
-    reasoning: z.string(),
-    turnCount: z.number(),
-    reason: z.enum(["turn_cap", "timeout", "screened_out"]).optional(),
-});
-/** LangGraph state annotation for the negotiation graph. */
-export const NegotiationGraphState = Annotation.Root({
-    sourceUser: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => ({ id: "", intents: [], profile: {} }),
-    }),
-    candidateUser: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => ({ id: "", intents: [], profile: {} }),
-    }),
-    sourceIntentId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    candidateIntentId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    indexContext: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => ({ networkId: "", prompt: "" }),
-    }),
-    seedAssessment: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => ({ reasoning: "", valencyRole: "" }),
-    }),
-    /**
-     * Explicit initiator seat for this match (purely additive metadata — no seat
-     * rules attach to it yet). Resolution when unset happens in the init node;
-     * the resolved value is written back to state and into task metadata.
-     */
-    initiatorUserId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** The explicit search query that triggered discovery (if any). */
-    discoveryQuery: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /**
-     * Negotiation protocol version for this session's task. Resolved by the
-     * init node: inherited from the prior task on the conversation when one
-     * exists (never re-stamped — a v1 conversation stays v1 mid-flight), else
-     * stamped from `NEGOTIATION_PROTOCOL_VERSION` for genuinely fresh runs.
-     */
-    protocolVersion: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => "v1",
-    }),
-    /**
-     * Screen-gate decision for this fresh run (P2.1 shadow mode). Written by the
-     * screen node; null when the gate is off, on continuations, or before the
-     * node runs. Mirrors `tasks.metadata.screenDecision`.
-     */
-    screenDecision: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => null,
-    }),
-    /**
-     * First applied deadlock→bargaining shift in this session (IND-428).
-     * Written by the turn node when the system agent first drafts in the
-     * bargaining stance; used to record the shift exactly once per session.
-     * Internal analytics only — mirrored to `tasks.metadata.deadlockShift`,
-     * never into any turn payload or public projection.
-     */
-    deadlockShift: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => null,
-    }),
-    /**
-     * Per-side negotiator-memory cache (P5.3 read path). Populated lazily the
-     * first time each side's memory is retrieved (screen node for the client,
-     * turn node for the speaker) so a multi-turn session pays for retrieval at
-     * most once per side. `undefined` per side = not yet retrieved; `[]` =
-     * retrieved and empty (flag off / no rows / retrieval failed).
-     */
-    memoryBySide: Annotation({
-        reducer: (curr, next) => ({ ...curr, ...next }),
-        default: () => ({}),
-    }),
-    /** Whether this run is continuing a prior conversation with the same pair. */
-    isContinuation: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => false,
-    }),
-    /**
-     * Immutable attributed prior dialogue derived once in the init node from the
-     * seeded prior messages (IND-569). Groups earlier-opportunity turns and
-     * legacy unattributed turns so the screen node and every turn prompt can
-     * label prior context per opportunity. Null on fresh runs / when there is no
-     * seeded prior dialogue. Typed as `unknown` to avoid a module cycle
-     * (attribution module imports NegotiationTurn from this module's shim);
-     * callers cast to `SeededAttribution` via the negotiation.attribution module.
-     */
-    priorAttribution: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => null,
-    }),
-    /**
-     * Whether the initiator has actually opened `outreach` within THIS task
-     * (IND-564). Set by the turn node the first time an `outreach` turn is
-     * persisted in the current session; seeded prior-task turns never flip it.
-     * `withdraw` is only legal after an in-task outreach — a withdraw before one
-     * would retract an outreach never made here and drop a spurious message into
-     * the shared thread, so the turn node maps it to a quiet screen-out instead.
-     */
-    outreachOpened: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => false,
-    }),
-    /**
-     * Set by the turn node when an opening-move `withdraw` (no in-task outreach)
-     * was blocked (IND-564). Signals finalize to record the quiet screen-out
-     * outcome (`reason: "screened_out"`, opportunity `rejected`) without ever
-     * persisting the withdraw message into the shared `dm_pair` conversation.
-     */
-    firstTurnScreenedOut: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => false,
-    }),
-    opportunityId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => "",
-    }),
-    /** Exact persisted lifecycle state claimed by this negotiation attempt. */
-    opportunityStatus: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    opportunityUpdatedAt: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Exact prior task selected by a durable continuation; bypasses latest-task lookup. */
-    resumeFromTaskId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Deterministic settlement key used to idempotently reuse a successor task. */
-    continuationSettlementId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    continuationExecution: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    continuationReceipt: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    privateConsultation: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Server-only IND-508 category recovered from the exact prior task binding. */
-    consultationPolicyReason: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    conversationId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => "",
-    }),
-    taskId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => "",
-    }),
-    messages: Annotation({
-        reducer: (curr, next) => [...curr, ...(next || [])],
-        default: () => [],
-    }),
-    turnCount: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => 0,
-    }),
-    maxTurns: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /**
-     * Park-window budget in milliseconds. The annotation default is a safety net
-     * for any caller that omits the field — keep it aligned with
-     * `AMBIENT_PARK_WINDOW_MS` in packages/protocol/src/negotiations/negotiation.tools.ts.
-     * Inlined rather than imported to avoid a state↔tools cycle.
-     */
-    timeoutMs: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => 5 * 60 * 1000,
-    }),
-    currentSpeaker: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => "source",
-    }),
-    lastTurn: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => null,
-    }),
-    /**
-     * Graph status.
-     * - `active` — agents are exchanging turns (default)
-     * - `waiting_for_agent` — graph suspended; awaiting external agent response or timeout
-     * - `input_required` — graph suspended on an `ask_user` pause; awaiting the
-     *   negotiator's own client (answer or 24 h window expiry resumes it)
-     * - `completed` — negotiation finalized (accept/reject/turn-cap/timeout)
-     */
-    status: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => 'active',
-    }),
-    /** Number of turns present in the conversation before this session started. */
-    priorTurnCount: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => 0,
-    }),
-    /** User answers collected by the questioner between negotiation sessions. */
-    userAnswers: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => [],
-    }),
-    outcome: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => null,
-    }),
-    error: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => null,
-    }),
-});

package/dist/negotiations/negotiation.summarizer.d.ts

@@ -1,25 +0,0 @@
-/**
- * NegotiationSummarizer — pure LLM pass that compresses one DiscoveryNegotiation
- * (potentially several KB of turn reasoning + outcome reasoning) into a
- * DiscoveryNegotiationDigest (≤256 bytes structured). The digest is what the decision-
- * question generator consumes, replacing the raw negotiation blob.
- *
- * Why: a 10-candidate discovery turn used to produce a 60+ KB prompt for the
- * question generator, which stalled upstream Gemini/OpenRouter routes and
- * dropped the connection at ~3 minutes. Per-negotiation summarization caps
- * the question-generator input at a fixed, predictable size.
- */
-import { type DiscoveryNegotiationDigest } from "../shared/schemas/negotiation-digest.schema.js";
-import type { DiscoveryNegotiation } from "../shared/schemas/discovery-question.schema.js";
-export declare class NegotiationSummarizer {
-    private model;
-    constructor();
-    summarize(negotiation: DiscoveryNegotiation, options?: {
-        signal?: AbortSignal;
-    }): Promise<DiscoveryNegotiationDigest | null>;
-}
-/**
- * Deterministic fallback when the LLM summarizer fails or isn't wired. Produces
- * a minimal but valid digest so the question generator still has *some* signal.
- */
-export declare function buildFallbackDigest(n: DiscoveryNegotiation): DiscoveryNegotiationDigest;

package/dist/negotiations/negotiation.summarizer.js

@@ -1,101 +0,0 @@
-/**
- * NegotiationSummarizer — pure LLM pass that compresses one DiscoveryNegotiation
- * (potentially several KB of turn reasoning + outcome reasoning) into a
- * DiscoveryNegotiationDigest (≤256 bytes structured). The digest is what the decision-
- * question generator consumes, replacing the raw negotiation blob.
- *
- * Why: a 10-candidate discovery turn used to produce a 60+ KB prompt for the
- * question generator, which stalled upstream Gemini/OpenRouter routes and
- * dropped the connection at ~3 minutes. Per-negotiation summarization caps
- * the question-generator input at a fixed, predictable size.
- */
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-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 { DiscoveryNegotiationDigestSchema } from "../shared/schemas/negotiation-digest.schema.js";
-const logger = protocolLogger("NegotiationSummarizer");
-const SYSTEM_PROMPT = `You summarize one negotiation between a seeker's agent and a candidate's agent into a structured digest for downstream decision-question generation.
-
-Output requirements (ALL fields — set optional fields to null when not applicable):
-- counterpartyHint: copy the input field verbatim, truncated to ≤120 chars.
-- indexContext: copy the input field verbatim, truncated to ≤120 chars.
-- outcomeRole: "opportunity" when hasOpportunity=true, else "no-opportunity".
-- outcomeReason: when outcomeRole="no-opportunity", set to "turn_cap" / "timeout" / "screened_out" if the input's reason matches; else "rejected" (if a turn explicitly rejected) or "stalled". When outcomeRole="opportunity", set to null. "screened_out" means the seeker's own agent chose not to reach out before any turn was exchanged — never describe it as the candidate declining or stalling.
-- keyTake: ONE sentence (≤180 chars). Describe the decisive moment, the alignment gap, or the recurring signal — anything a question generator could use to formulate a clarifying question. NOT a generic outcome restatement. Anchor in a concrete detail from the negotiation if possible (a role mismatch, a missing input the candidate flagged, a pivot one party suggested).
-- suggestedRoles: when both parties agreed on roles (the last turn's suggestedRoles), copy them from input. Otherwise set to null.
-
-Do not include candidate identity, PII, names, or IDs. Reuse only counterpartyHint and indexContext as provided.`;
-function buildUserPrompt(n) {
-    const turnLines = n.turns
-        .map((t, i) => `[${i + 1}] action=${t.action} roles=${t.suggestedRoles.ownUser}↔${t.suggestedRoles.otherUser} reasoning=${t.reasoning}`)
-        .join("\n");
-    return [
-        `counterpartyHint: ${n.counterpartyHint}`,
-        `indexContext: ${n.indexContext}`,
-        `turns (${n.turns.length}):`,
-        turnLines || "(no turns)",
-        `outcome.hasOpportunity: ${n.outcome.hasOpportunity}`,
-        `outcome.reasoning: ${n.outcome.reasoning}`,
-        n.outcome.reason ? `outcome.reason: ${n.outcome.reason}` : "",
-    ]
-        .filter(Boolean)
-        .join("\n");
-}
-export class NegotiationSummarizer {
-    constructor() {
-        this.model = createStructuredModel("negotiationSummarizer", DiscoveryNegotiationDigestSchema, {
-            name: "negotiation_digest",
-        });
-    }
-    async summarize(negotiation, options) {
-        const user = buildUserPrompt(negotiation);
-        let raw;
-        try {
-            raw = await invokeWithAbortSignal(this.model, [new SystemMessage(SYSTEM_PROMPT), new HumanMessage(user)], options?.signal);
-        }
-        catch (err) {
-            const aborted = options?.signal?.aborted ?? false;
-            if (aborted) {
-                logger.info("NegotiationSummarizer aborted by signal", {
-                    reason: options?.signal?.reason instanceof Error ? options.signal.reason.message : String(options?.signal?.reason ?? "unknown"),
-                });
-            }
-            else {
-                logger.warn("NegotiationSummarizer LLM call failed", {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            return null;
-        }
-        const parsed = DiscoveryNegotiationDigestSchema.safeParse(raw);
-        if (!parsed.success) {
-            logger.warn("NegotiationSummarizer parse failed", { error: parsed.error.message });
-            return null;
-        }
-        return parsed.data;
-    }
-}
-/**
- * Deterministic fallback when the LLM summarizer fails or isn't wired. Produces
- * a minimal but valid digest so the question generator still has *some* signal.
- */
-export function buildFallbackDigest(n) {
-    const outcomeRole = n.outcome.hasOpportunity ? "opportunity" : "no-opportunity";
-    const lastTurn = n.turns[n.turns.length - 1];
-    const keyTakeRaw = n.outcome.reasoning && n.outcome.reasoning.trim().length > 0
-        ? n.outcome.reasoning
-        : `${n.turns.length} turn(s); ended ${outcomeRole}`;
-    return {
-        counterpartyHint: n.counterpartyHint.slice(0, 120),
-        indexContext: n.indexContext.slice(0, 120),
-        outcomeRole,
-        outcomeReason: outcomeRole === "no-opportunity"
-            ? (n.outcome.reason ?? "stalled")
-            : null,
-        keyTake: keyTakeRaw.slice(0, 180),
-        suggestedRoles: lastTurn?.action === "accept" && lastTurn.suggestedRoles
-            ? lastTurn.suggestedRoles
-            : null,
-    };
-}

package/dist/negotiations/negotiation.task-lock-policy.d.ts

@@ -1,10 +0,0 @@
-/**
- * Whether a persisted negotiation task still admits an exclusive conversation
- * lock. A paused `ask_user` consultation holds the lock for its complete
- * answer window plus expiry-worker slack; ordinary active turns use the
- * existing five-minute freshness window.
- */
-export declare function holdsNegotiationConversationLock(task: {
-    state: string;
-    updatedAt: Date;
-}, now?: number): boolean;

package/dist/negotiations/negotiation.task-lock-policy.js

@@ -1,22 +0,0 @@
-import { ASK_USER_LOCK_SLACK_MS, askUserAnswerWindowMs } from "./negotiation.protocol.js";
-const ACTIVE_NEGOTIATION_TASK_STATES = [
-    "submitted",
-    "working",
-    "input_required",
-    "waiting_for_agent",
-    "claimed",
-];
-/**
- * Whether a persisted negotiation task still admits an exclusive conversation
- * lock. A paused `ask_user` consultation holds the lock for its complete
- * answer window plus expiry-worker slack; ordinary active turns use the
- * existing five-minute freshness window.
- */
-export function holdsNegotiationConversationLock(task, now = Date.now()) {
-    if (!ACTIVE_NEGOTIATION_TASK_STATES.includes(task.state))
-        return false;
-    const freshnessMs = task.state === "input_required"
-        ? askUserAnswerWindowMs() + ASK_USER_LOCK_SLACK_MS
-        : 5 * 60 * 1000;
-    return now - new Date(task.updatedAt).getTime() < freshnessMs;
-}

package/dist/negotiations/negotiation.tools.d.ts

@@ -1,18 +0,0 @@
-import type { DefineTool } from '../shared/agent/tool.helpers.js';
-import type { NegotiationToolDeps } from './negotiation.tools.port.js';
-export { buildLifecycleNarration } from './negotiation.lifecycle-narration.js';
-/**
- * Default park-window budget for ambient (background) negotiations. When a personal
- * agent is fresh, the dispatcher parks the turn and this is how long we wait before
- * the system agent takes over as a fallback.
- *
- * Short enough that ambient opportunities materialize in minutes (not hours),
- * long enough to cover two full polling cycles (30s * 2 = 60s) plus an agent
- * subagent turn. 5 minutes gives generous headroom.
- */
-export declare const AMBIENT_PARK_WINDOW_MS: number;
-/**
- * Creates negotiation MCP tools for external agent access.
- * Exposes negotiation state for listing, reading, and responding to bilateral negotiations.
- */
-export declare function createNegotiationTools(defineTool: DefineTool, deps: NegotiationToolDeps): readonly [any, any, any];