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

package/dist/chat/chat.state.js

@@ -1,120 +0,0 @@
-import { Annotation, messagesStateReducer } from "@langchain/langgraph";
-// ══════════════════════════════════════════════════════════════════════════════
-// CHAT GRAPH STATE (Agent Loop Architecture)
-// ══════════════════════════════════════════════════════════════════════════════
-/**
- * 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 const ChatGraphState = Annotation.Root({
-    // ═══════════════════════════════════════════════════════════════════════════
-    // CORE INPUTS
-    // ═══════════════════════════════════════════════════════════════════════════
-    /**
-     * The User ID - required for all operations.
-     */
-    userId: (Annotation),
-    /**
-     * 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: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Focused request scope type. Network scope uses a network id; intent scope uses an intent id. */
-    scopeType: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /** Focused request scope id. Network scope uses a network id; intent scope uses an intent id. */
-    scopeId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /**
-     * Chat session ID when streaming with context. Used by tools to create draft
-     * opportunities tied to this conversation (context.conversationId).
-     */
-    sessionId: Annotation({
-        reducer: (curr, next) => next ?? curr,
-        default: () => undefined,
-    }),
-    /**
-     * Conversation history using LangGraph's built-in message reducer.
-     * Includes: HumanMessage, AIMessage, ToolMessage, SystemMessage
-     * Automatically handles message appending, ID management, and ordering.
-     */
-    messages: Annotation({
-        reducer: messagesStateReducer,
-        default: () => [],
-    }),
-    // ═══════════════════════════════════════════════════════════════════════════
-    // LOOP CONTROL
-    // ═══════════════════════════════════════════════════════════════════════════
-    /**
-     * Current iteration count in the agent loop.
-     * Used for soft limit (nudge) and hard limit (force exit).
-     */
-    iterationCount: Annotation({
-        reducer: (curr, next) => next,
-        default: () => 0,
-    }),
-    /**
-     * Flag indicating whether the agent loop should continue.
-     * Set to false when agent produces final response or hits hard limit.
-     */
-    shouldContinue: Annotation({
-        reducer: (curr, next) => next,
-        default: () => true,
-    }),
-    // ═══════════════════════════════════════════════════════════════════════════
-    // OUTPUTS
-    // ═══════════════════════════════════════════════════════════════════════════
-    /**
-     * The final generated response text.
-     * Set when the agent decides to stop and respond.
-     */
-    responseText: Annotation({
-        reducer: (curr, next) => next,
-        default: () => undefined,
-    }),
-    /**
-     * Error message if the agent loop fails.
-     */
-    error: Annotation({
-        reducer: (curr, next) => next,
-        default: () => undefined,
-    }),
-    /**
-     * 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: Annotation({
-        reducer: (curr, next) => next,
-        default: () => undefined,
-    }),
-    // Legacy subgraph state (used by index/intent/response nodes when present)
-    /** Router output: target, operationType, extractedContext. */
-    routingDecision: Annotation({
-        reducer: (curr, next) => next,
-        default: () => undefined,
-    }),
-    /** Results from intent/profile/opportunities/scrape subgraphs. */
-    subgraphResults: Annotation({
-        reducer: (curr, next) => next,
-        default: () => undefined,
-    }),
-    /** User profile context (e.g. for intent nodes). */
-    userProfile: Annotation({
-        reducer: (curr, next) => next,
-        default: () => undefined,
-    }),
-});

package/dist/chat/chat.streamer.d.ts

