@indexnetwork/protocol 6.12.1-rc.404.1 → 6.13.22-rc.405.1

package/dist/communities/application/indexer.graph.js

@@ -0,0 +1,420 @@
+import { StateGraph, START, END } from "@langchain/langgraph";
+import { buildNetworkAssignmentDecision } from "../../shared/assignment/network-assignment.policy.js";
+import { protocolLogger } from "../../shared/observability/protocol.logger.js";
+import { timed } from "../../shared/observability/performance.js";
+import { requestContext } from "../../shared/observability/request-context.js";
+import { renderNetworkContext } from "../../shared/network/metadata.renderer.js";
+import { IntentNetworkGraphState } from "./indexer.state.js";
+const logger = protocolLogger("IntentNetworkGraphFactory");
+/**
+ * Factory class to build and compile the Intent–Network (indexer) Graph.
+ *
+ * Handles CRUD for the intent_indexes junction table:
+ * - create: Assign an intent to a network (direct or LLM-evaluated)
+ * - read: List intent–network links (by intentId or by networkId)
+ * - delete: Unassign an intent from a network
+ *
+ * ## Signal assignment policy
+ *
+ * The `IntentIndexer` is injected at construction time from the signals public
+ * facade via the communities ports layer — this factory never imports signals
+ * application internals directly.
+ *
+ * Two assignment paths:
+ * 1. Direct (`skipEvaluation: true`):
+ *    - Writes the link immediately with `mode: manual_override`, `score: 1`.
+ * 2. Evaluated (`skipEvaluation: false`):
+ *    - Loads intent + network context (indexPrompt, memberPrompt).
+ *    - No-prompt fast path: if both prompts are absent, assigns with
+ *      `mode: automatic, promptPresence: 'none'` without calling the LLM.
+ *    - Otherwise invokes IntentIndexer to get indexScore + memberScore + reasoning.
+ *    - Applies `buildNetworkAssignmentDecision` to produce the threshold/metadata.
+ *    - Only writes the link when the decision's `assigned` flag is true.
+ *
+ * ## Membership authority for assignment
+ *
+ * A user may only assign their own intents.
+ * The user must be a member (or owner) of the target network.
+ * Assignment is rejected if membership has been revoked between intent creation
+ * and assignment time (`assignIntentToNetworkIfMember` returns `membership_required`).
+ *
+ * Flow:
+ * START → router → {
+ *   create: assignNode (direct or evaluated) → END
+ *   read: readNode → END
+ *   delete: unassignNode → END
+ * }
+ *
+ * IND-546: canonical home — previously network/indexer/indexer.graph.ts.
+ * Signals dependency consumed via capabilities/signals.facade.ts (through ports).
+ */
+export class IntentNetworkGraphFactory {
+    constructor(database, intentNetworker) {
+        this.database = database;
+        this.intentNetworker = intentNetworker;
+    }
+    createGraph() {
+        const indexer = this.intentNetworker;
+        const finalizeAssignment = async (userId, intentId, networkId, score, metadata, successMessage) => {
+            const outcome = await this.database.assignIntentToNetworkIfMember(userId, intentId, networkId, score, metadata);
+            if (outcome.kind === 'assigned') {
+                return {
+                    assignmentResult: { networkId, assigned: true, success: true },
+                    mutationResult: { success: true, message: successMessage },
+                };
+            }
+            if (outcome.kind === 'already_assigned') {
+                return {
+                    assignmentResult: { networkId, assigned: true, success: true },
+                    mutationResult: { success: true, message: 'That intent is already in this network.' },
+                };
+            }
+            if (outcome.kind === 'membership_required') {
+                return {
+                    assignmentResult: { networkId, assigned: false, success: false },
+                    mutationResult: { success: false, error: 'Current network membership is required to assign this intent.' },
+                };
+            }
+            return {
+                assignmentResult: { networkId, assigned: false, success: false },
+                mutationResult: { success: false, error: 'Intent is no longer available for assignment.' },
+            };
+        };
+        // --- NODE DEFINITIONS ---
+        /**
+         * Assign Node: Assign an intent to a network.
+         *
+         * Sub-paths selected by `skipEvaluation`:
+         * - true  → direct assignment (manual_override)
+         * - false → evaluated assignment (automatic, with optional LLM fast-path)
+         */
+        const assignNode = async (state) => {
+            return timed("IntentNetworkGraph.assign", async () => {
+                const intentId = state.intentId;
+                const networkId = state.networkId;
+                logger.verbose("Assign intent to network", { userId: state.userId, intentId, networkId, skipEvaluation: state.skipEvaluation });
+                const agentTimingsAccum = [];
+                if (!intentId || !networkId) {
+                    return { agentTimings: agentTimingsAccum, mutationResult: { success: false, error: "Both intentId and networkId are required." } };
+                }
+                try {
+                    // Validate ownership and membership
+                    const intent = await this.database.getIntent(intentId);
+                    if (!intent) {
+                        return { agentTimings: agentTimingsAccum, mutationResult: { success: false, error: "Intent not found." } };
+                    }
+                    if (intent.userId !== state.userId) {
+                        return { agentTimings: agentTimingsAccum, mutationResult: { success: false, error: "You can only add your own intents to a network." } };
+                    }
+                    const [isMember, isOwner] = await Promise.all([
+                        this.database.isNetworkMember(networkId, state.userId),
+                        this.database.isIndexOwner(networkId, state.userId),
+                    ]);
+                    if (!isMember && !isOwner) {
+                        return { agentTimings: agentTimingsAccum, mutationResult: { success: false, error: "You are not a member of that network." } };
+                    }
+                    // Check if already assigned
+                    const alreadyAssigned = await this.database.isIntentAssignedToIndex(intentId, networkId);
+                    if (alreadyAssigned) {
+                        return { agentTimings: agentTimingsAccum, mutationResult: { success: true, message: "That intent is already in this network." } };
+                    }
+                    // Direct assignment (skip LLM evaluation)
+                    if (state.skipEvaluation) {
+                        const decision = buildNetworkAssignmentDecision({
+                            resourceType: "intent",
+                            mode: "manual_override",
+                            scope: "network",
+                            evaluator: "intent-network-graph",
+                            source: "manual-index-assignment",
+                            createdAt: new Date().toISOString(),
+                        });
+                        const finalized = await finalizeAssignment(state.userId, intentId, networkId, decision.finalScore, decision.metadata, 'Intent saved to the network.');
+                        return { agentTimings: agentTimingsAccum, ...finalized };
+                    }
+                    // Evaluated assignment path
+                    const intentForIndexing = await this.database.getIntentForIndexing(intentId);
+                    if (!intentForIndexing) {
+                        return { agentTimings: agentTimingsAccum, mutationResult: { success: false, error: "Intent not found for evaluation." } };
+                    }
+                    const indexContext = await this.database.getNetworkAssignmentContext(networkId, intentForIndexing.userId);
+                    if (!indexContext) {
+                        return {
+                            agentTimings: agentTimingsAccum,
+                            assignmentResult: { networkId, assigned: false, success: false },
+                            mutationResult: { success: false, error: "Network assignment context not found." },
+                        };
+                    }
+                    const indexPrompt = indexContext.indexPrompt ?? null;
+                    const memberPrompt = indexContext.memberPrompt ?? null;
+                    const hasNoPrompts = !indexPrompt?.trim() && !memberPrompt?.trim();
+                    // No-prompt fast path: assign without LLM
+                    if (hasNoPrompts) {
+                        const decision = buildNetworkAssignmentDecision({
+                            resourceType: "intent",
+                            mode: "automatic",
+                            scope: "network",
+                            indexPrompt,
+                            memberPrompt,
+                            evaluator: "intent-networker",
+                            source: "intent-network-graph",
+                            createdAt: new Date().toISOString(),
+                        });
+                        const finalized = await finalizeAssignment(state.userId, intentId, networkId, decision.finalScore, decision.metadata, 'Intent assigned to network (no prompts).');
+                        return { agentTimings: agentTimingsAccum, ...finalized };
+                    }
+                    // Render network context for the evaluator
+                    const network = await this.database.getNetwork(networkId);
+                    const renderedContext = network
+                        ? renderNetworkContext({
+                            type: network.type ?? 'community',
+                            title: network.title,
+                            prompt: network.prompt,
+                            metadata: network.metadata ?? {},
+                        })
+                        : null;
+                    const sourceName = intentForIndexing.sourceType
+                        ? `${intentForIndexing.sourceType}:${intentForIndexing.sourceId ?? ""}`
+                        : undefined;
+                    // Run IntentIndexer evaluation (injected from signals public facade via ports)
+                    const _traceEmitter = requestContext.getStore()?.traceEmitter;
+                    const _indexerStart = Date.now();
+                    _traceEmitter?.({ type: "agent_start", name: "intent-networker" });
+                    let result = null;
+                    try {
+                        result = await indexer.evaluate(intentForIndexing.payload, indexPrompt, memberPrompt, sourceName, renderedContext);
+                    }
+                    finally {
+                        const _indexerMs = Date.now() - _indexerStart;
+                        agentTimingsAccum.push({ name: 'intent.indexer', durationMs: _indexerMs });
+                        _traceEmitter?.({
+                            type: "agent_end",
+                            name: "intent-networker",
+                            durationMs: _indexerMs,
+                            summary: result
+                                ? `Scored: index=${result.indexScore.toFixed(2)}, member=${result.memberScore.toFixed(2)}`
+                                : "intent-networker failed",
+                        });
+                    }
+                    if (!result) {
+                        return {
+                            agentTimings: agentTimingsAccum,
+                            evaluation: null,
+                            shouldAssign: false,
+                            finalScore: 0,
+                            mutationResult: { success: false, error: "Evaluation returned no result." },
+                        };
+                    }
+                    const decision = buildNetworkAssignmentDecision({
+                        resourceType: "intent",
+                        mode: "automatic",
+                        scope: "network",
+                        indexPrompt,
+                        memberPrompt,
+                        rawScores: { indexScore: result.indexScore, memberScore: result.memberScore },
+                        evaluator: "intent-networker",
+                        source: "intent-network-graph",
+                        reason: result.reasoning,
+                        createdAt: new Date().toISOString(),
+                    });
+                    if (decision.assigned) {
+                        const finalized = await finalizeAssignment(state.userId, intentId, networkId, decision.finalScore, decision.metadata, `Intent assigned to network (score: ${decision.finalScore.toFixed(2)}).`);
+                        return {
+                            agentTimings: agentTimingsAccum,
+                            evaluation: result,
+                            shouldAssign: finalized.assignmentResult.assigned,
+                            finalScore: decision.finalScore,
+                            ...finalized,
+                        };
+                    }
+                    return {
+                        agentTimings: agentTimingsAccum,
+                        evaluation: result,
+                        shouldAssign: false,
+                        finalScore: decision.finalScore,
+                        assignmentResult: { networkId, assigned: false, success: true },
+                        mutationResult: { success: false, error: `Intent did not qualify for this network (score: ${decision.finalScore.toFixed(2)}).` },
+                    };
+                }
+                catch (err) {
+                    logger.error("Assign failed", { error: err });
+                    return { agentTimings: agentTimingsAccum, mutationResult: { success: false, error: "Failed to assign intent to network." } };
+                }
+            });
+        };
+        /**
+         * Read Node: Query intent–network relationships.
+         *
+         * Three modes (selected by which inputs are provided):
+         * - Both intentId + networkId: check if the specific link exists (owner only).
+         * - intentId only: list all networks the intent is linked to (owner only).
+         * - networkId only: list intents in the network (member only, up to 50).
+         *   Add `queryUserId` to filter to one member's intents.
+         */
+        const readNode = async (state) => {
+            return timed("IntentNetworkGraph.read", async () => {
+                const intentId = state.intentId;
+                const networkId = state.networkId;
+                logger.verbose("Read intent–network links", { userId: state.userId, intentId, networkId, queryUserId: state.queryUserId });
+                try {
+                    // By both: check if specific intent–network link exists
+                    if (intentId && networkId) {
+                        const intent = await this.database.getIntent(intentId);
+                        if (!intent) {
+                            return { readResult: { links: [], count: 0, mode: "check_link" }, error: "Intent not found." };
+                        }
+                        if (intent.userId !== state.userId) {
+                            return { readResult: { links: [], count: 0, mode: "check_link" }, error: "You can only check links for your own intents." };
+                        }
+                        const isLinked = await this.database.isIntentAssignedToIndex(intentId, networkId);
+                        return {
+                            readResult: {
+                                links: isLinked ? [{ intentId, networkId }] : [],
+                                count: isLinked ? 1 : 0,
+                                mode: "check_link",
+                                note: isLinked ? "Intent is linked to this network." : "Intent is not linked to this network.",
+                            },
+                        };
+                    }
+                    // By intent only: list all networks for this intent
+                    if (intentId) {
+                        const intent = await this.database.getIntent(intentId);
+                        if (!intent) {
+                            return { readResult: { links: [], count: 0, mode: "networks_for_intent" }, error: "Intent not found." };
+                        }
+                        if (intent.userId !== state.userId) {
+                            return { readResult: { links: [], count: 0, mode: "networks_for_intent" }, error: "You can only list networks for your own intents." };
+                        }
+                        const networkIds = await this.database.getNetworkIdsForIntent(intentId);
+                        return {
+                            readResult: {
+                                links: networkIds.map((id) => ({ intentId, networkId: id })),
+                                count: networkIds.length,
+                                mode: "networks_for_intent",
+                                note: "To show network titles, use read_networks.",
+                            },
+                        };
+                    }
+                    // By network: list intents in the network
+                    if (!networkId) {
+                        return {
+                            readResult: { links: [], count: 0, mode: "unknown" },
+                            error: "Provide networkId or intentId.",
+                        };
+                    }
+                    const [isMember, isOwner] = await Promise.all([
+                        this.database.isNetworkMember(networkId, state.userId),
+                        this.database.isIndexOwner(networkId, state.userId),
+                    ]);
+                    if (!isMember && !isOwner) {
+                        return {
+                            readResult: { links: [], count: 0, mode: "intents_in_network" },
+                            error: "Network not found or you are not a member.",
+                        };
+                    }
+                    if (!state.queryUserId) {
+                        const intents = await this.database.getNetworkIntentsForMember(networkId, state.userId, { limit: 50, offset: 0 });
+                        return {
+                            readResult: {
+                                links: intents.map((i) => ({
+                                    intentId: i.id,
+                                    networkId,
+                                    intentTitle: i.payload,
+                                    userId: i.userId,
+                                    userName: i.userName,
+                                    createdAt: i.createdAt,
+                                    relevancyScore: i.relevancyScore,
+                                })),
+                                count: intents.length,
+                                mode: "intents_in_network",
+                                note: "To show network title and full intent details, use read_networks and read_intents.",
+                            },
+                        };
+                    }
+                    // Specific user's intents in the network
+                    const intents = await this.database.getIntentsInIndexForMember(state.queryUserId, networkId);
+                    return {
+                        readResult: {
+                            links: intents.map((i) => ({
+                                intentId: i.id,
+                                networkId,
+                                intentTitle: i.payload,
+                                createdAt: i.createdAt,
+                                relevancyScore: i.relevancyScore,
+                            })),
+                            count: intents.length,
+                            mode: "intents_in_network",
+                            note: "To show network title and full intent details, use read_networks and read_intents.",
+                        },
+                    };
+                }
+                catch (err) {
+                    logger.error("Read intent–network failed", { error: err });
+                    return { error: "Failed to fetch intent–network links." };
+                }
+            });
+        };
+        /**
+         * Unassign Node: Remove an intent from a network.
+         * Only the intent owner may unassign, and only if they are a member/owner of the network.
+         */
+        const unassignNode = async (state) => {
+            return timed("IntentNetworkGraph.unassign", async () => {
+                const intentId = state.intentId;
+                const networkId = state.networkId;
+                logger.verbose("Unassign intent from network", { userId: state.userId, intentId, networkId });
+                if (!intentId || !networkId) {
+                    return { mutationResult: { success: false, error: "Both intentId and networkId are required." } };
+                }
+                try {
+                    const intent = await this.database.getIntent(intentId);
+                    if (!intent) {
+                        return { mutationResult: { success: false, error: "Intent not found." } };
+                    }
+                    if (intent.userId !== state.userId) {
+                        return { mutationResult: { success: false, error: "You can only remove your own intents from a network." } };
+                    }
+                    const [isMember, isOwner] = await Promise.all([
+                        this.database.isNetworkMember(networkId, state.userId),
+                        this.database.isIndexOwner(networkId, state.userId),
+                    ]);
+                    if (!isMember && !isOwner) {
+                        return { mutationResult: { success: false, error: "You are not a member of that network." } };
+                    }
+                    const assigned = await this.database.isIntentAssignedToIndex(intentId, networkId);
+                    if (!assigned) {
+                        return { mutationResult: { success: true, message: "That intent is not in this network." } };
+                    }
+                    await this.database.unassignIntentFromIndex(intentId, networkId);
+                    return { mutationResult: { success: true, message: "Intent removed from the network." } };
+                }
+                catch (err) {
+                    logger.error("Unassign failed", { error: err });
+                    return { mutationResult: { success: false, error: "Failed to remove intent from network." } };
+                }
+            });
+        };
+        // --- CONDITIONAL ROUTING ---
+        const routeByMode = (state) => {
+            switch (state.operationMode) {
+                case 'create': return 'assign';
+                case 'read': return 'read';
+                case 'delete': return 'unassign';
+                default: return 'read';
+            }
+        };
+        // --- GRAPH ASSEMBLY ---
+        const workflow = new StateGraph(IntentNetworkGraphState)
+            .addNode("assign", assignNode)
+            .addNode("read", readNode)
+            .addNode("unassign", unassignNode)
+            .addConditionalEdges(START, routeByMode, {
+            assign: "assign",
+            read: "read",
+            unassign: "unassign",
+        })
+            .addEdge("assign", END)
+            .addEdge("read", END)
+            .addEdge("unassign", END);
+        return workflow.compile();
+    }
+}

