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

package/dist/chat/chat.graph.js

@@ -1,257 +0,0 @@
-import { StateGraph, START, END } from "@langchain/langgraph";
-import { HumanMessage } from "@langchain/core/messages";
-import { ChatGraphState } from "./chat.state.js";
-import { ChatAgent } from "./chat.agent.js";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-import { truncateToTokenLimit, MAX_CONTEXT_TOKENS } from "./chat.utils.js";
-import { ChatStreamer } from "./chat.streamer.js";
-import { timed } from "../shared/observability/performance.js";
-const logger = protocolLogger("ChatGraphFactory");
-function isRetriableError(err) {
-    const status = err.status ?? err.statusCode;
-    if (typeof status === "number" && status >= 500 && status <= 599)
-        return true;
-    const msg = err instanceof Error ? err.message : String(err);
-    const lower = msg.toLowerCase();
-    return (lower.includes("internal server error") ||
-        /\b500\b|status[: ]*500/i.test(msg) ||
-        lower.includes("econnreset") ||
-        lower.includes("etimedout"));
-}
-const RETRY_DELAY_MS = 800;
-export class ChatGraphFactory {
-    constructor(database, embedder, scraper, chatSession, protocolDeps, 
-    /** Persona driving this graph's agent loop. Required — there is no default. */
-    persona) {
-        this.database = database;
-        this.embedder = embedder;
-        this.scraper = scraper;
-        this.chatSession = chatSession;
-        this.protocolDeps = protocolDeps;
-        this.persona = persona;
-        this.streamingService = new ChatStreamer((sessionId, maxMessages) => this.loadSessionContext(sessionId, maxMessages), (checkpointer) => this.createStreamingGraph(checkpointer));
-    }
-    /**
-     * Returns a sibling factory sharing all dependencies but driven by a
-     * different persona. Used to derive per-session persona factories (e.g. the
-     * negotiator, whose identity comes from the user's personal agent row) from
-     * the composition-root orchestrator factory without re-wiring deps.
-     *
-     * @param persona - The persona config for the derived factory
-     * @returns A new ChatGraphFactory with identical deps and the given persona
-     */
-    withPersona(persona) {
-        return new ChatGraphFactory(this.database, this.embedder, this.scraper, this.chatSession, this.protocolDeps, persona);
-    }
-    /**
-     * Creates and compiles the Chat Graph without persistence.
-     * @returns Compiled StateGraph ready for invocation
-     */
-    createGraph() {
-        return this.buildGraph().compile();
-    }
-    /**
-     * Creates a streaming-enabled graph with optional checkpointer for persistence.
-     * @param checkpointer - Optional checkpointer (e.g., MemorySaver or PostgresSaver)
-     * @returns Compiled StateGraph ready for streaming
-     */
-    createStreamingGraph(checkpointer) {
-        const graph = this.buildGraph();
-        if (checkpointer) {
-            return graph.compile({ checkpointer });
-        }
-        return graph.compile();
-    }
-    /**
-     * Load previous messages from a session and convert to LangChain messages.
-     * Handles token truncation to fit within context window limits.
-     *
-     * @param sessionId - The session ID to load context from
-     * @param maxMessages - Maximum number of messages to load (default: 20)
-     * @returns Array of LangChain BaseMessage objects
-     */
-    async loadSessionContext(sessionId, maxMessages = 20) {
-        logger.verbose("Loading session context", {
-            sessionId,
-            maxMessages,
-        });
-        try {
-            const messages = await this.chatSession.getSessionMessages(sessionId, maxMessages);
-            if (messages.length === 0) {
-                logger.verbose("No previous messages found", { sessionId });
-                return [];
-            }
-            // Convert database messages to LangChain format.
-            // All roles map to HumanMessage to avoid circular dependency.
-            const langchainMessages = messages.map((msg) => new HumanMessage(msg.content));
-            // Truncate to fit within token limits
-            const truncatedMessages = truncateToTokenLimit(langchainMessages, MAX_CONTEXT_TOKENS);
-            logger.verbose("Context loaded", {
-                sessionId,
-                originalCount: messages.length,
-                truncatedCount: truncatedMessages.length,
-            });
-            return truncatedMessages;
-        }
-        catch (error) {
-            logger.error("Failed to load context", {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Return empty array on error - don't fail the entire request
-            return [];
-        }
-    }
-    /**
-     * Streams chat events with full session context.
-     * Delegates to ChatGraphStreamingService.
-     */
-    async *streamChatEventsWithContext(input, checkpointer, signal) {
-        yield* this.streamingService.streamChatEventsWithContext(input, checkpointer, signal);
-    }
-    /**
-     * Streams chat events from the graph execution.
-     * Delegates to ChatGraphStreamingService.
-     */
-    async *streamChatEvents(input, sessionId, checkpointer, signal) {
-        yield* this.streamingService.streamChatEvents(input, sessionId, checkpointer, signal);
-    }
-    /**
-     * Internal method to build the graph structure.
-     * @returns Uncompiled StateGraph
-     */
-    buildGraph() {
-        const deps = {
-            database: this.database,
-            embedder: this.embedder,
-            scraper: this.scraper,
-            protocolDeps: this.protocolDeps,
-            persona: this.persona,
-        };
-        // ─────────────────────────────────────────────────────────────────────────
-        // GRAPH ASSEMBLY
-        // ─────────────────────────────────────────────────────────────────────────
-        const workflow = new StateGraph(ChatGraphState)
-            .addNode("agent_loop", (state, config) => agentLoopNode(state, config, deps))
-            .addEdge(START, "agent_loop")
-            .addEdge("agent_loop", END);
-        logger.verbose("Graph built successfully (agent loop architecture)");
-        return workflow;
-    }
-}
-/**
- * The main agent loop node.
- * Runs a ReAct-style agent that calls tools until it decides to respond.
- *
- * Uses `agent.streamRun()` + `config.writer` so that text tokens and
- * tool-activity events are pushed into the graph's custom stream in
- * real-time rather than batched at the end.
- */
-export async function agentLoopNode(state, config, deps) {
-    return timed("ChatGraph.agentLoop", async () => {
-        logger.verbose("Agent loop starting", {
-            userId: state.userId,
-            messageCount: state.messages.length,
-            currentIteration: state.iterationCount
-        });
-        const runLoop = async () => {
-            const legacyNetworkId = state.networkId;
-            const scopeType = state.scopeType ?? (legacyNetworkId ? 'network' : undefined);
-            const scopeId = state.scopeId ?? legacyNetworkId;
-            const agent = await ChatAgent.create({
-                ...deps.protocolDeps,
-                userId: state.userId,
-                database: deps.database,
-                embedder: deps.embedder,
-                scraper: deps.scraper,
-                ...(legacyNetworkId ? { networkId: legacyNetworkId } : {}),
-                ...(scopeType && scopeId ? { scopeType, scopeId } : {}),
-                sessionId: state.sessionId,
-            }, deps.persona);
-            // Direct streaming writer - emit events immediately instead of buffering
-            const directWriter = (data) => {
-                try {
-                    config.writer?.(data);
-                }
-                catch {
-                    /* swallow if writer is gone */
-                }
-            };
-            // Get signal from configurable (passed by streamer via graph.stream() config)
-            const signal = config.configurable?.signal;
-            const result = await agent.streamRun(state.messages, directWriter, signal);
-            return result;
-        };
-        try {
-            const result = await runLoop();
-            logger.debug("Agent streamRun result", {
-                responseText: result.responseText,
-                iterationCount: result.iterationCount,
-                messageCount: result.messages.length,
-            });
-            logger.verbose("Agent loop complete", {
-                userId: state.userId,
-                iterations: result.iterationCount,
-                responseLength: result.responseText.length
-            });
-            return {
-                messages: result.messages,
-                responseText: result.responseText,
-                iterationCount: result.iterationCount,
-                shouldContinue: false,
-                debugMeta: result.debugMeta,
-            };
-        }
-        catch (error) {
-            if (isRetriableError(error)) {
-                const signal = config.configurable?.signal;
-                if (signal?.aborted) {
-                    return {
-                        error: "Request aborted",
-                        responseText: "",
-                        shouldContinue: false,
-                    };
-                }
-                logger.warn("Agent loop failed with retriable error, retrying once", {
-                    userId: state.userId,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-                await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-                try {
-                    const result = await runLoop();
-                    logger.verbose("Agent loop complete after retry", {
-                        userId: state.userId,
-                        iterations: result.iterationCount,
-                    });
-                    return {
-                        messages: result.messages,
-                        responseText: result.responseText,
-                        iterationCount: result.iterationCount,
-                        shouldContinue: false,
-                        debugMeta: result.debugMeta,
-                    };
-                }
-                catch (retryError) {
-                    logger.error("Agent loop failed on retry", {
-                        userId: state.userId,
-                        error: retryError instanceof Error ? retryError.message : String(retryError)
-                    });
-                    return {
-                        error: retryError instanceof Error ? retryError.message : "Agent loop failed",
-                        responseText: "I apologize, but I encountered an issue processing your request. Please try again.",
-                        shouldContinue: false
-                    };
-                }
-            }
-            logger.error("Agent loop failed", {
-                userId: state.userId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return {
-                error: error instanceof Error ? error.message : "Agent loop failed",
-                responseText: "I apologize, but I encountered an issue processing your request. Please try again.",
-                shouldContinue: false
-            };
-        }
-    });
-}

package/dist/chat/chat.interrupt.classifier.d.ts

@@ -1,25 +0,0 @@
-export interface ClassifyInterruptInput {
-    /** The new user message sent while the agent is running. */
-    message: string;
-    /**
-     * Current agent activity summary derived from the last few SSE trace event names
-     * (e.g. "tool_start: discover_opportunities, graph_start: opportunity").
-     */
-    agentState: string;
-}
-/**
- * Binary classifier that decides whether a mid-stream user message should steer
- * (interrupt the current run) or queue (buffer until the run completes).
- * Uses a low-temperature, minimal-token model for sub-1 s latency.
- */
-export declare class ChatInterruptClassifier {
-    private model;
-    constructor();
-    /**
-     * Classify a mid-stream interrupt as steer or queue.
-     *
-     * @param input - The new message and current agent state context
-     * @returns "steer" to interrupt the current run; "queue" to buffer
-     */
-    classify(input: ClassifyInterruptInput): Promise<"steer" | "queue">;
-}

package/dist/chat/chat.interrupt.classifier.js

@@ -1,64 +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 { log } from "../shared/observability/log.js";
-import { Timed } from "../shared/observability/performance.js";
-import { createResilientModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-const logger = log.lib.from("ChatInterruptClassifier");
-const SYSTEM_PROMPT = `You decide whether a new user message sent during an active AI process should STEER or QUEUE.
-
-Rules:
-- Reply with ONLY one word: steer or queue (lowercase).
-- STEER: the message redirects, corrects, stops, contradicts, or changes what the AI is doing. Keywords: "wait", "stop", "actually", "ignore that", "instead", "no", "cancel".
-- QUEUE: the message adds context, asks a follow-up, or complements what the AI is doing. Keywords: "also", "and", "when done", "additionally", "plus".
-- When ambiguous, default to steer.`;
-/**
- * Binary classifier that decides whether a mid-stream user message should steer
- * (interrupt the current run) or queue (buffer until the run completes).
- * Uses a low-temperature, minimal-token model for sub-1 s latency.
- */
-export class ChatInterruptClassifier {
-    constructor() {
-        this.model = createResilientModel("interruptClassifier");
-    }
-    /**
-     * Classify a mid-stream interrupt as steer or queue.
-     *
-     * @param input - The new message and current agent state context
-     * @returns "steer" to interrupt the current run; "queue" to buffer
-     */
-    async classify(input) {
-        const { message, agentState } = input;
-        try {
-            const response = await invokeWithAbortSignal(this.model, [
-                new SystemMessage(SYSTEM_PROMPT),
-                new HumanMessage(`Current agent activity: ${agentState || "idle"}\n\nNew user message: "${message.slice(0, 500)}"\n\nDecision:`),
-            ]);
-            const text = String(response.content ?? "").trim().toLowerCase();
-            if (text.startsWith("queue"))
-                return "queue";
-            // Default to steer on any ambiguity or unexpected output
-            return "steer";
-        }
-        catch (error) {
-            logger.warn("Classification failed, defaulting to steer", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return "steer";
-        }
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], ChatInterruptClassifier.prototype, "classify", null);

package/dist/chat/chat.persona.d.ts

@@ -1,39 +0,0 @@
-import type { ChatTools, ToolContext, ResolvedToolContext } from "../shared/agent/tool.factory.js";
-import type { IterationContext } from "./chat.prompt.modules.js";
-/**
- * Behaviors that live in the agent loop itself (not in the prompt or toolset).
- * Each persona opts in explicitly.
- */
-export interface ChatPersonaLoopBehaviors {
-    /**
-     * Detect hallucinated ```opportunity / ```intent_proposal code blocks in model
-     * text, auto-invoke the corresponding tool, and strip unbacked blocks from the
-     * final response. Only meaningful for personas whose toolset can legitimately
-     * produce those blocks — enabled for onboarding, signal and negotiator.
-     */
-    hallucinationRecovery: boolean;
-}
-/**
- * Persona configuration injected into `ChatAgent.create()`.
- *
- * A persona bundles the three persona-coupled seams of the chat runtime:
- * system-prompt construction, toolset creation, and loop behaviors.
- */
-export interface ChatPersonaConfig {
-    /**
-     * Stable persona identifier. Matches the `conversations.persona` column value
-     * for sessions driven by this persona.
-     */
-    id: string;
-    /** Builds the system prompt for each agent-loop iteration. */
-    buildSystemContent: (ctx: ResolvedToolContext, iterCtx: IterationContext) => string;
-    /** Creates the persona's toolset bound to the resolved user context. */
-    createTools: (deps: ToolContext, preResolvedContext?: ResolvedToolContext) => Promise<ChatTools>;
-    /**
-     * Optionally resolves a turn without an LLM or tools. Use only for narrow,
-     * deterministic safety redirects derived entirely from iteration context.
-     */
-    resolveDeterministicResponse?: (ctx: ResolvedToolContext, iterCtx: IterationContext) => string | null;
-    /** Loop behaviors this persona opts into. */
-    loopBehaviors: ChatPersonaLoopBehaviors;
-}

package/dist/chat/chat.prompt.d.ts

@@ -1,4 +0,0 @@
-/**
- * Nudge message injected after SOFT_ITERATION_LIMIT iterations.
- */
-export declare const ITERATION_NUDGE = "[System Note: You've made several tool calls. Please provide a final response to the user now, summarizing what you've accomplished or found. If you need more information from the user, ask for it in your response.]";

package/dist/chat/chat.prompt.js

@@ -1,12 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════════
-// SHARED CHAT-LOOP PROMPT FRAGMENTS
-// ═══════════════════════════════════════════════════════════════════════════════
-//
-// Persona-neutral prompt text owned by the agent loop rather than by any one
-// persona. Each persona builds its own system prompt (see signal.prompt.ts,
-// negotiator.prompt.ts, onboarding.prompt.ts); what remains
-// here is only what the loop itself injects regardless of persona.
-/**
- * Nudge message injected after SOFT_ITERATION_LIMIT iterations.
- */
-export const ITERATION_NUDGE = `[System Note: You've made several tool calls. Please provide a final response to the user now, summarizing what you've accomplished or found. If you need more information from the user, ask for it in your response.]`;

package/dist/chat/chat.prompt.modules.d.ts

@@ -1,30 +0,0 @@
-import type { BaseMessage } from "@langchain/core/messages";
-import type { ResolvedToolContext } from "../shared/agent/tool.factory.js";
-/**
- * State available to each persona's prompt builder at each iteration.
- */
-export interface IterationContext {
-    /** Tool calls from all iterations since the last user message. */
-    recentTools: Array<{
-        name: string;
-        args: Record<string, unknown>;
-    }>;
-    /** Text of the latest user message (for regex matching). */
-    currentMessage?: string;
-    /** Resolved tool context (user, profile, indexes, etc.). */
-    ctx: ResolvedToolContext;
-}
-/**
- * Extracts tool calls from all AI messages since the last HumanMessage.
- *
- * Scans backwards to find the last HumanMessage, then collects all tool calls
- * from AIMessages after that point. This ensures multi-iteration tool history
- * is available for prompt construction within a single user turn.
- *
- * @param messages - The current conversation message array
- * @returns Flattened array of tool name + args from the current agent turn
- */
-export declare function extractRecentToolCalls(messages: BaseMessage[]): Array<{
-    name: string;
-    args: Record<string, unknown>;
-}>;

package/dist/chat/chat.prompt.modules.js

@@ -1,40 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXTRACTION
-// ═══════════════════════════════════════════════════════════════════════════════
-/**
- * Extracts tool calls from all AI messages since the last HumanMessage.
- *
- * Scans backwards to find the last HumanMessage, then collects all tool calls
- * from AIMessages after that point. This ensures multi-iteration tool history
- * is available for prompt construction within a single user turn.
- *
- * @param messages - The current conversation message array
- * @returns Flattened array of tool name + args from the current agent turn
- */
-export function extractRecentToolCalls(messages) {
-    // Find the index of the last HumanMessage
-    let lastHumanIdx = -1;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i]._getType() === "human") {
-            lastHumanIdx = i;
-            break;
-        }
-    }
-    // Collect tool calls from all AIMessages after the last HumanMessage
-    const toolCalls = [];
-    const startIdx = lastHumanIdx + 1;
-    for (let i = startIdx; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg._getType() === "ai") {
-            const aiMsg = msg;
-            const calls = aiMsg.tool_calls ?? [];
-            for (const tc of calls) {
-                toolCalls.push({
-                    name: tc.name,
-                    args: (tc.args ?? {}),
-                });
-            }
-        }
-    }
-    return toolCalls;
-}

package/dist/chat/chat.question-dedup.d.ts

@@ -1,14 +0,0 @@
-/**
- * Pure deduplication logic for decision questions.
- * Filters out questions whose `id` is already in the surfaced set.
- * Questions without an `id` (inline-generated) are always passed through.
- */
-interface QuestionLike {
-    id?: string;
-    [key: string]: unknown;
-}
-export declare function deduplicateQuestions<T extends QuestionLike>(questions: T[], surfacedIds: Set<string>): {
-    fresh: T[];
-    newIds: string[];
-};
-export {};

package/dist/chat/chat.question-dedup.js

@@ -1,17 +0,0 @@
-/**
- * Pure deduplication logic for decision questions.
- * Filters out questions whose `id` is already in the surfaced set.
- * Questions without an `id` (inline-generated) are always passed through.
- */
-export function deduplicateQuestions(questions, surfacedIds) {
-    const fresh = [];
-    const newIds = [];
-    for (const q of questions) {
-        if (q.id && surfacedIds.has(q.id))
-            continue;
-        fresh.push(q);
-        if (q.id)
-            newIds.push(q.id);
-    }
-    return { fresh, newIds };
-}

package/dist/chat/chat.state.d.ts

@@ -1,135 +0,0 @@
-import type { BaseMessage } from "@langchain/core/messages";
-import type { ToolScopeType } from "../shared/agent/tool.scope.js";
-import type { DebugMetaToolCall, DebugMetaLlm, DebugMetaOrchestratorNegotiations } from "./chat-streaming.types.js";
-/** Routing decision from router node (target, operationType, extractedContext). */
-export interface RoutingDecision {
-    target: string;
-    operationType: string | null;
-    extractedContext?: string | null;
-}
-/** Intent subgraph result (actions, inferredIntents, etc.). */
-export interface IntentSubgraphResult {
-    actions?: Array<{
-        type: string;
-        payload?: string;
-    }>;
-    inferredIntents?: unknown[];
-    indexingResults?: unknown[];
-    mode?: string;
-    intents?: unknown[];
-    count?: number;
-    error?: string;
-    /** When the intent graph exits early (e.g. network-scoped without intents); surface to user. */
-    requiredMessage?: string;
-}
-/** Index subgraph result (memberships, ownedIndexes, specificIndexData). */
-export interface IndexSubgraphResult {
-    mode?: string;
-    memberships?: unknown[];
-    ownedIndexes?: unknown[];
-    specificIndexData?: unknown;
-    count?: number;
-    error?: string;
-}
-/** Aggregated results from subgraphs (intent, index, profile, opportunity, scrape). */
-export interface SubgraphResults {
-    intent?: IntentSubgraphResult;
-    index?: IndexSubgraphResult;
-    profile?: unknown;
-    opportunity?: unknown;
-    scrape?: unknown;
-}
-/**
- * The Chat Graph State using LangGraph Annotations.
- *
- * This is a simplified state for the agent loop architecture.
- * The agent handles all routing decisions internally via tool calling.
- *
- * Design Principles:
- * - Messages accumulate through the conversation (includes tool calls/results)
- * - Iteration count tracks loop progress for soft/hard limits
- * - Final response is extracted at the end
- */
-export declare const ChatGraphState: import("@langchain/langgraph").AnnotationRoot<{
-    /**
-     * The User ID - required for all operations.
-     */
-    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>;
-    };
-    /**
-     * Legacy optional index (community) ID when chat is scoped to a specific index.
-     * New callers should set scopeType/scopeId; networkId is retained as an edge alias.
-     */
-    networkId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /** Focused request scope type. Network scope uses a network id; intent scope uses an intent id. */
-    scopeType: import("@langchain/langgraph").BaseChannel<ToolScopeType | undefined, ToolScopeType | import("@langchain/langgraph").OverwriteValue<ToolScopeType | undefined> | undefined, unknown>;
-    /** Focused request scope id. Network scope uses a network id; intent scope uses an intent id. */
-    scopeId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /**
-     * Chat session ID when streaming with context. Used by tools to create draft
-     * opportunities tied to this conversation (context.conversationId).
-     */
-    sessionId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /**
-     * Conversation history using LangGraph's built-in message reducer.
-     * Includes: HumanMessage, AIMessage, ToolMessage, SystemMessage
-     * Automatically handles message appending, ID management, and ordering.
-     */
-    messages: import("@langchain/langgraph").BaseChannel<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[], BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[] | import("@langchain/langgraph").OverwriteValue<BaseMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>, import("@langchain/core/messages").MessageType>[]>, unknown>;
-    /**
-     * Current iteration count in the agent loop.
-     * Used for soft limit (nudge) and hard limit (force exit).
-     */
-    iterationCount: import("@langchain/langgraph").BaseChannel<number, number | import("@langchain/langgraph").OverwriteValue<number>, unknown>;
-    /**
-     * Flag indicating whether the agent loop should continue.
-     * Set to false when agent produces final response or hits hard limit.
-     */
-    shouldContinue: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
-    /**
-     * The final generated response text.
-     * Set when the agent decides to stop and respond.
-     */
-    responseText: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /**
-     * Error message if the agent loop fails.
-     */
-    error: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
-    /**
-     * Per-turn debug meta (graph, iterations, tool calls) for copy-debug.
-     * Not persisted; only used so the streamer receives it in the updates chunk.
-     */
-    debugMeta: import("@langchain/langgraph").BaseChannel<{
-        graph: string;
-        iterations: number;
-        tools: DebugMetaToolCall[];
-        llm: DebugMetaLlm;
-        orchestratorNegotiations?: DebugMetaOrchestratorNegotiations;
-    } | undefined, {
-        graph: string;
-        iterations: number;
-        tools: DebugMetaToolCall[];
-        llm: DebugMetaLlm;
-        orchestratorNegotiations?: DebugMetaOrchestratorNegotiations;
-    } | import("@langchain/langgraph").OverwriteValue<{
-        graph: string;
-        iterations: number;
-        tools: DebugMetaToolCall[];
-        llm: DebugMetaLlm;
-        orchestratorNegotiations?: DebugMetaOrchestratorNegotiations;
-    } | undefined> | undefined, unknown>;
-    /** Router output: target, operationType, extractedContext. */
-    routingDecision: import("@langchain/langgraph").BaseChannel<RoutingDecision | undefined, RoutingDecision | import("@langchain/langgraph").OverwriteValue<RoutingDecision | undefined> | undefined, unknown>;
-    /** Results from intent/profile/opportunities/scrape subgraphs. */
-    subgraphResults: import("@langchain/langgraph").BaseChannel<SubgraphResults | undefined, SubgraphResults | import("@langchain/langgraph").OverwriteValue<SubgraphResults | undefined> | undefined, unknown>;
-    /** User profile context (e.g. for intent nodes). */
-    userProfile: import("@langchain/langgraph").BaseChannel<unknown, unknown, unknown>;
-}>;
-/**
- * The full state type for the Chat Graph.
- * Use this for typing node functions and graph invocations.
- */
-export type ChatGraphStateType = typeof ChatGraphState.State;