@@ -1,64 +0,0 @@
-import { BaseMessage } from "@langchain/core/messages";
-import { BaseCheckpointSaver } from "@langchain/langgraph";
-import type { ToolScopeType } from "../shared/agent/tool.scope.js";
-import type { ChatStreamEvent } from "./chat-streaming.types.js";
-/**
- * Top-level streaming service for Chat Graph events.
- *
- * Uses `graph.stream()` with `streamMode: ["custom", "updates"]` so that
- * the agent's `config.writer()` calls arrive as `"custom"` chunks (text
- * tokens and tool-activity events) and the final state update arrives as
- * an `"updates"` chunk.
- */
-export declare class ChatStreamer {
-    private loadSessionContext;
-    private createStreamingGraph;
-    constructor(loadSessionContext: (sessionId: string, maxMessages: number) => Promise<BaseMessage[]>, createStreamingGraph: (checkpointer?: BaseCheckpointSaver) => any);
-    /**
-     * Streams chat events with full session context.
-     * Loads previous conversation history and optionally uses a checkpointer
-     * for state persistence.
-     *
-     * @param input - Configuration for context-aware streaming
-     * @param checkpointer - Optional checkpointer for state persistence
-     * @yields ChatStreamEvent objects
-     */
-    streamChatEventsWithContext(input: {
-        userId: string;
-        message: string;
-        sessionId: string;
-        maxContextMessages?: number;
-        /** @deprecated Use scopeType/scopeId. Kept for REST/session edge compatibility. */
-        networkId?: string;
-        scopeType?: ToolScopeType;
-        scopeId?: string;
-        prefillMessages?: Array<{
-            role: "assistant" | "user";
-            content: string;
-        }>;
-        /** Per-run identifier used to form a composite LangGraph thread_id (sessionId:runId).
-         * When provided, prevents stale checkpoint state from a prior run being resumed.
-         * Defaults to sessionId alone when absent (backward compatible). */
-        runId?: string;
-    }, checkpointer?: BaseCheckpointSaver, signal?: AbortSignal): AsyncGenerator<ChatStreamEvent>;
-    /**
-     * Streams chat events from the graph execution.
-     *
-     * Uses `graph.stream()` with `streamMode: ["custom", "updates"]`:
-     * - `"custom"` chunks carry {@link AgentStreamEvent} objects emitted by
-     *   `ChatAgent.streamRun()` via `config.writer()`
-     * - `"updates"` chunks carry the final state update from `agentLoopNode`
-     *
-     * @param input - The input state for the graph (userId and messages)
-     * @param sessionId - The session ID for event attribution
-     * @param checkpointer - Optional checkpointer for persistence
-     * @yields ChatStreamEvent objects
-     */
-    streamChatEvents(input: {
-        userId: string;
-        messages: BaseMessage[];
-        networkId?: string;
-        scopeType?: ToolScopeType;
-        scopeId?: string;
-    }, sessionId: string, checkpointer?: BaseCheckpointSaver, signal?: AbortSignal, threadId?: string): AsyncGenerator<ChatStreamEvent>;
-}

package/dist/chat/chat.streamer.js

