@juspay/neurolink 9.10.1 → 9.11.0

package/dist/lib/core/redisConversationMemoryManager.js

@@ -4,6 +4,7 @@
  */
 import { randomUUID } from "crypto";
 import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
+import { generateToolOutputPreview } from "../context/toolOutputLimits.js";
 import { SummarizationEngine } from "../context/summarizationEngine.js";
 import { NeuroLink } from "../neurolink.js";
 import { ConversationMemoryError } from "../types/conversation.js";
@@ -102,7 +103,7 @@ export class RedisConversationMemoryManager {
     /**
      * Get session by ID, reconstructing a SessionMemory from Redis storage.
      */
-    async getSession(sessionId, userId) {
+    async getSession(sessionId, userId, requestId) {
         await this.ensureInitialized();
         if (!this.redisClient) {
             return undefined;
@@ -114,6 +115,34 @@ export class RedisConversationMemoryManager {
             if (!conversation) {
                 return undefined;
             }
+            // Log session load metadata for observability
+            const blobSizeBytes = conversationData
+                ? Buffer.byteLength(conversationData, "utf8")
+                : 0;
+            const messageCount = conversation.messages.length;
+            const hasSummary = !!conversation.summarizedUpToMessageId;
+            const pointerIndex = hasSummary
+                ? conversation.messages.findIndex((msg) => msg.id === conversation.summarizedUpToMessageId)
+                : -1;
+            const recentMessageCount = hasSummary && pointerIndex !== -1
+                ? messageCount - pointerIndex - 1
+                : messageCount;
+            logger.info("[ConversationMemory] Session loaded", {
+                requestId,
+                sessionId,
+                blobSizeBytes,
+                messageCount,
+                hasSummary,
+                recentMessageCount,
+            });
+            if (blobSizeBytes > 512 * 1024) {
+                logger.warn("[ConversationMemory] Large session blob", {
+                    requestId,
+                    sessionId,
+                    blobSizeBytes,
+                    messageCount,
+                });
+            }
             return {
                 sessionId: conversation.sessionId,
                 userId: conversation.userId,
@@ -137,6 +166,30 @@ export class RedisConversationMemoryManager {
             return undefined;
         }
     }
+    /**
+     * Get raw session data without any filtering or transformation.
+     * Used by the memory retrieval tool and internal APIs that need
+     * access to full message data including unmodified tool outputs.
+     */
+    async getSessionRaw(sessionId, userId) {
+        try {
+            await this.ensureInitialized();
+            if (!this.redisClient) {
+                return null;
+            }
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            return deserializeConversation(conversationData || null);
+        }
+        catch (error) {
+            logger.error("[RedisConversationMemoryManager] Failed to get raw session", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
     /**
      * Get all sessions for a specific user
      */
@@ -377,7 +430,7 @@ export class RedisConversationMemoryManager {
                 if (!this.summarizationInProgress.has(summarizationKey)) {
                     setImmediate(async () => {
                         try {
-                            await this.checkAndSummarize(conversation, tokenThreshold, options.sessionId, options.userId);
+                            await this.checkAndSummarize(conversation, tokenThreshold, options.sessionId, options.userId, options.requestId);
                         }
                         catch (error) {
                             logger.error("Background summarization failed", {
@@ -396,6 +449,24 @@ export class RedisConversationMemoryManager {
             }
             const serializedData = serializeConversation(conversation);
             await this.redisClient.set(redisKey, serializedData);
+            // Log turn storage metadata for observability
+            const blobSizeBytes = Buffer.byteLength(serializedData, "utf8");
+            logger.info("[ConversationMemory] Turn stored", {
+                requestId: options.requestId,
+                sessionId: options.sessionId,
+                blobSizeBytes,
+                totalMessages: conversation.messages.length,
+                userMsgChars: options.userMessage.length,
+                assistantMsgChars: options.aiResponse.length,
+            });
+            if (blobSizeBytes > 512 * 1024) {
+                logger.warn("[ConversationMemory] Large session blob", {
+                    requestId: options.requestId,
+                    sessionId: options.sessionId,
+                    blobSizeBytes,
+                    messageCount: conversation.messages.length,
+                });
+            }
             if (this.redisConfig.ttl > 0) {
                 await this.redisClient.expire(redisKey, this.redisConfig.ttl);
             }
@@ -418,7 +489,7 @@ export class RedisConversationMemoryManager {
     /**
      * Check if summarization is needed based on token count
      */
-    async checkAndSummarize(conversation, threshold, sessionId, userId) {
+    async checkAndSummarize(conversation, threshold, sessionId, userId, requestId) {
         const normalizedUserId = userId || "randomUser";
         const summarizationKey = `${sessionId}:${normalizedUserId}`;
         if (this.summarizationInProgress.has(summarizationKey)) {
@@ -442,7 +513,7 @@ export class RedisConversationMemoryManager {
                 createdAt: new Date(conversation.createdAt).getTime(),
                 lastActivity: new Date(conversation.updatedAt).getTime(),
             };
-            const summarized = await this.summarizationEngine.checkAndSummarize(session, threshold, this.config, "[RedisConversationMemoryManager]");
+            const summarized = await this.summarizationEngine.checkAndSummarize(session, threshold, this.config, "[RedisConversationMemoryManager]", requestId);
             conversation.lastTokenCount = session.lastTokenCount;
             conversation.lastCountedAt = session.lastCountedAt;
             if (summarized) {
@@ -471,9 +542,9 @@ export class RedisConversationMemoryManager {
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
-     * Filters out tool_call and tool_result messages when summarization is enabled
+     * Applies sendToolPreview toggle and hydrates result.result for backward compat
      */
-    async buildContextMessages(sessionId, userId, enableSummarization) {
+    async buildContextMessages(sessionId, userId, enableSummarization, requestId) {
         logger.info("[RedisConversationMemoryManager] Building context messages", {
             sessionId,
             userId,
@@ -497,14 +568,34 @@ export class RedisConversationMemoryManager {
             createdAt: new Date(conversation.createdAt).getTime(),
             lastActivity: new Date(conversation.updatedAt).getTime(),
         };
-        const contextMessages = buildContextFromPointer(session);
-        const isSummarizationEnabled = enableSummarization !== undefined
-            ? enableSummarization
-            : this.config.enableSummarization === true;
-        let finalMessages = contextMessages;
-        if (isSummarizationEnabled) {
-            finalMessages = contextMessages.filter((msg) => msg.role !== "tool_call" && msg.role !== "tool_result");
-        }
+        const contextMessages = buildContextFromPointer(session, requestId);
+        const sendToolPreview = this.config?.contextCompaction?.sendToolPreview === true;
+        // Map tool_result messages: apply preview toggle + hydrate result.result
+        const finalMessages = contextMessages.map((msg) => {
+            if (msg.role !== "tool_result") {
+                return msg;
+            }
+            // Toggle: swap content to preview if enabled AND a preview exists
+            const content = sendToolPreview && msg.metadata?.toolOutputPreview
+                ? msg.metadata.toolOutputPreview
+                : msg.content;
+            // Hydrate result.result from content for backward compatibility
+            // (result.result is no longer stored — inferred from content at read time)
+            let hydratedResult = msg.result;
+            if (msg.result && msg.result.result === undefined) {
+                let parsedResult = content;
+                try {
+                    parsedResult = JSON.parse(content);
+                }
+                catch {
+                    /* plain text — use as-is */
+                }
+                hydratedResult = { ...msg.result, result: parsedResult };
+            }
+            return { ...msg, content, result: hydratedResult };
+        });
+        // Tool messages now have real content and participate in context properly.
+        // The tool output pruner (Stage 1) handles bounding old tool outputs.
         logger.info("[RedisConversationMemoryManager] Retrieved context messages", {
             sessionId,
             userId,
@@ -756,6 +847,75 @@ User message: "${userMessage}"`;
             },
         };
     }
+    /**
+     * Get the raw messages array for a session.
+     * Returns the full messages list without context filtering or summarization.
+     */
+    async getSessionMessages(sessionId, userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        try {
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            const conversation = deserializeConversation(conversationData || null);
+            return conversation?.messages ?? [];
+        }
+        catch (error) {
+            logger.error("[RedisConversationMemoryManager] Failed to get session messages", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Replace the entire messages array for a session.
+     * The session must already exist in Redis.
+     */
+    async setSessionMessages(sessionId, messages, userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            throw new ConversationMemoryError("Redis client not initialized", "STORAGE_ERROR", { sessionId });
+        }
+        try {
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            const conversation = deserializeConversation(conversationData || null);
+            if (!conversation) {
+                throw new ConversationMemoryError(`Session ${sessionId} not found`, "STORAGE_ERROR", { sessionId });
+            }
+            conversation.messages = messages;
+            conversation.updatedAt = new Date().toISOString();
+            // Reset summarization pointers — the old summary no longer applies
+            // to the replaced messages array
+            conversation.summarizedUpToMessageId = undefined;
+            conversation.summarizedMessage = undefined;
+            conversation.lastTokenCount = undefined;
+            conversation.lastCountedAt = undefined;
+            const serializedData = serializeConversation(conversation);
+            await this.redisClient.set(redisKey, serializedData);
+            if (this.redisConfig.ttl > 0) {
+                await this.redisClient.expire(redisKey, this.redisConfig.ttl);
+            }
+            logger.debug("[RedisConversationMemoryManager] Session messages replaced", {
+                sessionId,
+                userId,
+                messageCount: messages.length,
+            });
+        }
+        catch (error) {
+            if (error instanceof ConversationMemoryError) {
+                throw error;
+            }
+            throw new ConversationMemoryError(`Failed to set session messages for session ${sessionId}`, "STORAGE_ERROR", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     /**
      * Close Redis connection
      */
@@ -966,53 +1126,88 @@ User message: "${userMessage}"`;
             toolCallsCount: pendingData.toolCalls.length,
             toolResultsCount: pendingData.toolResults.length,
         });
-        // Create a mapping from toolCallId to toolName for matching tool results
-        const toolCallMap = new Map();
-        // Create separate messages for tool calls and build the mapping
-        for (const toolCall of pendingData.toolCalls) {
-            const toolCallId = String(toolCall.toolCallId);
-            const toolName = String(toolCall.toolName);
-            // Store in mapping for tool results
-            toolCallMap.set(toolCallId, toolName);
-            const toolCallMessage = {
-                id: randomUUID(),
-                timestamp: toolCall.timestamp?.toISOString() || this.generateTimestamp(),
-                role: "tool_call",
-                content: "", // Can be empty for tool calls
-                tool: toolName,
-                args: (toolCall.args ||
-                    toolCall.arguments ||
-                    toolCall.parameters ||
-                    {}),
-            };
-            conversation.messages.push(toolCallMessage);
-        }
-        // Create separate messages for tool results using the mapping
-        for (const toolResult of pendingData.toolResults) {
-            const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
-            const toolName = toolCallMap.get(toolCallId) || "unknown";
-            const toolResultMessage = {
-                id: randomUUID(),
-                timestamp: toolResult.timestamp?.toISOString() || this.generateTimestamp(),
-                role: "tool_result",
-                content: "", // Can be empty for tool results
-                tool: toolName, // Now correctly extracted from tool call mapping
-                result: {
+        try {
+            // Create a mapping from toolCallId to toolName for matching tool results
+            const toolCallMap = new Map();
+            // Create separate messages for tool calls and build the mapping
+            for (const toolCall of pendingData.toolCalls) {
+                const toolCallId = toolCall.toolCallId ?? "";
+                const toolName = toolCall.toolName ?? "";
+                // Store in mapping for tool results
+                toolCallMap.set(toolCallId, toolName);
+                const toolCallMessage = {
+                    id: randomUUID(),
+                    timestamp: toolCall.timestamp?.toISOString() || this.generateTimestamp(),
+                    role: "tool_call",
+                    content: "", // Can be empty for tool calls
+                    tool: toolName,
+                    args: (toolCall.args ||
+                        toolCall.arguments ||
+                        toolCall.parameters ||
+                        {}),
+                };
+                conversation.messages.push(toolCallMessage);
+            }
+            // Create separate messages for tool results using the mapping
+            for (const toolResult of pendingData.toolResults) {
+                const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
+                const toolName = toolCallMap.get(toolCallId) || "unknown";
+                // Serialize the tool result to string for content field
+                let serializedResult;
+                if (typeof toolResult.result === "string") {
+                    serializedResult = toolResult.result;
+                }
+                else if (toolResult.result === undefined ||
+                    toolResult.result === null) {
+                    serializedResult = String(toolResult.result ?? "null");
+                }
+                else {
+                    try {
+                        serializedResult = JSON.stringify(toolResult.result, null, 2);
+                    }
+                    catch (serializeError) {
+                        serializedResult = `[Serialization failed: ${serializeError instanceof Error ? serializeError.message : String(serializeError)}]`;
+                    }
+                }
+                // Generate preview (uses existing config fields that were previously unused)
+                const { preview, truncated, originalSize } = generateToolOutputPreview(serializedResult, {
+                    maxBytes: this.config?.contextCompaction?.maxToolOutputBytes,
+                    maxLines: this.config?.contextCompaction?.maxToolOutputLines,
+                });
+                // Build metadata — only store preview when truncation occurred (no duplication)
+                const metadata = {
+                    truncated,
+                    ...(truncated && { toolOutputPreview: preview }),
+                    ...(truncated && { originalSize }),
+                };
+                // Build result — success/error metadata only, NOT the output data
+                const result = {
                     success: !toolResult.error,
-                    result: toolResult.result,
+                    // result.result intentionally NOT stored — inferred from content at read time
                     error: toolResult.error ? String(toolResult.error) : undefined,
-                },
-            };
-            conversation.messages.push(toolResultMessage);
+                };
+                const toolResultMessage = {
+                    id: randomUUID(),
+                    timestamp: toolResult.timestamp?.toISOString() || this.generateTimestamp(),
+                    role: "tool_result",
+                    content: serializedResult, // Full output (was "")
+                    tool: toolName,
+                    result,
+                    metadata,
+                };
+                conversation.messages.push(toolResultMessage);
+            }
+            logger.debug("[RedisConversationMemoryManager] Successfully flushed pending tool data", {
+                sessionId,
+                userId,
+                toolMessagesAdded: pendingData.toolCalls.length + pendingData.toolResults.length,
+                totalMessages: conversation.messages.length,
+            });
+        }
+        finally {
+            // Always clean up pending data, even on failure, to prevent infinite retry loops
+            this.pendingToolExecutions.delete(pendingKey);
         }
-        // Remove the pending data now that it's been flushed
-        this.pendingToolExecutions.delete(pendingKey);
-        logger.debug("[RedisConversationMemoryManager] Successfully flushed pending tool data", {
-            sessionId,
-            userId,
-            toolMessagesAdded: pendingData.toolCalls.length + pendingData.toolResults.length,
-            totalMessages: conversation.messages.length,
-        });
     }
 }
 //# sourceMappingURL=redisConversationMemoryManager.js.map

package/dist/lib/files/fileTools.d.ts

@@ -338,8 +338,8 @@ export declare function createFileTools(registry: FileReferenceRegistry): {
     }, "strip", z.ZodTypeAny, {
         file_id: string;
         format?: "text" | "summary" | "detailed" | undefined;
-        columns?: string[] | undefined;
         sheet?: string | undefined;
+        columns?: string[] | undefined;
         start_time?: number | undefined;
         end_time?: number | undefined;
         frame_count?: number | undefined;
@@ -356,8 +356,8 @@ export declare function createFileTools(registry: FileReferenceRegistry): {
     }, {
         file_id: string;
         format?: "text" | "summary" | "detailed" | undefined;
-        columns?: string[] | undefined;
         sheet?: string | undefined;
+        columns?: string[] | undefined;
         start_time?: number | undefined;
         end_time?: number | undefined;
         frame_count?: number | undefined;
@@ -389,8 +389,8 @@ export declare function createFileTools(registry: FileReferenceRegistry): {
         execute: (args: {
             file_id: string;
             format?: "text" | "summary" | "detailed" | undefined;
-            columns?: string[] | undefined;
             sheet?: string | undefined;
+            columns?: string[] | undefined;
             start_time?: number | undefined;
             end_time?: number | undefined;
             frame_count?: number | undefined;

package/dist/lib/index.d.ts

@@ -42,6 +42,8 @@ export type { DynamicModelConfig, ModelRegistry } from "./types/modelTypes.js";
 export { getAvailableProviders, getBestProvider, isValidProvider, } from "./utils/providerUtils.js";
 export { calculateCost, hasPricing } from "./utils/pricing.js";
 export { isAbortError } from "./utils/errorHandling.js";
+export { TTSProcessor } from "./utils/ttsProcessor.js";
+export { GoogleTTSHandler } from "./adapters/tts/googleTTSHandler.js";
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
 export type { MCPServerInfo } from "./types/mcpTypes.js";

package/dist/lib/index.js

@@ -49,6 +49,9 @@ export { getAvailableProviders, getBestProvider, isValidProvider, } from "./util
 export { calculateCost, hasPricing } from "./utils/pricing.js";
 // Error utilities
 export { isAbortError } from "./utils/errorHandling.js";
+// TTS utilities
+export { TTSProcessor } from "./utils/ttsProcessor.js";
+export { GoogleTTSHandler } from "./adapters/tts/googleTTSHandler.js";
 // Main NeuroLink wrapper class and diagnostic types
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };

package/dist/lib/mcp/externalServerManager.js

@@ -44,6 +44,41 @@ function substituteEnvVariables(value) {
     }
     return value;
 }
+/**
+ * Sensitive CLI flag patterns whose following value should be masked in logs.
+ */
+const SENSITIVE_ARG_PATTERNS = /^--(api-key|token|secret|password|key|figma-api-key|access-token|auth|credential)$/i;
+/**
+ * Redact values that follow sensitive flags in a CLI args array.
+ * Handles: "--api-key sk-abc", "--api-key=sk-abc", consecutive flags.
+ * E.g. ["--api-key", "sk-abc123"] → ["--api-key", "[REDACTED]"]
+ *      ["--api-key=sk-abc123"]    → ["--api-key=[REDACTED]"]
+ */
+function redactSensitiveArgs(args) {
+    if (!args || args.length === 0) {
+        return args;
+    }
+    const redacted = [...args];
+    for (let i = 0; i < redacted.length; i++) {
+        // Handle --flag=value inline form
+        const eqIdx = redacted[i].indexOf("=");
+        if (eqIdx !== -1) {
+            const flag = redacted[i].substring(0, eqIdx);
+            if (SENSITIVE_ARG_PATTERNS.test(flag)) {
+                redacted[i] = `${flag}=[REDACTED]`;
+            }
+            continue;
+        }
+        // Handle --flag value (two-part form)
+        if (SENSITIVE_ARG_PATTERNS.test(redacted[i]) &&
+            i + 1 < redacted.length &&
+            !redacted[i + 1].startsWith("--")) {
+            redacted[i + 1] = "[REDACTED]";
+            i++; // skip the redacted value
+        }
+    }
+    return redacted;
+}
 /**
  * Type guard to validate if an object can be safely used as Record<string, JsonValue>
  */
@@ -714,7 +749,7 @@ export class ExternalServerManager extends EventEmitter {
             this.updateServerStatus(serverId, "connecting");
             mcpLogger.debug(`[ExternalServerManager] Starting server: ${serverId}`, {
                 command: config.command,
-                args: config.args,
+                args: redactSensitiveArgs(config.args),
                 transport: config.transport,
             });
             // Create MCP client using the factory

package/dist/lib/memory/memoryRetrievalTools.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Memory retrieval tools for LLM access to conversation history.
+ * Enables the AI to retrieve full tool outputs, review previous messages,
+ * and search conversation memory.
+ *
+ * Follows the createFileTools() factory pattern from files/fileTools.ts.
+ * @module
+ */
+import { z } from "zod";
+import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
+/**
+ * Factory function that creates memory retrieval tools bound to a memory manager.
+ * @param memoryManager - The Redis conversation memory manager instance
+ * @returns Record of tool name to Vercel AI SDK tool definition
+ */
+export declare function createMemoryRetrievalTools(memoryManager: RedisConversationMemoryManager): {
+    retrieve_context: import("ai").Tool<z.ZodObject<{
+        sessionId: z.ZodString;
+        messageId: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<["user", "assistant", "system", "tool_call", "tool_result"]>>;
+        lastN: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sessionId: string;
+        search?: string | undefined;
+        role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+        offset?: number | undefined;
+        limit?: number | undefined;
+        messageId?: string | undefined;
+        lastN?: number | undefined;
+    }, {
+        sessionId: string;
+        search?: string | undefined;
+        role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+        offset?: number | undefined;
+        limit?: number | undefined;
+        messageId?: string | undefined;
+        lastN?: number | undefined;
+    }>, {
+        error: string;
+        sessionId: string;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
+        error: string;
+        messageId: string;
+        sessionId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
+        messages: ({
+            id: string;
+            error: string;
+            role?: undefined;
+            tool?: undefined;
+            matchCount?: undefined;
+            matches?: undefined;
+            totalSize?: undefined;
+            content?: undefined;
+            hasMore?: undefined;
+        } | {
+            id: string;
+            role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+            tool: string | undefined;
+            matchCount: number;
+            matches: {
+                line: number;
+                text: string;
+            }[];
+            totalSize: number;
+            error?: undefined;
+            content?: undefined;
+            hasMore?: undefined;
+        } | {
+            id: string;
+            role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+            tool: string | undefined;
+            content: string;
+            totalSize: number;
+            hasMore: boolean;
+            error?: undefined;
+            matchCount?: undefined;
+            matches?: undefined;
+        })[];
+        totalMessages: number;
+        error?: undefined;
+        sessionId?: undefined;
+        messageId?: undefined;
+    } | {
+        error: string;
+        sessionId?: undefined;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    }> & {
+        execute: (args: {
+            sessionId: string;
+            search?: string | undefined;
+            role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+            offset?: number | undefined;
+            limit?: number | undefined;
+            messageId?: string | undefined;
+            lastN?: number | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            error: string;
+            sessionId: string;
+            messageId?: undefined;
+            messages?: undefined;
+            totalMessages?: undefined;
+        } | {
+            error: string;
+            messageId: string;
+            sessionId?: undefined;
+            messages?: undefined;
+            totalMessages?: undefined;
+        } | {
+            messages: ({
+                id: string;
+                error: string;
+                role?: undefined;
+                tool?: undefined;
+                matchCount?: undefined;
+                matches?: undefined;
+                totalSize?: undefined;
+                content?: undefined;
+                hasMore?: undefined;
+            } | {
+                id: string;
+                role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+                tool: string | undefined;
+                matchCount: number;
+                matches: {
+                    line: number;
+                    text: string;
+                }[];
+                totalSize: number;
+                error?: undefined;
+                content?: undefined;
+                hasMore?: undefined;
+            } | {
+                id: string;
+                role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+                tool: string | undefined;
+                content: string;
+                totalSize: number;
+                hasMore: boolean;
+                error?: undefined;
+                matchCount?: undefined;
+                matches?: undefined;
+            })[];
+            totalMessages: number;
+            error?: undefined;
+            sessionId?: undefined;
+            messageId?: undefined;
+        } | {
+            error: string;
+            sessionId?: undefined;
+            messageId?: undefined;
+            messages?: undefined;
+            totalMessages?: undefined;
+        }>;
+    };
+};