package/dist/communities/application/indexer.state.d.ts

@@ -0,0 +1,172 @@
+import type { DebugMetaAgent } from "../../capabilities/participant-agents.debug.facade.js";
+/**
+ * Intent payload and metadata loaded for network evaluation.
+ * Loaded from the database before LLM-based assignment scoring.
+ *
+ * IND-546: canonical home — previously network/indexer/indexer.state.ts.
+ */
+export interface IntentForIndexing {
+    id: string;
+    payload: string;
+    userId: string;
+    sourceType: string | null;
+    sourceId: string | null;
+}
+/**
+ * Index and member prompts for a single network (user must be member with autoAssign).
+ * Used by the evaluated assignment path in IntentNetworkGraphFactory.
+ *
+ * IND-546: canonical home — previously network/indexer/indexer.state.ts.
+ */
+export interface IndexMemberContext {
+    networkId: string;
+    indexPrompt: string | null;
+    memberPrompt: string | null;
+}
+/**
+ * Result of executing an assignment decision.
+ * Returned from the assign node as a structured output alongside mutationResult.
+ *
+ * IND-546: canonical home — previously network/indexer/indexer.state.ts.
+ */
+export interface AssignmentResult {
+    networkId: string;
+    assigned: boolean;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Intent Index Graph State.
+ * Handles CRUD for the intent_indexes junction table (linking intents to networks).
+ *
+ * ## Signal assignment policy
+ *
+ * Two assignment paths, selected via `skipEvaluation`:
+ * - `true` (direct / manual_override): writes the link immediately with a fixed
+ *   score of 1 and mode `manual_override`.  No LLM call.
+ * - `false` (automatic / evaluated): loads intent + network context, calls
+ *   IntentIndexer from the signals public facade, then applies
+ *   `buildNetworkAssignmentDecision` to produce the threshold / metadata.
+ *   A no-prompt fast path skips the LLM when both prompts are absent.
+ *
+ * The IntentIndexer is injected as a constructor argument — communities never
+ * imports signals internals directly.
+ *
+ * Flow:
+ * START → router → {
+ *   create: assignNode (direct or evaluated) → END
+ *   read: readNode → END
+ *   delete: unassignNode → END
+ * }
+ *
+ * IND-546: canonical home — previously network/indexer/indexer.state.ts.
+ * LangGraph state carries IntentIndexerOutput and DebugMetaAgent which are
+ * cross-capability types; this file therefore belongs in the application layer.
+ */
+export declare const IntentNetworkGraphState: import("@langchain/langgraph").AnnotationRoot<{
+    /** User performing the action. Always required. */
+    userId: {
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
+        (): import("@langchain/langgraph").LastValue<string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    /** Target network for assign/read-by-network. From ChatGraph or tool arg. */
+    networkId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /** Target intent for assign/read-by-intent. From tool arg. */
+    intentId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /** Operation mode. */
+    operationMode: import("@langchain/langgraph").BaseChannel<"delete" | "create" | "read", "delete" | "create" | "read" | import("@langchain/langgraph").OverwriteValue<"delete" | "create" | "read">, unknown>;
+    /**
+     * When true, skip LLM evaluation and assign directly (manual_override).
+     * When false, run IntentIndexer evaluation (automatic mode).
+     */
+    skipEvaluation: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
+    /** Intent payload and metadata.  Null if intent not found. */
+    intent: import("@langchain/langgraph").BaseChannel<IntentForIndexing | null, IntentForIndexing | import("@langchain/langgraph").OverwriteValue<IntentForIndexing | null> | null, unknown>;
+    /** Network + member context.  Null if user not eligible. */
+    indexContext: import("@langchain/langgraph").BaseChannel<IndexMemberContext | null, IndexMemberContext | import("@langchain/langgraph").OverwriteValue<IndexMemberContext | null> | null, unknown>;
+    /** LLM evaluation result from IntentIndexer.  Null if evaluation was skipped. */
+    evaluation: import("@langchain/langgraph").BaseChannel<{
+        reasoning: string;
+        indexScore: number;
+        memberScore: number;
+    } | null, {
+        reasoning: string;
+        indexScore: number;
+        memberScore: number;
+    } | import("@langchain/langgraph").OverwriteValue<{
+        reasoning: string;
+        indexScore: number;
+        memberScore: number;
+    } | null> | null, unknown>;
+    /** Final decision: should intent be in this network? */
+    shouldAssign: import("@langchain/langgraph").BaseChannel<boolean | undefined, boolean | import("@langchain/langgraph").OverwriteValue<boolean | undefined> | undefined, unknown>;
+    /** Final score used for decision (0–1). */
+    finalScore: import("@langchain/langgraph").BaseChannel<number | undefined, number | import("@langchain/langgraph").OverwriteValue<number | undefined> | undefined, unknown>;
+    /** Result of the assignment persistence operation. */
+    assignmentResult: import("@langchain/langgraph").BaseChannel<AssignmentResult | null, AssignmentResult | import("@langchain/langgraph").OverwriteValue<AssignmentResult | null> | null, unknown>;
+    /** For read-by-network: pass userId when listing one user's intents in a network. */
+    queryUserId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /** Output for read mode. */
+    readResult: import("@langchain/langgraph").BaseChannel<{
+        links: Array<{
+            intentId: string;
+            networkId: string;
+            intentTitle?: string;
+            networkTitle?: string;
+            userId?: string;
+            userName?: string;
+            createdAt?: Date;
+            relevancyScore?: number | null;
+        }>;
+        count: number;
+        mode: string;
+        note?: string;
+    } | undefined, {
+        links: Array<{
+            intentId: string;
+            networkId: string;
+            intentTitle?: string;
+            networkTitle?: string;
+            userId?: string;
+            userName?: string;
+            createdAt?: Date;
+            relevancyScore?: number | null;
+        }>;
+        count: number;
+        mode: string;
+        note?: string;
+    } | import("@langchain/langgraph").OverwriteValue<{
+        links: Array<{
+            intentId: string;
+            networkId: string;
+            intentTitle?: string;
+            networkTitle?: string;
+            userId?: string;
+            userName?: string;
+            createdAt?: Date;
+            relevancyScore?: number | null;
+        }>;
+        count: number;
+        mode: string;
+        note?: string;
+    } | undefined> | undefined, unknown>;
+    /** Output for create/delete modes. */
+    mutationResult: import("@langchain/langgraph").BaseChannel<{
+        success: boolean;
+        message?: string;
+        error?: string;
+    } | undefined, {
+        success: boolean;
+        message?: string;
+        error?: string;
+    } | import("@langchain/langgraph").OverwriteValue<{
+        success: boolean;
+        message?: string;
+        error?: string;
+    } | undefined> | undefined, unknown>;
+    /** Error message. */
+    error: import("@langchain/langgraph").BaseChannel<string | null, string | import("@langchain/langgraph").OverwriteValue<string | null> | null, unknown>;
+    /** Timing records for each agent invocation within this graph run. */
+    agentTimings: import("@langchain/langgraph").BaseChannel<DebugMetaAgent[], DebugMetaAgent[] | import("@langchain/langgraph").OverwriteValue<DebugMetaAgent[]>, unknown>;
+}>;