@@ -1,217 +0,0 @@
-import { AIMessage, HumanMessage } from "@langchain/core/messages";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-import { createAgentEndEvent, createAgentStartEvent, createDebugMetaEvent, createDecisionQuestionsEvent, createErrorEvent, createGraphEndEvent, createPhaseStartEvent, createPhaseEndEvent, createGraphStartEvent, createIterationStartEvent, createLlmStartEvent, createLlmEndEvent, createResponseCompleteEvent, createResponseResetEvent, createHallucinationDetectedEvent, createStatusEvent, createTokenEvent, createToolActivityEvent, createChatSummarizerStartEvent, createChatSummarizerEndEvent } from "./chat-streaming.types.js";
-const logger = protocolLogger("ChatStreamer");
-// ══════════════════════════════════════════════════════════════════════════════
-// CHAT STREAMER (Streaming Narration Architecture)
-// ══════════════════════════════════════════════════════════════════════════════
-/**
- * Top-level streaming service for Chat Graph events.
- *
- * Uses `graph.stream()` with `streamMode: ["custom", "updates"]` so that
- * the agent's `config.writer()` calls arrive as `"custom"` chunks (text
- * tokens and tool-activity events) and the final state update arrives as
- * an `"updates"` chunk.
- */
-export class ChatStreamer {
-    constructor(loadSessionContext, createStreamingGraph) {
-        this.loadSessionContext = loadSessionContext;
-        this.createStreamingGraph = createStreamingGraph;
-    }
-    /**
-     * Streams chat events with full session context.
-     * Loads previous conversation history and optionally uses a checkpointer
-     * for state persistence.
-     *
-     * @param input - Configuration for context-aware streaming
-     * @param checkpointer - Optional checkpointer for state persistence
-     * @yields ChatStreamEvent objects
-     */
-    async *streamChatEventsWithContext(input, checkpointer, signal) {
-        const { userId, message, sessionId, maxContextMessages = 20, networkId, scopeType, scopeId, prefillMessages, runId, } = input;
-        const effectiveScopeType = scopeType ?? (networkId ? 'network' : undefined);
-        const effectiveScopeId = scopeId ?? (effectiveScopeType === 'network' ? networkId : undefined);
-        logger.verbose("Starting context-aware streaming", {
-            userId,
-            sessionId,
-            maxContextMessages,
-            hasCheckpointer: !!checkpointer,
-            hasIndexScope: !!effectiveScopeId,
-            scopeType: effectiveScopeType,
-            scopeId: effectiveScopeId,
-        });
-        try {
-            // Load previous conversation context
-            const previousMessages = await this.loadSessionContext(sessionId, maxContextMessages);
-            // Inject prefill messages (e.g. hardcoded onboarding greeting) only for fresh sessions
-            const prefill = previousMessages.length === 0
-                ? (prefillMessages ?? []).map((pm) => pm.role === "assistant" ? new AIMessage(pm.content) : new HumanMessage(pm.content))
-                : [];
-            const allMessages = [...previousMessages, ...prefill, new HumanMessage(message)];
-            logger.verbose("Context prepared", {
-                previousCount: previousMessages.length,
-                totalCount: allMessages.length,
-            });
-            // Form composite thread_id when a runId is provided
-            const threadId = runId ? `${sessionId}:${runId}` : sessionId;
-            // Stream with context using the optional checkpointer
-            yield* this.streamChatEvents({ userId, messages: allMessages, scopeType: effectiveScopeType, scopeId: effectiveScopeId }, sessionId, checkpointer, signal, threadId);
-        }
-        catch (error) {
-            logger.error("Stream error", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            yield createErrorEvent(sessionId, error instanceof Error
-                ? error.message
-                : "Unknown error during context-aware streaming", "CONTEXT_STREAM_ERROR");
-        }
-    }
-    /**
-     * Streams chat events from the graph execution.
-     *
-     * Uses `graph.stream()` with `streamMode: ["custom", "updates"]`:
-     * - `"custom"` chunks carry {@link AgentStreamEvent} objects emitted by
-     *   `ChatAgent.streamRun()` via `config.writer()`
-     * - `"updates"` chunks carry the final state update from `agentLoopNode`
-     *
-     * @param input - The input state for the graph (userId and messages)
-     * @param sessionId - The session ID for event attribution
-     * @param checkpointer - Optional checkpointer for persistence
-     * @yields ChatStreamEvent objects
-     */
-    async *streamChatEvents(input, sessionId, checkpointer, signal, threadId) {
-        const graph = this.createStreamingGraph(checkpointer);
-        try {
-            const initialState = {
-                userId: input.userId,
-                messages: input.messages,
-            };
-            const effectiveScopeType = input.scopeType ?? (input.networkId ? 'network' : undefined);
-            const effectiveScopeId = input.scopeId ?? (effectiveScopeType === 'network' ? input.networkId : undefined);
-            if (input.networkId)
-                initialState.networkId = input.networkId;
-            if (effectiveScopeType && effectiveScopeId) {
-                initialState.scopeType = effectiveScopeType;
-                initialState.scopeId = effectiveScopeId;
-            }
-            initialState.sessionId = sessionId;
-            // Use graph.stream() with custom + updates modes.
-            // Custom events come from config.writer() inside agentLoopNode.
-            const eventStream = await graph.stream(initialState, {
-                streamMode: ["custom", "updates"],
-                configurable: { thread_id: threadId ?? sessionId, signal },
-                signal,
-            });
-            // Emit initial status
-            yield createStatusEvent(sessionId, "Processing your message...");
-            for await (const tuple of eventStream) {
-                if (signal?.aborted)
-                    break;
-                // graph.stream with multiple modes yields [mode, chunk] tuples
-                const [mode, chunk] = tuple;
-                // ─────────────────────────────────────────────────────────────────
-                // CUSTOM: writer events from ChatAgent.streamRun()
-                // ─────────────────────────────────────────────────────────────────
-                if (mode === "custom") {
-                    const event = chunk;
-                    if (event.type === "iteration_start") {
-                        yield createIterationStartEvent(sessionId, event.iteration);
-                    }
-                    if (event.type === "llm_start") {
-                        yield createLlmStartEvent(sessionId, event.iteration);
-                    }
-                    if (event.type === "text_chunk" && event.content) {
-                        yield createTokenEvent(sessionId, event.content);
-                    }
-                    if (event.type === "response_reset") {
-                        yield createResponseResetEvent(sessionId, event.reason);
-                    }
-                    if (event.type === "hallucination_detected") {
-                        yield createHallucinationDetectedEvent(sessionId, event.blockType, event.tool);
-                    }
-                    if (event.type === "llm_end") {
-                        yield createLlmEndEvent(sessionId, event.iteration, event.hasToolCalls, event.toolNames);
-                    }
-                    if (event.type === "tool_activity") {
-                        logger.debug("Tool activity", { name: event.name, phase: event.phase });
-                        if (event.phase === "start") {
-                            yield createToolActivityEvent(sessionId, event.name, event.name, "start");
-                        }
-                        else {
-                            yield createToolActivityEvent(sessionId, event.name, event.name, "end", event.success, event.summary, event.steps);
-                        }
-                    }
-                    if (event.type === "graph_start") {
-                        yield createGraphStartEvent(sessionId, event.name);
-                    }
-                    if (event.type === "graph_end") {
-                        yield createGraphEndEvent(sessionId, event.name, event.durationMs);
-                    }
-                    if (event.type === "phase_start") {
-                        yield createPhaseStartEvent(sessionId, event.name);
-                    }
-                    if (event.type === "phase_end") {
-                        yield createPhaseEndEvent(sessionId, event.name, event.durationMs);
-                    }
-                    if (event.type === "agent_start") {
-                        yield createAgentStartEvent(sessionId, event.name);
-                    }
-                    if (event.type === "agent_end") {
-                        yield createAgentEndEvent(sessionId, event.name, event.durationMs, event.summary);
-                    }
-                    if (event.type === "decision_questions") {
-                        yield createDecisionQuestionsEvent(sessionId, { questions: event.questions });
-                    }
-                    if (event.type === "status") {
-                        // Keep-alive/status line from long-blocking tools so SSE
-                        // transports do not idle out.
-                        yield createStatusEvent(sessionId, event.message);
-                    }
-                    if (event.type === "chat_summarizer_start") {
-                        yield createChatSummarizerStartEvent(sessionId, event.payload);
-                    }
-                    if (event.type === "chat_summarizer_end") {
-                        yield createChatSummarizerEndEvent(sessionId, event.payload);
-                    }
-                }
-                // ─────────────────────────────────────────────────────────────────
-                // UPDATES: final state from agentLoopNode
-                // ─────────────────────────────────────────────────────────────────
-                if (mode === "updates") {
-                    // The updates chunk is { agent_loop: { responseText, error, ... } }
-                    const updates = chunk;
-                    const agentOutput = updates?.agent_loop;
-                    if (agentOutput?.error) {
-                        logger.warn("Agent loop returned error via updates", {
-                            error: agentOutput.error,
-                        });
-                        yield createErrorEvent(sessionId, String(agentOutput.error), "AGENT_ERROR");
-                    }
-                    // Yield the agent's authoritative response text so the
-                    // controller can persist it without relying on token accumulation.
-                    const responseText = typeof agentOutput?.responseText === "string"
-                        ? agentOutput.responseText
-                        : "";
-                    yield createResponseCompleteEvent(sessionId, responseText);
-                    const debugMeta = agentOutput?.debugMeta;
-                    if (debugMeta?.graph != null &&
-                        typeof debugMeta.iterations === "number") {
-                        const llmFallback = { calls: 0, totalDurationMs: 0, resets: [], hallucinations: [] };
-                        yield createDebugMetaEvent(sessionId, debugMeta.graph, debugMeta.iterations, Array.isArray(debugMeta.tools) ? debugMeta.tools : [], debugMeta.llm ?? llmFallback, debugMeta.orchestratorNegotiations);
-                    }
-                    logger.verbose("Agent loop complete (updates)", {
-                        responseLength: responseText.length,
-                    });
-                }
-            }
-        }
-        catch (error) {
-            logger.error("Stream error", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            yield createErrorEvent(sessionId, error instanceof Error
-                ? error.message
-                : "Unknown error during streaming", "STREAM_ERROR");
-        }
-    }
-}

package/dist/chat/chat.suggester.d.ts

@@ -1,23 +0,0 @@
-import type { ChatSuggestion } from "./chat-streaming.types.js";
-export interface SuggestionGeneratorInput {
-    /** Last few messages (user and assistant) to derive context */
-    messages: Array<{
-        role: "user" | "assistant";
-        content: string;
-    }>;
-    /** Optional index/community context to tailor suggestions */
-    indexContext?: string;
-}
-/**
- * Lightweight generator for context-aware chat follow-up suggestions.
- * Uses a fast model and structured output to return 3-5 suggestions per call.
- */
-export declare class SuggestionGenerator {
-    private model;
-    constructor();
-    /**
-     * Generate follow-up suggestions from the last exchange.
-     * Returns empty array on failure (graceful degradation).
-     */
-    generate(input: SuggestionGeneratorInput): Promise<ChatSuggestion[]>;
-}

package/dist/chat/chat.suggester.js

@@ -1,95 +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 { protocolLogger } from "../shared/observability/protocol.logger.js";
-import { Timed } from "../shared/observability/performance.js";
-import { createStructuredModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-const logger = protocolLogger("SuggestionGenerator");
-const suggestionItemSchema = z.object({
-    label: z.string().describe("Short label for the chip (2-5 words)"),
-    type: z.enum(["direct", "prompt"]).describe("direct = auto-submit message; prompt = prefill input"),
-    followupText: z.string().nullable().describe("For type=direct: full message to send when clicked; null for prompt type"),
-    prefill: z.string().nullable().describe("For type=prompt: text to prefill the input; null for direct type"),
-});
-const suggestionsSchema = z.object({
-    suggestions: z
-        .array(suggestionItemSchema)
-        .min(1)
-        .max(6)
-        .describe("3-5 follow-up suggestions based on the conversation"),
-});
-const SYSTEM_PROMPT = `You generate follow-up suggestions for a chat user based on their conversation.
-
-Rules:
-- Return 3-5 suggestions. Mix of "direct" (one-click send) and "prompt" (prefill for user to edit).
-- Labels must be short: 2-5 words (e.g. "Find collaborators", "Add more details").
-- For type=direct: provide followupText as the exact message to send (complete sentence).
-- For type=prompt: provide prefill as the start of a sentence the user can complete (e.g. "I need help with ").
-- Suggestions must be relevant to the last exchange and natural next steps.
-- Do not repeat what the user or assistant just said; suggest logical follow-ups.
-- Voice: Calm, direct; no hype or networking clichés. Prefer words like opportunity, overlap, signal, pattern, relevant. Avoid: search, leverage, networking, match, optimize, scale.`;
-/**
- * Lightweight generator for context-aware chat follow-up suggestions.
- * Uses a fast model and structured output to return 3-5 suggestions per call.
- */
-export class SuggestionGenerator {
-    constructor() {
-        this.model = createStructuredModel("suggestionGenerator", suggestionsSchema, { name: "chat_suggestions" });
-    }
-    /**
-     * Generate follow-up suggestions from the last exchange.
-     * Returns empty array on failure (graceful degradation).
-     */
-    async generate(input) {
-        const { messages, indexContext } = input;
-        if (messages.length === 0)
-            return [];
-        const excerpt = messages
-            .slice(-6)
-            .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content.slice(0, 300)}`)
-            .join("\n\n");
-        const userContent = indexContext
-            ? `Conversation (community context: ${indexContext}):\n\n${excerpt}\n\nGenerate 3-5 follow-up suggestions.`
-            : `Conversation:\n\n${excerpt}\n\nGenerate 3-5 follow-up suggestions.`;
-        try {
-            const result = await invokeWithAbortSignal(this.model, [
-                new SystemMessage(SYSTEM_PROMPT),
-                new HumanMessage(userContent),
-            ]);
-            const parsed = suggestionsSchema.safeParse(result);
-            if (!parsed.success) {
-                logger.warn("Parse failed", { error: parsed.error.message });
-                return [];
-            }
-            const out = parsed.data.suggestions.map((s) => ({
-                label: s.label,
-                type: s.type,
-                ...(s.type === "direct" && s.followupText != null && { followupText: s.followupText }),
-                ...(s.type === "prompt" && s.prefill != null && { prefill: s.prefill }),
-            }));
-            logger.verbose("Generated", { count: out.length });
-            return out;
-        }
-        catch (error) {
-            logger.warn("Failed", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return [];
-        }
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], SuggestionGenerator.prototype, "generate", null);

package/dist/chat/chat.summarizer.d.ts

@@ -1,20 +0,0 @@
-import { type ChatContextDigest } from "../shared/schemas/chat-context.schema.js";
-export interface ChatSummarizerMessage {
-    role: "user" | "assistant";
-    content: string;
-}
-export interface ChatSummarizerInput {
-    previousDigest: ChatContextDigest | null;
-    newMessages: ChatSummarizerMessage[];
-}
-/** Pure LLM summarizer; no DB, no events. */
-export declare class ChatSummarizer {
-    private model;
-    constructor();
-    /**
-     * Summarize a chat session into a bounded structured digest.
-     * @param input - Previous digest (or null) and any messages added since.
-     * @returns Updated digest, or null on LLM failure / first-time empty input.
-     */
-    summarize(input: ChatSummarizerInput): Promise<ChatContextDigest | null>;
-}

package/dist/chat/chat.summarizer.js

@@ -1,97 +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);
-};
-/**
- * ChatSummarizer — rolling, incremental digest of a chat session. Takes the
- * previous persisted digest (if any) plus messages added since, returns a
- * structured ChatContextDigest. Pure: no DB, no events. Persistence is the
- * caller's responsibility (see backend ChatSummaryService).
- *
- * The model is instructed to drop entries in the previous digest that newer
- * messages override, keeping the digest bounded as the session grows.
- */
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { ChatContextDigestSchema } from "../shared/schemas/chat-context.schema.js";
-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";
-const logger = protocolLogger("ChatSummarizer");
-const MESSAGE_CONTENT_CAP = 240;
-const SYSTEM_PROMPT = `You distill chat sessions into a compact structured digest used to keep an assistant from asking obvious questions.
-
-Output four arrays:
-- statedFacts: facts the user volunteered (stage, location, role, timing, scope, budget, …).
-- openQuestions: questions the assistant asked that the user has not yet answered.
-- rejectionReasons: pushback the user gave on prior assistant proposals (e.g. "none of these fit — all US-based").
-- surfacedFindings: facts the assistant has already shared with the user from prior negotiation results.
-
-Rules:
-- Drop entries from the previous digest that newer messages override or contradict.
-- Keep each entry short (≤140 chars), specific, and standalone.
-- Bound the digest: at most 20 statedFacts, 10 openQuestions, 10 rejectionReasons, 20 surfacedFindings. Drop the least relevant when over.
-- Never invent facts. If the digest is empty for a category, output an empty array.`;
-/** Pure LLM summarizer; no DB, no events. */
-export class ChatSummarizer {
-    constructor() {
-        this.model = createStructuredModel("chatContextSummarizer", ChatContextDigestSchema, {
-            name: "chat_context_digest",
-        });
-    }
-    /**
-     * Summarize a chat session into a bounded structured digest.
-     * @param input - Previous digest (or null) and any messages added since.
-     * @returns Updated digest, or null on LLM failure / first-time empty input.
-     */
-    async summarize(input) {
-        if (input.newMessages.length === 0) {
-            return input.previousDigest;
-        }
-        const truncated = input.newMessages.map((m) => ({
-            role: m.role,
-            content: m.content.length > MESSAGE_CONTENT_CAP
-                ? m.content.slice(0, MESSAGE_CONTENT_CAP)
-                : m.content,
-        }));
-        const user = [
-            input.previousDigest
-                ? `Previous digest:\n${JSON.stringify(input.previousDigest, null, 2)}`
-                : "Previous digest: (none — this is the first summarization for this session)",
-            "",
-            "New messages (since previous digest):",
-            ...truncated.map((m) => `  [${m.role}] ${m.content}`),
-            "",
-            "Produce the updated digest now.",
-        ].join("\n");
-        try {
-            const response = await invokeWithAbortSignal(this.model, [
-                new SystemMessage(SYSTEM_PROMPT),
-                new HumanMessage(user),
-            ]);
-            const parsed = ChatContextDigestSchema.safeParse(response);
-            if (!parsed.success) {
-                logger.warn("ChatSummarizer parse failed", { error: parsed.error.message });
-                return null;
-            }
-            return parsed.data;
-        }
-        catch (err) {
-            logger.warn("ChatSummarizer LLM call failed", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return null;
-        }
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], ChatSummarizer.prototype, "summarize", null);

package/dist/chat/chat.title.generator.d.ts

@@ -1,19 +0,0 @@
-export interface TitleGeneratorInput {
-    messages: Array<{
-        role: string;
-        content: string;
-    }>;
-}
-/**
- * Generates a short, descriptive title for a chat session using the first exchange.
- * Only meaningful when there is at least one user message and one assistant message.
- */
-export declare class ChatTitleGenerator {
-    private model;
-    constructor();
-    /**
-     * Suggests a title from the conversation excerpt.
-     * Call only when there is at least one user and one assistant message.
-     */
-    invoke(input: TitleGeneratorInput): Promise<string>;
-}