@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/chat/chat.agent.js

@@ -1,1010 +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 { AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
-import { resolveChatContext } from "../shared/agent/tool.helpers.js";
-import { scopeFromNetworkId } from "../shared/agent/tool.scope.js";
-import { ITERATION_NUDGE } from "./chat.prompt.js";
-import { extractRecentToolCalls } from "./chat.prompt.modules.js";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-import { createModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-import { sanitizeForDebugMeta } from "../shared/observability/debug-meta.sanitizer.js";
-import { Timed } from "../shared/observability/performance.js";
-import { requestContext } from "../shared/observability/request-context.js";
-import { deduplicateQuestions } from "./chat.question-dedup.js";
-const logger = protocolLogger("ChatAgent");
-// Re-export for external consumers
-export { ITERATION_NUDGE } from "./chat.prompt.js";
-// ═══════════════════════════════════════════════════════════════════════════════
-// CONFIGURATION
-// ═══════════════════════════════════════════════════════════════════════════════
-/**
- * Soft limit: After this many iterations, inject a nudge message.
- */
-export const SOFT_ITERATION_LIMIT = 8;
-/**
- * Hard limit: Force exit after this many iterations to prevent infinite loops.
- */
-export const HARD_ITERATION_LIMIT = 12;
-/**
- * Extract plain text from message content (string or structured block array).
- * Filters to only `type: "text"` blocks, discarding tool metadata.
- */
-function extractTextContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text ?? "")
-            .join("");
-    }
-    return "";
-}
-/**
- * Extract plain text from an AIMessageChunk (string content or text blocks).
- */
-function extractTextFromChunk(chunk) {
-    return extractTextContent(chunk.content);
-}
-/**
- * ChatAgent: ReAct-style agent that uses tools to help users.
- *
- * The agent operates in a loop:
- * 1. Receive messages (conversation history + tool results)
- * 2. Decide: call tools OR respond to user
- * 3. If tools called: execute them, add results, loop back
- * 4. If response: return final text
- *
- * Use `ChatAgent.create(context)` to construct (async factory).
- */
-export class ChatAgent {
-    /**
-     * Private constructor — use `ChatAgent.create()` instead.
-     */
-    constructor(resolvedContext, persona, tools, modelConfig) {
-        this.resolvedContext = resolvedContext;
-        this.persona = persona;
-        this.model = createModel("chat", modelConfig);
-        // Store tools and index by name
-        this.tools = tools;
-        this.toolsByName = new Map();
-        for (const tool of this.tools) {
-            this.toolsByName.set(tool.name, tool);
-        }
-        // Bind tools to model
-        this.model = this.model.bindTools(this.tools);
-    }
-    /**
-     * Extracts the text content of the most recent HumanMessage.
-     */
-    static getCurrentUserMessage(messages) {
-        for (let i = messages.length - 1; i >= 0; i--) {
-            if (messages[i]._getType() === "human") {
-                const content = messages[i].content;
-                return typeof content === "string" ? content : undefined;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Async factory: creates a ChatAgent with resolved user/index context.
-     * Resolves user/network identity from DB during tool initialization.
-     *
-     * @param context - Tool context (database, userId, scope, deps)
-     * @param persona - Persona config (prompt builder, toolset, loop behaviors).
-     *                  Required — there is no default persona.
-     */
-    static async create(context, persona) {
-        const { networkId: legacyNetworkId } = context;
-        const explicitScope = context.scopeType && context.scopeId
-            ? { scopeType: context.scopeType, scopeId: context.scopeId }
-            : scopeFromNetworkId(legacyNetworkId);
-        const scopedNetworkId = explicitScope.scopeType === 'network' ? explicitScope.scopeId : undefined;
-        const resolved = await resolveChatContext({
-            database: context.database,
-            userId: context.userId,
-            networkId: scopedNetworkId,
-            sessionId: context.sessionId,
-        });
-        if (explicitScope.scopeType && explicitScope.scopeId) {
-            resolved.scopeType = explicitScope.scopeType;
-            resolved.scopeId = explicitScope.scopeId;
-        }
-        const tools = await persona.createTools(context, resolved);
-        return new ChatAgent(resolved, persona, tools, context.modelConfig);
-    }
-    /**
-     * Run a single iteration of the agent loop.
-     *
-     * @param messages - Current conversation including any tool results
-     * @param iterationCount - Current iteration number (for soft limit)
-     * @returns Result indicating whether to continue and any tool calls/response
-     */
-    async runIteration(messages, iterationCount) {
-        const iterCtx = {
-            recentTools: extractRecentToolCalls(messages),
-            currentMessage: ChatAgent.getCurrentUserMessage(messages),
-            ctx: this.resolvedContext,
-        };
-        const deterministicResponse = this.persona.resolveDeterministicResponse?.(this.resolvedContext, iterCtx);
-        if (deterministicResponse !== undefined && deterministicResponse !== null) {
-            const response = new AIMessage(deterministicResponse);
-            return {
-                shouldContinue: false,
-                responseText: deterministicResponse,
-                messages: [...messages, response],
-            };
-        }
-        const systemContent = this.persona.buildSystemContent(this.resolvedContext, iterCtx);
-        const fullMessages = [
-            new SystemMessage(systemContent),
-            ...messages,
-        ];
-        // Add nudge if past soft limit
-        if (iterationCount >= SOFT_ITERATION_LIMIT) {
-            fullMessages.push(new SystemMessage(ITERATION_NUDGE));
-        }
-        logger.verbose("Agent iteration", {
-            iteration: iterationCount,
-            messageCount: messages.length,
-            pastSoftLimit: iterationCount >= SOFT_ITERATION_LIMIT,
-        });
-        // Invoke model
-        const response = await invokeWithAbortSignal(this.model, fullMessages);
-        logger.debug("Chat model response", {
-            content: typeof response.content === "string"
-                ? response.content
-                : JSON.stringify(response.content),
-            toolCalls: response.tool_calls?.length ?? 0,
-            toolCallNames: response.tool_calls?.map((tc) => tc.name) ?? [],
-        });
-        // Check if model made tool calls
-        const toolCalls = response.tool_calls || [];
-        if (toolCalls.length > 0) {
-            logger.verbose("Agent made tool calls", {
-                iteration: iterationCount,
-                toolCount: toolCalls.length,
-                tools: toolCalls.map((tc) => tc.name),
-            });
-            // Execute tools (can be parallelized if independent)
-            const toolResults = await this.executeToolCalls(toolCalls);
-            // Build updated messages
-            const updatedMessages = [
-                ...messages,
-                response, // AIMessage with tool_calls
-                ...toolResults.map((tr) => new ToolMessage({
-                    tool_call_id: tr.toolCallId,
-                    content: tr.result,
-                    name: tr.name,
-                })),
-            ];
-            return {
-                shouldContinue: true,
-                toolCalls: toolCalls.map((tc) => ({
-                    id: tc.id,
-                    name: tc.name,
-                    args: tc.args,
-                })),
-                toolResults,
-                messages: updatedMessages,
-            };
-        }
-        // No tool calls - agent is responding
-        const responseText = extractTextContent(response.content);
-        logger.debug("Agent produced response (raw)", {
-            iteration: iterationCount,
-            responseText,
-        });
-        logger.verbose("Agent produced response", {
-            iteration: iterationCount,
-            responseLength: responseText.length,
-        });
-        return {
-            shouldContinue: false,
-            responseText,
-            messages: [...messages, response],
-        };
-    }
-    /**
-     * Execute tool calls, potentially in parallel.
-     */
-    async executeToolCalls(toolCalls) {
-        // Execute all tool calls in parallel
-        const results = await Promise.all(toolCalls.map(async (tc) => {
-            const tool = this.toolsByName.get(tc.name);
-            if (!tool) {
-                logger.error("Unknown tool", { name: tc.name });
-                return {
-                    toolCallId: tc.id || `unknown-${Date.now()}`,
-                    name: tc.name,
-                    result: JSON.stringify({
-                        success: false,
-                        error: `Unknown tool: ${tc.name}`,
-                    }),
-                };
-            }
-            try {
-                logger.verbose("Executing tool", { name: tc.name, args: tc.args });
-                const result = await tool.invoke(tc.args);
-                const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-                logger.debug("Tool response", { name: tc.name, result: resultStr });
-                logger.verbose("Tool completed", {
-                    name: tc.name,
-                    resultLength: resultStr.length,
-                });
-                return {
-                    toolCallId: tc.id || `${tc.name}-${Date.now()}`,
-                    name: tc.name,
-                    result: resultStr,
-                };
-            }
-            catch (error) {
-                logger.error("Tool execution failed", {
-                    name: tc.name,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return {
-                    toolCallId: tc.id || `${tc.name}-${Date.now()}`,
-                    name: tc.name,
-                    result: JSON.stringify({
-                        success: false,
-                        error: `Tool execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    }),
-                };
-            }
-        }));
-        return results;
-    }
-    /**
-     * Check whether `list_opportunities` returned valid opportunity blocks.
-     * Persisted cards from that tool are the only valid source.
-     */
-    static hasOpportunitySource(toolsUsed) {
-        return toolsUsed.some((t) => t.name === "list_opportunities" &&
-            t.success &&
-            !t.resultSummary?.startsWith("Found 0") &&
-            !t.resultSummary?.startsWith("No matches") &&
-            !t.resultSummary?.startsWith("No opportunities"));
-    }
-    /**
-     * Detect hallucinated ```intent_proposal or ```opportunity blocks in model text
-     * that were NOT generated by the corresponding tool call.
-     *
-     * A tool call that returned 0 cards (e.g. "Found 0 match(es)") counts as
-     * NOT having produced valid blocks — the LLM must not fabricate them.
-     *
-     * @returns Block info if hallucination detected, null otherwise
-     */
-    detectHallucinatedBlock(text, toolsUsed, userMessage) {
-        const hasSuccessfulCreateIntent = toolsUsed.some((t) => t.name === "create_intent" && t.success);
-        // Check for hallucinated intent_proposal
-        if (text.includes("```intent_proposal") && !hasSuccessfulCreateIntent) {
-            const match = text.match(/```intent_proposal\s*\n\s*\{[^}]*"description"\s*:\s*"([^"]+)"/);
-            if (match) {
-                return { type: "intent_proposal", tool: "create_intent", description: match[1] };
-            }
-        }
-        return null;
-    }
-    /**
-     * Strip ```opportunity and ```intent_proposal code blocks from text
-     * when no corresponding successful tool call was made.
-     * Defense-in-depth: catches hallucinated blocks that slip past detectHallucinatedBlock
-     * (e.g. after a correction iteration that still hallucinates).
-     *
-     * @param text - The response text to sanitize
-     * @param toolsUsed - Tool call records from the agent loop
-     * @returns Sanitized text with unbacked blocks removed
-     */
-    stripUnbackedBlocks(text, toolsUsed) {
-        let result = text;
-        let removedBlock = false;
-        const hasSuccessfulCreateIntent = toolsUsed.some((t) => t.name === "create_intent" && t.success);
-        if (!ChatAgent.hasOpportunitySource(toolsUsed) && result.includes("```opportunity")) {
-            const next = result.replace(/```opportunity\s*\n[\s\S]*?```/g, "");
-            removedBlock || (removedBlock = next !== result);
-            result = next;
-        }
-        if (!hasSuccessfulCreateIntent && result.includes("```intent_proposal")) {
-            const next = result.replace(/```intent_proposal\s*\n[\s\S]*?```/g, "");
-            removedBlock || (removedBlock = next !== result);
-            result = next;
-        }
-        // Clean up leftover double blank lines only when a block was actually removed
-        if (removedBlock) {
-            result = result.replace(/\n{3,}/g, "\n\n").trim();
-        }
-        return result;
-    }
-    /**
-     * Detect when the model claims to have performed a write action
-     * without having called any tools in the turn.
-     */
-    static detectPhantomWrite(responseText, toolsUsed) {
-        if (toolsUsed.length > 0)
-            return false;
-        return ChatAgent.PHANTOM_WRITE_PATTERNS.some(pattern => pattern.test(responseText));
-    }
-    /**
-     * Post-process a tool result: strip _graphTimings, extract summary/debugSteps,
-     * and optionally normalize a tool result before a create_intent callback.
-     *
-     * Returns the normalized result string and extracted debug metadata so both
-     * the normal streaming tool loop and the hallucination-recovery branch
-     * produce identical LLM-facing payloads.
-     */
-    async normalizeToolResult(toolName, resultStr, toolArgs) {
-        let normalized = resultStr;
-        let summary = "Done";
-        let debugSteps;
-        let graphTimings;
-        let decisionQuestions;
-        try {
-            const parsed = JSON.parse(normalized);
-            const payload = parsed.success && parsed.data != null ? parsed.data : parsed;
-            summary = payload.summary ?? parsed.summary ?? "Done";
-            const rawSteps = payload.debugSteps ?? parsed.debugSteps;
-            if (Array.isArray(rawSteps) && rawSteps.length > 0) {
-                debugSteps = rawSteps.map((s) => ({
-                    step: String(s.step ?? "").slice(0, ChatAgent.STEP_NAME_MAX),
-                    detail: s.detail != null
-                        ? String(s.detail).slice(0, ChatAgent.STEP_DETAIL_MAX)
-                        : undefined,
-                    ...(s.data && typeof s.data === "object" ? { data: s.data } : {}),
-                }));
-            }
-            const rawGraphTimings = payload._graphTimings ?? parsed._graphTimings;
-            if (Array.isArray(rawGraphTimings) && rawGraphTimings.length > 0) {
-                graphTimings = rawGraphTimings;
-                // Strip _graphTimings from the result string sent back to the LLM
-                try {
-                    const cleanedResult = JSON.parse(normalized);
-                    delete cleanedResult._graphTimings;
-                    if (cleanedResult.data && typeof cleanedResult.data === "object") {
-                        delete cleanedResult.data._graphTimings;
-                    }
-                    normalized = JSON.stringify(cleanedResult);
-                }
-                catch { /* keep original if can't clean */ }
-            }
-            const rawQuestions = payload.questions ?? parsed.questions;
-            if (Array.isArray(rawQuestions)) {
-                decisionQuestions = rawQuestions;
-            }
-        }
-        catch {
-            /* not JSON, keep default */
-        }
-        return {
-            resultStr: normalized,
-            summary,
-            debugSteps,
-            graphTimings,
-            ...(decisionQuestions !== undefined ? { decisionQuestions } : {}),
-        };
-    }
-    /**
-     * Run the full agent loop until completion or hard limit.
-     *
-     * @param initialMessages - Starting conversation messages
-     * @returns Final response text and full message history
-     */
-    async run(initialMessages) {
-        let messages = initialMessages;
-        let iterationCount = 0;
-        while (iterationCount < HARD_ITERATION_LIMIT) {
-            const result = await this.runIteration(messages, iterationCount);
-            iterationCount++;
-            messages = result.messages;
-            if (!result.shouldContinue) {
-                const responseText = result.responseText ||
-                    "I apologize, but I couldn't generate a response.";
-                logger.debug("Agent final response", { responseText });
-                return {
-                    responseText,
-                    messages,
-                    iterationCount,
-                };
-            }
-        }
-        // Hit hard limit - force a response
-        logger.warn("Hit hard iteration limit", { iterationCount });
-        const forceResponseMessages = [
-            ...messages,
-            new SystemMessage("You have reached the maximum number of tool calls. You MUST provide a final response now. Summarize what you've accomplished and what might still be needed."),
-        ];
-        const forcedResponse = await invokeWithAbortSignal(this.model, forceResponseMessages);
-        const responseText = extractTextContent(forcedResponse.content);
-        logger.debug("Agent forced response", { responseText });
-        return {
-            responseText,
-            messages: [...messages, forcedResponse],
-            iterationCount,
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════
-    // STREAMING RUN (for narration-style output)
-    // ═══════════════════════════════════════════════════════════════════════════
-    /**
-     * Run the full agent loop with streaming narration.
-     *
-     * Instead of returning a single blob at the end, this method calls
-     * `writer()` for every text token and tool-activity event so the
-     * consumer (graph node) can push them out via `config.writer`.
-     *
-     * @param initialMessages - Starting conversation messages
-     * @param writer - Callback to emit streaming events (from `config.writer`)
-     * @param signal - Optional AbortSignal to cancel the streaming LLM call and tool execution
-     * @returns Final response metadata (same shape as `run()`)
-     */
-    async streamRun(initialMessages, writer, signal) {
-        const llm = { calls: 0, totalDurationMs: 0, resets: [], hallucinations: [] };
-        const negotiationIds = new Set();
-        let lastLlmStart = 0;
-        const emit = (event) => {
-            if (event.type === "llm_start") {
-                llm.calls += 1;
-                lastLlmStart = Date.now();
-            }
-            else if (event.type === "llm_end") {
-                if (lastLlmStart > 0) {
-                    llm.totalDurationMs += Date.now() - lastLlmStart;
-                    lastLlmStart = 0;
-                }
-            }
-            else if (event.type === "response_reset") {
-                llm.resets.push({ reason: event.reason, at: Date.now() });
-            }
-            else if (event.type === "hallucination_detected") {
-                llm.hallucinations.push({ blockType: event.blockType, tool: event.tool, at: Date.now() });
-            }
-            else if (event.type === "negotiation_session_start") {
-                negotiationIds.add(event.opportunityId);
-            }
-            try {
-                writer?.(event);
-            }
-            catch {
-                /* swallow if writer is gone */
-            }
-        };
-        let messages = initialMessages;
-        let iterationCount = 0;
-        const toolsDebug = [];
-        const surfacedQuestionIds = new Set();
-        const hallucinationAutoInvokeCounts = new Map();
-        while (iterationCount < HARD_ITERATION_LIMIT) {
-            if (signal?.aborted) {
-                logger.verbose("Stream aborted by client", { iterationCount });
-                break;
-            }
-            emit({ type: "iteration_start", iteration: iterationCount });
-            const iterCtx = {
-                recentTools: extractRecentToolCalls(messages),
-                currentMessage: ChatAgent.getCurrentUserMessage(messages),
-                ctx: this.resolvedContext,
-            };
-            const deterministicResponse = this.persona.resolveDeterministicResponse?.(this.resolvedContext, iterCtx);
-            if (deterministicResponse !== undefined && deterministicResponse !== null) {
-                emit({ type: "text_chunk", content: deterministicResponse });
-                messages = [...messages, new AIMessage(deterministicResponse)];
-                iterationCount++;
-                return {
-                    responseText: deterministicResponse,
-                    messages,
-                    iterationCount,
-                    debugMeta: {
-                        graph: "agent_loop",
-                        iterations: iterationCount,
-                        tools: toolsDebug,
-                        llm,
-                    },
-                };
-            }
-            const systemContent = this.persona.buildSystemContent(this.resolvedContext, iterCtx);
-            const fullMessages = [
-                new SystemMessage(systemContent),
-                ...messages,
-            ];
-            if (iterationCount >= SOFT_ITERATION_LIMIT) {
-                fullMessages.push(new SystemMessage(ITERATION_NUDGE));
-            }
-            logger.verbose("Streaming iteration", {
-                iteration: iterationCount,
-                messageCount: messages.length,
-                pastSoftLimit: iterationCount >= SOFT_ITERATION_LIMIT,
-            });
-            // ── Stream the model response token-by-token ──────────────────────
-            emit({ type: "llm_start", iteration: iterationCount });
-            let accumulated;
-            let iterationText = "";
-            try {
-                const stream = await this.model.stream(fullMessages, { signal });
-                for await (const chunk of stream) {
-                    // Accumulate using AIMessageChunk.concat() so tool_call_chunks merge and tool_calls is populated
-                    accumulated = accumulated ? accumulated.concat(chunk) : chunk;
-                    // Emit text content tokens to the user immediately
-                    const textPart = extractTextFromChunk(chunk);
-                    if (textPart) {
-                        emit({ type: "text_chunk", content: textPart });
-                        iterationText += textPart;
-                    }
-                }
-            }
-            catch (err) {
-                if (err instanceof Error && err.name === "AbortError") {
-                    logger.verbose("LLM stream aborted by client", { iterationCount });
-                    break; // breaks the outer while loop
-                }
-                throw err; // re-throw non-abort errors
-            }
-            if (!accumulated) {
-                logger.warn("Empty model response in streaming iteration", {
-                    iterationCount,
-                });
-                iterationCount++;
-                continue;
-            }
-            // ── Check for tool calls ──────────────────────────────────────────
-            const toolCalls = accumulated.tool_calls || [];
-            emit({
-                type: "llm_end",
-                iteration: iterationCount,
-                hasToolCalls: toolCalls.length > 0,
-                toolNames: toolCalls.length > 0 ? toolCalls.map((tc) => tc.name) : undefined,
-            });
-            if (toolCalls.length > 0) {
-                logger.verbose("Streaming: agent made tool calls", {
-                    iteration: iterationCount,
-                    tools: toolCalls.map((tc) => tc.name),
-                });
-                // Clear any narration text streamed before tool calls — this text is
-                // intermediate reasoning and should not appear in the final response.
-                // The next iteration (after tool execution) will produce the real response.
-                if (iterationText) {
-                    emit({ type: "response_reset", reason: "Tool calls detected" });
-                }
-                // Execute tools one-by-one.
-                const toolResults = [];
-                for (const tc of toolCalls) {
-                    if (signal?.aborted) {
-                        logger.verbose("Stream aborted by client during tool execution");
-                        break;
-                    }
-                    emit({ type: "tool_activity", phase: "start", name: tc.name });
-                    const tool = this.toolsByName.get(tc.name);
-                    if (!tool) {
-                        const errResult = JSON.stringify({
-                            success: false,
-                            error: `Unknown tool: ${tc.name}`,
-                        });
-                        toolsDebug.push({
-                            name: tc.name,
-                            args: sanitizeForDebugMeta(tc.args),
-                            resultSummary: "Unknown tool",
-                            success: false,
-                            durationMs: 0,
-                        });
-                        emit({
-                            type: "tool_activity",
-                            phase: "end",
-                            name: tc.name,
-                            success: false,
-                            summary: "Unknown tool",
-                        });
-                        toolResults.push({
-                            toolCallId: tc.id || `unknown-${Date.now()}`,
-                            name: tc.name,
-                            result: errResult,
-                        });
-                        continue;
-                    }
-                    const toolStart = Date.now();
-                    try {
-                        logger.verbose("Streaming: executing tool", { name: tc.name });
-                        const currentCtx = requestContext.getStore() ?? {};
-                        let result = await requestContext.run({
-                            ...currentCtx,
-                            traceEmitter: (e) => emit(e),
-                            // Propagate the caller's AbortSignal into requestContext so
-                            // long-running graph nodes (orchestrator negotiation fan-out)
-                            // can suppress event emits after the chat session closes.
-                            ...(signal && { abortSignal: signal }),
-                        }, () => tool.invoke(tc.args));
-                        const toolDurationMs = Date.now() - toolStart;
-                        let resultStr = typeof result === "string" ? result : JSON.stringify(result);
-                        const normalized = await this.normalizeToolResult(tc.name, resultStr, tc.args);
-                        resultStr = normalized.resultStr;
-                        result = resultStr;
-                        if (normalized.decisionQuestions && normalized.decisionQuestions.length > 0) {
-                            const { fresh, newIds } = deduplicateQuestions(normalized.decisionQuestions, surfacedQuestionIds);
-                            if (fresh.length > 0) {
-                                emit({ type: "decision_questions", questions: fresh });
-                                for (const id of newIds)
-                                    surfacedQuestionIds.add(id);
-                            }
-                        }
-                        logger.verbose("Streaming: tool completed", {
-                            name: tc.name,
-                            resultLength: resultStr.length,
-                        });
-                        toolsDebug.push({
-                            name: tc.name,
-                            args: sanitizeForDebugMeta(tc.args),
-                            resultSummary: normalized.summary,
-                            success: true,
-                            durationMs: toolDurationMs,
-                            ...(normalized.debugSteps?.length ? { steps: normalized.debugSteps } : {}),
-                            ...(normalized.graphTimings?.length ? { graphs: normalized.graphTimings } : {}),
-                        });
-                        emit({
-                            type: "tool_activity",
-                            phase: "end",
-                            name: tc.name,
-                            success: true,
-                            summary: normalized.summary,
-                            steps: normalized.debugSteps,
-                        });
-                        toolResults.push({
-                            toolCallId: tc.id || `${tc.name}-${Date.now()}`,
-                            name: tc.name,
-                            result: resultStr,
-                        });
-                    }
-                    catch (error) {
-                        const errMsg = error instanceof Error ? error.message : "Unknown error";
-                        logger.error("Streaming: tool failed", {
-                            name: tc.name,
-                            error: errMsg,
-                        });
-                        toolsDebug.push({
-                            name: tc.name,
-                            args: sanitizeForDebugMeta(tc.args),
-                            resultSummary: errMsg,
-                            success: false,
-                            durationMs: Date.now() - toolStart,
-                        });
-                        emit({
-                            type: "tool_activity",
-                            phase: "end",
-                            name: tc.name,
-                            success: false,
-                            summary: errMsg,
-                        });
-                        toolResults.push({
-                            toolCallId: tc.id || `${tc.name}-${Date.now()}`,
-                            name: tc.name,
-                            result: JSON.stringify({
-                                success: false,
-                                error: `Tool execution failed: ${errMsg}`,
-                            }),
-                        });
-                    }
-                }
-                // If aborted during tool execution, discard partial results
-                if (signal?.aborted) {
-                    logger.verbose("Stream aborted after partial tool execution, discarding results");
-                    break; // break outer while loop — don't append partial toolResults to messages
-                }
-                // Build updated messages and loop
-                messages = [
-                    ...messages,
-                    accumulated, // AIMessage with tool_calls
-                    ...toolResults.map((tr) => new ToolMessage({
-                        tool_call_id: tr.toolCallId,
-                        content: tr.result,
-                        name: tr.name,
-                    })),
-                ];
-                iterationCount++;
-                continue;
-            }
-            // ── No tool calls → check for hallucinated code blocks ──────────
-            // LLMs sometimes write ```intent_proposal or ```opportunity blocks
-            // directly instead of calling the corresponding tool. These blocks
-            // lack valid proposalIds / data and won't work in the frontend.
-            // Auto-invoke the correct tool directly instead of re-asking the LLM.
-            // Persona-gated: only personas with hallucinationRecovery enabled run
-            // detection/auto-invoke — other personas never trigger this branch.
-            const hallucinatedBlock = this.persona.loopBehaviors.hallucinationRecovery
-                ? this.detectHallucinatedBlock(iterationText, toolsDebug, iterCtx.currentMessage)
-                : null;
-            const priorAutoInvokes = hallucinatedBlock ? (hallucinationAutoInvokeCounts.get(hallucinatedBlock.type) ?? 0) : 0;
-            if (hallucinatedBlock && priorAutoInvokes < 2 && iterationCount < HARD_ITERATION_LIMIT - 1) {
-                hallucinationAutoInvokeCounts.set(hallucinatedBlock.type, priorAutoInvokes + 1);
-                logger.warn("Streaming: detected hallucinated block, auto-invoking tool", {
-                    iteration: iterationCount,
-                    blockType: hallucinatedBlock.type,
-                    tool: hallucinatedBlock.tool,
-                    extractedDescription: hallucinatedBlock.description,
-                    autoInvokeAttempt: priorAutoInvokes + 1,
-                });
-                // Tell the frontend to discard all streamed tokens from this iteration
-                emit({ type: "response_reset", reason: `Hallucinated ${hallucinatedBlock.type} block detected` });
-                emit({ type: "hallucination_detected", blockType: hallucinatedBlock.type, tool: hallucinatedBlock.tool });
-                const tool = this.toolsByName.get(hallucinatedBlock.tool);
-                if (tool) {
-                    const toolCallId = `auto-${hallucinatedBlock.tool}-${Date.now()}`;
-                    const toolArgs = hallucinatedBlock.type === "opportunity"
-                        ? { searchQuery: hallucinatedBlock.description }
-                        : { description: hallucinatedBlock.description };
-                    emit({ type: "tool_activity", phase: "start", name: hallucinatedBlock.tool });
-                    const toolStart = Date.now();
-                    try {
-                        const currentCtx = requestContext.getStore() ?? {};
-                        const result = await requestContext.run({
-                            ...currentCtx,
-                            traceEmitter: (e) => emit(e),
-                            // Propagate the caller's AbortSignal into requestContext so
-                            // long-running graph nodes (orchestrator negotiation fan-out)
-                            // can suppress event emits after the chat session closes.
-                            ...(signal && { abortSignal: signal }),
-                        }, () => tool.invoke(toolArgs));
-                        const rawResultStr = typeof result === "string" ? result : JSON.stringify(result);
-                        const toolDurationMs = Date.now() - toolStart;
-                        // Same normalization as the main tool loop: callback + _graphTimings strip
-                        const normalized = await this.normalizeToolResult(hallucinatedBlock.tool, rawResultStr, toolArgs);
-                        toolsDebug.push({
-                            name: hallucinatedBlock.tool,
-                            args: sanitizeForDebugMeta(toolArgs),
-                            resultSummary: normalized.summary,
-                            success: true,
-                            durationMs: toolDurationMs,
-                            ...(normalized.debugSteps?.length ? { steps: normalized.debugSteps } : {}),
-                            ...(normalized.graphTimings?.length ? { graphs: normalized.graphTimings } : {}),
-                        });
-                        // Mirror the main tool loop's handling: forward decision questions
-                        // and capture debug metadata even when the discovery tool was invoked
-                        // via the hallucination-recovery path.
-                        if (normalized.decisionQuestions && normalized.decisionQuestions.length > 0) {
-                            const { fresh: freshHallucination, newIds: newIdsHallucination } = deduplicateQuestions(normalized.decisionQuestions, surfacedQuestionIds);
-                            if (freshHallucination.length > 0) {
-                                emit({ type: "decision_questions", questions: freshHallucination });
-                                for (const id of newIdsHallucination)
-                                    surfacedQuestionIds.add(id);
-                            }
-                        }
-                        emit({
-                            type: "tool_activity",
-                            phase: "end",
-                            name: hallucinatedBlock.tool,
-                            success: true,
-                            summary: normalized.summary,
-                            steps: normalized.debugSteps,
-                        });
-                        // Build synthetic tool call message + tool result so the next LLM
-                        // iteration can narrate around real data instead of hallucinated blocks.
-                        const syntheticAIMessage = new AIMessage({
-                            content: "",
-                            tool_calls: [{ id: toolCallId, name: hallucinatedBlock.tool, args: toolArgs }],
-                        });
-                        messages = [
-                            ...messages,
-                            syntheticAIMessage,
-                            new ToolMessage({ tool_call_id: toolCallId, content: normalized.resultStr, name: hallucinatedBlock.tool }),
-                        ];
-                    }
-                    catch (error) {
-                        const errMsg = error instanceof Error ? error.message : "Unknown error";
-                        logger.error("Streaming: auto-invoked tool failed after hallucination", {
-                            tool: hallucinatedBlock.tool,
-                            error: errMsg,
-                        });
-                        toolsDebug.push({
-                            name: hallucinatedBlock.tool,
-                            args: sanitizeForDebugMeta(toolArgs),
-                            resultSummary: errMsg,
-                            success: false,
-                            durationMs: Date.now() - toolStart,
-                        });
-                        emit({ type: "tool_activity", phase: "end", name: hallucinatedBlock.tool, success: false, summary: errMsg });
-                        // Fall back to correction message if tool invocation fails
-                        messages = [
-                            ...messages,
-                            accumulated,
-                            new SystemMessage(`CORRECTION: You wrote a \`\`\`${hallucinatedBlock.type} block without calling ${hallucinatedBlock.tool}. ` +
-                                `The auto-retry failed (${errMsg}). Please try calling the tool directly.`),
-                        ];
-                    }
-                }
-                else {
-                    // Tool not found — fall back to correction message
-                    messages = [
-                        ...messages,
-                        accumulated,
-                        new SystemMessage(`CORRECTION: You wrote a \`\`\`${hallucinatedBlock.type} block without calling ${hallucinatedBlock.tool}. ` +
-                            `That block is INVALID. Call the tool directly instead.`),
-                    ];
-                }
-                iterationCount++;
-                continue;
-            }
-            // ── Circuit breaker: hallucination detected but auto-invoke cap reached ──
-            if (hallucinatedBlock && priorAutoInvokes >= 2) {
-                logger.warn("Streaming: hallucination auto-invoke cap reached, stripping blocks", {
-                    iteration: iterationCount,
-                    blockType: hallucinatedBlock.type,
-                    attempts: priorAutoInvokes,
-                });
-                emit({ type: "response_reset", reason: `Hallucination cap reached for ${hallucinatedBlock.type}` });
-                const stripped = this.stripUnbackedBlocks(iterationText, toolsDebug);
-                if (stripped.trim()) {
-                    emit({ type: "text_chunk", content: stripped });
-                }
-                else {
-                    messages = [
-                        ...messages,
-                        accumulated,
-                        new SystemMessage("Your previous response only contained invalid code blocks that were removed. " +
-                            "Write a plain text response now — summarize the results of the tools you used. " +
-                            "Do NOT include ```opportunity or ```intent_proposal blocks."),
-                    ];
-                    iterationCount++;
-                    continue;
-                }
-            }
-            // ── Phantom write: model claims a write action without calling any tools ──
-            if (ChatAgent.detectPhantomWrite(iterationText, toolsDebug) &&
-                iterationCount < HARD_ITERATION_LIMIT - 1) {
-                logger.warn("Streaming: detected phantom write claim without tool calls", {
-                    iteration: iterationCount,
-                });
-                emit({ type: "response_reset", reason: "Phantom write detected — no tools were called" });
-                emit({ type: "hallucination_detected", blockType: "phantom_write", tool: "none" });
-                messages = [
-                    ...messages,
-                    accumulated,
-                    new SystemMessage("CORRECTION: You claimed to have performed an action (update, create, modify) but you did NOT call any tools. " +
-                        "The user's request has NOT been fulfilled. You MUST call the appropriate tool(s) to actually make the change, " +
-                        "then confirm based on the tool result. Do it now."),
-                ];
-                iterationCount++;
-                continue;
-            }
-            // ── Final response already streamed ─────────────────────────────
-            // Defense-in-depth: strip any code blocks that require tool backing
-            // but slipped through without a successful tool call (persona-gated,
-            // same flag as detection since both police tool-backed block types).
-            const sanitizedText = this.persona.loopBehaviors.hallucinationRecovery
-                ? this.stripUnbackedBlocks(iterationText, toolsDebug)
-                : iterationText;
-            if (sanitizedText !== iterationText) {
-                logger.warn("Streaming: stripped unbacked code blocks from final response", {
-                    originalLength: iterationText.length,
-                    sanitizedLength: sanitizedText.length,
-                });
-                emit({ type: "response_reset", reason: "Sanitized unbacked blocks from response" });
-                // Re-emit the sanitized text so the frontend displays clean content
-                if (sanitizedText.trim()) {
-                    emit({ type: "text_chunk", content: sanitizedText });
-                }
-                // If stripping removed ALL content, force a recovery iteration so the
-                // user sees an actual response instead of a blank message.
-                if (!sanitizedText.trim() && iterationCount < HARD_ITERATION_LIMIT - 1) {
-                    logger.warn("Streaming: sanitized text is empty, forcing recovery iteration", {
-                        iteration: iterationCount,
-                    });
-                    messages = [
-                        ...messages,
-                        accumulated,
-                        new SystemMessage("Your previous response only contained invalid code blocks that were removed. " +
-                            "Write a plain text response now — summarize the results of the tools you used. " +
-                            "Do NOT include ```opportunity or ```intent_proposal blocks."),
-                    ];
-                    iterationCount++;
-                    continue;
-                }
-            }
-            logger.verbose("Streaming: agent produced response", {
-                iteration: iterationCount,
-                responseLength: sanitizedText.length,
-            });
-            messages = [...messages, accumulated];
-            iterationCount++;
-            return {
-                responseText: sanitizedText,
-                messages,
-                iterationCount,
-                debugMeta: {
-                    graph: "agent_loop",
-                    iterations: iterationCount,
-                    tools: toolsDebug,
-                    llm,
-                    ...(negotiationIds.size > 0 && {
-                        orchestratorNegotiations: { opportunityIds: [...negotiationIds] },
-                    }),
-                },
-            };
-        }
-        // If aborted, return immediately without making another LLM call
-        if (signal?.aborted) {
-            return {
-                responseText: "",
-                messages,
-                iterationCount,
-                debugMeta: {
-                    graph: "agent_loop",
-                    iterations: iterationCount,
-                    tools: toolsDebug,
-                    llm,
-                    ...(negotiationIds.size > 0 && {
-                        orchestratorNegotiations: { opportunityIds: [...negotiationIds] },
-                    }),
-                },
-            };
-        }
-        // ── Hard limit: force a response ──────────────────────────────────────
-        logger.warn("Streaming: hit hard iteration limit", { iterationCount });
-        const forceMessages = [
-            ...messages,
-            new SystemMessage("You have reached the maximum number of tool calls. You MUST provide a final response now. Summarize what you've accomplished and what might still be needed."),
-        ];
-        let forcedAccumulated;
-        let forcedResponseText = "";
-        const forceStream = await this.model.stream(forceMessages);
-        for await (const chunk of forceStream) {
-            forcedAccumulated = forcedAccumulated
-                ? forcedAccumulated.concat(chunk)
-                : chunk;
-            const textPart = extractTextFromChunk(chunk);
-            if (textPart) {
-                emit({ type: "text_chunk", content: textPart });
-                forcedResponseText += textPart;
-            }
-        }
-        return {
-            responseText: forcedResponseText,
-            messages: [
-                ...messages,
-                ...(forcedAccumulated ? [forcedAccumulated] : []),
-            ],
-            iterationCount,
-            debugMeta: {
-                graph: "agent_loop",
-                iterations: iterationCount,
-                tools: toolsDebug,
-                llm,
-                ...(negotiationIds.size > 0 && {
-                    orchestratorNegotiations: { opportunityIds: [...negotiationIds] },
-                }),
-            },
-        };
-    }
-}
-// ─── Phantom write detection ─────────────────────────────────────────────
-ChatAgent.PHANTOM_WRITE_PATTERNS = [
-    /\bI(?:'ve| have) (?:updated|adjusted|changed|modified|edited|created|added|removed|deleted|saved|set up)\b/i,
-    /\bI (?:updated|adjusted|changed|modified|edited|created|added|removed|deleted|saved|set up)\b/i,
-    /\b(?:Updated|Adjusted|Changed|Modified|Edited|Created|Added|Removed|Deleted|Saved) (?:your|the|their)\b/i,
-    /\bEverything is (?:now )?(?:updated|changed|adjusted|saved|set)\b/i,
-    /\b(?:profile|bio|premise|signal|intent|membership|narrative) (?:has been|is now) (?:updated|changed|modified|adjusted|saved)\b/i,
-];
-// ─── Shared tool-result post-processing types ─────────────────────────────
-ChatAgent.STEP_DETAIL_MAX = 300;
-ChatAgent.STEP_NAME_MAX = 100;
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Number]),
-    __metadata("design:returntype", Promise)
-], ChatAgent.prototype, "runIteration", null);
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array]),
-    __metadata("design:returntype", Promise)
-], ChatAgent.prototype, "run", null);
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Function, AbortSignal]),
-    __metadata("design:returntype", Promise)
-], ChatAgent.prototype, "streamRun", null);